LSOAdaptiveContent.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\LearningSequence\Content\Adaptive;
 
use ilCtrl;
use ilGlobalTemplateInterface;
use ILIAS\LearningSequence\Content\Condition\AbstractCondition;
use ILIAS\LearningSequence\Content\Condition\ConditionTypes;
use ILIAS\LearningSequence\Content\Condition\StaticInputConfigurationAnalyzer;
use ILIAS\LearningSequence\Content\Condition\StaticInputConfigurationIssue;
use ILIAS\LearningSequence\Content\Condition\StaticInputConfigurationIssueDetail;
use ILIAS\LearningSequence\Content\LSOContentController;
use ILIAS\LearningSequence\Content\LSOContentDeletion;
use ILIAS\LearningSequence\Player\AdaptiveNavigator;
use ILIAS\UI\Factory;
use ILIAS\UI\Renderer;
use ilLanguage;
use ilLink;
use ilObject;
use ilObjLearningSequence;
use ilObjLearningSequenceActionData;
use ilObjLearningSequenceConditionData;
use ilObjLearningSequenceConditionsGUI;
use ilObjLearningSequenceContentData;
use ilObjLearningSequenceContentGUI;
use Psr\Http\Message\ServerRequestInterface;
 
class LSOAdaptiveContent implements LSOContentController
{
    use LSOContentDeletion;
 
    protected ilObjLearningSequenceContentGUI $parent_gui;
    protected Factory $ui_factory;
    protected Renderer $ui_renderer;
    protected ilLanguage $lng;
    protected ilCtrl $ctrl;
    protected ServerRequestInterface $request;
    protected ilGlobalTemplateInterface $tpl;
    protected int $ref_id;
    protected int $obj_id;
    private ?ilObjLearningSequence $lso = null;
 
    public function __construct(
        ilObjLearningSequenceContentGUI $parent_gui,
        Factory $ui_factory,
        Renderer $ui_renderer,
        ilLanguage $lng,
        ilCtrl $ctrl,
        ServerRequestInterface $request,
        ilGlobalTemplateInterface $tpl,
        int $ref_id,
        int $obj_id
    ) {
        $this->parent_gui = $parent_gui;
        $this->ui_factory = $ui_factory;
        $this->ui_renderer = $ui_renderer;
        $this->lng = $lng;
        $this->ctrl = $ctrl;
        $this->request = $request;
        $this->tpl = $tpl;
        $this->ref_id = $ref_id;
        $this->obj_id = $obj_id;
    }
 
    public function getSupportedCommands(): array
    {
        return [
            ilObjLearningSequenceContentGUI::CMD_MANAGE_CONTENT,
            ilObjLearningSequenceContentGUI::CMD_SET_START_OBJECT,
            ilObjLearningSequenceContentGUI::CMD_UNSET_START_OBJECT,
            ilObjLearningSequenceContentGUI::CMD_SET_END_OBJECT,
            ilObjLearningSequenceContentGUI::CMD_UNSET_END_OBJECT,
            ilObjLearningSequenceContentGUI::CMD_DELETE,
        ];
    }
 
    public function manageContent(): void
    {
        // Restore the "add new object" drilldown in the toolbar so that new
        // objects can be created directly from the content management view.
        $this->parent_gui->showPossibleSubObjects();
 
        $lso = $this->getLSO();
        $items = $lso->getLSItems();
        $navigator = new AdaptiveNavigator($lso->getDI()["conditions.factory"]);
        $navigator->preload($items);
        $structural_successors = [];
        foreach ($items as $item) {
            $structural_successors[$item->getRefId()] = array_map(
                static fn(\LSItem $successor): int => $successor->getRefId(),
                $navigator->getStructuralSuccessors($items, $item)
            );
        }
        $filter_gui = new LSOAdaptiveFilter($this->ui_factory, $this->lng, $this->ctrl, $this->parent_gui);
        $filter = $filter_gui->getFilter(
            'manageContent',
            $this->getInputConditionOptions(),
            $this->getOutputConditionOptions()
        )->withRequest($this->request);
 
        $filter_data = $filter->getData();
        $analyzer = new StaticInputConfigurationAnalyzer();
        $static_input_configuration_issues = $this->getStaticInputConfigurationIssues($items, $navigator);
        $misconfigured_ref_ids = array_fill_keys(
            $analyzer->getAffectedRefIds($static_input_configuration_issues),
            true
        );
        $issue_details_by_ref_id = $analyzer->getIssueDetailsByRefId($static_input_configuration_issues);
        $data = $this->getTableData(
            $items,
            $filter_data,
            $structural_successors,
            $misconfigured_ref_ids,
            $issue_details_by_ref_id
        );
 
        $boundaries_db = $this->getBoundaries();
        $boundary_data = $boundaries_db->getBoundariesFor($this->obj_id);
 
        $missing_hints = [];
        if ((int) $boundary_data['start_ref_id'] === 0) {
            $missing_hints[] = $this->lng->txt('lso_adaptive_missing_start_object');
        }
        if ((int) $boundary_data['end_ref_id'] === 0) {
            $missing_hints[] = $this->lng->txt('lso_adaptive_missing_end_object');
        }
        if ($missing_hints !== []) {
            $this->tpl->setOnScreenMessage('info', implode('<br>', $missing_hints));
        }
 
        $table = new LSOAdaptiveTable(
            $this->ui_factory,
            $this->ui_renderer,
            $data,
            $filter,
            (int) $boundary_data['start_ref_id'],
            (int) $boundary_data['end_ref_id'],
            $this->parent_gui,
            $this->ref_id,
            $this->lng,
            $this->ctrl,
            $this->request,
            $this->tpl
        );
 
        $this->parent_gui->setContent(
            $table->render()
        );
    }
 
    protected function getStaticInputConfigurationIssues(array $items, AdaptiveNavigator $navigator): array
    {
        $conditions_by_ref_id = [];
        foreach ($items as $item) {
            $conditions_by_ref_id[$item->getRefId()] = $navigator->getInputConditions($item);
        }
 
        return (new StaticInputConfigurationAnalyzer())->getIssues($conditions_by_ref_id);
    }
 
    protected function isMisconfiguredRefId(int $ref_id, array $misconfigured_ref_ids): bool
    {
        return isset($misconfigured_ref_ids[$ref_id]);
    }
 
    protected function getObjectTitleList(array $ref_ids): string
    {
        $titles = [];
        foreach (array_unique($ref_ids) as $ref_id) {
            $titles[] = ilObject::_lookupTitle(ilObject::_lookupObjId($ref_id));
        }
        sort($titles);
 
        if ($titles === []) {
            return $this->lng->txt('no_conditions');
        }
 
        return implode(', ', $titles);
    }
 
    protected function getTableData(
        array $items,
        ?array $filter_data,
        array $structural_successors,
        array $misconfigured_ref_ids,
        array $issue_details_by_ref_id
    ): array {
        $boundaries_db = $this->getBoundaries();
        $boundary_data = $boundaries_db->getBoundariesFor($this->obj_id);
        $start_ref_id = $boundary_data['start_ref_id'];
        $end_ref_id = $boundary_data['end_ref_id'];
 
        $structural_predecessors = [];
        foreach ($structural_successors as $source_ref_id => $successor_ref_ids) {
            foreach ($successor_ref_ids as $successor_ref_id) {
                $structural_predecessors[$successor_ref_id][] = (int) $source_ref_id;
            }
        }
 
        $name_filter = $filter_data['name'] ?? '';
        $input_filter = $filter_data['input_conditions'] ?? [];
        $output_filter = $filter_data['output_conditions'] ?? [];
        $online_filter = $filter_data['online_status'] ?? null;
        $position_filter = $filter_data['position'] ?? [];
 
        usort($items, function ($a, $b) use ($start_ref_id, $end_ref_id) {
            if ($a->getRefId() === $start_ref_id) {
                return -1;
            }
            if ($b->getRefId() === $start_ref_id) {
                return 1;
            }
            if ($a->getRefId() === $end_ref_id) {
                return 1;
            }
            if ($b->getRefId() === $end_ref_id) {
                return -1;
            }
            return $a->getOrderNumber() <=> $b->getOrderNumber();
        });
 
        $condition_handler = $this->getLSO()->getDI()["conditions.handler"];
        $lso_ref_id = $this->ref_id;
 
        $data = [];
        foreach ($items as $index => $item) {
            $ref_id = $item->getRefId();
            $obj_id = ilObject::_lookupObjId($ref_id);
            $title = ilObject::_lookupTitle($obj_id);
 
            if ($name_filter !== '' && mb_stripos($title, $name_filter) === false) {
                continue;
            }
 
            if ($online_filter !== null && $online_filter !== '') {
                $is_online = $item->isOnline();
                if ($online_filter === 'online' && !$is_online) {
                    continue;
                }
                if ($online_filter === 'offline' && $is_online) {
                    continue;
                }
            }
 
            if (count($position_filter) > 0) {
                $is_start = ($ref_id === $start_ref_id);
                $is_end = ($ref_id === $end_ref_id);
                $matches_position =
                    (in_array('start', $position_filter, true) && $is_start)
                    || (in_array('end', $position_filter, true) && $is_end);
                if (!$matches_position) {
                    continue;
                }
            }
 
            $type = $item->getType();
 
            $input_conditions = [];
            $db_input_conditions = $condition_handler->getInputConditionsByRefId($lso_ref_id, $ref_id);
            foreach ($db_input_conditions as $db_cond) {
                $input_conditions[] = new ilObjLearningSequenceConditionData(
                    title: $db_cond['title'],
                    value: $db_cond['value'],
                    internal_name: $db_cond['internal_name']
                );
            }
 
            $output_conditions = [];
            $db_output_conditions = $condition_handler->getOutputConditionsByRefId($lso_ref_id, $ref_id);
            foreach ($db_output_conditions as $db_cond) {
                $output_conditions[] = new ilObjLearningSequenceConditionData(
                    title: $db_cond['title'],
                    value: $db_cond['value'],
                    internal_name: $db_cond['internal_name']
                );
            }
 
            if (count($input_filter) > 0) {
                $found = false;
                foreach ($input_conditions as $ic) {
                    if (in_array($ic->internal_name, $input_filter)) {
                        $found = true;
                        break;
                    }
                }
                if (!$found) {
                    continue;
                }
            }
 
            if (count($output_filter) > 0) {
                $found = false;
                foreach ($output_conditions as $oc) {
                    if (in_array($oc->internal_name, $output_filter)) {
                        $found = true;
                        break;
                    }
                }
                if (!$found) {
                    continue;
                }
            }
 
            // Information
            $prev_title = $this->getObjectTitleList($structural_predecessors[$ref_id] ?? []);
            $next_title = $this->getObjectTitleList($structural_successors[$ref_id] ?? []);
 
            $icon_path = ilObject::_getIcon($obj_id, "small", $type);
            $actions = $this->parent_gui->getTableActionHandler()->collectActions(
                $ref_id,
                $this->getSpecificActions(
                    $ref_id,
                    $start_ref_id,
                    $end_ref_id
                ),
                $item->isOnline()
            );
 
            $row = new ilObjLearningSequenceContentData(
                $ref_id,
                $obj_id,
                $title,
                ilObject::_lookupDescription($obj_id),
                $type,
                $icon_path,
                ilLink::_getLink($ref_id, $type),
                $item->isOnline(),
                ($ref_id === $start_ref_id) ? 'Start' : '',
                ($ref_id === $end_ref_id) ? 'End' : '',
                $prev_title,
                $next_title,
                $input_conditions,
                $output_conditions,
                $this->isMisconfiguredRefId($ref_id, $misconfigured_ref_ids),
                $issue_details_by_ref_id[$ref_id] ?? [],
                ($structural_predecessors[$ref_id] ?? []) !== [],
                ($structural_successors[$ref_id] ?? []) !== [],
                $actions
            );
 
            $data[] = $row;
        }
 
        return $data;
    }
 
    protected function getInputConditionOptions(): array
    {
        return $this->buildConditionOptions(
            $this->getConditionTypes()->getAllInputConditions()
        );
    }
 
    protected function getOutputConditionOptions(): array
    {
        return $this->buildConditionOptions(
            $this->getConditionTypes()->getAllOutputConditions()
        );
    }
 
    private function getConditionTypes(): ConditionTypes
    {
        return $this->getLSO()->getDI()["conditions.types"];
    }
 
    private function getBoundaries(): LSOAdaptiveBoundaries
    {
        return $this->getLSO()->getDI()["db.boundaries"];
    }
 
    private function getLSO(): ilObjLearningSequence
    {
        if ($this->lso === null) {
            $lso = ilObjLearningSequence::getInstanceByRefId($this->ref_id);
            $this->lso = $lso;
        }
        return $this->lso;
    }
 
    private function buildConditionOptions(array $condition_classes): array
    {
        $options = [];
        foreach ($condition_classes as $class) {
            $condition = new $class();
            $options[AbstractCondition::getIdentifierForClass($class)] = $this->lng->txt((string) $condition->getName());
        }
        return $options;
    }
 
    public function getSpecificActions(int $ref_id, int $start_ref_id, int $end_ref_id): array
    {
        $specific_actions = [];
 
        // 1. Conditions
        $this->ctrl->setParameterByClass(ilObjLearningSequenceConditionsGUI::class, 'item_ref_id', $ref_id);
        $link = $this->ctrl->getLinkTargetByClass(ilObjLearningSequenceConditionsGUI::class, 'manageConditions');
        $specific_actions['conditions'] = new ilObjLearningSequenceActionData(
            label: $this->lng->txt('conditions'),
            link: $link
        );
 
        // 2. Start / End Switcher
        if ($ref_id > 0) {
            if ($ref_id === $start_ref_id) {
                $label = $this->lng->txt('unset_start_object');
                $link = ilObjLearningSequenceContentGUI::CMD_UNSET_START_OBJECT;
                $id = 'unset_start';
            } else {
                $label = $this->lng->txt('set_start_object');
                $link = ilObjLearningSequenceContentGUI::CMD_SET_START_OBJECT;
                $id = 'set_start';
            }
            $this->ctrl->setParameter($this->parent_gui, 'item_ref_id', $ref_id);
            $link = $this->ctrl->getLinkTarget($this->parent_gui, $link);
            $specific_actions[$id] = new ilObjLearningSequenceActionData(label: $label, link: $link);
 
            if ($ref_id === $end_ref_id) {
                $label = $this->lng->txt('unset_end_object');
                $link = ilObjLearningSequenceContentGUI::CMD_UNSET_END_OBJECT;
                $id = 'unset_end';
            } else {
                $label = $this->lng->txt('set_end_object');
                $link = ilObjLearningSequenceContentGUI::CMD_SET_END_OBJECT;
                $id = 'set_end';
            }
            $this->ctrl->setParameter($this->parent_gui, 'item_ref_id', $ref_id);
            $link = $this->ctrl->getLinkTarget($this->parent_gui, $link);
            $specific_actions[$id] = new ilObjLearningSequenceActionData(label: $label, link: $link);
        } else {
            // Template
            $specific_actions['set_start'] = new ilObjLearningSequenceActionData(
                label: $this->lng->txt('set_start_object'),
                link: ilObjLearningSequenceContentGUI::CMD_SET_START_OBJECT
            );
            $specific_actions['unset_start'] = new ilObjLearningSequenceActionData(
                label: $this->lng->txt('unset_start_object'),
                link: ilObjLearningSequenceContentGUI::CMD_UNSET_START_OBJECT
            );
            $specific_actions['set_end'] = new ilObjLearningSequenceActionData(
                label: $this->lng->txt('set_end_object'),
                link: ilObjLearningSequenceContentGUI::CMD_SET_END_OBJECT
            );
            $specific_actions['unset_end'] = new ilObjLearningSequenceActionData(
                label: $this->lng->txt('unset_end_object'),
                link: ilObjLearningSequenceContentGUI::CMD_UNSET_END_OBJECT
            );
        }
 
        $this->ctrl->setParameterByClass(ilObjLearningSequenceConditionsGUI::class, 'item_ref_id', '');
        return $specific_actions;
    }
 
    public function setStartObject(): void
    {
        $ref_id = $this->parent_gui->extractItemRefId();
        if ($ref_id > 0) {
            $boundaries = $this->getBoundaries();
            $current = $boundaries->getBoundariesFor($this->obj_id);
            if ((int) $current['end_ref_id'] === $ref_id) {
                // An object must never be start and end object at the same time.
                $this->tpl->setOnScreenMessage(
                    'failure',
                    $this->lng->txt('lso_adaptive_start_end_not_same'),
                    true
                );
                $this->ctrl->redirect($this->parent_gui, ilObjLearningSequenceContentGUI::CMD_MANAGE_CONTENT);
            }
            $boundaries->setStartRefId($this->obj_id, $ref_id);
            $this->tpl->setOnScreenMessage('success', $this->lng->txt('msg_obj_modified'), true);
        }
        $this->ctrl->redirect($this->parent_gui, ilObjLearningSequenceContentGUI::CMD_MANAGE_CONTENT);
    }
 
    public function unsetStartObject(): void
    {
        $boundaries = $this->getBoundaries();
        $boundaries->unsetStartRefId($this->obj_id);
        $this->tpl->setOnScreenMessage('success', $this->lng->txt('msg_obj_modified'), true);
 
        $this->enforceOfflineForMissingBoundaries($this->getLSO());
        $this->ctrl->redirect($this->parent_gui, ilObjLearningSequenceContentGUI::CMD_MANAGE_CONTENT);
    }
 
    public function setEndObject(): void
    {
        $ref_id = $this->parent_gui->extractItemRefId();
        if ($ref_id > 0) {
            $boundaries = $this->getBoundaries();
            $current = $boundaries->getBoundariesFor($this->obj_id);
            if ((int) $current['start_ref_id'] === $ref_id) {
                // An object must never be start and end object at the same time.
                $this->tpl->setOnScreenMessage(
                    'failure',
                    $this->lng->txt('lso_adaptive_start_end_not_same'),
                    true
                );
                $this->ctrl->redirect($this->parent_gui, ilObjLearningSequenceContentGUI::CMD_MANAGE_CONTENT);
            }
            $boundaries->setEndRefId($this->obj_id, $ref_id);
            $this->tpl->setOnScreenMessage('success', $this->lng->txt('msg_obj_modified'), true);
        }
        $this->ctrl->redirect($this->parent_gui, ilObjLearningSequenceContentGUI::CMD_MANAGE_CONTENT);
    }
 
    public function unsetEndObject(): void
    {
        $boundaries = $this->getBoundaries();
        $boundaries->unsetEndRefId($this->obj_id);
        $this->tpl->setOnScreenMessage('success', $this->lng->txt('msg_obj_modified'), true);
 
        $this->enforceOfflineForMissingBoundaries($this->getLSO());
        $this->ctrl->redirect($this->parent_gui, ilObjLearningSequenceContentGUI::CMD_MANAGE_CONTENT);
    }
}