ProvideDocument.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\LegalDocuments\Provide;
 
use Closure;
use ILIAS\Data\Factory;
use ILIAS\Data\Result;
use ILIAS\Data\Result\Error;
use ILIAS\Data\Result\Ok;
use ILIAS\DI\Container;
use ILIAS\LegalDocuments\Condition;
use ILIAS\LegalDocuments\ConditionDefinition;
use ILIAS\LegalDocuments\ConsumerToolbox\UI;
use ILIAS\LegalDocuments\EditLinks;
use ILIAS\LegalDocuments\Repository\DocumentRepository;
use ILIAS\LegalDocuments\SelectionMap;
use ILIAS\LegalDocuments\Table\DocumentModal;
use ILIAS\LegalDocuments\Table\DocumentTable;
use ILIAS\LegalDocuments\Value\Criterion;
use ILIAS\LegalDocuments\Value\CriterionContent;
use ILIAS\LegalDocuments\Value\Document;
use ILIAS\LegalDocuments\Value\DocumentContent;
use ILIAS\UI\Component\Component;
use ILIAS\UI\Component\Input\Field\Group;
use ilObjUser;
 
class ProvideDocument
{
    public const CRITERION_ALREADY_EXISTS = 'Criterion already exists.';
    public const CRITERION_WOULD_NEVER_MATCH = 'Criterion would never match.';
 
    public function __construct(
        private readonly string $id,
        private readonly DocumentRepository $document_repository,
        private readonly SelectionMap $conditions,
        private readonly array $content_as_component,
        private readonly Container $container,
    ) {
    }
 
    public function table(object $gui, ?EditLinks $edit_links = null): DocumentTable
    {
        return new DocumentTable(
            fn($criterion) => $this->toCondition($criterion)->asComponent(),
            $this->document_repository,
            new UI(
                $this->id,
                $this->container->ui(),
                $this->container->language()
            ),
            new DocumentModal($this->container->ui(), $this->contentAsComponent(...)),
            $gui,
            $edit_links,
            $this->container->http()->request(),
            new Factory(),
            $this->container->ctrl(),
            $this->container->ui()->renderer(),
            $this->container->user()
        );
    }
 
    public function chooseDocumentFor(ilObjUser $user): Result
    {
        return $this->find(
            fn(Document $document): bool => $this->documentMatches($document, $user),
            $this->document_repository->all()
        );
    }
 
    public function documentMatches(Document $document, ilObjUser $user): bool
    {
        return $this->all(
            fn($c) => $this->toCondition($c->content())->eval($user),
            $document->criteria()
        );
    }
 
    public function repository(): DocumentRepository
    {
        return $this->document_repository;
    }
 
    public function hash(): string
    {
        return bin2hex(openssl_random_pseudo_bytes((int) floor(255 / 2)));
    }
 
    public function toCondition(CriterionContent $content): Condition
    {
        return $this->conditions->choices()[$content->type()]->withCriterion($content);
    }
 
    public function conditionGroups(?CriterionContent $criterion = null): SelectionMap
    {
        $selected = $criterion ? [
            $criterion->type() => $criterion->arguments()
        ] : [];
 
        $choices = $this->conditions->choices();
        $groups = array_combine(array_keys($choices), array_map(
            fn(ConditionDefinition $condition, string $key) => $condition->formGroup($selected[$key] ?? []),
            array_values($choices),
            array_keys($choices)
        ));
 
        return new SelectionMap($groups, $this->conditions->defaultSelection());
    }
 
    public function validateCriteriaContent(array $criteria, CriterionContent $content): Result
    {
        return array_reduce(
            $criteria,
            $this->validateAgainst(...),
            new Ok($content)
        );
    }
 
    public function contentAsComponent(DocumentContent $content): Component
    {
        return $this->content_as_component[$content->type()]($content);
    }
 
    private function validateAgainst(Result $b, Criterion $a): Result
    {
        return $b->then(function (CriterionContent $b) use ($a) {
            $a = $a->content();
            if ($a->equals($b)) {
                return new Error(self::CRITERION_ALREADY_EXISTS);
            }
            $a = $this->toCondition($a);
            if ($a->knownToNeverMatchWith($this->toCondition($b))) {
                return new Error(self::CRITERION_WOULD_NEVER_MATCH);
            }
            return new Ok($b);
        });
    }
 
    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);
    }
}