class.ilDclBaseFieldModel.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2009 ILIAS open source, Extended GPL, see docs/LICENSE */
 
class ilDclBaseFieldModel
{
 
    protected $id;
    protected $table_id;
    protected $title;
    protected $description;
    protected $datatypeId;
    protected $order;
    protected $unique;
    protected $property = array();
    protected $exportable;
    protected $datatype;
    protected $storage_location_override = null;
    const PROP_LENGTH = "lenght";
    const PROP_REGEX = "regex";
    const PROP_REFERENCE = "table_id";
    const PROP_URL = "url";
    const PROP_TEXTAREA = "text_area";
    const PROP_REFERENCE_LINK = "reference_link";
    const PROP_WIDTH = "width";
    const PROP_HEIGHT = "height";
    const PROP_LEARNING_PROGRESS = "learning_progress";
    const PROP_ILIAS_REFERENCE_LINK = "ILIAS_reference_link";
    const PROP_N_REFERENCE = "multiple_selection";
    const PROP_FORMULA_EXPRESSION = "expression";
    const PROP_DISPLAY_COPY_LINK_ACTION_MENU = "display_action_menu";
    const PROP_LINK_DETAIL_PAGE_TEXT = "link_detail_page";
    const PROP_SUPPORTED_FILE_TYPES = "supported_file_types";
    const PROP_PLUGIN_HOOK_NAME = "plugin_hook_name";
    const PROP_TEXT_SELECTION_OPTIONS = "text_selection_options";
    const PROP_TEXT_SELECTION_TYPE = "text_selection_type";
    const PROP_DATE_SELECTION_OPTIONS = "date_selection_options";
    const PROP_DATE_SELECTION_TYPE = "date_selection_type";
    // type of table il_dcl_view
    const EDIT_VIEW = 2;
    const EXPORTABLE_VIEW = 4;
 
 
    public function __construct($a_id = 0)
    {
        if ($a_id != 0) {
            $this->id = $a_id;
            $this->doRead();
        }
    }
 
 
    public static function _getTitleInvalidChars($a_as_regex = true)
    {
        if ($a_as_regex) {
            return '/^[^<>\\\\":]*$/i';
        } else {
            return '\ < > " :';
        }
    }
 
 
    public static function _getFieldIdByTitle($title, $table_id)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $result = $ilDB->query(
            'SELECT id FROM il_dcl_field WHERE title = ' . $ilDB->quote($title, 'text') . ' AND table_id = '
            . $ilDB->quote($table_id, 'integer')
        );
        $id = 0;
        while ($rec = $ilDB->fetchAssoc($result)) {
            $id = $rec['id'];
        }
 
        return $id;
    }
 
 
    public function setId($a_id)
    {
        $this->id = $a_id;
    }
 
 
    public function getId()
    {
        return $this->id;
    }
 
 
    public function setTableId($a_id)
    {
        $this->table_id = $a_id;
    }
 
 
    public function getTableId()
    {
        return $this->table_id;
    }
 
 
    public function setTitle($a_title)
    {
        //title cannot begin with _ as this is saved for other purposes. make __ instead.
        if (substr($a_title, 0, 1) == "_" && substr($a_title, 0, 2) != "__") {
            $a_title = "_" . $a_title;
        }
        $this->title = $a_title;
    }
 
 
    public function getTitle()
    {
        return $this->title;
    }
 
 
    public function setDescription($a_desc)
    {
        $this->description = $a_desc;
    }
 
 
    public function getDescription()
    {
        return $this->description;
    }
 
 
    public function setDatatypeId($a_id)
    {
        //unset the cached datatype.
        $this->datatype = null;
        $this->datatypeId = $a_id;
    }
 
 
    public function getDatatypeId()
    {
        if ($this->isStandardField()) {
            return ilDclStandardField::_getDatatypeForId($this->getId());
        }
 
        return $this->datatypeId;
    }
 
 
    public function isUnique()
    {
        return $this->unique;
    }
 
 
    public function setUnique($unique)
    {
        $this->unique = $unique ? 1 : 0;
    }
 
 
    public function getDatatype()
    {
        $this->loadDatatype();
 
        return $this->datatype;
    }
 
 
    public function getDatatypeTitle()
    {
        $this->loadDatatype();
 
        return $this->datatype->getTitle();
    }
 
 
    public function getStorageLocation()
    {
        if ($this->getStorageLocationOverride() !== null) {
            return $this->getStorageLocationOverride();
        }
 
        $this->loadDatatype();
 
        return $this->datatype->getStorageLocation();
    }
 
 
    protected function loadDatatype()
    {
        if ($this->datatype == null) {
            $this->datatype = ilDclCache::getDatatype($this->datatypeId);
        }
    }
 
 
    protected function loadTableFieldSetting()
    {
        $tablefield_setting = ilDclTableFieldSetting::getInstance($this->getTableId(), $this->getId());
        $this->exportable = $tablefield_setting->isExportable();
        $this->order = $tablefield_setting->getFieldOrder();
    }
 
 
    public function getExportable()
    {
        if (!isset($this->exportable)) {
            $this->loadExportability();
        }
 
        return $this->exportable;
    }
 
 
    private function loadExportability()
    {
        if ($this->exportable == null) {
            $this->loadTableFieldSetting();
        }
    }
 
 
    public function toArray()
    {
        return (array) $this;
    }
 
 
    public function isStandardField()
    {
        return false;
    }
 
 
    public function doRead()
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        //THEN 1 ELSE 0 END AS has_options FROM il_dcl_field f WHERE id = ".$ilDB->quote($this->getId(),"integer");
        $query = "SELECT * FROM il_dcl_field WHERE id = " . $ilDB->quote($this->getId(), "integer");
        $set = $ilDB->query($query);
        $rec = $ilDB->fetchAssoc($set);
 
        $this->setTableId($rec["table_id"]);
        $this->setTitle($rec["title"]);
        $this->setDescription($rec["description"]);
        $this->setDatatypeId($rec["datatype_id"]);
        $this->setUnique($rec["is_unique"]);
        $this->loadProperties();
        $this->loadTableFieldSetting();
    }
 
 
    public function buildFromDBRecord($rec)
    {
        $this->setId($rec["id"]);
        $this->setTableId($rec["table_id"]);
        $this->setTitle($rec["title"]);
        $this->setDescription($rec["description"]);
        $this->setDatatypeId($rec["datatype_id"]);
        $this->setUnique($rec["is_unique"]);
    }
 
 
    public function doCreate()
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        if (!ilDclTable::_tableExists($this->getTableId())) {
            throw new ilException("The field does not have a related table!");
        }
 
        $id = $ilDB->nextId("il_dcl_field");
        $this->setId($id);
        $query = "INSERT INTO il_dcl_field (" . "id" . ", table_id" . ", datatype_id" . ", title" . ", description" . ", is_unique"
            . " ) VALUES (" . $ilDB->quote($this->getId(), "integer") . "," . $ilDB->quote($this->getTableId(), "integer") . ","
            . $ilDB->quote($this->getDatatypeId(), "integer") . "," . $ilDB->quote($this->getTitle(), "text") . ","
            . $ilDB->quote($this->getDescription(), "text") . "," . $ilDB->quote($this->isUnique(), "integer") . ")";
        $ilDB->manipulate($query);
 
        $this->updateTableFieldSetting();
 
        $this->addToTableViews();
    }
 
 
    protected function addToTableViews()
    {
        foreach (ilDclTableView::getAllForTableId($this->table_id) as $tableview) {
            $tableview->createFieldSetting($this->id);
        }
    }
 
 
    public function doUpdate()
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $ilDB->update(
            "il_dcl_field",
            array(
                "table_id"    => array(
                    "integer",
                    $this->getTableId(),
                ),
                "datatype_id" => array(
                    "text",
                    $this->getDatatypeId(),
                ),
                "title"       => array(
                    "text",
                    $this->getTitle(),
                ),
                "description" => array(
                    "text",
                    $this->getDescription(),
                ),
                "is_unique"   => array(
                    "integer",
                    $this->isUnique(),
                ),
            ),
            array(
                "id" => array(
                    "integer",
                    $this->getId(),
                ),
            )
        );
        $this->updateTableFieldSetting();
        $this->updateProperties();
    }
 
 
    public function updateProperties()
    {
        foreach ($this->property as $prop) {
            $prop->store();
        }
    }
 
 
    protected function updateTableFieldSetting()
    {
        $tablefield_setting = ilDclTableFieldSetting::getInstance($this->getTableId(), $this->getId());
        $tablefield_setting->setExportable($this->exportable);
        $tablefield_setting->setFieldOrder($this->order);
        $tablefield_setting->store();
    }
 
 
    public function doDelete()
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        // delete tablefield setting.
        ilDclTableFieldSetting::getInstance($this->getTableId(), $this->getId())->delete();
 
        $query = "DELETE FROM il_dcl_field_prop WHERE field_id = " . $ilDB->quote($this->getId(), "text");
        $ilDB->manipulate($query);
 
        $query = "DELETE FROM il_dcl_field WHERE id = " . $ilDB->quote($this->getId(), "text");
        $ilDB->manipulate($query);
 
        foreach ($this->getViewSettings() as $field_setting) {
            $field_setting->delete();
        }
    }
 
    public function getViewSettings() : array
    {
        return ilDclTableViewFieldSetting::where(array('field' => $this->getId()))->get();
    }
 
    public function getViewSetting(int $tableview_id) : ilDclTableViewFieldSetting
    {
        return ilDclTableViewFieldSetting::where(array('field' => $this->getId(), 'tableview_id' => $tableview_id))->first();
    }
 
 
    public function getOrder()
    {
        if ($this->order == null) {
            $this->loadTableFieldSetting();
        }
 
        return !$this->order ? 0 : $this->order;
    }
 
 
    public function setOrder($order)
    {
        $this->order = $order;
    }
 
 
    protected function loadProperties()
    {
        $this->property = ilDclCache::getFieldProperties($this->getId());
    }
 
 
    public function hasProperty($key)
    {
        $this->loadProperties();
 
        return (isset($this->property[$key]) && $this->property[$key]->getValue() != null);
    }
 
 
    public function getProperty($key)
    {
        $instance = $this->getPropertyInstance($key);
 
        return ($instance !== null) ? $instance->getValue() : null;
    }
 
 
    public function getPropertyInstance($key)
    {
        $this->loadProperties();
        if ($this->hasProperty($key)) {
            $value = $this->property[$key];
 
            return $value;
        }
 
        return null;
    }
 
 
    public function setProperty($key, $value)
    {
        $this->loadProperties();
        if (isset($this->property[$key])) {
            $this->property[$key]->setValue($value);
        } else {
            $property = new ilDclFieldProperty();
            $property->setName($key);
            $property->setFieldId($this->getId());
            $property->setValue($value);
 
            $this->property[$key] = $property;
        }
 
        return $this->property[$key];
    }
 
 
    public function getValidFieldProperties()
    {
        return array();
    }
 
 
    public function checkValidityFromForm(ilPropertyFormGUI &$form, $record_id = null)
    {
        $value = $form->getInput('field_' . $this->getId());
        $this->checkValidity($value, $record_id);
    }
 
 
    public function checkValidity($value, $record_id = null)
    {
        //Don't check empty values
        if ($value == null) {
            return true;
        }
 
        if ($this->isUnique()) {
            $table = ilDclCache::getTableCache($this->getTableId());
            foreach ($table->getRecords() as $record) {
                if ($this->normalizeValue($record->getRecordFieldValue($this->getId())) == $this->normalizeValue($value) && ($record->getId() != $record_id || $record_id == 0)) {
                    throw new ilDclInputException(ilDclInputException::UNIQUE_EXCEPTION);
                }
            }
        }
 
        return true;
    }
 
 
    protected function normalizeValue($value)
    {
        if (is_string($value)) {
            $value = trim(preg_replace("/\\s+/uism", " ", $value));
        }
 
        return $value;
    }
 
 
    public function cloneStructure($original_id)
    {
        $original = ilDclCache::getFieldCache($original_id);
        $this->setTitle($original->getTitle());
        $this->setDatatypeId($original->getDatatypeId());
        $this->setDescription($original->getDescription());
        $this->setOrder($original->getOrder());
        $this->setUnique($original->isUnique());
        $this->setExportable($original->getExportable());
        $this->doCreate();
        $this->cloneProperties($original);
 
        // mandatory for all cloning functions
        ilDclCache::setCloneOf($original_id, $this->getId(), ilDclCache::TYPE_FIELD);
    }
 
 
    public function afterClone($records)
    {
        foreach ($records as $rec) {
            ilDclCache::getRecordFieldCache($rec, $this)->afterClone();
        }
    }
 
 
    public function cloneProperties(ilDclBaseFieldModel $originalField)
    {
        $orgProps = $originalField->getValidFieldProperties();
        if (count($orgProps) == 0) {
            return;
        }
        foreach ($orgProps as $prop_name) {
            $fieldprop_obj = new ilDclFieldProperty();
            $fieldprop_obj->setFieldId($this->getId());
            $fieldprop_obj->setName($prop_name);
 
            $value = $originalField->getProperty($prop_name);
 
            // If reference field, we must reset the referenced field, otherwise it will point to the old ID
            if ($originalField->getDatatypeId() == ilDclDatatype::INPUTFORMAT_REFERENCE && $prop_name == ilDclBaseFieldModel::PROP_REFERENCE) {
                $value = null;
            }
 
            $fieldprop_obj->setValue($value);
            $fieldprop_obj->create();
        }
    }
 
 
    public function setExportable($exportable)
    {
        $this->exportable = $exportable;
    }
 
 
    public function allowFilterInListView()
    {
        return true;
    }
 
 
    public function getRecordQuerySortObject($direction = "asc", $sort_by_status = false)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $sql_obj = new ilDclRecordQueryObject();
 
        $select_str = "sort_stloc_{$this->getId()}.value AS field_{$this->getId()}";
        $join_str
            = "LEFT JOIN il_dcl_record_field AS sort_record_field_{$this->getId()} ON (sort_record_field_{$this->getId()}.record_id = record.id AND sort_record_field_{$this->getId()}.field_id = "
            . $ilDB->quote($this->getId(), 'integer') . ") ";
        $join_str .= "LEFT JOIN il_dcl_stloc{$this->getStorageLocation()}_value AS sort_stloc_{$this->getId()} ON (sort_stloc_{$this->getId()}.record_field_id = sort_record_field_{$this->getId()}.id)";
 
        $sql_obj->setSelectStatement($select_str);
        $sql_obj->setJoinStatement($join_str);
        $sql_obj->setOrderStatement("field_{$this->getId()} {$direction}");
 
        return $sql_obj;
    }
 
 
    public function getRecordQueryFilterObject($filter_value = "", ilDclBaseFieldModel $sort_field = null)
    {
        return null;
    }
 
 
    public function getSortField()
    {
        return $this->getTitle();
    }
 
 
    public function hasNumericSorting()
    {
        if ($this->getDatatypeId() == ilDclDatatype::INPUTFORMAT_NUMBER) {
            return true;
        }
 
        return false;
    }
 
 
    public function checkFieldCreationInput(ilPropertyFormGUI $form)
    {
        return true;
    }
 
 
    public function getStorageLocationOverride()
    {
        return $this->storage_location_override;
    }
 
 
    public function setStorageLocationOverride($storage_location_override)
    {
        $this->storage_location_override = $storage_location_override;
    }
 
 
    public function fillHeaderExcel(ilExcel $worksheet, &$row, &$col)
    {
        $worksheet->setCell($row, $col, $this->getTitle());
        $col++;
    }
 
 
    public function checkTitlesForImport(array &$titles, array &$import_fields)
    {
        foreach ($titles as $k => $title) {
            if (!ilStr::isUtf8($title)) {
                $title = utf8_encode($title);
            }
            if ($title == $this->getTitle()) {
                $import_fields[$k] = $this;
            }
        }
    }
 
 
    public function storePropertiesFromForm(ilPropertyFormGUI $form)
    {
        $field_props = $this->getValidFieldProperties();
        foreach ($field_props as $property) {
            $representation = ilDclFieldFactory::getFieldRepresentationInstance($this);
            $value = $form->getInput($representation->getPropertyInputFieldId($property));
 
            // save non empty values and set them to null, when they already exist. Do not override plugin-hook when already set.
            if (!empty($value) || ($this->getPropertyInstance($property) != null && $property != self::PROP_PLUGIN_HOOK_NAME)) {
                $this->setProperty($property, $value)->store();
            }
        }
    }
 
 
    public function fillPropertiesForm(ilPropertyFormGUI &$form)
    {
        $values = array(
            'table_id'      => $this->getTableId(),
            'field_id'      => $this->getId(),
            'title'         => $this->getTitle(),
            'datatype'      => $this->getDatatypeId(),
            'description'   => $this->getDescription(),
            'unique'        => $this->isUnique(),
        );
 
        $properties = $this->getValidFieldProperties();
        foreach ($properties as $prop) {
            $values['prop_' . $prop] = $this->getProperty($prop);
        }
 
        $form->setValuesByArray($values);
 
        return true;
    }
 
 
    public function isConfirmationRequired(ilPropertyFormGUI $form)
    {
        return false;
    }
 
 
    public function getConfirmationGUI(ilPropertyFormGUI $form)
    {
        global $DIC;
        $ilConfirmationGUI = new ilConfirmationGUI();
        $ilConfirmationGUI->setFormAction($form->getFormAction());
        $ilConfirmationGUI->addHiddenItem('confirmed', 1);
        $ilConfirmationGUI->addHiddenItem('field_id', $form->getInput('field_id'));
        $ilConfirmationGUI->addHiddenItem('title', $form->getInput('title'));
        $ilConfirmationGUI->addHiddenItem('description', $form->getInput('description'));
        $ilConfirmationGUI->addHiddenItem('datatype', $form->getInput('datatype'));
        $ilConfirmationGUI->addHiddenItem('unique', $form->getInput('unique'));
        $ilConfirmationGUI->setConfirm($DIC->language()->txt('dcl_update_field'), 'update');
        $ilConfirmationGUI->setCancel($DIC->language()->txt('cancel'), 'edit');
 
        return $ilConfirmationGUI;
    }
}