Input.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\UI\Implementation\Component\Input;

use ILIAS\Data\Factory as DataFactory;
use ILIAS\Data\Result;
use ILIAS\Refinery\Constraint;
use ILIAS\Refinery\Factory as Refinery;
use ILIAS\Refinery\Transformation;
use ILIAS\UI\Component\Signal;
use ILIAS\UI\Implementation\Component\ComponentHelper;
use ILIAS\UI\Implementation\Component\Input\InputData;
use ILIAS\UI\Implementation\Component\Input\NameSource;
use ILIAS\UI\Implementation\Component\JavaScriptBindable;
use ILIAS\UI\Implementation\Component\Triggerer;
use LogicException;
use Generator;
use InvalidArgumentException;
use ILIAS\UI\Implementation\Component\Input\DynamicInputsNameSource;

abstract class Input implements InputInternal
{
    use ComponentHelper;

    protected $value = null;

    protected ?string $error = null;

    private ?string $name = null;

    protected ?string $dedicated_name = null;

    protected ?Result $content = null;

    protected array $operations = [];

    protected DataFactory $data_factory;
    protected Refinery $refinery;

    public function __construct(
        DataFactory $data_factory,
        Refinery $refinery
    ) {
        $this->data_factory = $data_factory;
        $this->refinery = $refinery;
    }

    public function getValue()
    {
        return $this->value;
    }

    public function withValue($value)
    {
        $this->checkArg("value", $this->isClientSideValueOk($value), "Display value does not match input type.");
        $clone = clone $this;
        $clone->value = $value;
        return $clone;
    }

    abstract protected function isClientSideValueOk($value): bool;

    public function getError(): ?string
    {
        return $this->error;
    }

    public function withError(string $error)
    {
        $clone = clone $this;
        $clone->setError($error);
        return $clone;
    }

    private function setError(string $error): void
    {
        $this->error = $error;
    }

    public function withAdditionalTransformation(Transformation $trafo)
    {
        $clone = clone $this;
        $clone->setAdditionalTransformation($trafo);
        return $clone;
    }

    protected function setAdditionalTransformation(Transformation $trafo): void
    {
        $this->operations[] = $trafo;
        if ($this->content !== null) {
            if (!$this->content->isError()) {
                $this->content = $trafo->applyTo($this->content);
            }
            if ($this->content->isError()) {
                $this->setError($this->content->error());
            }
        }
    }

    final public function getDedicatedName(): ?string
    {
        return $this->dedicated_name;
    }

    final public function withDedicatedName(string $dedicated_name): self
    {
        $clone = clone $this;
        $clone->dedicated_name = $dedicated_name;
        return $clone;
    }

    final public function getName(): ?string
    {
        return $this->name;
    }

    public function withNameFrom(NameSource $source, ?string $parent_name = null)
    {
        $clone = clone $this;
        if ($source instanceof DynamicInputsNameSource) {
            $clone->name = '';
        } else {
            $clone->name = ($parent_name !== null) ? $parent_name . '/' : '';
        }
        $clone->name .= ($clone->dedicated_name !== null)
                        ? $source->getNewDedicatedName($clone->dedicated_name)
                        : $source->getNewName();
        return $clone;
    }

    public function withInput(InputData $input)
    {
        if ($this->getName() === null) {
            throw new LogicException("Can only collect if input has a name.");
        }


        //TODO: Discuss, is this correct here. If there is no input contained in this post
        //We assign null. Note that unset checkboxes are not contained in POST.
        $value = $input->getOr($this->getName(), null);
        // ATTENTION: There was a special case for the Filter Input Container here,
        // which lead to #27909. The issue will most certainly appear again in. If
        // you are the one debugging it and came here: Please don't put knowledge
        // of the special case for the filter in this general class. Have a look
        // into https://mantis.ilias.de/view.php?id=27909 for the according discussion.
        $clone = $this->withValue($value);

        $clone->content = $this->applyOperationsTo($clone->getValue());
        if ($clone->content->isError()) {
            $error = $clone->content->error();
            if ($error instanceof \Exception) {
                $error = $error->getMessage();
            }
            return $clone->withError("" . $error);
        }

        return $clone;
    }

    protected function applyOperationsTo($res): Result
    {
        $res = $this->data_factory->ok($res);
        foreach ($this->getOperations() as $op) {
            if ($res->isError()) {
                return $res;
            }
            $res = $op->applyTo($res);
        }

        return $res;
    }

    protected function getOperations(): Generator
    {
        foreach ($this->operations as $op) {
            yield $op;
        }
    }

    public function getContent(): Result
    {
        if (is_null($this->content)) {
            throw new LogicException("No content of this field has been evaluated yet. Seems withRequest was not called.");
        }
        return $this->content;
    }
}