class_DateAttribute.inc

<?php
/*
  This code is part of FusionDirectory (http://www.fusiondirectory.org/)

  Copyright (C) 2012-2019  FusionDirectory

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*/

class DateAttribute extends \FusionDirectory\Core\SimplePlugin\Attribute
{
  protected $format;
  protected $minDate = NULL;
  protected $maxDate = NULL;

  function __construct (string $label, string $description, string $ldapName, bool $required, string $format, $defaultValue = 'today', $min = NULL, $max = NULL, string $acl = '')
  {
    parent::__construct($label, $description, $ldapName, $required, $defaultValue, $acl);
    $this->format = $format;
    if ($min !== NULL) {
      try {
        $this->minDate = new DateTime($min, new DateTimeZone('UTC'));
      } catch (Exception $e) {
        // Failed to parse min date, ignore
      }
    }
    if ($max !== NULL) {
      try {
        $this->maxDate = new DateTime($max, new DateTimeZone('UTC'));
      } catch (Exception $e) {
        // Failed to parse max date, ignore
      }
    }
  }

  function inputValue ($value)
  {
    if (
        ($value === '') ||
        ($this->isTemplate() && preg_match('/%/', $value))
      ) {
      return $value;
    } else {
      return $this->ldapToDate($value);
    }
  }

  function getValue ()
  {
    if ($this->value === '') {
      return $this->value;
    } else {
      try {
        return $this->getDateValue()->format('Y-m-d');
      } catch (Exception $e) {
        return $this->value;
      }
    }
  }

  protected function ldapToDate ($ldapValue)
  {
    $date = DateTime::createFromFormat('!'.$this->format, $ldapValue, new DateTimeZone('UTC'));
    if ($date !== FALSE) {
      return $date;
    } else {
      return $ldapValue;
    }
  }

  protected function dateToLdap (DateTime $dateValue)
  {
    return $dateValue->format($this->format);
  }

  function getDateValue ()
  {
    $value = $this->value;
    if (!($value instanceof DateTime)) {
      try {
        $value = new DateTime($value, new DateTimeZone('UTC'));
      } catch (Exception $e) {
        /* Fallback to LdapGeneralizedTime to accept LDAP format */
        try {
          $value = LdapGeneralizedTime::fromString($value);
        } catch (LdapGeneralizedTimeBadFormatException $e2) {
          throw $e;
        }
      }
    }
    return $value;
  }

  function computeLdapValue ()
  {
    if ($this->value === '') {
      return $this->value;
    } elseif (!($this->value instanceof DateTime)) {
      try {
        $this->setValue($this->getDateValue());
      } catch (Exception $e) {
        return $this->value;
      }
    }
    return $this->dateToLdap($this->value);
  }

  function check ()
  {
    $error = parent::check();
    if (!empty($error)) {
      return $error;
    } else {
      if (empty($this->value)) {
        return '';
      }
      try {
        $dateValue = $this->getDateValue();
        if (($this->minDate !== NULL) && ($dateValue < $this->minDate)) {
          return new SimplePluginCheckError(
            $this,
            SimplePluginCheckError::invalidValue(sprintf(_('%s is older than %s'), $dateValue->format('Y-m-d'), $this->minDate->format('Y-m-d')))
          );
        }
        if (($this->maxDate !== NULL) && ($dateValue > $this->maxDate)) {
          return new SimplePluginCheckError(
            $this,
            SimplePluginCheckError::invalidValue(sprintf(_('%s is newer than %s'), $dateValue->format('Y-m-d'), $this->maxDate->format('Y-m-d')))
          );
        }
      } catch (Exception $e) {
        if ($this->isTemplate() && preg_match('/%/', $this->value)) {
          return '';
        } else {
          return new SimplePluginCheckError(
            $this,
            SimplePluginCheckError::invalidValue(sprintf(_('Incorrect date: %s'), $e->getMessage())),
            0,
            $e
          );
        }
      }
      return '';
    }
  }

  function renderFormInput (): string
  {
    $attributes = [
      'value'   => $this->getValue(),
      'pattern' => '[0-9]{4}-[0-9]{2}-[0-9]{2}',
    ];
    if ($this->minDate !== NULL) {
      $attributes['min'] = $this->minDate->format('Y-m-d');
    }
    if ($this->maxDate !== NULL) {
      $attributes['max'] = $this->maxDate->format('Y-m-d');
    }
    $display = $this->renderInputField('date', $this->getHtmlId(), $attributes);
    return $this->renderAcl($display);
  }

  function renderTemplateInput (): string
  {
    $id = $this->getHtmlId();
    $attributes = [
      'value' => $this->getValue()
    ];
    if ($this->isSubAttribute) {
      $attributes['class'] = 'subattribute';
    }
    $display = $this->renderInputField('text', $id, $attributes);
    return $this->renderAcl($display);
  }
}

class GeneralizedTimeDateAttribute extends DateAttribute
{
  function __construct (string $label, string $description, string $ldapName, bool $required, $defaultValue = 'today', $min = NULL, $max = NULL, string $acl = '')
  {
    parent::__construct($label, $description, $ldapName, $required, '', $defaultValue, $min, $max, $acl);
  }

  protected function ldapToDate ($ldapValue)
  {
    try {
      return LdapGeneralizedTime::fromString($ldapValue);
    } catch (LdapGeneralizedTimeBadFormatException $e) {
      return $ldapValue;
    }
  }

  protected function dateToLdap (DateTime $dateValue)
  {
    return LdapGeneralizedTime::toString($dateValue);
  }
}

class TimeHisAttribute extends CompositeAttribute
{
  protected $convert;

  function __construct ($label, $description, $ldapName, $required, $convert = TRUE, $acl = '')
  {
    $this->convert = $convert;
    $attributes = [
      new IntAttribute(
        '',  _('Hours'),
        $ldapName.'_hours', TRUE,
        0, 23, 1
      ),
      new IntAttribute(
        ':', _('Minutes'),
        $ldapName.'_minutes', TRUE,
        0, 59, 0
      ),
      new IntAttribute(
        ':', _('Seconds'),
        $ldapName.'_seconds', TRUE,
        0, 59, 0
      )
    ];
    parent::__construct($description, $ldapName, $attributes, '/^(\d\d)(\d\d)(\d\d)$/', '%02d%02d%02d', $acl, $label);
    $this->setLinearRendering(TRUE);
  }

  function readValues (string $value): array
  {
    $values = parent::readValues($value);
    if ($this->convert) {
      $datetime = new DateTime('T'.implode(':', $values), timezone::utc());

      $datetime->setTimeZone(timezone::getDefaultTimeZone());
      if (count($values) < 3) {
        $values = explode(':', $datetime->format('H:i'));
      } else {
        $values = explode(':', $datetime->format('H:i:s'));
      }
    }
    return $values;
  }

  function writeValues (array $values)
  {
    if ($this->convert) {
      $datetime = new DateTime('T'.implode(':', $values), timezone::getDefaultTimeZone());
      $datetime->setTimeZone(timezone::utc());
      if (count($values) < 3) {
        $values = explode(':', $datetime->format('H:i'));
      } else {
        $values = explode(':', $datetime->format('H:i:s'));
      }
    }
    return parent::writeValues($values);
  }

  function displayValue ($value): string
  {
    $values = parent::readValues($value);
    $datetime = new DateTime('T'.implode(':', $values), timezone::utc());
    if ($this->convert) {
      $datetime->setTimeZone(timezone::getDefaultTimeZone());
    }
    if (count($values) < 3) {
      return $datetime->format('H:i');
    } else {
      return $datetime->format('H:i:s');
    }
  }
}

class TimeHiAttribute extends TimeHisAttribute
{
  function __construct ($label, $description, $ldapName, $required, $convert = TRUE, $acl = '')
  {
    $this->convert = $convert;
    $attributes = [
      new IntAttribute(
        '',  _('Hours'),
        $ldapName.'_hours', TRUE,
        0, 23, 1
      ),
      new IntAttribute(
        ':', _('Minutes'),
        $ldapName.'_minutes', TRUE,
        0, 59, 0
      )
    ];
    CompositeAttribute::__construct($description, $ldapName, $attributes, '/^(\d\d)(\d\d)$/', '%02d%02d', $acl, $label);
    $this->setLinearRendering(TRUE);
  }
}

class DateTimeAttribute extends CompositeAttribute
{
  function __construct ($label, $description, $ldapName, $required, $acl = '')
  {
    $attributes = [
      new DateAttribute(
        _('Date'), '',
        $ldapName.'_date', $required,
        'Ymd'
      ),
      /* Disabling conversion as it needs to be done on the date+time level (see argonautAction for an example) */
      new TimeHisAttribute(
        _('Time'), '',
        $ldapName.'_time', $required,
        FALSE
      )
    ];
    parent::__construct($description, $ldapName, $attributes, '/^(\d{8})(\d{6})$/', '%s%s', $acl, $label);
  }
}

class GeneralizedTimeDisplayAttribute extends GeneralizedTimeDateAttribute
{
  protected $displayFormat;

  function __construct (string $label, string $description, string $ldapName, bool $required, $defaultValue = '', $format = 'Y-m-d, H:i:s', $min = NULL, $max = NULL, string $acl = '')
  {
    parent::__construct($label, $description, $ldapName, $required, $defaultValue, $min, $max, $acl);
    $this->displayFormat = $format;
  }

  function getValue ()
  {
    return $this->computeLdapValue();
  }

  function renderFormInput (): string
  {
    if (empty($this->value)) {
      return '';
    }
    $date = $this->getDateValue();
    $date->setTimezone(timezone::getDefaultTimeZone());
    return htmlescape($date->format($this->displayFormat));
  }
}

class EpochDaysDateAttribute extends DateAttribute
{
  /* 24 * 60 * 60 = 86400 */
  public static $secondsPerDay = 86400;

  function __construct (string $label, string $description, string $ldapName, bool $required, $defaultValue = 'today', $min = NULL, $max = NULL, string $acl = '')
  {
    parent::__construct($label, $description, $ldapName, $required, '', $defaultValue, $min, $max, $acl);
  }

  protected function ldapToDate ($ldapValue)
  {
    $date = DateTime::createFromFormat('U', (string)($ldapValue * static::$secondsPerDay), timezone::utc());
    if ($date !== FALSE) {
      return $date;
    } else {
      trigger_error('LDAP value for '.$this->getLdapName().' was not in the right date format.');
      return new DateTime($ldapValue, timezone::utc());
    }
  }

  protected function dateToLdap (DateTime $dateValue)
  {
    return floor($dateValue->format('U') / static::$secondsPerDay);
  }

  function getEpochDays ()
  {
    if (empty($this->value)) {
      return 0;
    } else {
      try {
        return $this->dateToLdap($this->getDateValue());
      } catch (Exception $e) {
        if (is_object($this->plugin) && $this->plugin->is_template) {
          return $this->value;
        } else {
          throw $e;
        }
      }
    }
  }
}