class.ilDclCache.php

Go to the documentation of this file.

<?php
require_once('./Modules/DataCollection/classes/Fields/Reference/class.ilDclReferenceRecordFieldModel.php');
require_once('./Modules/DataCollection/classes/Fields/Rating/class.ilDclRatingRecordFieldModel.php');
require_once('./Modules/DataCollection/classes/Fields/IliasReference/class.ilDclIliasReferenceRecordFieldModel.php');
require_once('./Modules/DataCollection/classes/Fields/Formula/class.ilDclFormulaRecordFieldModel.php');
require_once('./Modules/DataCollection/classes/Fields/Text/class.ilDclTextRecordFieldModel.php');
require_once('./Modules/DataCollection/classes/Fields/NReference/class.ilDclNReferenceRecordFieldModel.php');
require_once('./Modules/DataCollection/classes/Fields/class.ilDclFieldFactory.php');
 
class ilDclCache {
 
        const TYPE_DATACOLLECTION = 'dcl';
        const TYPE_TABLE = 'table';
        const TYPE_FIELD = 'field';
        const TYPE_RECORD = 'record';
        const TYPE_TABLEVIEW = 'tableview';
 
        protected static $tables_cache;
        protected static $fields_cache;
        protected static $records_cache;
        protected static $record_field_cache;
 
        protected static $field_representation_cache;
 
        protected static $record_representation_cache;
        protected static $field_properties_cache;
 
        protected static $datatype_cache;
 
        protected static $clone_mapping;
 
        public static function setCloneOf($old, $new, $type) {
                if (!self::$clone_mapping) {
                        self::initCloneMapping();
                }
                self::$clone_mapping[$type][$old] = $new;
        }
 
        protected static function initCloneMapping() {
                self::$clone_mapping = array(
                        self::TYPE_DATACOLLECTION => array(),
                        self::TYPE_TABLE => array(),
                        self::TYPE_FIELD => array(),
                        self::TYPE_RECORD => array(),
                        self::TYPE_TABLEVIEW => array(),
                );
        }
 
        public static function getCloneOf($id, $type) {
                $type_cache = self::$clone_mapping[$type];
                if (!is_array($type_cache)) {
                        return false;
                }
 
                if (isset($type_cache[$id])) {
                        $clone_id = $type_cache[$id];
                } else {
                        foreach ($type_cache as $key => $mapping) {
                                if ($mapping == $id) {
                                        $clone_id = $key;
                                }
                        }
                }
 
                if (!$clone_id) {
                        return false;
                }
 
 
                switch ($type) {
                        case self::TYPE_DATACOLLECTION:
                                return new ilObjDataCollection($clone_id);
                        case self::TYPE_FIELD:
                                return self::getFieldCache($clone_id);
                        case self::TYPE_TABLE:
                                return self::getTableCache($clone_id);
                        case self::TYPE_RECORD:
                                return self::getRecordCache($clone_id);
                }
        }
 
        public static function getTableCache($table_id = 0) {
                if ($table_id == 0) {
                        return new ilDclTable();
                }
                $tables_cache = &self::$tables_cache;
                if (!isset($tables_cache[$table_id])) {
                        $tables_cache[$table_id] = new ilDclTable($table_id);
                }
 
                return $tables_cache[$table_id];
        }
 
 
        public static function getFieldCache($field_id = 0) {
                $fields_cache = &self::$fields_cache;
                if (!isset($fields_cache[$field_id])) {
                        $fields_cache[$field_id] = ilDclFieldFactory::getFieldModelInstance($field_id);
                }
 
                return $fields_cache[$field_id];
        }
 
 
        public static function getRecordCache($record_id = 0) {
                $records_cache = &self::$records_cache;
                if (!isset($records_cache[$record_id])) {
                        $records_cache[$record_id] = ilDclFieldFactory::getRecordModelInstance($record_id);
                }
 
                return $records_cache[$record_id];
        }
 
 
        public static function getRecordFieldCache($record, $field) {
                $fid = $field->getId();
                $rid = $record->getId();
                if (!isset(self::$record_field_cache[$rid])) {
                        self::$record_field_cache[$rid] = array();
                        self::$record_field_cache[$rid][$fid] = ilDclFieldFactory::getRecordFieldInstance($field, $record);
                } elseif (!isset(self::$record_field_cache[$rid][$fid])) {
                        self::$record_field_cache[$rid][$fid] = ilDclFieldFactory::getRecordFieldInstance($field, $record);
                }
 
                return self::$record_field_cache[$rid][$fid];
        }
 
 
        public static function getFieldRepresentation(ilDclBaseFieldModel $field) {
                if(!isset(self::$field_representation_cache[$field->getId()])) {
                        self::$field_representation_cache[$field->getId()] = ilDclFieldFactory::getFieldRepresentationInstance($field);
                }
                return self::$field_representation_cache[$field->getId()];
        }
 
 
        public static function getRecordRepresentation(ilDclBaseRecordFieldModel $record_field) {
                if($record_field == null) {
                        throw new ilDclException("Cannot get Representation of null object!");
                }
 
                if(!isset(self::$record_representation_cache[$record_field->getId()])) {
                        self::$record_representation_cache[$record_field->getId()] = ilDclFieldFactory::getRecordRepresentationInstance($record_field);
                }
                return self::$record_representation_cache[$record_field->getId()];
        }
 
 
        public static function getFieldProperties($field_id) {
                if(!isset(self::$field_properties_cache[$field_id])) {
                        self::$field_properties_cache[$field_id] = array();
                        $result = ilDclFieldProperty::where(array('field_id'=>$field_id))->get();
                        foreach($result as $prop) {
                                self::$field_properties_cache[$field_id][$prop->getName()] = $prop;
                        }
                }
                return self::$field_properties_cache[$field_id];
        }
 
 
        public static function preloadFieldProperties(array $fields) {
                foreach($fields as $field_key => $field) {
                        if(isset(self::$field_properties_cache[$field->getId()])) {
                                unset($fields[$field_key]);
                        }
                }
 
                if(count($fields) > 0) {
                        $field_ids = array();
                        foreach ($fields as $field) {
                                $field_ids[] = $field->getId();
                        }
                        $result = ilDclFieldProperty::where(array('field_id'=>$field_ids), 'IN')->get();
                        foreach($result as $prop) {
                                if(!isset(self::$field_properties_cache[$prop->getFieldId()])) {
                                        self::$field_properties_cache[$prop->getFieldId()] = array();
                                }
                                self::$field_properties_cache[$prop->getFieldId()][$prop->getName()] = $prop;
                        }
                }
        }
 
 
        public static function getDatatype($datatyp_id) {
                if(self::$datatype_cache == NULL) {
                        self::$datatype_cache = ilDclDatatype::getAllDatatype();
                }
 
                if(!isset(self::$datatype_cache[$datatyp_id])) {
                        return new ilDclDatatype();
                }
                return self::$datatype_cache[$datatyp_id];
        }
 
 
        public static function buildFieldFromRecord($rec) {
                $fields_cache = &self::$fields_cache;
                if (isset($fields_cache[$rec["id"]])) {
                        return $fields_cache[$rec["id"]];
                }
                $field = ilDclFieldFactory::getFieldModelInstanceByClass(new ilDclBaseFieldModel($rec['id']));
                $field->setId($rec["id"]);
                $field->setTableId($rec["table_id"]);
                $field->setTitle($rec["title"]);
                $field->setDescription($rec["description"]);
                $field->setDatatypeId($rec["datatype_id"]);
                $field->setRequired($rec["required"]);
                $field->setUnique($rec["is_unique"]);
                $field->setLocked($rec["is_locked"]);
                $fields_cache[$rec["id"]] = $field;
 
                return $field;
        }
 
 
        public static function resetCache() {
                self::$fields_cache = array();
                self::$record_field_cache = array();
                self::$records_cache = array();
        }
}