SwitchableGroup.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\UI\Implementation\Component\Input\Field;
 
use ILIAS\Data\Factory as DataFactory;
use ILIAS\Refinery\Constraint;
use ILIAS\UI\Implementation\Component\JavaScriptBindable;
use ILIAS\UI\Implementation\Component\Input\Input;
use ILIAS\UI\Implementation\Component\Triggerer;
use ILIAS\UI\Component\Input\InputData;
use ILIAS\UI\Component\Input\Field as I;
use ILIAS\Language\Language;
use LogicException;
use InvalidArgumentException;
 
class SwitchableGroup extends Group implements I\SwitchableGroup
{
    use JavaScriptBindable;
    use Triggerer;
 
    public function __construct(
        DataFactory $data_factory,
        \ILIAS\Refinery\Factory $refinery,
        Language $lng,
        array $inputs,
        string $label,
        ?string $byline = null
    ) {
        $this->checkArgListElements('inputs', $inputs, [I\Group::class]);
        parent::__construct($data_factory, $refinery, $lng, $inputs, $label, $byline);
    }
 
    protected function getConstraintForRequirement(): ?Constraint
    {
        if ($this->requirement_constraint !== null) {
            return $this->requirement_constraint;
        }
 
        return null;
    }
 
    protected function isClientSideValueOk($value): bool
    {
        if (is_string($value) || is_int($value)) {
            return array_key_exists($value, $this->getInputs());
        }
        if (!is_array($value)) {
            return false;
        }
        [$key, $group_value] = $value;
        if (!array_key_exists($key, $this->getInputs())) {
            return false;
        }
        return $this->inputs[$key]->isClientSideValueOk($group_value);
    }
 
    public function withRequired($is_required, ?Constraint $requirement_constraint = null): self
    {
        return FormInput::withRequired($is_required, $requirement_constraint);
    }
 
    public function withValue($value): self
    {
        $this->checkArg('value', null === $value || $this->isClientSideValueOk($value), 'Display value does not match input type.');
        if (null === $value || is_string($value) || is_int($value)) {
            return Input::withValue($value);
        }
        [$key, $group_value] = $value;
        $clone = Input::withValue($key);
        $clone->setInputs($clone->getInputsWithOperationForKey($key, fn($i) => $i->withValue($group_value)));
        return $clone;
    }
 
    public function getValue()
    {
        $key = Input::getValue();
        if (is_null($key)) {
            return null;
        }
 
        $input = $this->getInputs()[$key] ?? null;
        if (null === $input) {
            return null;
        }
 
        return [$key, $input->getValue()];
    }
 
    public function withInput(InputData $input): self
    {
        if ($this->getName() === null) {
            throw new LogicException("Can only collect if input has a name.");
        }
 
        $key = $input->getOr($this->getName(), "");
        $clone = clone $this;
 
        if ($key === "") {
            if ($this->isRequired()) {
                $clone->content = $clone->data_factory->error($this->lng->txt("ui_error_switchable_group_required"));
                return $clone->withError("" . $clone->content->error());
            }
 
            $clone->content = $clone->data_factory->ok([$key, []]);
            return $clone;
        }
 
        if (!$this->isDisabled()) {
            $clone = $clone->withValue($key);
            $clone->setInputs($clone->getInputsWithOperationForKey($key, fn($i) => $i->withInput($input)));
        }
 
        $inputs = $clone->getInputs();
        if (!array_key_exists($key, $inputs)) {
            $clone->content = $clone->data_factory->ok([$key, []]);
            return $clone;
        }
 
        if ($inputs[$key]->getContent()->isError()) {
            $clone->content = $clone->data_factory->error($this->lng->txt("ui_error_in_group"));
            return $clone;
        }
 
        $contents = [];
        foreach ($inputs[$key]->getInputs() as $subkey => $group_input) {
            $content = $group_input->getContent();
            if ($content->isOK()) {
                $contents[$subkey] = $content->value();
            }
        }
 
        $clone->content = $this->applyOperationsTo([$key, $contents]);
        if ($clone->content->isError()) {
            return $clone->withError("" . $clone->content->error());
        }
 
        return $clone;
    }
 
    protected function getInputsWithOperationForKey(int|string $key, \Closure $operation): array
    {
        $inputs = $this->getInputs();
        if (!array_key_exists($key, $inputs)) {
            throw new LogicException("Key '$key' does not exist in inputs.");
        }
        $inputs[$key] = $operation($inputs[$key]);
        return $inputs;
    }
}