Input.php

Go to the documentation of this file.

<?php

/* Copyright (c) 2017 Richard Klees <richard.klees@concepts-and-training.de> Extended GPL, see docs/LICENSE */

namespace ILIAS\UI\Implementation\Component\Input\Field;

use ILIAS\Data\Factory as DataFactory;
use ILIAS\Data\Result;
use ILIAS\Refinery\Constraint;
use ILIAS\Refinery\Factory;
use ILIAS\Refinery\Transformation;
use ILIAS\UI\Component as C;
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;

abstract class Input implements C\Input\Field\Input, InputInternal
{
    use ComponentHelper;
    use JavaScriptBindable;
    use Triggerer;
    protected $data_factory;
    protected $refinery;
    protected $label;
    protected $byline;
    protected $is_required = false;
    protected $is_disabled = false;
    protected $value = null;
    protected $error = null;
    private $name = null;
    protected $content = null;
    private $operations;


    public function __construct(
        DataFactory $data_factory,
        Factory $refinery,
        $label,
        $byline
    ) {
        $this->data_factory = $data_factory;
        $this->refinery = $refinery;
        $this->checkStringArg("label", $label);
        if ($byline !== null) {
            $this->checkStringArg("byline", $byline);
        }
        $this->label = $label;
        $this->byline = $byline;
        $this->operations = [];
    }

    // Observable properties of the input as it is shown to the client.


    public function getLabel()
    {
        return $this->label;
    }


    public function withLabel($label)
    {
        $this->checkStringArg("label", $label);
        $clone = clone $this;
        $clone->label = $label;

        return $clone;
    }


    public function getByline()
    {
        return $this->byline;
    }


    public function withByline($byline)
    {
        $this->checkStringArg("byline", $byline);
        $clone = clone $this;
        $clone->byline = $byline;

        return $clone;
    }


    public function isRequired()
    {
        return $this->is_required;
    }


    public function withRequired($is_required)
    {
        $this->checkBoolArg("is_required", $is_required);
        $clone = clone $this;
        $clone->is_required = $is_required;

        return $clone;
    }


    abstract protected function getConstraintForRequirement();


    public function isDisabled()
    {
        return $this->is_disabled;
    }


    public function withDisabled($is_disabled)
    {
        $this->checkBoolArg("is_disabled", $is_disabled);
        $clone = clone $this;
        $clone->is_disabled = $is_disabled;

        return $clone;
    }


    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()
    {
        return $this->error;
    }


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

        return $clone;
    }


    private function setError($error)
    {
        $this->checkStringArg("error", $error);
        $this->error = $error;
    }

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

        return $clone;
    }


    protected function setAdditionalTransformation(Transformation $trafo)
    {
        $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());
            }
        }
    }

    // Implementation of InputInternal

    // This is the machinery to be used to process the input from the client side.
    // This should not be exposed to the consumers of the inputs. These methods
    // should instead only be used by the forms wrapping the input.

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


    public function withNameFrom(NameSource $source)
    {
        $clone = clone $this;
        $clone->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.
        if (!$this->isDisabled()) {
            $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);
        } else {
            $clone = $this;
        }

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

        return $clone;
    }


    protected function applyOperationsTo($res)
    {
        if ($res === null && !$this->isRequired()) {
            return $this->data_factory->ok($res);
        }

        $res = $this->data_factory->ok($res);
        foreach ($this->getOperations() as $op) {
            if ($res->isError()) {
                return $res;
            }

            $res = $op->applyTo($res);
        }

        return $res;
    }


    private function getOperations()
    {
        if ($this->isRequired()) {
            $op = $this->getConstraintForRequirement();
            if ($op !== null) {
                yield $op;
            }
        }

        foreach ($this->operations as $op) {
            yield $op;
        }
    }


    public function getContent()
    {
        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;
    }

    public function withOnUpdate(Signal $signal)
    {
        return $this->withTriggeredSignal($signal, 'update');
    }

    public function appendOnUpdate(Signal $signal)
    {
        return $this->appendTriggeredSignal($signal, 'update');
    }
}