class.ilObjDashboardSettingsGUI.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use ILIAS\DI\UIServices;
use ILIAS\Style\Content\GUIService;
use ILIAS\UI\Factory;
use ILIAS\UI\Implementation\Component\Input\Field\FormInput;
use ILIAS\UI\Renderer;
use ILIAS\UI\Component\Input\Container\Form\Standard as StandardForm;
use ILIAS\UI\Component\Input\Field\Section;
use ILIAS\UI\Component\Input\Input;
 
class ilObjDashboardSettingsGUI extends ilObjectGUI
{
    public const VIEW_MODE_SETTINGS = 'Settings';
    public const VIEW_MODE_PRESENTATION = 'Presentation';
    public const VIEW_MODE_SORTING = 'Sorting';
    public const DASH_SORT_PREFIX = 'dash_sort_by_';
    public const DASH_ENABLE_PREFIX = 'dash_enable_';
 
    protected readonly ilPDSelectedItemsBlockViewSettings $view_settings;
    protected readonly UIServices $ui;
    protected readonly ilDashboardSidePanelSettingsRepository $side_panel_settings;
    protected readonly GUIService $style_gui;
 
    public function __construct(
        $a_data,
        int $a_id,
        bool $a_call_by_reference = true,
        bool $a_prepare_output = true
    ) {
        global $DIC;
 
        $this->ui = $DIC->ui();
        $this->style_gui = $DIC->contentStyle()->gui();
 
        parent::__construct($a_data, $a_id, $a_call_by_reference, $a_prepare_output);
 
        $this->lng->loadLanguageModule('dash');
        $this->view_settings = new ilPDSelectedItemsBlockViewSettings($this->user);
        $this->side_panel_settings = new ilDashboardSidePanelSettingsRepository();
    }
 
    public function executeCommand(): void
    {
        $cmd = $this->ctrl->getCmd();
 
        $this->prepareOutput();
 
        if (!$this->rbac_system->checkAccess('read', $this->object->getRefId())) {
            throw new ilPermissionException($this->lng->txt('no_permission'));
        }
 
        switch ($this->ctrl->getNextClass($this)) {
            case strtolower(ilPermissionGUI::class):
                $this->tabs_gui->activateTab('perm_settings');
                $perm_gui = new ilPermissionGUI($this);
                $this->ctrl->forwardCommand($perm_gui);
                break;
            case strtolower(ilDashboardPageLanguageSelectGUI::class):
                $this->tabs_gui->activateTab('dash_customization');
                $this->ctrl->forwardCommand(new ilDashboardPageLanguageSelectGUI());
                break;
            case strtolower(ilObjectContentStyleSettingsGUI::class):
                $this->tabs_gui->clearTargets();
                $this->ctrl->setParameterByClass(ilDashboardPageGUI::class, 'dshs_lang', $this->request->getQueryParams()['dshs_lang']);
                $this->tabs_gui->setBackTarget($this->lng->txt('back'), $this->ctrl->getLinkTargetByClass(
                    [ilDashboardPageLanguageSelectGUI::class, ilDashboardPageGUI::class],
                    'edit'
                ));
                $gui = $this->style_gui->objectSettingsGUIForRefId(null, $this->getRefId());
                $this->ctrl->setParameter($gui, 'dshs_lang', $this->request->getQueryParams()['dshs_lang']);
                $this->ctrl->forwardCommand($gui);
                break;
            default:
                $this->tabs_gui->activateTab('settings');
                if (!$cmd || $cmd === 'view') {
                    $cmd = 'editSettings';
                }
 
                $this->$cmd();
                break;
        }
    }
 
    public function getAdminTabs(): void
    {
        if ($this->rbac_system->checkAccess('read', $this->object->getRefId())) {
            $this->tabs_gui->addTarget(
                'settings',
                $this->ctrl->getLinkTarget($this, 'editSettings'),
                ['editSettings', 'view']
            );
            $this->tabs_gui->addTarget(
                'dash_customization',
                $this->ctrl->getLinkTargetByClass(ilDashboardPageLanguageSelectGUI::class)
            );
        }
 
        if ($this->rbac_system->checkAccess('edit_permission', $this->object->getRefId())) {
            $this->tabs_gui->addTarget(
                'perm_settings',
                $this->ctrl->getLinkTargetByClass(ilPermissionGUI::class, 'perm'),
                [],
                ilPermissionGUI::class
            );
        }
    }
 
    public function editSettings(): void
    {
        if ($this->settings->get('rep_favourites', '0') !== '1') {
            $content[] = $this->ui_factory->messageBox()->info($this->lng->txt('favourites_disabled_info'));
        }
 
        if ($this->settings->get('mmbr_my_crs_grp', '0') !== '1') {
            $content[] = $this->ui_factory->messageBox()->info($this->lng->txt('memberships_disabled_info'));
        }
        $this->setSettingsSubTabs('general');
        $table = new ilDashboardSortationTableGUI($this, 'editSettings', !$this->canWrite());
        $this->tpl->setContent($table->getHTML());
    }
 
    public function editSorting(?StandardForm $form = null): void
    {
        $this->tabs_gui->activateTab('settings');
        $this->setSettingsSubTabs('sorting');
        $form = $form ?? $this->getViewForm(self::VIEW_MODE_SORTING);
        $this->tpl->setContent($this->ui_renderer->renderAsync($form));
    }
 
    public function getViewForm(string $mode): ?StandardForm
    {
        switch ($mode) {
            case self::VIEW_MODE_PRESENTATION:
            case self::VIEW_MODE_SORTING:
                return $this->ui_factory->input()->container()->form()->standard(
                    $this->ctrl->getFormAction($this, 'save' . $mode),
                    array_map(
                        fn(int $view): Section => $this->getViewByMode($mode, $view),
                        $this->view_settings->getPresentationViews()
                    )
                );
        }
        return null;
    }
 
    public function getViewSectionSorting(int $view, string $title): Section
    {
        if ($this->canWrite()) {
            $this->tpl->addJavaScript("assets/js/SortationUserInputHandler.js");
        }
        $available = $this->view_settings->getAvailableSortOptionsByView($view);
        $options = array_combine($available, $available);
        $select_options = array_map(fn($s) => $this->lng->txt(self::DASH_SORT_PREFIX . $s), $options);
        $available_sorting = array_map($this->sortingInputs($view), $options);
        $default_sorting = $this->ui_factory
            ->input()
            ->field()
            ->select($this->lng->txt('dash_default_sortation'), $select_options)
            ->withValue($this->view_settings->getDefaultSortingByView($view))
            ->withAdditionalOnLoadCode(
                static fn(string $id) => "
                document.getElementById('$id').setAttribute('data-select', 'sorting$view');
                window.addEventListener('DOMContentLoaded', () => il.Dashboard.handleUserInputForSortationsByView($view));
            "
            );
 
        return $this->ui_factory->input()->field()->section(
            $this->maybeDisable([...$available_sorting, 'default_sorting' => $default_sorting]),
            $title
        );
    }
 
    public function getViewByMode(string $mode, int $view): Section
    {
        switch ($mode) {
            case self::VIEW_MODE_SORTING:
                return $this->getViewSectionSorting(
                    $view,
                    $this->lng->txt('dash_' . $this->view_settings->getViewName($view))
                );
            case self::VIEW_MODE_PRESENTATION:
            default:
                return $this->getViewSectionPresentation(
                    $view,
                    $this->lng->txt('dash_' . $this->view_settings->getViewName($view))
                );
        }
    }
 
    public function saveSettings(): void
    {
        if ($this->canWrite()) {
            $form_data = $this->request->getParsedBody();
            foreach ($this->view_settings->getPresentationViews() as $presentation_view) {
                if (isset($form_data['main_panel']['enable'][$presentation_view])) {
                    $this->view_settings->enableView(
                        $presentation_view,
                        (bool) $form_data['main_panel']['enable'][$presentation_view]
                    );
                } elseif ($presentation_view !== ilPDSelectedItemsBlockConstants::VIEW_RECOMMENDED_CONTENT) {
                    $this->view_settings->enableView($presentation_view, false);
                }
            }
 
            $positions = $form_data['main_panel']['position'];
            asort($positions);
            $this->view_settings->setViewPositions(array_keys($positions));
 
            foreach ($this->side_panel_settings->getValidModules() as $mod) {
                $this->side_panel_settings->enable($mod, (bool) ($form_data['side_panel']['enable'][$mod] ?? false));
            }
 
            $positions = $form_data['side_panel']['position'];
            asort($positions);
            $this->side_panel_settings->setPositions(array_keys($positions));
 
            $this->tpl->setOnScreenMessage($this->tpl::MESSAGE_TYPE_SUCCESS, $this->lng->txt('settings_saved'), true);
        } else {
            $this->tpl->setOnScreenMessage($this->tpl::MESSAGE_TYPE_FAILURE, $this->lng->txt('no_permission'), true);
        }
        $this->ctrl->redirect($this, 'editSettings');
    }
 
    public function setSettingsSubTabs(string $a_active): void
    {
        $tabs = $this->tabs_gui;
        $ctrl = $this->ctrl;
        $lng = $this->lng;
 
        if ($this->rbac_system->checkAccess('read', $this->object->getRefId())) {
            $tabs->addSubTab(
                'general',
                $lng->txt('general_settings'),
                $ctrl->getLinkTarget($this, 'editSettings')
            );
 
            $tabs->addSubTab(
                'presentation',
                $lng->txt('dash_presentation'),
                $ctrl->getLinkTarget($this, 'editPresentation')
            );
 
            $tabs->addSubTab(
                'sorting',
                $lng->txt('dash_sortation'),
                $ctrl->getLinkTarget($this, 'editSorting')
            );
        }
 
        $tabs->activateSubTab($a_active);
    }
 
    public function editPresentation(): void
    {
        $this->tabs_gui->activateTab('settings');
        $this->setSettingsSubTabs('presentation');
 
        $form = $this->getViewForm(self::VIEW_MODE_PRESENTATION);
 
        $this->tpl->setContent($this->ui_renderer->renderAsync($form));
    }
 
    public function editCustomization(): void
    {
        $this->ui->mainTemplate()->setOnScreenMessage(
            $this->ui->mainTemplate()::MESSAGE_TYPE_INFO,
            $this->lng->txt('dash_page_edit_info'),
            true
        );
 
        $this->tabs_gui->activateTab('dash_customization');
 
        $content = $this->ui->renderer()->render(
            $this->ui->factory()->button()->standard(
                $this->lng->txt('customize_page'),
                $this->ctrl->getLinkTargetByClass([self::class, ilDashboardPageLanguageSelectGUI::class], 'select')
            )
        );
 
        if (ilDashboardPageGUI::isLanguageAvailable($this->user->getLanguage())) {
            $content .= (new ilDashboardPageGUI($this->user->getLanguage()))->showPage();
        } elseif (ilDashboardPageGUI::isLanguageAvailable($this->lng->getContentLanguage())) {
            $content .= (new ilDashboardPageGUI($this->lng->getDefaultLanguage()))->showPage();
        }
 
        $this->tpl->setContent($content);
    }
 
    public function getViewSectionPresentation(int $view, string $title): Section
    {
        $lng = $this->lng;
        $ops = $this->view_settings->getAvailablePresentationsByView($view);
        $pres_options = array_column(
            array_map(
                static fn(int $k, string $v): array => [$v, $lng->txt('dash_' . $v)],
                array_keys($ops),
                $ops
            ),
            1,
            0
        );
        $avail_pres = $this->ui_factory->input()->field()->multiSelect(
            $lng->txt('dash_avail_presentation'),
            $pres_options
        )
                                       ->withValue($this->view_settings->getActivePresentationsByView($view));
        $default_pres = $this->ui_factory->input()->field()->radio($lng->txt('dash_default_presentation'))
                                         ->withOption('list', $lng->txt('dash_list'))
                                         ->withOption('tile', $lng->txt('dash_tile'));
        $default_pres = $default_pres->withValue($this->view_settings->getDefaultPresentationByView($view));
        return $this->ui_factory->input()->field()->section(
            $this->maybeDisable(['avail_pres' => $avail_pres, 'default_pres' => $default_pres]),
            $title
        );
    }
 
    protected function savePresentation(): void
    {
        if ($this->canWrite()) {
            $data = $this->getViewForm(self::VIEW_MODE_PRESENTATION)->withRequest($this->request)->getData();
 
            foreach ($data as $view => $view_data) {
                $this->view_settings->storeViewPresentation(
                    $view,
                    $view_data['default_pres'],
                    $view_data['avail_pres'] ?? []
                );
            }
            $this->tpl->setOnScreenMessage($this->tpl::MESSAGE_TYPE_SUCCESS, $this->lng->txt('msg_obj_modified'), true);
        } else {
            $this->tpl->setOnScreenMessage($this->tpl::MESSAGE_TYPE_FAILURE, $this->lng->txt('no_permission'), true);
        }
        $this->ctrl->redirect($this, 'editPresentation');
    }
 
    public function saveSorting(): void
    {
        $form = null;
        if ($this->canWrite()) {
            $form = $this->getViewForm(self::VIEW_MODE_SORTING)->withRequest($this->request);
            $data = $form->getData();
            if ($data) {
                foreach ($data as $view => $view_data) {
                    $avail_sorting = array_keys(array_filter($view_data));
                    $saved = array_filter($view_data, fn($x) => !is_bool($x));
                    if (isset($view_data['default_sorting'])) {
                        $this->view_settings->storeViewSorting(
                            $view,
                            $view_data['default_sorting'],
                            $avail_sorting
                        );
                        $this->view_settings->storeViewSortingOptions($view, $saved);
                    }
                }
                $this->tpl->setOnScreenMessage($this->tpl::MESSAGE_TYPE_SUCCESS, $this->lng->txt('msg_obj_modified'), true);
            } else {
                $this->editSorting($form);
                return;
            }
        } else {
            $this->tpl->setOnScreenMessage($this->tpl::MESSAGE_TYPE_FAILURE, $this->lng->txt('no_permission'), true);
        }
        $this->ctrl->redirect($this, 'editSorting');
    }
 
    private function maybeDisable(array $fields): array
    {
        if ($this->canWrite()) {
            return $fields;
        }
 
        return array_map(static fn(FormInput $field): FormInput => $field->withDisabled(true), $fields);
    }
 
    private function canWrite(): bool
    {
        return $this->rbac_system->checkAccess('write', $this->object->getRefId());
    }
 
    private function manuallySortingSettings(int $view, string $name, array $saved): Input
    {
        $options = $this->view_settings->getSortingOptionsByView($view);
        $sort_options = $this->view_settings->getAvailableOptionsBySortation($name);
        $value = isset($saved[$name]) ?
            ['new_items' => ($options[$name]['new_items'] ?? null) ?: 'top'] :
            null;
 
        return $this->ui_factory->input()->field()->optionalGroup([
            'new_items' => array_reduce(
                $sort_options,
                fn($r, $o) => $r->withOption($o, $this->lng->txt('dash_manual_new_item_pos_' . $o)),
                $this->ui_factory->input()->field()->radio($this->lng->txt('dash_manual_new_item_pos'), '')
            )
        ], $this->lng->txt(self::DASH_SORT_PREFIX . $name))
            ->withValue($value);
    }
 
    private function sortingCheckbox(int $view, string $name, array $saved): Input
    {
        return $this->ui_factory->input()->field()
            ->checkbox($this->lng->txt(self::DASH_SORT_PREFIX . $name))
            ->withAdditionalOnLoadCode(fn(string $id) => "
                document.getElementById('$id').closest('form').addEventListener('submit', e => (
                    e.target.querySelectorAll('input[disabled]').forEach(x => {x.disabled = false;})
                ));
            ")
            ->withValue(isset($saved[$name]));
    }
 
    private function sortingInputs(int $view): Closure
    {
        $saved = array_flip($this->view_settings->getActiveSortingsByView($view));
        $with_js = fn($name, $check) => $check->withAdditionalOnLoadCode(fn($id) => "
            document.getElementById('$id').setAttribute('data-checkbox', 'activeSorting$view');
            document.querySelector('#$id input').setAttribute('data-value', '$name')
        ");
 
        $special_settings = ['manually'];
        $method_for = fn($name) => in_array($name, $special_settings, true) ?
            $name . 'SortingSettings' :
            'sortingCheckbox';
 
        return fn(string $name) => $with_js($name, $this->{$method_for($name)}($view, $name, $saved));
    }
}