class.ilDclTable.php

Go to the documentation of this file.

<?php

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

include_once './Modules/DataCollection/classes/Fields/Base/class.ilDclStandardField.php';
include_once './Modules/DataCollection/classes/Fields/Base/class.ilDclBaseRecordModel.php';
include_once './Modules/DataCollection/classes/TableView/class.ilDclTableView.php';

class ilDclTable
{

    protected $id = 0;
    protected $objId;
    protected $obj;
    protected $title;
    protected $fields;
    protected $stdFields;
    protected $records;
    protected $is_visible;
    protected $add_perm;
    protected $edit_perm;
    protected $delete_perm;
    protected $edit_by_owner;
    protected $delete_by_owner;
    protected $save_confirmation;
    protected $limited;
    protected $limit_start;
    protected $limit_end;
    protected $export_enabled;
    protected $table_order;
    protected $import_enabled;
    protected $default_sort_field = 0;
    protected $default_sort_field_order = 'asc';
    protected $description = '';
    protected $public_comments = 0;
    protected $view_own_records_perm = 0;

    protected $all_fields = null;


    public function __construct($a_id = 0)
    {
        if ($a_id != 0) {
            $this->id = $a_id;
            $this->doRead();
        }
    }


    public function doRead()
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];

        $query = "SELECT * FROM il_dcl_table WHERE id = " . $ilDB->quote($this->getId(), "integer");
        $set = $ilDB->query($query);
        $rec = $ilDB->fetchAssoc($set);

        $this->setObjId($rec["obj_id"]);
        $this->setTitle($rec["title"]);
        $this->setAddPerm($rec["add_perm"]);
        $this->setEditPerm($rec["edit_perm"]);
        $this->setDeletePerm($rec["delete_perm"]);
        $this->setEditByOwner($rec["edit_by_owner"]);
        $this->setExportEnabled($rec["export_enabled"]);
        $this->setImportEnabled($rec["import_enabled"]);
        $this->setLimited($rec["limited"]);
        $this->setLimitStart($rec["limit_start"]);
        $this->setLimitEnd($rec["limit_end"]);
        $this->setIsVisible($rec["is_visible"]);
        $this->setDescription($rec['description']);
        $this->setDefaultSortField($rec['default_sort_field_id']);
        $this->setDefaultSortFieldOrder($rec['default_sort_field_order']);
        $this->setPublicCommentsEnabled($rec['public_comments']);
        $this->setViewOwnRecordsPerm($rec['view_own_records_perm']);
        $this->setDeleteByOwner($rec['delete_by_owner']);
        $this->setSaveConfirmation($rec['save_confirmation']);
        $this->setOrder($rec['table_order']);
    }


    public function doDelete($delete_only_content = false, $omit_notification = false)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];

        foreach ($this->getRecords() as $record) {
            $record->doDelete($omit_notification);
        }

        foreach ($this->getRecordFields() as $field) {
            $field->doDelete();
        }

        //              // SW: Fix #12794 und #11405
        //              // Problem is that when the DC object gets deleted, $this::getCollectionObject() tries to load the DC but it's not in the DB anymore
        //              // If $delete_main_table is true, avoid getting the collection object
        //              $exec_delete = false;
        //              if ($delete_main_table) {
        //                      $exec_delete = true;
        //              }
        //              if (!$exec_delete && $this->getCollectionObject()->getFirstVisibleTableId() != $this->getId()) {
        //                      $exec_delete = true;
        //              }
        if (!$delete_only_content) {
            $query = "DELETE FROM il_dcl_table WHERE id = " . $ilDB->quote($this->getId(), "integer");
            $ilDB->manipulate($query);
        }
    }


    public function doCreate($create_tablefield_setting = true, $create_standardview = true)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];

        $id = $ilDB->nextId("il_dcl_table");
        $this->setId($id);
        $query = "INSERT INTO il_dcl_table (" . "id" . ", obj_id" . ", title" . ", add_perm" . ", edit_perm" . ", delete_perm" . ", edit_by_owner"
            . ", limited" . ", limit_start" . ", limit_end" . ", is_visible" . ", export_enabled" . ", import_enabled" . ", default_sort_field_id"
            . ", default_sort_field_order" . ", description" . ", public_comments" . ", view_own_records_perm"
            . ", delete_by_owner, save_confirmation , table_order ) VALUES (" . $ilDB->quote($this->getId(), "integer") . ","
            . $ilDB->quote($this->getObjId(), "integer") . "," . $ilDB->quote($this->getTitle(), "text") . ","
            . $ilDB->quote($this->getAddPerm() ? 1 : 0, "integer") . "," . $ilDB->quote($this->getEditPerm() ? 1 : 0, "integer") . ","
            . $ilDB->quote($this->getDeletePerm() ? 1 : 0, "integer") . "," . $ilDB->quote($this->getEditByOwner() ? 1 : 0, "integer") . ","
            . $ilDB->quote($this->getLimited() ? 1 : 0, "integer") . "," . $ilDB->quote($this->getLimitStart(), "timestamp") . ","
            . $ilDB->quote($this->getLimitEnd(), "timestamp") . "," . $ilDB->quote($this->getIsVisible() ? 1 : 0, "integer") . ","
            . $ilDB->quote($this->getExportEnabled() ? 1 : 0, "integer") . "," . $ilDB->quote($this->getImportEnabled() ? 1 : 0, "integer") . ","
            . $ilDB->quote($this->getDefaultSortField(), "text") . "," . $ilDB->quote($this->getDefaultSortFieldOrder(), "text") . ","
            . $ilDB->quote($this->getDescription(), "text") . "," . $ilDB->quote($this->getPublicCommentsEnabled(), "integer") . ","
            . $ilDB->quote($this->getViewOwnRecordsPerm(), "integer") . "," . $ilDB->quote($this->getDeleteByOwner() ? 1 : 0, 'integer') . ","
            . $ilDB->quote($this->getSaveConfirmation() ? 1 : 0, 'integer') . "," . $ilDB->quote($this->getOrder(), 'integer') . ")";

        $ilDB->manipulate($query);

        if ($create_standardview) {
            //standard tableview
            ilDclTableView::createOrGetStandardView($this->id);
        }

        if ($create_tablefield_setting) {
            $this->buildOrderFields();
        }
    }

    /*
     * doUpdate
     */
    public function doUpdate()
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];

        $ilDB->update("il_dcl_table", array(
            "obj_id" => array( "integer", $this->getObjId() ),
            "title" => array( "text", $this->getTitle() ),
            "add_perm" => array( "integer", (int) $this->getAddPerm() ),
            "edit_perm" => array( "integer", (int) $this->getEditPerm() ),
            "delete_perm" => array( "integer", (int) $this->getDeletePerm() ),
            "edit_by_owner" => array( "integer", (int) $this->getEditByOwner() ),
            "limited" => array( "integer", $this->getLimited() ),
            "limit_start" => array( "timestamp", $this->getLimitStart() ),
            "limit_end" => array( "timestamp", $this->getLimitEnd() ),
            "is_visible" => array( "integer", $this->getIsVisible() ? 1 : 0 ),
            "export_enabled" => array( "integer", $this->getExportEnabled() ? 1 : 0 ),
            "import_enabled" => array( "integer", $this->getImportEnabled() ? 1 : 0 ),
            "description" => array( "text", $this->getDescription() ),
            "default_sort_field_id" => array( "text", $this->getDefaultSortField() ),
            "default_sort_field_order" => array( "text", $this->getDefaultSortFieldOrder() ),
            "public_comments" => array( "integer", $this->getPublicCommentsEnabled() ? 1 : 0 ),
            "view_own_records_perm" => array( "integer", $this->getViewOwnRecordsPerm() ),
            'delete_by_owner' => array( 'integer', $this->getDeleteByOwner() ? 1 : 0 ),
            'save_confirmation' => array( 'integer', $this->getSaveConfirmation() ? 1 : 0 ),
            'table_order' => array( 'integer', $this->getOrder() ),
        ), array(
            "id" => array( "integer", $this->getId() )
        ));
    }


    public function setId($a_id)
    {
        $this->id = $a_id;
    }


    public function getId()
    {
        return $this->id;
    }


    public function setObjId($a_id)
    {
        $this->objId = $a_id;
    }


    public function getObjId()
    {
        return $this->objId;
    }


    public function setTitle($a_title)
    {
        $this->title = $a_title;
    }


    public function getTitle()
    {
        return $this->title;
    }


    public function getCollectionObject()
    {
        $this->loadObj();

        return $this->obj;
    }


    protected function loadObj()
    {
        if ($this->obj == null) {
            $this->obj = new ilObjDataCollection($this->objId, false);
        }
    }


    public function getRecords()
    {
        if ($this->records == null) {
            $this->loadRecords();
        }

        return $this->records;
    }

    public function loadRecords()
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];

        $records = array();
        $query = "SELECT id FROM il_dcl_record WHERE table_id = " . $ilDB->quote($this->id, "integer");
        $set = $ilDB->query($query);

        while ($rec = $ilDB->fetchAssoc($set)) {
            $records[$rec['id']] = ilDclCache::getRecordCache($rec['id']);
        }

        $this->records = $records;
    }

    public function deleteField($field_id)
    {
        $field = ilDclCache::getFieldCache($field_id);
        $records = $this->getRecords();

        foreach ($records as $record) {
            $record->deleteField($field_id);
        }

        $field->doDelete();
    }


    public function getField($field_id)
    {
        $fields = $this->getFields();
        $field = null;
        foreach ($fields as $field_1) {
            if ($field_1->getId() == $field_id) {
                $field = $field_1;
            }
        }

        return $field;
    }

    public function getFieldIds()
    {
        $field_ids = array();
        foreach ($this->getFields() as $field) {
            if ($field->getId()) {
                $field_ids[] = $field->getId();
            }
        }
        return $field_ids;
    }


    protected function loadCustomFields()
    {
        if (!$this->fields) {
            global $DIC;
            $ilDB = $DIC['ilDB'];
            $query = "SELECT DISTINCT il_dcl_field.*, il_dcl_tfield_set.field_order
                                                    FROM il_dcl_field
                                                         INNER JOIN il_dcl_tfield_set
                                                            ON (    il_dcl_tfield_set.field NOT IN ('owner',
                                                                                                    'last_update',
                                                                                                    'last_edit_by',
                                                                                                    'id',
                                                                                                    'create_date')
                                                                AND il_dcl_tfield_set.table_id = il_dcl_field.table_id
                                                                AND il_dcl_tfield_set.field = " . $ilDB->cast("il_dcl_field.id", "text") . ")
                                                   WHERE il_dcl_field.table_id = %s
                                                ORDER BY il_dcl_tfield_set.field_order ASC";

            $set = $ilDB->queryF($query, array('integer'), array((int) $this->getId()));
            $fields = array();
            while ($rec = $ilDB->fetchAssoc($set)) {
                $field = ilDclCache::buildFieldFromRecord($rec);
                $fields[] = $field;
            }
            $this->fields = $fields;

            ilDclCache::preloadFieldProperties($fields);
        }
    }

    public function getCustomFields()
    {
        if (!$this->fields) {
            $this->loadCustomFields();
        }
        return $this->fields;
    }


    public function getNewFieldOrder()
    {
        $fields = $this->getFields();
        $place = 0;
        foreach ($fields as $field) {
            if (!$field->isStandardField()) {
                $place = $field->getOrder() + 1;
            }
        }

        return $place;
    }

    public function getNewTableviewOrder()
    {
        return (ilDclTableView::getCountForTableId($this->getId()) + 1) * 10;
    }

    public function sortTableViews(array $tableviews = null)
    {
        if ($tableviews == null) {
            $tableviews = $this->getTableViews();
        }

        $order = 10;
        foreach ($tableviews as $tableview) {
            $tableview->setTableviewOrder($order);
            $tableview->update();
            $order += 10;
        }
    }


    public function getFields()
    {
        if ($this->all_fields == null) {
            $this->reloadFields();
        }

        return $this->all_fields;
    }

    public function reloadFields()
    {
        $this->loadCustomFields();
        $this->stdFields = $this->getStandardFields();
        $fields = array_merge($this->fields, $this->stdFields);

        $this->sortByOrder($fields);

        $this->all_fields = $fields;
    }

    public function getTableViews()
    {
        return ilDclTableView::getAllForTableId($this->getId());
    }

    public function getVisibleTableViews($ref_id, $with_active_detailedview = false, $user_id = 0)
    {
        if (ilObjDataCollectionAccess::hasWriteAccess($ref_id, $user_id) && !$with_active_detailedview) {
            return $this->getTableViews();
        }

        $visible_views = array();
        foreach ($this->getTableViews() as $tableView) {
            if (ilObjDataCollectionAccess::hasAccessToTableView($tableView, $user_id)) {
                if (!$with_active_detailedview || ilDclDetailedViewDefinition::isActive($tableView->getId())) {
                    $visible_views[] = $tableView;
                }
            }
        }
        return $visible_views;
    }

    public function getFirstTableViewId($ref_id, $user_id = 0)
    {
        $tableview = array_shift($this->getVisibleTableViews($ref_id, false, $user_id));
        return $tableview ? $tableview->getId() : false;
    }
    
    public function getFieldsForFormula()
    {
        $unsupported = array(
            ilDclDatatype::INPUTFORMAT_ILIAS_REF,
            ilDclDatatype::INPUTFORMAT_FORMULA,
            ilDclDatatype::INPUTFORMAT_MOB,
            ilDclDatatype::INPUTFORMAT_BOOLEAN,
            ilDclDatatype::INPUTFORMAT_REFERENCELIST,
            ilDclDatatype::INPUTFORMAT_REFERENCE,
            ilDclDatatype::INPUTFORMAT_FILE,
            ilDclDatatype::INPUTFORMAT_RATING,
        );

        $this->loadCustomFields();
        $return = $this->getStandardFields();
        foreach ($this->fields as $field) {
            if (!in_array($field->getDatatypeId(), $unsupported)) {
                $return[] = $field;
            }
        }

        return $return;
    }


    public function getStandardFields()
    {
        if ($this->stdFields == null) {
            $this->stdFields = ilDclStandardField::_getStandardFields($this->id);
            // Don't return comments as field if this feature is not activated in the settings
            if (!$this->getPublicCommentsEnabled()) {
                foreach ($this->stdFields as $k => $field) {
                    if ($field->getId() == 'comments') {
                        unset($this->stdFields[$k]);
                        break;
                    }
                }
            }
        }

        return $this->stdFields;
    }


    public function getRecordFields()
    {
        $this->loadCustomFields();

        return $this->fields;
    }

    public function getEditableFields()
    {
        $fields = $this->getRecordFields();
        $editableFields = array();

        foreach ($fields as $field) {
            if (!$field->getLocked()) {
                $editableFields[] = $field;
            }
        }

        return $editableFields;
    }

    public function getExportableFields()
    {
        $fields = $this->getFields();
        $exportableFields = array();
        foreach ($fields as $field) {
            if ($field->getExportable()) {
                $exportableFields[] = $field;
            }
        }

        return $exportableFields;
    }


    public function hasPermissionToEditRecord($ref_id, ilDclBaseRecordModel $record)
    {
        if ($this->getObjId() != ilObjDataCollection::_lookupObjectId($ref_id)) {
            return false;
        }
        if (ilObjDataCollectionAccess::hasWriteAccess($ref_id) || ilObjDataCollectionAccess::hasEditAccess($ref_id)) {
            return true;
        }
        if (!ilObjDataCollectionAccess::hasAddRecordAccess($ref_id)) {
            return false;
        }
        if (!$this->checkLimit()) {
            return false;
        }
        if ($this->getEditPerm() && !$this->getEditByOwner()) {
            return true;
        }
        if ($this->getEditByOwner()) {
            return $this->doesRecordBelongToUser($record);
        }

        return false;
    }


    public function hasPermissionToDeleteRecord($ref_id, ilDclBaseRecordModel $record)
    {
        if ($this->getObjId() != ilObjDataCollection::_lookupObjectId($ref_id)) {
            return false;
        }
        if (ilObjDataCollectionAccess::hasWriteAccess($ref_id)) {
            return true;
        }
        if (!ilObjDataCollectionAccess::hasAddRecordAccess($ref_id)) {
            return false;
        }
        if (!$this->checkLimit()) {
            return false;
        }
        if ($this->getDeletePerm() && !$this->getDeleteByOwner()) {
            return true;
        }
        if ($this->getDeleteByOwner()) {
            return $this->doesRecordBelongToUser($record);
        }

        return false;
    }


    public function hasPermissionToDeleteRecords($ref_id)
    {
        if ($this->getObjId() != ilObjDataCollection::_lookupObjectId($ref_id)) {
            return false;
        }
        return ((ilObjDataCollectionAccess::hasAddRecordAccess($ref_id) && $this->getDeletePerm())
            || ilObjDataCollectionAccess::hasWriteAccess($ref_id));
    }


    public function hasPermissionToViewRecord($ref_id, $record, $user_id = 0)
    {
        global $DIC;
        $ilUser = $DIC['ilUser'];
        if ($this->getObjId() != ilObjDataCollection::_lookupObjectId($ref_id)) {
            return false;
        }
        if (ilObjDataCollectionAccess::hasWriteAccess($ref_id, $user_id) || ilObjDataCollectionAccess::hasEditAccess($ref_id, $user_id)) {
            return true;
        }
        if (ilObjDataCollectionAccess::hasReadAccess($ref_id)) {
            // Check for view only own entries setting
            if ($this->getViewOwnRecordsPerm() && ($user_id ? $user_id : $ilUser->getId()) != $record->getOwner()) {
                return false;
            }

            return true;
        }

        return false;
    }


    protected function doesRecordBelongToUser(ilDclBaseRecordModel $record)
    {
        global $DIC;
        $ilUser = $DIC['ilUser'];

        return ($ilUser->getId() == $record->getOwner());
    }


    public function checkLimit()
    {
        if ($this->getLimited()) {
            $now = new ilDateTime(date("Y-m-d H:i:s"), IL_CAL_DATE);
            $from = new ilDateTime($this->getLimitStart(), IL_CAL_DATE);
            $to = new ilDateTime($this->getLimitEnd(), IL_CAL_DATE);

            return ($from <= $now && $now <= $to);
        }

        return true;
    }


    public function updateFields()
    {
        foreach ($this->getFields() as $field) {
            $field->doUpdate();
        }
    }
    
    public function sortFields(&$fields)
    {
        $this->sortByOrder($fields);
        //After sorting the array loses it's keys respectivly their keys are set form $field->id to 1,2,3... so we reset the keys.
        $named = array();
        foreach ($fields as $field) {
            $named[$field->getId()] = $field;
        }

        $fields = $named;
    }


    protected function sortByOrder(&$array)
    {
        // php-bug: https://bugs.php.net/bug.php?id=50688
        // fixed in php 7 but for now we need the @ a workaround
        @usort($array, array( $this, "compareOrder" ));
    }


    public function buildOrderFields()
    {
        $fields = $this->getFields();
        $this->sortByOrder($fields);
        $count = 10;
        $offset = 10;
        foreach ($fields as $field) {
            if (!is_null($field->getOrder())) {
                $field->setOrder($count);
                $count = $count + $offset;
                $field->doUpdate();
            }
        }
    }


    public function getFieldByTitle($title)
    {
        $return = null;
        foreach ($this->getFields() as $field) {
            if ($field->getTitle() == $title) {
                $return = $field;
                break;
            }
        }

        return $return;
    }


    public function setAddPerm($add_perm)
    {
        $this->add_perm = $add_perm;
    }


    public function getAddPerm()
    {
        return (bool) $this->add_perm;
    }


    public function setDeletePerm($delete_perm)
    {
        $this->delete_perm = $delete_perm;
        if (!$delete_perm) {
            $this->setDeleteByOwner(false);
        }
    }


    public function getDeletePerm()
    {
        return (bool) $this->delete_perm;
    }


    public function setEditByOwner($edit_by_owner)
    {
        $this->edit_by_owner = $edit_by_owner;
        if ($edit_by_owner) {
            $this->setEditPerm(true);
        }
    }


    public function getEditByOwner()
    {
        return (bool) $this->edit_by_owner;
    }


    public function getDeleteByOwner()
    {
        return (bool) $this->delete_by_owner;
    }


    public function setDeleteByOwner($delete_by_owner)
    {
        $this->delete_by_owner = $delete_by_owner;
        if ($delete_by_owner) {
            $this->setDeletePerm(true);
        }
    }


    public function setEditPerm($edit_perm)
    {
        $this->edit_perm = $edit_perm;
        if (!$edit_perm) {
            $this->setEditByOwner(false);
        }
    }


    public function getEditPerm()
    {
        return (bool) $this->edit_perm;
    }


    public function setLimited($limited)
    {
        $this->limited = $limited;
    }


    public function getLimited()
    {
        return $this->limited;
    }


    public function setLimitEnd($limit_end)
    {
        $this->limit_end = $limit_end;
    }


    public function getLimitEnd()
    {
        return $this->limit_end;
    }


    public function setLimitStart($limit_start)
    {
        $this->limit_start = $limit_start;
    }


    public function getLimitStart()
    {
        return $this->limit_start;
    }


    public function setIsVisible($is_visible)
    {
        $this->is_visible = $is_visible;
    }


    public function getIsVisible()
    {
        return $this->is_visible;
    }


    public function setDescription($description)
    {
        $this->description = $description;
    }


    public function getDescription()
    {
        return $this->description;
    }


    public function setDefaultSortField($default_sort_field)
    {
        $default_sort_field = ($default_sort_field) ? $default_sort_field : 0; // Change null or empty strings to zero
        $this->default_sort_field = $default_sort_field;
    }


    public function getDefaultSortField()
    {
        return $this->default_sort_field;
    }


    public function setDefaultSortFieldOrder($default_sort_field_order)
    {
        if (!in_array($default_sort_field_order, array( 'asc', 'desc' ))) {
            $default_sort_field_order = 'asc';
        }
        $this->default_sort_field_order = $default_sort_field_order;
    }


    public function getDefaultSortFieldOrder()
    {
        return $this->default_sort_field_order;
    }


    public function setPublicCommentsEnabled($public_comments)
    {
        $this->public_comments = $public_comments;
    }


    public function getPublicCommentsEnabled()
    {
        return $this->public_comments;
    }


    public function setViewOwnRecordsPerm($view_own_perm)
    {
        $this->view_own_records_perm = (int) $view_own_perm;
    }


    public function getViewOwnRecordsPerm()
    {
        return (bool) $this->view_own_records_perm;
    }


    public function getSaveConfirmation()
    {
        return $this->save_confirmation;
    }


    public function setSaveConfirmation($save_confirmation)
    {
        $this->save_confirmation = $save_confirmation;
    }


    public function hasCustomFields()
    {
        $this->loadCustomFields();

        return (count($this->fields) > 0) ? true : false;
    }


    public function compareOrder($a, $b)
    {
        if (is_null($a->getOrder() == null) && is_null($b->getOrder() == null)) {
            return 0;
        }
        if (is_null($a->getOrder())) {
            return 1;
        }
        if (is_null($b->getOrder())) {
            return -1;
        }

        return $a->getOrder() < $b->getOrder() ? -1 : 1;
    }


    public function cloneStructure(ilDclTable $original)
    {
        $this->setTitle($original->getTitle());
        $this->setDescription($original->getDescription());
        $this->setIsVisible($original->getIsVisible());
        $this->setEditByOwner($original->getEditByOwner());
        $this->setAddPerm($original->getAddPerm());
        $this->setEditPerm($original->getEditPerm());
        $this->setDeleteByOwner($original->getDeleteByOwner());
        $this->setSaveConfirmation($original->getSaveConfirmation());
        $this->setDeletePerm($original->getDeletePerm());
        $this->setLimited($original->getLimited());
        $this->setLimitStart($original->getLimitStart());
        $this->setLimitEnd($original->getLimitEnd());
        $this->setViewOwnRecordsPerm($original->getViewOwnRecordsPerm());
        $this->setExportEnabled($original->getExportEnabled());
        $this->setImportEnabled($original->getImportEnabled());
        $this->setPublicCommentsEnabled($original->getPublicCommentsEnabled());
        $this->setDefaultSortFieldOrder($original->getDefaultSortFieldOrder());
        $this->setOrder($original->getOrder());

        $this->doCreate(true, false);
        // reset stdFields to get new for the created object

        $default_sort_field = 0;
        // Clone standard-fields
        $org_std_fields = $original->getStandardFields();
        foreach ($this->getStandardFields() as $element_key => $std_field) {
            $std_field->cloneStructure($org_std_fields[$element_key]);
            if ($std_field->getId() === $original->getDefaultSortField()) {
                $default_sort_field = $std_field->getId();
            }
        }

        // Clone fields
        $new_fields = array();
        foreach ($original->getFields() as $orig_field) {
            if (!$orig_field->isStandardField()) {
                $class_name = get_class($orig_field);
                $new_field = new $class_name();
                $new_field->setTableId($this->getId());
                $new_field->cloneStructure($orig_field->getId());
                $new_fields[$orig_field->getId()] = $new_field;

                if ($orig_field->getId() === $original->getDefaultSortField()) {
                    $default_sort_field = $new_field->getId();
                }
            }
        }

        $this->setDefaultSortField($default_sort_field);
        $this->doUpdate();

        // Clone Records with recordfields
        foreach ($original->getRecords() as $orig_record) {
            $new_record = new ilDclBaseRecordModel();
            $new_record->setTableId($this->getId());
            $new_record->cloneStructure($orig_record->getId(), $new_fields);
        }

        //clone tableviews (includes pageobjects)
        foreach ($original->getTableViews() as $orig_tableview) {
            $new_tableview = new ilDclTableView();
            $new_tableview->setTableId($this->getId());
            $new_tableview->cloneStructure($orig_tableview, $new_fields);
        }

        // mandatory for all cloning functions
        ilDclCache::setCloneOf($original->getId(), $this->getId(), ilDclCache::TYPE_TABLE);
    }


    public function afterClone()
    {
        foreach ($this->getFields() as $field) {
            $field->afterClone($this->getRecords());
        }
    }


    public function _hasRecords()
    {
        return (count($this->getRecords()) > 0) ? true : false;
    }


    public function addField($field)
    {
        $this->all_fields[$field->getId()] = $field;
    }


    public static function _tableExists($table_id)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $query = "SELECT * FROM il_dcl_table WHERE id = " . $table_id;
        $result = $ilDB->query($query);

        return $result->numRows() != 0;
    }


    public static function _getTableIdByTitle($title, $obj_id)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $result = $ilDB->query('SELECT id FROM il_dcl_table WHERE title = ' . $ilDB->quote($title, 'text') . ' AND obj_id = '
            . $ilDB->quote($obj_id, 'integer'));
        $id = 0;
        while ($rec = $ilDB->fetchAssoc($result)) {
            $id = $rec['id'];
        }

        return $id;
    }

    public function setExportEnabled($export_enabled)
    {
        $this->export_enabled = $export_enabled;
    }


    public function getExportEnabled()
    {
        return $this->export_enabled;
    }

    public function getOrder()
    {
        if (!$this->table_order) {
            $this->updateOrder();
        }
        return $this->table_order;
    }

    public function updateOrder()
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $result = $ilDB->query('SELECT MAX(table_order) AS table_order FROM il_dcl_table WHERE obj_id = ' . $ilDB->quote($this->getCollectionObject()->getId(), 'integer'));
        $this->table_order = $ilDB->fetchObject($result)->table_order + 10;
        $ilDB->query('UPDATE il_dcl_table SET table_order = ' . $ilDB->quote($this->table_order, 'integer') . ' WHERE id = ' . $ilDB->quote($this->getId(), 'integer'));
    }

    public function setOrder($table_order)
    {
        $this->table_order = $table_order;
    }


    public function setImportEnabled($import_enabled)
    {
        $this->import_enabled = $import_enabled;
    }


    public function getImportEnabled()
    {
        return $this->import_enabled;
    }


    public static function _hasFieldByTitle($title, $obj_id)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $result = $ilDB->query('SELECT * FROM il_dcl_field WHERE table_id = ' . $ilDB->quote($obj_id, 'integer') . ' AND title = '
            . $ilDB->quote($title, 'text'));

        return ($ilDB->numRows($result)) ? true : false;
    }


    public function getPartialRecords($sort, $direction, $limit, $offset, array $filter = array())
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $ilUser = $DIC['ilUser'];
        $rbacreview = $DIC['rbacreview'];

        $sort_field = ($sort) ? $this->getFieldByTitle($sort) : $this->getField('id');
        $direction = strtolower($direction);
        $direction = (in_array($direction, array( 'desc', 'asc' ))) ? $direction : 'asc';

        // Sorting by a status from an ILIAS Ref field. This column is added dynamically to the table, there is no field model
        $sort_by_status = false;
        if (substr($sort, 0, 8) == '_status_') {
            $sort_by_status = true;
            $sort_field = $this->getFieldByTitle(substr($sort, 8));
        }

        if (is_null($sort_field)) {
            $sort_field = $this->getField('id');
        }

        $sort_query_object = $sort_field->getRecordQuerySortObject($direction, $sort_by_status);

        $select_str = ($sort_query_object != null) ? $sort_query_object->getSelectStatement() : '';
        $join_str = ($sort_query_object != null) ? $sort_query_object->getJoinStatement() : '';
        $where_str = ($sort_query_object != null) ? $sort_query_object->getWhereStatement() : '';
        $order_str = ($sort_query_object != null) ? $sort_query_object->getOrderStatement() : '';
        $group_str = ($sort_query_object != null) ? $sort_query_object->getGroupStatement() : '';

        if (count($filter)) {
            foreach ($filter as $key => $filter_value) {
                $filter_field_id = substr($key, 7);
                $filter_field = $this->getField($filter_field_id);
                $filter_record_query_object = $filter_field->getRecordQueryFilterObject($filter_value, $sort_field);

                if ($filter_record_query_object) {
                    $select_str .= $filter_record_query_object->getSelectStatement();
                    $join_str .= $filter_record_query_object->getJoinStatement();
                    $where_str .= $filter_record_query_object->getWhereStatement();
                    $group_str .= $filter_record_query_object->getGroupStatement();
                }
            }
        }

        // Build the query string
        $sql = "SELECT DISTINCT record.id, record.owner";
        if ($select_str) {
            $sql .= ', ';
        }

        $as = $ilDB->getDBType() == 'oracle' ? '' : ' AS ';

        $sql .= rtrim($select_str, ',') . " FROM il_dcl_record {$as} record ";
        $sql .= $join_str;
        $sql .= " WHERE record.table_id = " . $ilDB->quote($this->getId(), 'integer');

        if (strlen($where_str) > 0) {
            $sql .= $where_str;
        }

        if (strlen($group_str) > 0) {
            $sql .= " GROUP BY " . $group_str;
        }

        if (strlen($order_str) > 0) {
            $sql .= " ORDER BY " . $order_str;
        }

        //var_dump($sql);
        /*global $DIC;
        /*$ilLog = $DIC['ilLog'];
        $ilLog->write($sql, ilLogLevel::CRITICAL);*/

        $set = $ilDB->query($sql);
        $total_record_ids = array();
        // Save record-ids in session to enable prev/next links in detail view
        $_SESSION['dcl_record_ids'] = array();
        $_SESSION['dcl_table_id'] = $this->getId();
        $ref = filter_input(INPUT_GET, 'ref_id');
        $is_allowed_to_view = (ilObjDataCollectionAccess::hasWriteAccess($ref) || ilObjDataCollectionAccess::hasEditAccess($ref));
        while ($rec = $ilDB->fetchAssoc($set)) {
            // Quick check if the current user is allowed to view the record
            if (!$is_allowed_to_view && ($this->getViewOwnRecordsPerm() && $ilUser->getId() != $rec['owner'])) {
                continue;
            }
            $total_record_ids[] = $rec['id'];
            $_SESSION['dcl_record_ids'][] = $rec['id'];
        }

        if ($sort_query_object != null) {
            $total_record_ids = $sort_query_object->applyCustomSorting($sort_field, $total_record_ids, $direction);
        }

        // Now slice the array to load only the needed records in memory
        $record_ids = array_slice($total_record_ids, $offset, $limit);

        $records = array();
        foreach ($record_ids as $id) {
            $records[] = ilDclCache::getRecordCache($id);
        }

        return array( 'records' => $records, 'total' => count($total_record_ids) );
    }
}