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()) {
                                $new_field = new ilDclBaseFieldModel();
                                $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) );
        }
}