class.ilDateDurationInputGUI.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
class ilDateDurationInputGUI extends ilSubEnabledFormPropertyGUI implements ilTableFilterItem
{
    protected ilObjUser $user;
 
    protected ?ilDateTime $start = null;
    protected ?int $startyear = null;
    protected ?string $start_text = null;
    protected ?string $end_text = null;
    protected int $minute_step_size = 5;
    protected ?ilDateTime $end = null;
    protected bool $showtime = false;
    protected bool $toggle_fulltime = false;
    protected string $toggle_fulltime_txt = '';
    protected bool $toggle_fulltime_checked = false;
    protected bool $allowOpenIntervals = false;
    protected string $invalid_input_start = '';
    protected string $invalid_input_end = '';
 
    public function __construct(
        string $a_title = "",
        string $a_postvar = ""
    ) {
        global $DIC;
 
        $this->lng = $DIC->language();
        $this->user = $DIC->user();
        parent::__construct($a_title, $a_postvar);
        $this->setType("dateduration");
    }
 
    // Enable toggling between date and time
    public function enableToggleFullTime(
        string $a_title,
        bool $a_checked
    ): void {
        $this->toggle_fulltime_txt = $a_title;
        $this->toggle_fulltime_checked = $a_checked;
        $this->toggle_fulltime = true;
    }
 
    public function enabledToggleFullTime(): bool
    {
        return $this->toggle_fulltime;
    }
 
    public function setStart(?ilDateTime $a_date = null): void
    {
        $this->start = $a_date;
    }
 
    public function setStartText(string $a_txt): void
    {
        $this->start_text = $a_txt;
    }
 
    public function getStartText(): ?string
    {
        return $this->start_text;
    }
 
    public function setEndText(string $a_txt): void
    {
        $this->end_text = $a_txt;
    }
 
    public function getEndText(): ?string
    {
        return $this->end_text;
    }
 
    public function getStart(): ?ilDateTime
    {
        return $this->start;
    }
 
    public function setEnd(?ilDateTime $a_date = null): void
    {
        $this->end = $a_date;
    }
 
    public function getEnd(): ?ilDateTime
    {
        return $this->end;
    }
 
    public function setShowTime(bool $a_showtime): void
    {
        $this->showtime = $a_showtime;
    }
 
    public function getShowTime(): bool
    {
        return $this->showtime;
    }
 
    public function setStartYear(int $a_year): void
    {
        $this->startyear = $a_year;
    }
 
    public function getStartYear(): ?int
    {
        return $this->startyear;
    }
 
    public function setMinuteStepSize(int $a_step_size): void
    {
        $this->minute_step_size = $a_step_size;
    }
 
    public function getMinuteStepSize(): int
    {
        return 1;
    }
 
    public function setValueByArray(array $a_values): void
    {
        $incoming = $a_values[$this->getPostVar()] ?? [];
        if (is_array($incoming) && $incoming !== []) {
            $format = isset($incoming['tgl']) ? 0 : $this->getDatePickerTimeFormat();
            $this->toggle_fulltime_checked = (bool) ($incoming['tgl'] ?? false);
 
            if ($this->openIntervalsAllowed()) {
                if (isset($incoming['start']) && is_string($incoming['start']) && trim($incoming['start']) !== '') {
                    $this->setStart(ilCalendarUtil::parseIncomingDate($incoming["start"], (bool) $format));
                } else {
                    $this->setStart(new ilDate(null, IL_CAL_UNIX));
                }
 
                if (isset($incoming['end']) && is_string($incoming['end']) && trim($incoming['end']) !== '') {
                    $this->setEnd(ilCalendarUtil::parseIncomingDate($incoming["end"], (bool) $format));
                } else {
                    $this->setEnd(new ilDate(null, IL_CAL_UNIX));
                }
            } else {
                # 0033160
                if ($incoming['start'] instanceof ilDateTime) {
                    $this->setStart($incoming['start']);
                } else {
                    $this->setStart(ilCalendarUtil::parseIncomingDate((string) $incoming["start"], (bool) $format));
                }
                if ($incoming['end'] instanceof ilDateTime) {
                    $this->setEnd($incoming['end']);
                } else {
                    $this->setEnd(ilCalendarUtil::parseIncomingDate((string) $incoming["end"], (bool) $format));
                }
            }
        }
 
        foreach ($this->getSubItems() as $item) {
            $item->setValueByArray($a_values);
        }
    }
 
    public function checkInput(): bool
    {
        $lng = $this->lng;
 
        if ($this->getDisabled()) {
            return true;
        }
 
        $post = $this->strArray($this->getPostVar());
 
        $start = $post["start"] ?? '';
        $end = $post["end"] ?? '';
 
        // if full day is active, ignore time format
        $format = isset($post['tgl'])
            ? 0
            : $this->getDatePickerTimeFormat();
 
        // always done to make sure there are no obsolete values left
        $this->setStart();
        $this->setEnd();
 
        $valid_start = false;
        if (trim($start)) {
            $parsed = ilCalendarUtil::parseIncomingDate($start, (bool) $format);
            if ($parsed) {
                $this->setStart($parsed);
                $valid_start = true;
            }
        } elseif (!$this->getRequired() && !trim($end)) {
            $valid_start = true;
        } elseif ($this->openIntervalsAllowed() && !strlen(trim($start))) {
            $valid_start = true;
        }
 
        $valid_end = false;
        if (trim($end)) {
            $parsed = ilCalendarUtil::parseIncomingDate($end, (bool) $format);
            if ($parsed) {
                $this->setEnd($parsed);
                $valid_end = true;
            }
        } elseif (!$this->getRequired() && !trim($start)) {
            $valid_end = true;
        } elseif ($this->openIntervalsAllowed() && !strlen(trim($end))) {
            $valid_end = true;
        }
 
        if ($this->getStartYear()) {
            if ($valid_start &&
                $this->getStart()->get(IL_CAL_FKT_DATE, "Y") < $this->getStartYear()) {
                $valid_start = false;
            }
            if ($valid_end &&
                $this->getEnd()->get(IL_CAL_FKT_DATE, "Y") < $this->getStartYear()) {
                $valid_end = false;
            }
        }
        $valid = ($valid_start && $valid_end);
 
        if ($valid &&
            $this->getStart() &&
            $this->getEnd() &&
            ilDateTime::_after($this->getStart(), $this->getEnd())) {
            $valid = false;
        }
 
        if ($this->openIntervalsAllowed()) {
            $valid = true;
        } elseif (!$valid) {
            $this->invalid_input_start = $start;
            $this->invalid_input_end = $end;
            $this->setAlert($lng->txt("form_msg_wrong_date"));
        }
 
        if ($valid) {
            $valid = $this->checkSubItemsInput();
        }
 
        return $valid;
    }
 
    public function getInput(): array
    {
        $ret = $this->strArray($this->getPostVar());
 
        if ($this->openIntervalsAllowed()) {
            if (!$this->getStart()) {
                $ret["start"] = null;
            }
 
            if (!$this->getEnd()) {
                $ret["end"] = null;
            }
        } elseif (
            !$this->getStart() ||
            !$this->getEnd()
        ) {
            $ret["start"] = null;
            $ret["end"] = null;
        }
        $ret["fullday"] = (bool) ($ret["tgl"] ?? false);
        return $ret;
    }
 
    protected function getDatePickerTimeFormat(): int
    {
        return (int) $this->getShowTime();
    }
 
    protected function getDatetimeFormatForInput(): string
    {
        $format = 'Y-m-d';
        if ($this->getShowTime()) {
            $format .= '\TH:i';
        }
        return $format;
    }
 
    public function render(): string
    {
        $ilUser = $this->user;
        $lng = $this->lng;
        $toggle_id = null;
 
        $tpl = new ilTemplate("tpl.prop_datetime_duration.html", true, true, "components/ILIAS/Form");
 
        if ($this->enabledToggleFullTime()) {
            $this->setShowTime(true);
 
            $toggle_id = 't' . md5($this->getPostVar() . '_fulltime'); // :TODO: unique?
 
            $tpl->setCurrentBlock('toggle_fullday');
            $tpl->setVariable('DATE_TOGGLE_ID', $this->getPostVar() . '[tgl]');
            $tpl->setVariable('FULLDAY_TOGGLE_ID', $toggle_id);
            $tpl->setVariable('FULLDAY_TOGGLE_CHECKED', $this->toggle_fulltime_checked ? 'checked="checked"' : '');
            $tpl->setVariable('FULLDAY_TOGGLE_DISABLED', $this->getDisabled() ? 'disabled="disabled"' : '');
            $tpl->setVariable('TXT_TOGGLE_FULLDAY', $this->toggle_fulltime_txt);
            $tpl->parseCurrentBlock();
        }
 
        // config picker
        if (!$this->getDisabled()) {
            // :TODO: unique?
            $picker_start_id = 'p' . md5($this->getPostVar() . '_start');
            $picker_end_id = 'p' . md5($this->getPostVar() . '_end');
 
            $tpl->setVariable('DATEPICKER_START_ID', $picker_start_id);
            $tpl->setVariable('DATEPICKER_END_ID', $picker_end_id);
 
            $this->global_tpl->addOnLoadCode(
                'il.Form.initDateDurationPicker("' .
                $picker_start_id . '","' .
                $picker_end_id . '","' .
                $toggle_id .
                '");'
            );
        } else {
            $tpl->setVariable('DATEPICKER_START_DISABLED', 'disabled="disabled" ');
            $tpl->setVariable('DATEPICKER_END_DISABLED', 'disabled="disabled" ');
        }
 
        $type = 'date';
        if ($this->getShowTime()) {
            $type = 'datetime-local';
        }
        $tpl->setVariable('DATEPICKER_START_TYPE', $type);
        $tpl->setVariable('DATEPICKER_END_TYPE', $type);
 
        $start_txt = $this->getStartText();
        if ($start_txt === null) {
            $start_txt = $lng->txt("form_date_duration_start");
        }
        if (trim($start_txt)) {
            $tpl->setVariable('START_LABEL', $start_txt);
            $tpl->setVariable('START_ARIA_LABEL', ilLegacyFormElementsUtil::prepareFormOutput($start_txt));
            $tpl->touchBlock('start_width_bl');
        }
 
        $end_txt = $this->getEndText();
        if ($end_txt === null) {
            $end_txt = $lng->txt("form_date_duration_end");
        }
        if (trim($end_txt)) {
            $tpl->setVariable('END_LABEL', $end_txt);
            $tpl->setVariable('END_ARIA_LABEL', ilLegacyFormElementsUtil::prepareFormOutput($end_txt));
            $tpl->touchBlock('end_width_bl');
        }
 
 
        $tpl->setVariable('DATE_START_ID', $this->getPostVar() . '[start]');
        $tpl->setVariable('DATE_END_ID', $this->getPostVar() . '[end]');
 
        /*
         * For date input, step is in days, for datetime-local
         * it is in seconds.
         */
        $step_size = 60;
        if (!$this->getShowTime()) {
            $step_size = 1;
        }
        $tpl->setVariable('DATEPICKER_START_STEP', $step_size);
        $tpl->setVariable('DATEPICKER_END_STEP', $step_size);
 
        if ($this->getStartYear()) {
            $min = DateTimeImmutable::createFromFormat(
                'Y',
                (string) $this->getStartYear()
            )->format($this->getDatetimeFormatForInput());
            $tpl->setVariable('DATEPICKER_START_MIN', $min);
            $tpl->setVariable('DATEPICKER_END_MIN', $min);
        }
 
        // values
 
        $out_format = $this->getDatetimeFormatForInput();
        $date_value = $this->prepareInvalidInputAsValue($this->invalid_input_start);
        if (!$date_value &&
            $this->getStart()) {
            $date_value = $this->getStart()->get(IL_CAL_FKT_DATE, $out_format, $ilUser->getTimeZone());
        }
        $tpl->setVariable('DATEPICKER_START_VALUE', $date_value);
 
        $date_value = $this->prepareInvalidInputAsValue($this->invalid_input_end);
        if (!$date_value &&
            $this->getEnd()) {
            $date_value = $this->getEnd()->get(IL_CAL_FKT_DATE, $out_format, $ilUser->getTimeZone());
        }
        $tpl->setVariable('DATEPICKER_END_VALUE', $date_value);
 
        if ($this->getRequired()) {
            $tpl->setVariable("START_REQUIRED", "required=\"required\"");
            $tpl->setVariable("END_REQUIRED", "required=\"required\"");
        }
 
        return $tpl->get();
    }
 
    protected function prepareInvalidInputAsValue(string $invalid_input): string
    {
        $timestamp = strtotime(htmlspecialchars($invalid_input));
        if ($timestamp === false) {
            return '';
        }
        return date($this->getDatetimeFormatForInput(), $timestamp);
    }
 
 
    public function insert(ilTemplate $a_tpl): void
    {
        $html = $this->render();
 
        $a_tpl->setCurrentBlock("prop_generic");
        $a_tpl->setVariable("PROP_GENERIC", $html);
        $a_tpl->parseCurrentBlock();
    }
 
    public function getTableFilterHTML(): string
    {
        return $this->render();
    }
 
    public function getValue(): array
    {
        return array(
            'start' => $this->getStart() ? $this->getStart()->get(IL_CAL_UNIX) : null,
            'end' => $this->getEnd() ? $this->getEnd()->get(IL_CAL_UNIX) : null
        );
    }
 
    public function setValue($value): void
    {
        if (is_array($value)) {
            $this->setStart(new ilDateTime($value['start'], IL_CAL_UNIX));
            $this->setEnd(new ilDateTime($value['end'], IL_CAL_UNIX));
        }
    }
 
    public function hideSubForm(): bool
    {
        if ($this->invalid_input_start ||
            $this->invalid_input_end) {
            return false;
        }
 
        return ((!$this->getStart() || $this->getStart()->isNull()) &&
            (!$this->getEnd() || $this->getEnd()->isNull()));
    }
 
    public function openIntervalsAllowed(): bool
    {
        return $this->allowOpenIntervals;
    }
 
    public function setAllowOpenIntervals(bool $allowOpenInterval): void
    {
        $this->allowOpenIntervals = $allowOpenInterval;
    }
 
    public function getTableFilterLabelFor(): string
    {
        return $this->getFieldId() . "[start]";
    }
 
    public function getFormLabelFor(): string
    {
        return $this->getFieldId() . "[start]";
    }
}