Duration.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\UI\Implementation\Component\Input\Field;
 
use ILIAS\UI\Component as C;
use ILIAS\Data\Factory as DataFactory;
use ILIAS\Data\DateFormat\DateFormat;
use ILIAS\Refinery as Refinery;
use ILIAS\Refinery\Constraint;
use ILIAS\UI\Implementation\Component\ComponentHelper;
use ILIAS\UI\Implementation\Component\JavaScriptBindable;
use DateTimeImmutable;
use Closure;
use ILIAS\Language\Language;
 
class Duration extends Group implements C\Input\Field\Duration
{
    use ComponentHelper;
    use JavaScriptBindable;
 
    protected DateFormat $format;
    protected DateTimeImmutable $min_date;
    protected DateTimeImmutable $max_date;
    protected bool $with_time = false;
    protected bool $with_time_only = false;
    protected ?string $timezone = null;
 
    public function __construct(
        DataFactory $data_factory,
        \ILIAS\Refinery\Factory $refinery,
        Language $lng,
        Factory $field_factory,
        string $label,
        ?string $byline
    ) {
        $inputs = [
            $field_factory->dateTime($lng->txt('duration_default_label_start'), null)->withDedicatedName('start'),
            $field_factory->dateTime($lng->txt('duration_default_label_end'), null)->withDedicatedName('end')
        ];
 
        parent::__construct($data_factory, $refinery, $lng, $inputs, $label, $byline);
 
        $this->addTransformation();
        $this->addValidation();
    }
 
    protected function addTransformation(): void
    {
        $duration = $this->refinery->custom()->transformation(function ($v): ?array {
            list($from, $until) = $v;
            if ($from && $until) {
                return ['start' => $from, 'end' => $until, 'interval' => $from->diff($until)];
            }
            return null;
        });
        $this->setAdditionalTransformation($duration);
    }
 
    protected function addValidation(): void
    {
        $txt_id = 'duration_end_must_not_be_earlier_than_start';
        $error = fn(callable $txt, $value) => $txt($txt_id, $value);
        $is_ok = function ($v) {
            if (is_null($v)) {
                return true;
            }
            return $v['start'] <= $v['end'];
        };
 
        $from_before_until = $this->refinery->custom()->constraint($is_ok, $error);
        $this->setAdditionalTransformation($from_before_until);
    }
 
    public function withFormat(DateFormat $format): C\Input\Field\Duration
    {
        $clone = clone $this;
        $clone->format = $format;
        $clone->applyFormat();
        return $clone;
    }
 
    public function getFormat(): DateFormat
    {
        return $this->format;
    }
 
    protected function applyFormat(): void
    {
        $this->inputs = array_map(
            fn($input) => $input->withFormat($this->getFormat()),
            $this->inputs
        );
    }
 
    public function withMinValue(DateTimeImmutable $date): C\Input\Field\Duration
    {
        $clone = clone $this;
        $clone->min_date = $date;
        $clone->applyMinValue();
        return $clone;
    }
 
    protected function applyMinValue(): void
    {
        $this->inputs = array_map(
            fn($input) => $input->withMinValue($this->getMinValue()),
            $this->inputs
        );
    }
 
    public function getMinValue(): ?DateTimeImmutable
    {
        return $this->min_date;
    }
 
    public function withMaxValue(DateTimeImmutable $date): C\Input\Field\Duration
    {
        $clone = clone $this;
        $clone->max_date = $date;
        $clone->applyMaxValue();
        return $clone;
    }
 
    protected function applyMaxValue(): void
    {
        $this->inputs = array_map(
            fn($inpt) => $inpt->withMaxValue($this->getMaxValue()),
            $this->inputs
        );
    }
 
    public function getMaxValue(): ?DateTimeImmutable
    {
        return $this->max_date;
    }
 
    public function withTimeOnly(bool $time_only): C\Input\Field\Duration
    {
        $clone = clone $this;
        $clone->with_time_only = $time_only;
        $clone->applyWithTimeOnly();
        return $clone;
    }
 
    protected function applyWithTimeOnly(): void
    {
        $this->inputs = array_map(
            fn($input) => $input->withTimeOnly($this->getTimeOnly()),
            $this->inputs
        );
    }
 
    public function getTimeOnly(): bool
    {
        return $this->with_time_only;
    }
 
    public function withUseTime(bool $with_time): C\Input\Field\Duration
    {
        $clone = clone $this;
        $clone->with_time = $with_time;
        $clone->applyWithUseTime();
        return $clone;
    }
 
    public function getUseTime(): bool
    {
        return $this->with_time;
    }
 
    protected function applyWithUseTime(): void
    {
        $this->inputs = array_map(
            fn($input) => $input->withUseTime($this->getUseTime()),
            $this->inputs
        );
    }
 
    public function withTimezone(string $tz): C\Input\Field\Duration
    {
        $clone = clone $this;
        $clone->timezone = $tz;
        $clone->inputs = array_map(
            fn($input) => $input->withTimezone($tz),
            $clone->inputs
        );
        return $clone;
    }
 
    public function getTimezone(): ?string
    {
        return $this->timezone;
    }
 
    protected function isClientSideValueOk($value): bool
    {
        return true;
    }
 
    protected function getConstraintForRequirement(): ?Constraint
    {
        if ($this->requirement_constraint !== null) {
            return $this->requirement_constraint;
        }
 
        return null;
    }
 
    public function getUpdateOnLoadCode(): Closure
    {
        return static fn($id) => <<<JS
          (function () {
            function formatDateTimeValue(value) {
              const date = new Date(value);
              if (value.includes('T')) {
                return date.toLocaleString([], { dateStyle: 'short', timeStyle: 'short' });
              }
              return date.toLocaleDateString();
            }
            function reduceDateTimeInputs(inputs) {
              return Array
                  .from(dateTimeInputs)
                  .map((input) => (input.value) ? formatDateTimeValue(input.value) : '')
                  .join(' - ');
            }
            const durationField = document.getElementById('$id');
            const dateTimeInputs = durationField.querySelectorAll('.c-field-datetime');
            dateTimeInputs.forEach((input) => {
              input.addEventListener('input', (event) => {
                il.UI.input.onFieldUpdate(event, '$id', reduceDateTimeInputs(dateTimeInputs));
              });
            });
            il.UI.input.onFieldUpdate(undefined, '$id', reduceDateTimeInputs(dateTimeInputs));
          })();
JS;
    }
 
    public function withLabels(string $start_label, string $end_label): C\Input\Field\Duration
    {
        $clone = clone $this;
        $clone->inputs = [
            $clone->inputs[0]->withLabel($start_label),
            $clone->inputs[1]->withLabel($end_label)
        ];
        return $clone;
    }
 
    public function isComplex(): bool
    {
        return true;
    }
}