GroupHelper.php

Go to the documentation of this file.

<?php

/* Copyright (c) 2017 Timon Amstutz <timon.amstutz@ilub.unibe.ch> Extended GPL, see
docs/LICENSE */

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

use ILIAS\UI\Component as Component;
use ILIAS\UI\Implementation\Component\Input\InputData;
use ILIAS\UI\Implementation\Component\Input\NameSource;
use ILIAS\Data\Factory as DataFactory;

trait GroupHelper
{
    protected $inputs = [];


    protected function isClientSideValueOk($value)
    {
        return true;
    }


    public function getGroupValues()
    {
        $values = [];
        foreach ($this->getInputs() as $key => $input) {
            $values[$key] = $input->getValue();
        }

        return $values;
    }


    public function withGroupValues($values)
    {
        $this->checkArg("value", $this->isClientSideValueOk($values), "Values given do not match given inputs in group.");

        $clone = clone $this;
        $inputs = [];

        foreach ($this->getInputs() as $key => $input) {
            $inputs[$key] = $input->withValue($values[$key]);
        }

        $clone->inputs = $inputs;

        return $clone;
    }


    protected function isClientGroupSideValueOk($value)
    {
        if (!is_array($value)) {
            return false;
        }
        if (!sizeof($this->getInputs() == sizeof($value))) {
            return false;
        }

        foreach ($this->getInputs() as $key => $input) {
            if (!array_key_exists($key, $value)) {
                return false;
            }
        }

        return true;
    }


    public function withInput(InputData $post_input)
    {
        $clone = parent::withInput($post_input);
        if ($clone->getError()) {
            return $clone;
        }

        return $clone->withGroupInput($post_input);
    }


    protected function withGroupInput(InputData $post_input)
    {
        $clone = $this;

        if (sizeof($this->getInputs()) === 0) {
            return $clone;
        }

        $inputs = [];
        $values = [];
        $error = false;
        foreach ($this->getInputs() as $key => $input) {
            $filled = $input->withInput($post_input);
            //Todo: Is this correct here or should it be getValue? Design decision...
            $content = $filled->getContent();
            if ($content->isOk()) {
                $values[$key] = $content->value();
            } else {
                $error = true;
            }
            $inputs[$key] = $filled;
        }
        $clone->inputs = $inputs;
        if ($error) {
            //Todo: Improve this error message on the group
            $clone->content = $clone->data_factory->error("error in grouped input");

            return $clone;
        }

        if ($clone->content->value()) {
            $group_content = $clone->applyOperationsTo($values);
            $f = $this->data_factory;
            $clone->content = $clone->content->then(function ($value) use ($f, $group_content) {
                if ($group_content->isError()) {
                    return $f->error($group_content->error());
                }

                return $f->ok(["value" => $value, "group_values" => $group_content->value()]);
            });
        } else {
            $clone->content = $clone->applyOperationsTo($values);
        }

        if ($clone->content->isError()) {
            return $clone->withError($clone->content->error());
        }

        return $clone;
    }


    public function withNameFrom(NameSource $source)
    {
        $clone = parent::withNameFrom($source);
        $named_inputs = [];
        foreach ($this->getInputs() as $key => $input) {
            $named_inputs[$key] = $input->withNameFrom($source);
        }

        $clone->inputs = $named_inputs;

        return $clone;
    }


    public function getInputs()
    {
        return $this->inputs;
    }

    protected function getConstraintForRequirement()
    {
        return null;
    }
}