class.ilDclBaseFieldModel.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2009 ILIAS open source, Extended GPL, see docs/LICENSE */

require_once('./Modules/DataCollection/classes/Fields/Base/class.ilDclFieldProperty.php');
require_once('./Services/Exceptions/classes/class.ilException.php');
require_once('./Modules/DataCollection/classes/Helpers/class.ilDclCache.php');
require_once('./Modules/DataCollection/classes/Helpers/class.ilDclRecordQueryObject.php');
require_once('./Modules/DataCollection/classes/Table/class.ilDclTableFieldSetting.php');

class ilDclBaseFieldModel {

        protected $id;
        protected $table_id;
        protected $title;
        protected $description;
        protected $datatypeId;
        protected $required;
        protected $order;
        protected $unique;
        protected $locked;
        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";


        // 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 setRequired($a_required) {
                $this->required = $a_required;
        }


        public function getRequired() {
                return $this->required;
        }

        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->setRequired($rec["required"]);
                $this->setUnique($rec["is_unique"]);
                $this->setLocked($rec["is_locked"]);
                $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->setRequired($rec["required"]);
                $this->setUnique($rec["is_unique"]);
                $this->setLocked($rec["is_locked"]);
        }


        public function doCreate() {
                global $DIC;
                $ilDB = $DIC['ilDB'];
                $this->getLocked() == NULL ? $this->setLocked(false) : true;

                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" . ", required" . ", is_unique"
                        . ", is_locked" . " ) 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->getRequired(), "integer") . ","
                        . $ilDB->quote($this->isUnique(), "integer") . "," . $ilDB->quote($this->getLocked() ? 1 : 0, "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()
                        ),
                        "required" => array(
                                "integer",
                                $this->getRequired()
                        ),
                        "is_unique" => array(
                                "integer",
                                $this->isUnique()
                        ),
                        "is_locked" => array(
                                "integer",
                                $this->getLocked() ? 1 : 0
                        ),
                ), 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->getFieldSettings() as $field_setting)
                {
                        $field_setting->delete();
                }
        }

        public function getFieldSettings() {
                return ilDclTableViewFieldSetting::where(array('field' => $this->getId()))->get();
        }

        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 setLocked($locked) {
                $this->locked = $locked;
        }


        public function getLocked() {
                return $this->locked;
        }


        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->setLocked($original->getLocked());
                $this->setOrder($original->getOrder());
                $this->setRequired($original->getRequired());
                $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;
                        }
                }
        }
}