class.ilDclFieldFactory.php

Go to the documentation of this file.

<?php
 
class ilDclFieldFactory
{
 
    public static $field_base_path_patter = "./Modules/DataCollection/classes/Fields/%s/";
    public static $default_prefix = "ilDcl";
    public static $record_field_class_patter = "%sRecordFieldModel";
    public static $field_class_patter = "%sFieldModel";
    public static $record_class_patter = "%sRecordModel";
    public static $record_representation_class_pattern = "%sRecordRepresentation";
    public static $field_representation_class_pattern = "%sFieldRepresentation";
    protected static $record_field_cache = array();
 
 
    public static function getRecordFieldInstance(ilDclBaseFieldModel $field, ilDclBaseRecordModel $record)
    {
        if (!empty(self::$record_field_cache[$field->getId()][$record->getId()])) {
            return self::$record_field_cache[$field->getId()][$record->getId()];
        }
 
        $path = self::getClassPathByInstance($field, self::$record_field_class_patter);
        if (file_exists($path)) {
            require_once($path);
            $class = self::getClassByInstance($field, self::$record_field_class_patter);
            $instance = new $class($record, $field);
            if ($instance instanceof ilDclBaseRecordFieldModel) {
                if (!$instance->getFieldRepresentation()) {
                    $instance->setFieldRepresentation(self::getFieldRepresentationInstance($field));
                }
 
                if (!$instance->getRecordRepresentation()) {
                    $instance->setRecordRepresentation(self::getRecordRepresentationInstance($instance));
                }
                self::$record_field_cache[$field->getId()][$record->getId()] = $instance;
 
                return $instance;
            }
        }
    }
 
 
    protected static $field_class_cache = array();
 
 
    public static function getFieldClass($datatype, $class_pattern)
    {
        if (!empty(self::$field_class_cache[$datatype . $class_pattern])) {
            return self::$field_class_cache[$datatype . $class_pattern];
        }
 
        $fieldtype = $datatype;
 
        $class = sprintf($class_pattern, $fieldtype);
        self::$field_class_cache[$datatype . $class_pattern] = $class;
 
        return $class;
    }
 
 
    public static function getFieldClassFile($datatype, $class_pattern)
    {
        return "class." . self::getFieldClass($datatype, $class_pattern) . ".php";
    }
 
 
    protected static $field_representation_cache = array();
 
 
    public static function getFieldRepresentationInstance(ilDclBaseFieldModel $field)
    {
        // when the datatype overview is generated no field-models are available, so an empty instance is used => no caching there
        if ($field->getId() != null && !empty(self::$field_representation_cache[$field->getId()])) {
            return self::$field_representation_cache[$field->getId()];
        }
 
        $class_path = self::getClassPathByInstance($field, self::$field_representation_class_pattern);
 
        $instance = null;
        if (file_exists($class_path)) {
            require_once($class_path);
            $class = self::getClassByInstance($field, self::$field_representation_class_pattern);
            $instance = new $class($field);
        } else {
            throw new ilDclException("Path for FieldRepresentation with file " . $class_path . " does not exists!");
        }
 
        if ($instance == null) {
            throw new ilDclException("Could not create FieldRepresentation of " . $class . " with file " . $class_path);
        }
 
        if ($field->getId() != null) {
            self::$field_representation_cache[$field->getId()] = $instance;
        }
 
        return $instance;
    }
 
 
    protected static $record_representation_cache = array();
 
 
    public static function getRecordRepresentationInstance(ilDclBaseRecordFieldModel $record_field)
    {
        // there are some field types which have no recordFieldModel object (e.g rating) => no caching
        if ($record_field->getId() != null && !empty(self::$record_representation_cache[$record_field->getId()])) {
            return self::$record_representation_cache[$record_field->getId()];
        }
 
        $class_path = self::getClassPathByInstance($record_field->getField(), self::$record_representation_class_pattern);
        $instance = null;
 
        if (file_exists($class_path)) {
            require_once($class_path);
            $class = self::getClassByInstance($record_field->getField(), self::$record_representation_class_pattern);
        } else {
            $class = self::getFieldClass(self::$default_prefix . "Base", self::$record_representation_class_pattern);
        }
 
        $instance = new $class($record_field);
 
        if ($instance == null) {
            throw new ilDclException("Could not create RecordRepresentation of " . $class_path . " " . $record_field->getField()->getDatatype()->getTitle());
        }
 
        if ($record_field->getId() != null) {
            self::$record_representation_cache[$record_field->getId()] = $instance;
        }
 
        return $instance;
    }
 
 
    public static function getFieldModelInstance($field_id, $datatype = null)
    {
        $base = new ilDclBaseFieldModel($field_id);
        if ($datatype != null) {
            $base->setDatatypeId($datatype);
        }
 
        $ilDclBaseFieldModel = self::getFieldModelInstanceByClass($base, $field_id);
 
        return $ilDclBaseFieldModel;
    }
 
 
    protected static $field_model_cache = array();
 
 
    public static function getFieldModelInstanceByClass(ilDclBaseFieldModel $field, $field_id = null)
    {
        if ($field->getId() != null && !empty(self::$field_model_cache[$field->getId()])) {
            return self::$field_model_cache[$field->getId()];
        }
 
        $path_type = self::getClassPathByInstance($field, self::$field_class_patter);
 
        if (file_exists($path_type)) {
            require_once($path_type);
            $class = self::getClassByInstance($field, self::$field_class_patter);
        } else {
            $class = self::getFieldClass(self::$default_prefix . "Base", self::$field_class_patter);
        }
 
        if ($field_id) {
            $instance = new $class($field_id);
        } else {
            $instance = new $class();
        }
 
        if ($instance == null) {
            throw new ilDclException("Could not create FieldModel of " . $class);
        }
 
        if ($field->getId() != null) {
            self::$field_model_cache[$field->getId()] = $instance;
        }
 
        return $instance;
    }
 
 
    protected static $field_type_cache = array();
 
 
    public static function getFieldTypeByInstance(ilDclBaseFieldModel $field)
    {
        $datatype = $field->getDatatype();
 
        if (!empty(self::$field_type_cache[$datatype->getId()])) {
            if ($datatype->getId() == ilDclDatatype::INPUTFORMAT_PLUGIN) {
                if (!empty(self::$field_type_cache[$datatype->getId()][$field->getId()])) {
                    return self::$field_type_cache[$datatype->getId()][$field->getId()];
                }
            } else {
                return self::$field_type_cache[$datatype->getId()];
            }
        }
 
        if ($datatype->getId() == ilDclDatatype::INPUTFORMAT_PLUGIN) {
            if ($field->hasProperty(ilDclBaseFieldModel::PROP_PLUGIN_HOOK_NAME)) {
                $plugin_data
                    = ilPlugin::getPluginObject(IL_COMP_MODULE, ilDclFieldTypePlugin::COMPONENT_NAME, ilDclFieldTypePlugin::SLOT_ID, $field->getProperty(ilDclBaseFieldModel::PROP_PLUGIN_HOOK_NAME));
                $fieldtype = $plugin_data->getPluginClassPrefix() . ucfirst($plugin_data->getPluginName());
            } else {
                $fieldtype = self::$default_prefix . ucfirst(self::parseDatatypeTitle($datatype->getTitle()));
            }
            self::$field_type_cache[$datatype->getId()][$field->getId()] = $fieldtype;
        } else {
            $fieldtype = self::$default_prefix . ucfirst(self::parseDatatypeTitle($datatype->getTitle()));
            self::$field_type_cache[$datatype->getId()] = $fieldtype;
        }
 
        return $fieldtype;
    }
 
 
    public static function getClassByInstance(ilDclBaseFieldModel $field, $class_pattern)
    {
        $fieldtype = self::getFieldTypeByInstance($field);
 
        return self::getFieldClass($fieldtype, $class_pattern);
    }
 
 
    protected static $class_path_cache = array();
 
 
    public static function getClassPathByInstance(ilDclBaseFieldModel $field, $class_pattern)
    {
        $datatype = $field->getDatatype();
 
        if ($field->getId() != null && !empty(self::$class_path_cache[$field->getId()][$class_pattern])) {
            return self::$class_path_cache[$field->getId()][$class_pattern];
        }
 
        if ($datatype->getId() == ilDclDatatype::INPUTFORMAT_PLUGIN) {
            if ($field->hasProperty(ilDclBaseFieldModel::PROP_PLUGIN_HOOK_NAME)) {
                $plugin_data
                    = ilPlugin::getPluginObject(IL_COMP_MODULE, ilDclFieldTypePlugin::COMPONENT_NAME, ilDclFieldTypePlugin::SLOT_ID, $field->getProperty(ilDclBaseFieldModel::PROP_PLUGIN_HOOK_NAME));
                if ($plugin_data == null) {
                    throw new ilDclException(
                        "Something went wrong by initializing the FieldHook-Plugin '"
                        . $field->getProperty(ilDclBaseFieldModel::PROP_PLUGIN_HOOK_NAME) . "' on Component '"
                        . ilDclFieldTypePlugin::COMPONENT_NAME . "' with slot '" . ilDclFieldTypePlugin::SLOT_ID . "' on field: "
                        . $field->getTitle()
                    );
                }
 
                $class_path = $plugin_data->getDirectory() . "/classes/";
            } else {
                $class_path = sprintf(self::$field_base_path_patter, ucfirst(self::parseDatatypeTitle($datatype->getTitle())));
            }
        } else {
            $class_path = sprintf(self::$field_base_path_patter, ucfirst(self::parseDatatypeTitle($datatype->getTitle())));
        }
 
        $return = $class_path . self::getFieldClassFile(self::getFieldTypeByInstance($field), $class_pattern);
 
        if ($field->getId() != null) {
            self::$class_path_cache[$field->getId()][$class_pattern] = $return;
        }
 
        return $return;
    }
 
 
    public static function parseDatatypeTitle($title)
    {
        $parts = explode("_", $title);
        $func = function ($value) {
            return ucfirst($value);
        };
 
        $parts = array_map($func, $parts);
        $title = implode("", $parts);
 
        return $title;
    }
 
 
    public static function getRecordModelInstance($record_id)
    {
        return new ilDclBaseRecordModel($record_id);
    }
 
 
    public static function getPluginNameFromFieldModel(ilDclBaseFieldModel $object)
    {
        $class_name = get_class($object);
        $class_name = substr($class_name, 2, -(strlen(self::$field_class_patter) - 2));
 
        return $class_name;
    }
}