Conductor.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\LegalDocuments;

use ilNonEditableValueGUI;
use ILIAS\UI\Component\Modal\Modal;
use ILIAS\DI\Container;
use ILIAS\LegalDocuments\ConsumerSlots\SelfRegistration;
use ILIAS\LegalDocuments\ConsumerSlots\SelfRegistration\Bundle;
use Closure;
use ILIAS\Data\Result;
use ILIAS\Data\Result\Ok;
use ILIAS\Data\Result\Error;
use ILIAS\Refinery\Transformation;
use ilStartUpGUI;
use ilObjUser;
use Exception;
use ILIAS\Data\Factory as DataFactory;
use ilLegalDocumentsAgreementGUI;
use ilInitialisation;
use ILIAS\LegalDocuments\ConsumerToolbox\SelectSetting;
use ILIAS\LegalDocuments\ConsumerToolbox\KeyValueStore\SessionStore;
use ILIAS\LegalDocuments\ConsumerToolbox\Marshal;
use ILIAS\LegalDocuments\ConsumerToolbox\Routing;
use ILIAS\components\Authentication\Logout\LogoutTarget;
use ILIAS\LegalDocuments\Value\Target;

class Conductor
{
    private readonly Internal $internal;
    private readonly Routing $routing;

    private array $modals = [];

    public function __construct(private readonly Container $container, ?Internal $internal = null, Routing $routing = null)
    {
        $this->internal = $internal ?? $this->createInternal();
        $this->routing = $routing ?? new Routing(
            $this->container->ctrl(),
            new SelectSetting(new SessionStore(), new Marshal($this->container->refinery())),
            ilInitialisation::redirectToStartingPage(...),
            ilStartUpGUI::logoutUrl(...)
        );
    }

    public function provide(string $id): Provide
    {
        return new Provide($id, $this->internal, $this->container);
    }

    public function loginPageHTML(string $id): string
    {
        $create = $this->internal->get('show-on-login-page', $id);
        if (!$create) {
            return '';
        }
        return $this->container->ui()->renderer()->render($create());
    }

    public function logoutText(): string
    {
        try {
            $id = $this->container->http()->wrapper()->query()->retrieve(
                'withdraw_consent',
                $this->container->refinery()->to()->string()
            );
        } catch (Exception) {
            return '';
        }

        $logout_text = $this->internal->get('logout-text', $id);

        return null === $logout_text ? '' : $this->container->ui()->renderer()->render($logout_text());
    }

    public function logoutTarget(LogoutTarget $target): LogoutTarget
    {
        return new WithdrawalAcknowledgementLogoutTarget(
            $target,
            $this->container->http()->wrapper()->query()->has('withdraw_consent'),
            $this->container->ctrl()
        );
    }

    public function modifyFooter(Closure $footer): Closure
    {
        return array_reduce($this->internal->all('footer'), fn(Closure $footer, Closure $proc) => $proc($footer), $footer);
    }

    public function agree(string $gui, string $cmd): void
    {
        $this->setMainTemplateContent($this->agreeContent($gui, $cmd));
    }

    public function agreeContent(string $gui, string $cmd): string
    {
        $key = ilLegalDocumentsAgreementGUI::class === $gui ? 'agreement-form' : 'public-page';
        $result = $this->byQueryParams($gui, $cmd, $key)->then($this->renderPageFragment($gui, $cmd));

        if (!$result->isOk() && $result->error() === 'Not available.') {
            $this->routing->redirectToOriginalTarget();
        }

        return $result->value();
    }

    public function withdraw(string $gui, string $cmd): void
    {
        $this->setMainTemplateContent($this->byQueryParams($gui, $cmd, 'withdraw')->then($this->renderPageFragment($gui, $cmd))->value());
    }

    public function usersWithHiddenOnlineStatus(array $users): array
    {
        $filters = $this->internal->all('filter-online-users');

        $visible_users = array_reduce(
            $filters,
            fn($users, $only_visible_users) => $only_visible_users($users),
            $users,
        );

        return array_values(array_diff($users, $visible_users));
    }

    public function userCanReadInternalMail(): Transformation
    {
        return $this->container->refinery()->in()->series(array_values($this->internal->all('constrain-internal-mail')));
    }

    public function canUseSoapApi(): Transformation
    {
        return $this->container->refinery()->in()->series(array_values($this->internal->all('use-soap-api')));
    }

    public function afterLogin(): void
    {
        array_map(fn($proc) => $proc(), $this->internal->all('after-login'));
    }

    public function findGotoLink(string $goto_target): Result
    {
        return $this->find(
            fn($goto_link) => $goto_link->name() === $goto_target,
            $this->internal->all('goto')
        )->map(fn($goto_link) => $goto_link->target());
    }

    public function intercepting(): array
    {
        return $this->internal->all('intercept');
    }

    public function selfRegistration(): SelfRegistration
    {
        return new Bundle($this->internal->all('self-registration'));
    }

    public function userManagementFields(ilObjUser $user): array
    {
        $this->modals = [];
        return array_reduce(
            $this->internal->all('user-management-fields'),
            fn(array $prev, callable $f): array => [
                ...$prev,
                ...array_map(function ($val) {
                    if (is_array($val)) {
                        $this->find(fn($x) => $x instanceof Modal, $val)
                             ->map(fn($modal) => array_push($this->modals, $modal));
                        return $this->find(fn($x) => $x instanceof ilNonEditableValueGUI, $val)->value();
                    }
                    return $val;
                }, $f($user))
            ],
            []
        );
    }

    public function userManagementModals(): string
    {
        $string = $this->container->ui()->renderer()->render($this->modals);
        $this->modals = [];

        return $string;
    }

    private function find(Closure $predicate, array $array): Result
    {
        foreach ($array as $x) {
            if ($predicate($x)) {
                return new Ok($x);
            }
        }

        return new Error('Not found.');
    }

    private function any(Closure $predicate, array $array): bool
    {
        return $this->find($predicate, $array)->isOk();
    }

    private function all(Closure $predicate, array $array): bool
    {
        return !$this->any(static fn($x) => !$predicate($x), $array);
    }

    private function byQueryParams(string $gui, string $cmd, string $key): Result
    {
        try {
            $id = $this->container->http()->wrapper()->query()->retrieve('id', $this->container->refinery()->to()->string());
        } catch (Exception) {
            return new Error('No provider ID given.');
        }

        $this->container->ctrl()->setParameterByClass($gui, 'id', $id);

        $value = $this->internal->get($key, $id);

        if (null === $value) {
            return new Error('Field not defined.');
        }

        return new Ok($value);
    }

    private function renderPageFragment(string $gui, string $cmd): Closure
    {
        return fn(Closure $proc) => $proc($gui, $cmd)->map(fn($fragment) => $fragment->render(
            $this->container->ui()->mainTemplate(),
            $this->container->ui()->renderer()
        ));
    }

    private function setMainTemplateContent(string $content): void
    {
        $this->container->ui()->mainTemplate()->setContent($content);
    }

    private function createInternal(): Internal
    {
        $clock = (new DataFactory())->clock()->system();
        $action = new UserAction($this->container->user(), $clock);

        return new Internal($this->provide(...), fn(string $id) => new Wiring(new SlotConstructor(
            $id,
            $this->container,
            $action
        )));
    }
}