class.ilObjCategoryGUI.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use ILIAS\Category\StandardGUIRequest;
use ILIAS\ILIASObject\Properties\Translations\TranslationGUI;
 
class ilObjCategoryGUI extends ilContainerGUI implements \ILIAS\Taxonomy\Settings\ModifierGUIInterface
{
    public const CONTAINER_SETTING_TAXBLOCK = "tax_sblock_";
    protected \ILIAS\Category\InternalDomainService $cat_domain;
    protected \ILIAS\Category\InternalGUIService $cat_gui;
    protected \ILIAS\Taxonomy\Service $taxonomy;
 
    protected ilNavigationHistory $nav_history;
    protected ilHelpGUI $help;
    protected bool $info_screen_enabled = false;
    protected ilObjectGUI $gui_obj;
    protected bool $creation_mode;
    protected ilAdvancedMDRecordGUI $record_gui;
    protected StandardGUIRequest $cat_request;
 
    public function __construct(
        $a_data,
        int $a_id,
        bool $a_call_by_reference = true,
        bool $a_prepare_output = true
    ) {
        global $DIC;
 
        $this->rbacsystem = $DIC->rbac()->system();
        $this->nav_history = $DIC["ilNavigationHistory"];
        $this->access = $DIC->access();
        $this->ctrl = $DIC->ctrl();
        $this->tabs = $DIC->tabs();
        $this->help = $DIC["ilHelp"];
        $this->lng = $DIC->language();
        $this->user = $DIC->user();
        $this->tree = $DIC->repositoryTree();
        $this->error = $DIC["ilErr"];
        $this->settings = $DIC->settings();
        $this->tpl = $DIC["tpl"];
        $this->toolbar = $DIC->toolbar();
        $this->rbacreview = $DIC->rbac()->review();
        $this->rbacadmin = $DIC->rbac()->admin();
 
        $this->lng->loadLanguageModule('cat');
        $this->lng->loadLanguageModule('obj');
 
        $this->type = "cat";
        parent::__construct($a_data, $a_id, $a_call_by_reference, false);
 
        if (is_object($this->object)) {
            $this->info_screen_enabled = (bool) ilContainer::_lookupContainerSetting(
                $this->object->getId(),
                ilObjectServiceSettingsGUI::INFO_TAB_VISIBILITY,
                '1'
            );
 
        }
        $this->cat_request = $DIC
            ->category()
            ->internal()
            ->gui()
            ->standardRequest();
        $this->taxonomy = $DIC->taxonomy();
        $this->cat_gui = $DIC->category()->internal()->gui();
        $this->cat_domain = $DIC->category()->internal()->domain();
    }
 
    public function executeCommand(): void
    {
        $ilNavigationHistory = $this->nav_history;
        $ilAccess = $this->access;
        $ilCtrl = $this->ctrl;
        $ilTabs = $this->tabs;
 
        $next_class = $this->ctrl->getNextClass($this);
        $cmd = $this->ctrl->getCmd();
 
        $header_action = true;
        switch ($next_class) {
            case strtolower(ilRepositoryTrashGUI::class):
                $ru = new ilRepositoryTrashGUI($this);
                $this->ctrl->setReturn($this, 'trash');
                $this->ctrl->forwardCommand($ru);
                break;
 
            case "ilobjusergui":
                $this->tabs_gui->setTabActive('administrate_users');
                if ($this->cat_request->getObjId() === 0) {
                    $this->gui_obj = new ilObjUserGUI(
                        "",
                        $this->cat_request->getRefId(),
                        true,
                        false
                    );
                } else {
                    $this->gui_obj = new ilObjUserGUI(
                        "",
                        $this->cat_request->getObjId(),
                        false,
                        false
                    );
                }
                $this->gui_obj->setCreationMode($this->creation_mode);
                $this->ctrl->forwardCommand($this->gui_obj);
 
                $ilTabs->clearTargets();
                $ilTabs->setBackTarget($this->lng->txt('backto_lua'), $this->ctrl->getLinkTarget($this, 'listUsers'));
                $ilHelp = $this->help;
                $ilHelp->setScreenIdComponent("cat");
                $ilHelp->setScreenId("administrate_user");
                $ilHelp->setSubScreenId($ilCtrl->getCmd());
                break;
 
            case "ilobjuserfoldergui":
                $this->gui_obj = new ilObjUserFolderGUI(
                    "",
                    $this->cat_request->getRefId(),
                    true
                );
                $this->gui_obj->setUserOwnerId($this->cat_request->getRefId());
                $this->gui_obj->setCreationMode($this->creation_mode);
                $this->ctrl->forwardCommand($this->gui_obj);
 
                $ilTabs->clearTargets();
                $ilTabs->setBackTarget($this->lng->txt('backto_lua'), $this->ctrl->getLinkTarget($this, 'listUsers'));
                $ilHelp = $this->help;
                $ilHelp->setScreenIdComponent("cat");
                $ilHelp->setScreenId("administrate_user");
                $ilHelp->setSubScreenId($ilCtrl->getCmd());
                break;
 
            case "ilcolumngui":
                $this->checkPermission("read");
                $this->prepareOutput();
                $this->content_style_gui->addCss(
                    $this->tpl,
                    $this->object->getRefId()
                );
                $this->renderObject();
                break;
 
            case 'ilpermissiongui':
                $this->prepareOutput();
                $this->tabs_gui->setTabActive('perm_settings');
                $perm_gui = new ilPermissionGUI($this);
                $this->ctrl->forwardCommand($perm_gui);
                break;
 
            case 'ilinfoscreengui':
                if ($this->info_screen_enabled) {
                    $this->prepareOutput();
                    $this->infoScreen();
                }
                break;
 
                // container page editing
            case "ilcontainerpagegui":
                $this->prepareOutput(false);
                $ret = $this->forwardToPageObject();
                if ($ret !== "") {
                    $this->tpl->setContent($ret);
                }
                $header_action = false;
                break;
 
            case 'ilobjectcopygui':
                $this->prepareOutput();
 
                $cp = new ilObjectCopyGUI($this);
                $cp->setType('cat');
                $this->ctrl->forwardCommand($cp);
                break;
 
            case "ilobjectcontentstylesettingsgui":
                $this->checkPermission("write");
                $this->setTitleAndDescription();
                $this->showContainerPageTabs();
                $settings_gui = $this->content_style_gui
                    ->objectSettingsGUIForRefId(
                        null,
                        $this->object->getRefId()
                    );
                $this->ctrl->forwardCommand($settings_gui);
                break;
 
            case 'ilusertablegui':
                $u_table = new ilUserTableGUI($this, "listUsers");
                $u_table->initFilter();
                $this->ctrl->setReturn($this, 'listUsers');
                $this->ctrl->forwardCommand($u_table);
                break;
 
            case "ilcommonactiondispatchergui":
                $this->prepareOutput();
                $gui = ilCommonActionDispatcherGUI::getInstanceFromAjaxCall();
                $this->ctrl->forwardCommand($gui);
                break;
 
            case 'ildidactictemplategui':
                $this->ctrl->setReturn($this, 'edit');
                $did = new ilDidacticTemplateGUI($this);
                $this->ctrl->forwardCommand($did);
                break;
 
            case 'ilexportgui':
                $this->prepareOutput();
                $this->tabs_gui->setTabActive('export');
                $exp = new ilExportGUI($this);
                $exp->addFormat('xml');
                $this->ctrl->forwardCommand($exp);
                break;
 
            case strtolower(TranslationGUI::class):
                $this->checkPermissionBool("write");
                $this->prepareOutput();
                //$this->tabs_gui->setTabActive('export');
                $this->setEditTabs("settings_trans");
                $transgui = new TranslationGUI(
                    $this->getObject(),
                    $this->lng,
                    $this->access,
                    $this->user,
                    $this->ctrl,
                    $this->tpl,
                    $this->ui_factory,
                    $this->ui_renderer,
                    $this->http,
                    $this->refinery,
                    $this->toolbar
                );
                $this->ctrl->forwardCommand($transgui);
                break;
 
            case strtolower(ilTaxonomySettingsGUI::class):
                $this->checkPermissionBool("write");
                $this->prepareOutput();
                $this->setEditTabs("taxonomy");
                $tax_gui = $this->taxonomy->gui()->getSettingsGUI(
                    $this->object->getId(),
                    $this->lng->txt("cntr_tax_settings_info"),
                    true,
                    $this
                );
                $this->ctrl->forwardCommand($tax_gui);
                break;
 
            case 'ilobjectmetadatagui':
                $this->checkPermissionBool("write");
                $this->prepareOutput();
                $this->tabs_gui->activateTab('meta_data');
                $this->ctrl->forwardCommand($this->getObjectMetadataGUI());
                break;
 
            case "ilcontainernewssettingsgui":
                $this->prepareOutput();
                $this->tabs_gui->setTabActive('settings');
                $this->setEditTabs();
                $this->tabs_gui->activateSubTab('obj_news_settings');
                $news_set_gui = new ilContainerNewsSettingsGUI($this);
                $news_set_gui->setHideByDate(true);
                $this->ctrl->forwardCommand($news_set_gui);
                break;
 
            case 'ilcontainerfilteradmingui':
                $this->checkPermissionBool("write");
                $this->prepareOutput();
                $this->setEditTabs($active_tab = "settings_filter");
                $this->tabs_gui->activateTab('settings');
                $this->ctrl->forwardCommand(new ilContainerFilterAdminGUI($this));
                break;
 
            default:
                if ($cmd === "infoScreen") {
                    $this->checkPermission("visible");
                } else {
                    $this->checkPermission("read");
                }
 
                // add entry to navigation history
                if (!$this->getCreationMode() &&
                    $ilAccess->checkAccess("read", "", $this->cat_request->getRefId())) {
                    $ilNavigationHistory->addItem(
                        $this->cat_request->getRefId(),
                        ilLink::_getLink($this->cat_request->getRefId(), "cat"),
                        "cat"
                    );
                }
 
                $this->prepareOutput();
                if (is_object($this->object)) {
                    $this->content_style_gui->addCss(
                        $this->tpl,
                        $this->object->getRefId()
                    );
                }
 
                if (!$cmd) {
                    $cmd = "render";
                }
                $cmd .= "Object";
                $this->tabs_gui->activateTab("view_content");   // see #19868
                $this->$cmd();
 
                break;
        }
 
        if ($header_action) {
            $this->addHeaderAction();
        }
    }
 
 
    public function getObjectMetadataGUI(): ilObjectMetaDataGUI
    {
        $md_gui = new ilObjectMetaDataGUI($this->object);
        /*
        if (ilContainer::_lookupContainerSetting(
            $this->object->getId(),
            ilObjectServiceSettingsGUI::TAXONOMIES,
            '0'
        )) {
            $md_gui->enableTaxonomyDefinition(true);
            $tax = $md_gui->getTaxonomyObjGUI();
            $tax->setMultiple(true);
            $tax->setListInfo($this->lng->txt("cntr_tax_list_info"));
            $taxonomies = $this->getTaxonomiesForRefId();
            if (count($taxonomies)) {
                $md_gui->setTaxonomySettings(function ($form) {
                    $tax = $this->getTaxonomiesForRefId();
                    $block = new ilCheckboxGroupInputGUI($this->lng->txt("cntr_taxonomy_show_sideblock"), "sblock");
                    $form->addItem($block);
 
                    $current = $this->getActiveBlocks();
 
                    $value = null;
                    foreach ($tax as $tax_id => $tax_item) {
                        $option = new ilCheckboxOption(
                            $tax_item["title"],
                            (string) $tax_id,
                            ilObject::_lookupDescription($tax_id)
                        );
 
                        if ((int) $tax_item["source"] !== $this->object->getRefId()) {
                            $loc = new ilLocatorGUI();
                            $loc->setTextOnly(true);
                            $loc->addRepositoryItems((int) $tax_item["source"]);
                            $option->setInfo($loc->getHTML());
                        }
 
                        $block->addOption($option);
 
                        if (in_array($tax_id, $current)) {
                            $value[] = $tax_id;
                        }
                    }
 
                    $block->setValue($value);
                }, function ($form) {
                    $taxonomies = $this->getTaxonomiesForRefId();
                    if (count($taxonomies)) {
                        $sblock = $form->getInput("sblock");
 
                        $prefix = self::CONTAINER_SETTING_TAXBLOCK;
 
                        ilContainer::_deleteContainerSettings(
                            $this->object->getId(),
                            $prefix . "%",
                            true
                        );
 
                        if (is_array($sblock)) {
                            foreach ($sblock as $tax_id) {
                                ilContainer::_writeContainerSetting(
                                    $this->object->getId(),
                                    $prefix . $tax_id,
                                    '1'
                                );
                            }
                        }
                    }
                });
            }
        }*/
        return $md_gui;
    }
 
    protected function showTaxAsSideBlockObject(): void
    {
        $prefix = self::CONTAINER_SETTING_TAXBLOCK;
        $tax_id = $this->cat_request->getTaxId();
        ilContainer::_writeContainerSetting(
            $this->object->getId(),
            $prefix . $tax_id,
            '1'
        );
        $this->ctrl->redirectByClass(ilTaxonomySettingsGUI::class, "");
    }
 
    protected function hideTaxAsSideBlockObject(): void
    {
        $prefix = self::CONTAINER_SETTING_TAXBLOCK;
        $tax_id = $this->cat_request->getTaxId();
        ilContainer::_deleteContainerSettings(
            $this->object->getId(),
            $prefix . $tax_id
        );
        $this->ctrl->redirectByClass(ilTaxonomySettingsGUI::class, "");
    }
 
    public function getProperties(
        int $tax_id
    ): array {
        $active = in_array($tax_id, $this->getActiveBlocks());
        $value = $active
            ? $this->lng->txt("yes")
            : $this->lng->txt("no");
 
        return [
            $this->lng->txt("cntr_taxonomy_show_sideblock") => $value
        ];
    }
 
    public function getActions(
        int $tax_id
    ): array {
        $actions = [];
        $this->ctrl->setParameterByClass(self::class, "cat_tax_id", $tax_id);
        $active = in_array($tax_id, $this->getActiveBlocks());
        if (!$active) {
            $actions[] = $this->ui->factory()->button()->shy(
                $this->lng->txt("cat_show_tax_in_side_block"),
                $this->ctrl->getLinkTargetByClass(
                    self::class,
                    "showTaxAsSideBlock"
                )
            );
        } else {
            $actions[] = $this->ui->factory()->button()->shy(
                $this->lng->txt("cat_hide_tax_in_side_block"),
                $this->ctrl->getLinkTargetByClass(
                    self::class,
                    "hideTaxAsSideBlock"
                )
            );
        }
        $this->ctrl->setParameterByClass(self::class, "cat_tax_id", null);
 
        return $actions;
    }
 
 
    protected function getTabs(): void
    {
        $rbacsystem = $this->rbacsystem;
        $lng = $this->lng;
        $ilHelp = $this->help;
        $ilAccess = $this->access;
 
        if ($this->ctrl->getCmd() === "editPageContent") {
            return;
        }
 
        $ilHelp->setScreenIdComponent("cat");
 
        if ($rbacsystem->checkAccess('read', $this->ref_id)) {
            $this->tabs_gui->addTab(
                "view_content",
                $lng->txt("content"),
                $this->ctrl->getLinkTarget($this, "")
            );
 
            //BEGIN ChangeEvent add info tab to category object
            if ($this->info_screen_enabled) {
                $force_active = $this->ctrl->getNextClass() === "ilinfoscreengui"
                    || strtolower($this->cat_request->getCmdClass()) === "ilnotegui";
                $this->tabs_gui->addTarget(
                    "info_short",
                    $this->ctrl->getLinkTargetByClass(
                        ["ilobjcategorygui", "ilinfoscreengui"],
                        "showSummary"
                    ),
                    ["showSummary", "", "infoScreen"],
                    "",
                    "",
                    $force_active
                );
            }
            //END ChangeEvent add info tab to category object
        }
 
        if ($rbacsystem->checkAccess('write', $this->ref_id)) {
            $force_active = ($this->ctrl->getCmd() === "edit");
            $this->tabs_gui->addTarget(
                "settings",
                $this->ctrl->getLinkTarget($this, "edit"),
                "edit",
                get_class($this),
                "",
                $force_active
            );
 
 
 
            // metadata / taxonomies
            $mdgui = new ilObjectMetaDataGUI($this->object);
            /*if (ilContainer::_lookupContainerSetting(
                $this->object->getId(),
                ilObjectServiceSettingsGUI::TAXONOMIES,
                '0'
            )) {
                $mdgui->enableTaxonomyDefinition(true);
            }*/
            $mdtab = $mdgui->getTab();
            if ($mdtab) {
                $this->tabs_gui->addTab(
                    "meta_data",
                    $this->lng->txt("meta_data"),
                    $mdtab
                );
            }
        }
 
        if (ilUserAccountSettings::getInstance()->isLocalUserAdministrationEnabled() &&
            $rbacsystem->checkAccess('cat_administrate_users', $this->ref_id)) {
            $this->tabs_gui->addTarget(
                "administrate_users",
                $this->ctrl->getLinkTarget($this, "listUsers"),
                "listUsers",
                get_class($this)
            );
        }
 
        if ($ilAccess->checkAccess('write', '', $this->object->getRefId())) {
            $this->tabs_gui->addTarget(
                'export',
                $this->ctrl->getLinkTargetByClass([ilRepositoryGUI::class, self::class, 'ilexportgui'], ''),
                'export',
                'ilexportgui'
            );
        }
 
        // parent tabs (all container: edit_permission, clipboard, trash
        parent::getTabs();
    }
 
    public function renderObject(): void
    {
        $ilTabs = $this->tabs;
 
        $ilTabs->activateTab("view_content");
        parent::renderObject();
 
        ilChangeEvent::_recordReadEvent(
            $this->object->getType(),
            $this->object->getRefId(),
            $this->object->getId(),
            $this->user->getId()
        );
    }
 
    public function viewObject(): void
    {
        if (strtolower($this->cat_request->getBaseClass()) === "iladministrationgui") {
            parent::viewObject();
            return;
        }
        $this->renderObject();
    }
 
    protected function afterSave(ilObject $new_object): void
    {
        $tree = $this->tree;
 
        // default: sort by title
        $settings = new ilContainerSortingSettings($new_object->getId());
        $settings->setSortMode(ilContainer::SORT_TITLE);
        $settings->save();
 
        // inherit parents content style, if not individual
        $this->content_style_domain
            ->styleForRefId($new_object->getRefId())
            ->inheritFromParent();
 
        // always send a message
        $this->tpl->setOnScreenMessage('success', $this->lng->txt("cat_added"), true);
        $this->ctrl->setParameter($this, "ref_id", $new_object->getRefId());
        $this->redirectToRefId($new_object->getRefId(), "");
    }
 
    public function infoScreenObject(): void
    {
        $this->ctrl->redirectByClass(ilInfoScreenGUI::class, "showSummary");
    }
 
    public function infoScreen(): string
    {
        $ilAccess = $this->access;
        $ilCtrl = $this->ctrl;
        $ilErr = $this->error;
 
        if (!$ilAccess->checkAccess("visible", "", $this->ref_id)) {
            $ilErr->raiseError($this->lng->txt("msg_no_perm_read"), $ilErr->MESSAGE);
        }
 
        if (!$this->info_screen_enabled) {
            return "";
        }
 
        // #10986
        $this->tabs_gui->setTabActive('info_short');
 
        $info = new ilInfoScreenGUI($this);
 
        $info->enablePrivateNotes();
 
        if ($ilAccess->checkAccess("read", "", $this->cat_request->getRefId())) {
            $info->enableNews();
        }
 
        // no news editing for files, just notifications
        $info->enableNewsEditing(false);
        if ($ilAccess->checkAccess("write", "", $this->cat_request->getRefId())) {
            $news_set = new ilSetting("news");
            $enable_internal_rss = $news_set->get("enable_rss_for_internal");
 
            if ($enable_internal_rss) {
                $info->setBlockProperty("news", "settings", '1');
                $info->setBlockProperty("news", "public_notifications_option", '1');
            }
        }
 
        $record_gui = new ilAdvancedMDRecordGUI(ilAdvancedMDRecordGUI::MODE_INFO, 'cat', $this->object->getId());
        $record_gui->setInfoObject($info);
        $record_gui->parse();
 
 
        // standard meta data
        $info->addMetaDataSections($this->object->getId(), 0, $this->object->getType());
 
        // forward the command
        if ($ilCtrl->getNextClass() === "ilinfoscreengui") {
            $ilCtrl->forwardCommand($info);
        } else {
            return $ilCtrl->getHTML($info);
        }
        return "";
    }
 
    protected function editInfoObject(): void
    {
        $this->checkPermission("write");
        $this->setEditTabs();
        $this->tabs_gui->activateTab('settings');
        $this->tabs_gui->setSubTabActive('edit_cat_settings');
 
        $this->initExtendedSettings();
        $this->tpl->setContent($this->form->getHTML());
    }
 
    // Update info (extended meta data)
    protected function updateInfoObject(): void
    {
        $this->checkPermission("write");
 
        // init form
        $this->initExtendedSettings();
 
        // still needed for date conversion and so on
        $this->form->checkInput();
 
        if ($this->record_gui->importEditFormPostValues()) {
            $this->record_gui->writeEditForm();
 
            $this->tpl->setOnScreenMessage('success', $this->lng->txt("settings_saved"), true);
            $this->ctrl->redirect($this, "editInfo");
        }
 
        $this->editInfoObject();
    }
 
 
    // build property form for extended category settings
    protected function initExtendedSettings(): bool
    {
        if (is_object($this->form)) {
            return true;
        }
 
        $this->form = new ilPropertyFormGUI();
        $this->form->setFormAction($this->ctrl->getFormAction($this));
        $this->form->setTitle($this->lng->txt('ext_cat_settings'));
        $this->form->addCommandButton('updateInfo', $this->lng->txt('save'));
        $this->form->addCommandButton('editInfo', $this->lng->txt('cancel'));
 
        $this->record_gui = new ilAdvancedMDRecordGUI(ilAdvancedMDRecordGUI::MODE_EDITOR, 'cat', $this->object->getId());
        $this->record_gui->setPropertyForm($this->form);
        $this->record_gui->parse();
 
        return true;
    }
 
    protected function setEditTabs($active_tab = "settings_misc"): void
    {
        $this->tabs_gui->addSubTab(
            "settings_misc",
            $this->lng->txt("general"),
            $this->ctrl->getLinkTarget($this, "edit")
        );
 
        $this->tabs_gui->addSubTab(
            "settings_trans",
            $this->lng->txt("obj_multilinguality"),
            $this->ctrl->getLinkTargetByClass(TranslationGUI::class, "")
        );
 
        //news tab
        $news_active = ilContainer::_lookupContainerSetting(
            $this->object->getId(),
            ilObjectServiceSettingsGUI::NEWS_VISIBILITY,
            '1'
        );
 
        if ($news_active) {
            $this->tabs_gui->addSubTab(
                'obj_news_settings',
                $this->lng->txt("cont_news_settings"),
                $this->ctrl->getLinkTargetByClass('ilcontainernewssettingsgui')
            );
        }
 
        $this->tabs_gui->addSubTab(
            "settings_filter",
            $this->lng->txt("cont_filter"),
            $this->ctrl->getLinkTargetByClass("ilcontainerfilteradmingui", "")
        );
 
        if ($obj = $this->getObject()) {
            $this->taxonomy->gui()->addSettingsSubTab($obj->getId());
        }
 
        $this->tabs_gui->activateTab("settings");
        $this->tabs_gui->activateSubTab($active_tab);
    }
 
    protected function initEditForm(): ilPropertyFormGUI
    {
        $obj_service = $this->getObjectService();
 
        $this->lng->loadLanguageModule($this->object->getType());
        $this->setEditTabs();
 
        $form = new ilPropertyFormGUI();
        $form->setFormAction($this->ctrl->getFormAction($this));
        $form->setTitle($this->lng->txt($this->object->getType() . "_edit"));
 
        // title/description
        $this->initFormTitleDescription($form);
 
        // Show didactic template type
        $this->initDidacticTemplate($form);
 
        // presentation
        $pres = new ilFormSectionHeaderGUI();
        $pres->setTitle($this->lng->txt('obj_presentation'));
        $form->addItem($pres);
 
        // title and icon visibility
        $form = $obj_service->commonSettings()->legacyForm($form, $this->object)->addTitleIconVisibility();
 
        // top actions visibility
        $form = $obj_service->commonSettings()->legacyForm($form, $this->object)->addTopActionsVisibility();
 
        // custom icon
        $form = $obj_service->commonSettings()->legacyForm($form, $this->object)->addIcon();
 
        // tile image
        $form = $obj_service->commonSettings()->legacyForm($form, $this->object)->addTileImage();
 
        // list presentation
        $form = $this->initListPresentationForm($form);
 
        // sorting
        $form = $this->initSortingForm(
            $form,
            [
                    ilContainer::SORT_TITLE,
                    ilContainer::SORT_CREATION,
                    ilContainer::SORT_MANUAL
            ]
        );
 
        // block limit
        $bl = new ilNumberInputGUI($this->lng->txt("cont_block_limit"), "block_limit");
        $bl->setInfo($this->lng->txt("cont_block_limit_info"));
        $bl->setValue(ilContainer::_lookupContainerSetting($this->object->getId(), "block_limit"));
        $form->addItem($bl);
 
        // icon settings
 
        // Edit ecs export settings
        $ecs = new ilECSCategorySettings($this->object);
        $ecs->addSettingsToForm($form, 'cat');
 
        // services
        $sh = new ilFormSectionHeaderGUI();
        $sh->setTitle($this->lng->txt('obj_features'));
        $form->addItem($sh);
 
        ilObjectServiceSettingsGUI::initServiceSettingsForm(
            $this->object->getId(),
            $form,
            [
                    ilObjectServiceSettingsGUI::INFO_TAB_VISIBILITY,
                    ilObjectServiceSettingsGUI::NEWS_VISIBILITY,
                    ilObjectServiceSettingsGUI::TAXONOMIES,
                    ilObjectServiceSettingsGUI::CUSTOM_METADATA,
                    ilObjectServiceSettingsGUI::TAG_CLOUD,
                    ilObjectServiceSettingsGUI::FILTER
            ]
        );
 
        $form->addCommandButton("update", $this->lng->txt("save"));
 
        return $form;
    }
 
    protected function getEditFormValues(): array
    {
        return [];
    }
 
    public function updateObject(): void
    {
        $ilErr = $this->error;
        $ilUser = $this->user;
        $obj_service = $this->getObjectService();
 
        if (!$this->checkPermissionBool("write")) {
            $ilErr->raiseError($this->lng->txt("msg_no_perm_write"), $ilErr->MESSAGE);
        } else {
            $form = $this->initEditForm();
            if ($form->checkInput()) {
                $title = $form->getInput("title");
                $desc = $form->getInput("desc");
 
                $this->object->setTitle($title);
                $this->object->setDescription($desc);
                $this->object->update();
 
                $this->saveSortingSettings($form);
 
                // title icon visibility
                $obj_service->commonSettings()->legacyForm($form, $this->object)->saveTitleIconVisibility();
 
                // top actions visibility
                $obj_service->commonSettings()->legacyForm($form, $this->object)->saveTopActionsVisibility();
 
                // custom icon
                $obj_service->commonSettings()->legacyForm($form, $this->object)->saveIcon();
 
                // tile image
                $obj_service->commonSettings()->legacyForm($form, $this->object)->saveTileImage();
 
                // list presentation
                $this->saveListPresentation($form);
 
                // BEGIN ChangeEvent: Record update
                ilChangeEvent::_recordWriteEvent($this->object->getId(), $ilUser->getId(), 'update');
                ilChangeEvent::_catchupWriteEvents($this->object->getId(), $ilUser->getId());
                // END ChangeEvent: Record update
 
                // services
                ilObjectServiceSettingsGUI::updateServiceSettingsForm(
                    $this->object->getId(),
                    $form,
                    [
                        ilObjectServiceSettingsGUI::INFO_TAB_VISIBILITY,
                        ilObjectServiceSettingsGUI::NEWS_VISIBILITY,
                        ilObjectServiceSettingsGUI::TAXONOMIES,
                        ilObjectServiceSettingsGUI::CUSTOM_METADATA,
                        ilObjectServiceSettingsGUI::TAG_CLOUD,
                        ilObjectServiceSettingsGUI::FILTER
                    ]
                );
 
                // block limit
                if ((int) $form->getInput("block_limit") > 0) {
                    ilContainer::_writeContainerSetting(
                        $this->object->getId(),
                        "block_limit",
                        (string) ((int) $form->getInput("block_limit"))
                    );
                } else {
                    ilContainer::_deleteContainerSettings($this->object->getId(), "block_limit");
                }
                // Update ecs export settings
                $ecs = new ilECSCategorySettings($this->object);
                if ($ecs->handleSettingsUpdate($form)) {
                    $this->afterUpdate();
                    return;
                }
            }
 
            // display form to correct errors
            $this->setEditTabs();
            $form->setValuesByPost();
            $this->tpl->setContent($form->getHTML());
        }
    }
 
 
    public static function _getImportDir(): string
    {
        return ilFileUtils::getDataDir() . "/cat_import";
    }
 
    protected function resetFilterObject(): void
    {
        $utab = new ilUserTableGUI($this, "listUsers", ilUserTableGUI::MODE_LOCAL_USER);
        $utab->resetOffset();
        $utab->resetFilter();
 
        // from "old" implementation
        $this->listUsersObject();
    }
 
    protected function applyFilterObject(): void
    {
        $ilTabs = $this->tabs;
 
        $utab = new ilUserTableGUI($this, "listUsers", ilUserTableGUI::MODE_LOCAL_USER);
        $utab->resetOffset();
        $utab->writeFilterToSession();
        $this->listUsersObject();
    }
 
    // METHODS for local user administration
    public function listUsersObject(bool $show_delete = false): void
    {
        $ilUser = $this->user;
        $ilErr = $this->error;
        $ilToolbar = $this->toolbar;
 
        $rbacsystem = $this->rbacsystem;
        $rbacreview = $this->rbacreview;
 
        if (!$rbacsystem->checkAccess("cat_administrate_users", $this->object->getRefId())) {
            $ilErr->raiseError($this->lng->txt("msg_no_perm_admin_users"), $ilErr->MESSAGE);
        }
        $this->tabs_gui->setTabActive('administrate_users');
 
 
 
        $this->tpl->addBlockfile(
            'ADM_CONTENT',
            'adm_content',
            'tpl.cat_admin_users.html',
            "components/ILIAS/Category"
        );
 
        if (count($rbacreview->getGlobalAssignableRoles()) ||
            in_array(SYSTEM_ROLE_ID, $rbacreview->assignedRoles($ilUser->getId()), true)) {
            $ilToolbar->addButton(
                $this->lng->txt('add_user'),
                $this->ctrl->getLinkTargetByClass('ilobjusergui', 'create')
            );
 
            $ilToolbar->addButton(
                $this->lng->txt('import_users'),
                $this->ctrl->getLinkTargetByClass('ilobjuserfoldergui', 'importUserForm')
            );
        } else {
            $this->tpl->setOnScreenMessage('info', $this->lng->txt('no_roles_user_can_be_assigned_to'));
        }
 
        if ($show_delete) {
            $this->tpl->setCurrentBlock("confirm_delete");
            $this->tpl->setVariable("CONFIRM_FORMACTION", $this->ctrl->getFormAction($this));
            $this->tpl->setVariable("TXT_CANCEL", $this->lng->txt('cancel'));
            $this->tpl->setVariable("CONFIRM_CMD", 'performDeleteUsers');
            $this->tpl->setVariable("TXT_CONFIRM", $this->lng->txt('delete'));
            $this->tpl->parseCurrentBlock();
        }
 
        $this->lng->loadLanguageModule('user');
 
        $utab = new ilUserTableGUI($this, 'listUsers', ilUserTableGUI::MODE_LOCAL_USER);
        $this->tpl->setVariable('USERS_TABLE', $utab->getHTML());
    }
 
    protected function addUserAutoCompleteObject(): void
    {
        $auto = new ilUserAutoComplete();
        $auto->setSearchFields(['login', 'firstname', 'lastname', 'email']);
        $auto->enableFieldSearchableCheck(true);
        //$auto->isMoreLinkAvailable(true);
 
        if (($this->cat_request->getFetchAll())) {
            $auto->setLimit(ilUserAutoComplete::MAX_ENTRIES);
        }
 
        echo $auto->getList($this->cat_request->getTerm());
        exit();
    }
 
    public function performDeleteUsersObject(): void
    {
        $this->checkPermission("cat_administrate_users");
 
        foreach ($this->cat_request->getUserIds() as $user_id) {
            if (!in_array($user_id, ilLocalUser::_getAllUserIds($this->object->getRefId()), true)) {
                throw new ilException('user id not valid');
            }
            if (!$tmp_obj = ilObjectFactory::getInstanceByObjId($user_id, false)) {
                continue;
            }
            $tmp_obj->delete();
        }
        $this->tpl->setOnScreenMessage('success', $this->lng->txt('deleted_users'));
        $this->listUsersObject();
    }
 
    public function deleteUsersObject(): void
    {
        $this->checkPermission("cat_administrate_users");
        if ($this->cat_request->getIds() === []) {
            $this->tpl->setOnScreenMessage('failure', $this->lng->txt('no_users_selected'));
            $this->listUsersObject();
            return;
        }
 
        $confirm = new ilConfirmationGUI();
        $confirm->setFormAction($this->ctrl->getFormAction($this));
        $confirm->setHeaderText($this->lng->txt('sure_delete_selected_users'));
        $confirm->setConfirm($this->lng->txt('delete'), 'performDeleteUsers');
        $confirm->setCancel($this->lng->txt('cancel'), 'listUsers');
 
        foreach ($this->cat_request->getIds() as $user) {
            $name = ilObjUser::_lookupName($user);
 
            $confirm->addItem(
                'user_ids[]',
                (string) $user,
                $name['lastname'] . ', ' . $name['firstname'] . ' [' . $name['login'] . ']'
            );
        }
        $this->tpl->setContent($confirm->getHTML());
    }
 
    public function assignRolesObject(): void
    {
        $this->ctrl->saveParameterByClass(self::class, "obj_id");
        $ilTabs = $this->tabs;
 
        $this->checkPermission("cat_administrate_users");
 
        if ($this->cat_request->getObjId() === 0) {
            $this->tpl->setOnScreenMessage('failure', 'no_user_selected');
            $this->listUsersObject();
            return;
        }
 
        $ilTabs->clearTargets();
        $ilTabs->setBackTarget($this->lng->txt('backto_lua'), $this->ctrl->getLinkTarget($this, 'listUsers'));
        $ilHelp = $this->help;
        $ilHelp->setScreenIdComponent("cat");
        $ilHelp->setScreenId("administrate_user");
        $ilHelp->setSubScreenId("assign_roles");
 
        $table = $this->cat_gui->assignedRoleTableBuilder(
            $this->ref_id,
            $this->cat_request->getObjId(),
            $this->user->getId(),
            $this,
            "assignRoles"
        )->getTable();
        if ($table->handleCommand()) {
            return;
        }
        $this->tpl->setContent($table->render());
    }
 
    public function assignSave(array $ids): void
    {
        $this->ctrl->saveParameterByClass(self::class, "obj_id");
        $this->checkPermission("cat_administrate_users");
        $lng = $this->domain->lng();
 
        // check hack
        if ($this->cat_request->getObjId() === 0 ||
            !in_array($this->cat_request->getObjId(), ilLocalUser::_getAllUserIds(), true)) {
            $this->tpl->setOnScreenMessage('failure', 'no_user_selected');
            $this->listUsersObject();
            return;
        }
        try {
            $this->cat_domain->assignedRolesManager(
                $this->ref_id,
                $this->cat_request->getObjId(),
                $this->user->getId()
            )->switchAssignment($ids);
            $this->tpl->setOnScreenMessage('success', $lng->txt("msg_obj_modified"), true);
        } catch (Exception $e) {
            $this->tpl->setOnScreenMessage('failure', $e->getMessage(), true);
        }
        $this->ctrl->redirectByClass(self::class, "assignRoles");
    }
 
 
    public static function _goto(string $a_target): void
    {
        global $DIC;
        $main_tpl = $DIC->ui()->mainTemplate();
 
        $ilAccess = $DIC->access();
        $ilErr = $DIC["ilErr"];
        $lng = $DIC->language();
        if ($ilAccess->checkAccess("read", "", (int) $a_target)) {
            ilObjectGUI::_gotoRepositoryNode((int) $a_target);
        } elseif ($ilAccess->checkAccess("visible", "", (int) $a_target)) {
            ilObjectGUI::_gotoRepositoryNode((int) $a_target, "infoScreen");
        } elseif ($ilAccess->checkAccess("read", "", ROOT_FOLDER_ID)) {
            $main_tpl->setOnScreenMessage('failure', sprintf(
                $lng->txt("msg_no_perm_read_item"),
                ilObject::_lookupTitle(ilObject::_lookupObjId((int) $a_target))
            ), true);
            ilObjectGUI::_gotoRepositoryRoot();
        }
 
        $ilErr->raiseError($lng->txt("msg_no_perm_read"), $ilErr->FATAL);
    }
 
    //
    // taxonomy
    //
 
    protected function initTaxSubTabs($a_active = "tax_list"): void
    {
        $this->tabs_gui->setTabActive("obj_tool_setting_taxonomies");
        $this->tabs_gui->addSubTab(
            "tax_settings",
            $this->lng->txt("cntr_taxonomy_sideblock_settings"),
            $this->ctrl->getLinkTarget($this, "editTaxonomySettings")
        );
        $this->tabs_gui->addSubTab(
            "tax_list",
            $this->lng->txt("cntr_taxonomy_definitions"),
            $this->ctrl->getLinkTargetByClass("ilobjtaxonomygui", "")
        );
        $this->tabs_gui->activateSubTab($a_active);
    }
 
    protected function getTaxonomiesForRefId(): array
    {
        $tree = $this->tree;
 
        // see ilTaxMDGUI::getSelectableTaxonomies()
 
        $res = [];
        foreach ($tree->getPathFull($this->object->getRefId()) as $node) {
            //if ($node["ref_id"] != $this->object->getRefId())
            {
                // find all defined taxes for parent node, activation is not relevant
                $node_taxes = ilObjTaxonomy::getUsageOfObject((int) $node["obj_id"], true);
                if (count($node_taxes)) {
                    foreach ($node_taxes as $node_tax) {
                        $res[$node_tax["tax_id"]] = [
                            "title" => $node_tax["title"]
                        , "source" => $node["child"]
                        ];
                    }
                }
            }
        }
 
        asort($res);
        return $res;
    }
 
    protected function getActiveBlocks(): array
    {
        $res = [];
 
        $prefix = self::CONTAINER_SETTING_TAXBLOCK;
 
        foreach (ilContainer::_getContainerSettings($this->object->getId()) as $keyword => $value) {
            if ($value && strpos($keyword, $prefix) === 0) {
                $res[] = substr($keyword, strlen($prefix));
            }
        }
 
        return $res;
    }
}