trait.StdObjProperties.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Repository\Form;
 
use ILIAS\DI\Container;
use ILIAS\ILIASObject\Properties\CoreProperties\TitleAndDescription;
use ILIAS\ILIASObject\LocalDIC;
 
trait StdObjProperties
{
    protected \ILIAS\ILIASObject\Properties\Aggregator $object_prop;
 
    protected function initStdObjProperties(Container $DIC): void
    {
        $this->object_prop = LocalDIC::dic()['properties.aggregator'];
    }
 
    public function addStdTitleAndDescription(
        int $obj_id,
        string $type
    ): FormAdapterGUI {
        $obj_prop = $this->object_prop->getFor($obj_id, $type);
        $inputs = $obj_prop
            ->getPropertyTitleAndDescription()
            ->toForm($this->lng, $this->ui->factory()->input()->field(), $this->refinery)->getInputs();
        $this->addField("title", $inputs[0]);
        $this->addField("description", $inputs[1]);
        return $this;
    }
 
    public function addStdTitle(
        int $obj_id,
        string $type
    ): FormAdapterGUI {
        $obj_prop = $this->object_prop->getFor($obj_id, $type);
        $inputs = $obj_prop
            ->getPropertyTitleAndDescription()
            ->toForm($this->lng, $this->ui->factory()->input()->field(), $this->refinery)->getInputs();
        $this->addField("title", $inputs[0]);
        return $this;
    }
 
    public function saveStdTitleAndDescription(
        int $obj_id,
        string $type
    ): void {
        $obj_prop = $this->object_prop->getFor($obj_id, $type);
        $obj_prop->storePropertyTitleAndDescription(
            new TitleAndDescription(
                $this->getData("title"),
                $this->getData("description")
            )
        );
    }
 
    public function saveStdTitle(
        int $obj_id,
        string $type
    ): void {
        $obj_prop = $this->object_prop->getFor($obj_id, $type);
        $obj_prop->storePropertyTitleAndDescription(
            new TitleAndDescription(
                $this->getData("title"),
                ""
            )
        );
    }
 
    public function addStdTile(
        int $obj_id,
        string $type
    ): FormAdapterGUI {
        $obj_prop = $this->object_prop->getFor($obj_id, $type);
        $input = $obj_prop->getPropertyTileImage()
                          ->toForm($this->lng, $this->ui->factory()->input()->field(), $this->refinery);
        $this->addField("tile", $input, true);
        return $this;
    }
 
    public function saveStdTile(
        int $obj_id,
        string $type
    ): void {
        $obj_prop = $this->object_prop->getFor($obj_id, $type);
        $tile = $this->getData("tile");
        if (!is_null($tile)) {
            $obj_prop->storePropertyTileImage($this->getData("tile"));
        }
    }
 
    public function addOnline(
        int $obj_id,
        string $type
    ): FormAdapterGUI {
        $obj_prop = $this->object_prop->getFor($obj_id, $type);
        $input = $obj_prop->getPropertyIsOnline()
                          ->toForm($this->lng, $this->ui->factory()->input()->field(), $this->refinery);
        $this->addField("is_online", $input, true);
        return $this;
    }
 
    public function saveOnline(
        int $obj_id,
        string $type
    ): void {
        $obj_prop = $this->object_prop->getFor($obj_id, $type);
        $obj_prop->storePropertyIsOnline($this->getData("is_online"));
    }
 
    public function addStdAvailability(int $ref_id, $visibility_info = ""): self
    {
        $lng = $this->lng;
        $activation = \ilObjectActivation::getItem($ref_id);
        $start = $end = $visibility = null;
        if (($activation["timing_type"] ?? null) === \ilObjectActivation::TIMINGS_ACTIVATION) {
            $start = (int) $activation["timing_start"];
            $end = (int) $activation["timing_end"];
            $visibility = (bool) $activation["visible"];
        }
        $enabled = ($end > 0) || ($start > 0);
        $form = $this
            ->optional(
                "limited",
                $lng->txt("rep_time_based_availability"),
                "",
                $enabled
            )
            ->dateTimeDuration(
                "availability",
                $this->lng->txt("rep_time_period"),
                "",
                new \ilDateTime($start, IL_CAL_UNIX),
                new \ilDateTime($end, IL_CAL_UNIX)
            )
            ->checkbox(
                "visibility",
                $this->lng->txt("rep_activation_limited_visibility"),
                $visibility_info,
                $visibility
            )
            ->end();
        return $form;
    }
 
    public function saveStdAvailability(int $ref_id): void
    {
        $item = new \ilObjectActivation();
        if (!$this->getData("limited")) {
            $item->setTimingType(\ilObjectActivation::TIMINGS_DEACTIVATED);
        } else {
            $avail = $this->getData("availability");
            $from = $to = null;
            if (!is_null($avail) && !is_null($avail[0])) {
                $from = $avail[0]->getUnixTime();
            }
            if (!is_null($avail) && !is_null($avail[1])) {
                $to = $avail[1]->getUnixTime();
            }
            if ($from > 0 || $to > 0) {
                $item->setTimingType(\ilObjectActivation::TIMINGS_ACTIVATION);
                $item->setTimingStart($from);
                $item->setTimingEnd($to);
                $item->toggleVisible($this->getData("visibility"));
            } else {
                $item->setTimingType(\ilObjectActivation::TIMINGS_DEACTIVATED);
            }
        }
        $item->update($ref_id);
    }
 
 
    public function addAdditionalFeatures(
        int $obj_id,
        array $services
    ): self {
        global $DIC;
 
        $lng = $DIC->language();
 
        $lng->loadLanguageModule("obj");
 
        $form = $this->section("add", $lng->txt("obj_features"));
 
        // (local) custom metadata
        if (in_array(\ilObjectServiceSettingsGUI::CUSTOM_METADATA, $services)) {
            $form = $this->checkbox(
                \ilObjectServiceSettingsGUI::CUSTOM_METADATA,
                $lng->txt('obj_tool_setting_custom_metadata'),
                $lng->txt('obj_tool_setting_custom_metadata_info'),
                (bool) \ilContainer::_lookupContainerSetting(
                    $obj_id,
                    \ilObjectServiceSettingsGUI::CUSTOM_METADATA
                )
            );
        }
 
        // taxonomies
        if (in_array(\ilObjectServiceSettingsGUI::TAXONOMIES, $services)) {
            $form = $this->checkbox(
                \ilObjectServiceSettingsGUI::TAXONOMIES,
                $lng->txt('obj_tool_setting_taxonomies'),
                "",
                (bool) \ilContainer::_lookupContainerSetting(
                    $obj_id,
                    \ilObjectServiceSettingsGUI::TAXONOMIES
                )
            );
        }
 
        if (\in_array(\ilObjectServiceSettingsGUI::ORGU_POSITION_ACCESS, $services, true)) {
            $position_settings = \ilOrgUnitGlobalSettings::getInstance()->getObjectPositionSettingsByType(
                \ilObject::_lookupType($obj_id)
            );
            if ($position_settings->isActive()) {
                $form = $this->checkbox(
                    \ilObjectServiceSettingsGUI::ORGU_POSITION_ACCESS,
                    $lng->txt('obj_orgunit_positions'),
                    $lng->txt('obj_orgunit_positions_info'),
                    \ilOrgUnitGlobalSettings::getInstance()->isPositionAccessActiveForObject($obj_id),
                    !$position_settings->isChangeableForObject()
                );
            }
        }
 
        return $form;
    }
 
    public function saveAdditionalFeatures(
        int $obj_id,
        array $services
    ): void {
        // (local) custom metadata
        $key = \ilObjectServiceSettingsGUI::CUSTOM_METADATA;
        if (in_array($key, $services)) {
            \ilContainer::_writeContainerSetting($obj_id, $key, (string) $this->getData($key));
        }
        // taxonomies
        $key = \ilObjectServiceSettingsGUI::TAXONOMIES;
        if (in_array($key, $services)) {
            \ilContainer::_writeContainerSetting($obj_id, $key, (string) $this->getData($key));
        }
        // extended user access
        if (\in_array(\ilObjectServiceSettingsGUI::ORGU_POSITION_ACCESS, $services, true)) {
            $position_settings = \ilOrgUnitGlobalSettings::getInstance()->getObjectPositionSettingsByType(
                \ilObject::_lookupType($obj_id)
            );
            if ($position_settings->isActive() && $position_settings->isChangeableForObject()) {
                $orgu_object_settings = new \ilOrgUnitObjectPositionSetting($obj_id);
                $orgu_object_settings->setActive($this->getData(\ilObjectServiceSettingsGUI::ORGU_POSITION_ACCESS));
                $orgu_object_settings->update();
            }
        }
    }
 
    public function addDidacticTemplates(
        string $type,
        int $ref_id,
        bool $creation_mode,
        array $additional_template_options = []
    ): self {
        list($existing_exclusive, $options) = $this->buildDidacticTemplateOptions(
            $type,
            $ref_id,
            $additional_template_options
        );
        if (sizeof($options) < 2) {
            return $this;
        }
 
        // workaround for containers in edit mode
        if (!$creation_mode) {
            $current_value = 'dtpl_' . \ilDidacticTemplateObjSettings::lookupTemplateId($ref_id);
 
            if (!in_array(
                $current_value,
                array_keys($options)
            ) || ($existing_exclusive && $current_value == "dtpl_0")) {
                //add or rename actual value to not available
                $options[$current_value] = [$this->lng->txt('not_available')];
            }
        } else {
            if ($existing_exclusive) {
                //if an exclusive template exists use the second template as default value - Whatever the f*** that means!
                $keys = array_keys($options);
                $current_value = $keys[1];
            } else {
                $current_value = 'dtpl_0';
            }
        }
 
        $form = $this->radio(
            'didactic_type',
            $this->lng->txt('type'),
            "",
            $current_value
        );
 
        foreach ($options as $id => $data) {
            /*
            if ($existing_exclusive && $id == 'dtpl_0') {
                //set default disabled if an exclusive template exists
                $option->setDisabled(true);
            }*/
            $form = $this->radioOption(
                (string) $id,
                $data[0] ?? '',
                $data[1] ?? ''
            );
        }
        return $form;
    }
 
    private function buildDidacticTemplateOptions(
        string $type,
        int $ref_id,
        array $additional_template_options = []
    ): array {
        $this->lng->loadLanguageModule('didactic');
        $existing_exclusive = false;
        $options = [];
        $options['dtpl_0'] = [
            $this->lng->txt('didactic_default_type'),
            sprintf(
                $this->lng->txt('didactic_default_type_info'),
                $this->lng->txt('objs_' . $type)
            )
        ];
 
        $templates = \ilDidacticTemplateSettings::getInstanceByObjectType($type)->getTemplates();
        if ($templates) {
            foreach ($templates as $template) {
                if ($template->isEffective((int) $ref_id)) {
                    $options["dtpl_" . $template->getId()] = [
                        $template->getPresentationTitle(),
                        $template->getPresentationDescription()
                    ];
 
                    if ($template->isExclusive()) {
                        $existing_exclusive = true;
                    }
                }
            }
        }
 
        return [$existing_exclusive, array_merge($options, $additional_template_options)];
    }
 
    public function redirectToDidacticConfirmationIfChanged(
        int $ref_id,
        string $type,
        string $gui_class,
        array $additional_template_options = []
    ): void {
        list($existing_exclusive, $options) = $this->buildDidacticTemplateOptions(
            $type,
            $ref_id,
            $additional_template_options
        );
 
        if (sizeof($options) < 2) {
            return;
        }
 
        $current_tpl_id = \ilDidacticTemplateObjSettings::lookupTemplateId(
            $ref_id
        );
        $new_tpl_id = (int) substr($this->getData('didactic_type'), 5);
 
        if ($new_tpl_id !== $current_tpl_id) {
            // redirect to didactic template confirmation
            $this->ctrl->setParameterByClass(\ilDidacticTemplateGUI::class, "didactic_template_id", $new_tpl_id);
            $this->ctrl->redirectByClass([$gui_class, \ilDidacticTemplateGUI::class], "confirmTemplateSwitch");
            return;
        }
    }
 
    public function getDidacticTemplateIdFromRequest(): ?int
    {
        $new_tpl_id = null;
        if ($this->http->wrapper()->query()->has('didactic_template_id')) {
            $new_tpl_id = $this->http->wrapper()->query()->retrieve(
                'didactic_template_id',
                $this->refinery->kindlyTo()->int()
            );
            $this->ctrl->saveParameterByClass(\ilDidacticTemplateGUI::class, "didactic_template_id", $new_tpl_id);
        }
        return $new_tpl_id;
    }
 
 
}