Charcoal\Property\DateTimeProperty

Complexity

Total Complexity

51

Size/Duplication

Total Lines	361
Duplicated Lines	25.76 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	type()	0	4	1
A	setMultiple()	10	10	2
A	getMultiple()	0	4	1
A	parseOne()	0	4	1
A	inputVal()	0	11	2
A	storageVal()	0	16	3
A	displayVal()	0	15	3
A	setMin()	23	26	5
A	getMin()	0	4	1
A	setMax()	23	26	5
A	getMax()	0	4	1
A	setFormat()	13	13	3
A	getFormat()	0	4	1
A	validationMethods()	0	9	1
A	validateMin()	12	12	3
A	validateMax()	12	12	3
A	sqlType()	0	4	1
A	sqlPdoType()	0	4	1
B	dateTimeVal()	0	26	10
A	isValidTimeStamp()	0	6	3

<?php

namespace Charcoal\Property;

use PDO;
use DateTime;
use DateTimeInterface;
use Exception;
use InvalidArgumentException;

// From 'charcoal-property'
use Charcoal\Property\AbstractProperty;

/**
 * Date/Time Property
 */
class DateTimeProperty extends AbstractProperty
{
    const DEFAULT_MIN = null;
    const DEFAULT_MAX = null;
    const DEFAULT_FORMAT = 'Y-m-d H:i:s';

    /**
     * @var DateTimeInterface|null
     */
    private $min = self::DEFAULT_MIN;

    /**
     * @var DateTimeInterface|null
     */
    private $max = self::DEFAULT_MAX;

    /**
     * @var string
     */
    private $format = self::DEFAULT_FORMAT;

    /**
     * @return string
     */
    public function type()
    {
        return 'date-time';
    }

    /**
     * Ensure multiple can not be true for DateTime property.
     *
     * @see AbstractProperty::setMultiple()
     *
     * @param  boolean $multiple Multiple flag.
     * @throws InvalidArgumentException If the multiple argument is true (must be false).
     * @return self
     */
    public function setMultiple($multiple)

This method seems to be duplicated in your project.

    {
        $multiple = !!$multiple;
        if ($multiple === true) {
            throw new InvalidArgumentException(
                'Multiple can not be TRUE for date/time property.'
            );
        }
        return $this;
    }

    /**
     * Multiple is always false for DateTime property.
     *
     * @see AbstractProperty::getMultiple()
     *
     * @return boolean
     */
    public function getMultiple()
    {
        return false;
    }

    /**
     * Ensure `DateTime` object in val.
     *
     * @see AbstractProperty::parseOne()
     * @see AbstractProperty::parseVal()
     *
     * @param  string|DateTimeInterface $val The value to set.
     * @return DateTimeInterface|null
     */
    public function parseOne($val)
    {
        return $this->dateTimeVal($val);
    }

    /**
     * Convert `DateTime` to input-friendly string.
     *
     * @see AbstractProperty::inputVal()
     *
     * @param  mixed $val     The value to to convert for input.
     * @param  array $options Unused, optional options.
     * @throws Exception If the date/time is invalid.
     * @return string|null
     */
    public function inputVal($val, array $options = [])
    {
        unset($options);
        $val = $this->dateTimeVal($val);

        if ($val instanceof DateTimeInterface) {
            return $val->format('Y-m-d H:i:s');
        } else {
            return '';
        }
    }

    /**
     * Convert `DateTime` to SQL-friendly string.
     *
     * @see StorablePropertyTrait::storageVal()
     *
     * @param  string|DateTime $val Optional. Value to convert to storage format.
     * @throws Exception If the date/time is invalid.
     * @return string|null
     */
    public function storageVal($val)
    {
        $val = $this->dateTimeVal($val);

        if ($val instanceof DateTimeInterface) {
            return $val->format('Y-m-d H:i:s');
        }

        if ($this['allowNull']) {
            return null;
        }

        throw new Exception(
            'Invalid date/time value. Must be a DateTimeInterface instance.'
        );
    }

    /**
     * Format a date/time object to string.
     *
     * @see AbstractProperty::displayVal()
     *
     * @param  mixed $val     The value to to convert for display.
     * @param  array $options Optional display options.
     * @return string
     */
    public function displayVal($val, array $options = [])
    {
        $val = $this->dateTimeVal($val);
        if ($val === null) {
            return '';
        }

        if (isset($options['format'])) {
            $format = $options['format'];
        } else {
            $format = $this->getFormat();
        }

        return $val->format($format);
    }

    /**
     * @param  string|DateTime|null $min The minimum allowed value.
     * @throws InvalidArgumentException If the date/time is invalid.
     * @return self
     */
    public function setMin($min)

This method seems to be duplicated in your project.

    {
        if ($min === null) {
            $this->min = null;
            return $this;
        }

        if (is_string($min)) {
            try {
                $min = new DateTime($min);
            } catch (Exception $e) {
                throw new InvalidArgumentException(
                    'Can not set min: '.$e->getMessage()
                );
            }
        }

        if (!($min instanceof DateTimeInterface)) {
            throw new InvalidArgumentException(
                'Invalid min'
            );
        }

        $this->min = $min;
        return $this;
    }

    /**
     * @return DateTimeInterface|null
     */
    public function getMin()
    {
        return $this->min;
    }

    /**
     * @param  string|DateTime|null $max The maximum allowed value.
     * @throws InvalidArgumentException If the date/time is invalid.
     * @return self
     */
    public function setMax($max)

This method seems to be duplicated in your project.

    {
        if ($max === null) {
            $this->max = null;
            return $this;
        }

        if (is_string($max)) {
            try {
                $max = new DateTime($max);
            } catch (Exception $e) {
                throw new InvalidArgumentException(
                    'Can not set min: '.$e->getMessage()
                );
            }
        }

        if (!($max instanceof DateTimeInterface)) {
            throw new InvalidArgumentException(
                'Invalid max'
            );
        }

        $this->max = $max;
        return $this;
    }

    /**
     * @return DateTimeInterface|null
     */
    public function getMax()
    {
        return $this->max;
    }

    /**
     * @param  string|null $format The date format.
     * @throws InvalidArgumentException If the format is not a string.
     * @return DateTimeProperty Chainable
     */
    public function setFormat($format)

This method seems to be duplicated in your project.

    {
        if ($format === null) {
            $format = '';
        }
        if (!is_string($format)) {
            throw new InvalidArgumentException(
                'Format must be a string'
            );
        }
        $this->format = $format;
        return $this;
    }

    /**
     * @return string
     */
    public function getFormat()
    {
        return $this->format;
    }

    /**
     * @return array
     */
    public function validationMethods()
    {
        $parentMethods = parent::validationMethods();

        return array_merge($parentMethods, [
            'min',
            'max',
        ]);
    }

    /**
     * @return boolean
     */
    public function validateMin()

This method seems to be duplicated in your project.

    {
        $min = $this->getMin();
        if (!$min) {
            return true;
        }
        $valid = ($this->val() >= $min);

The method Charcoal\Property\AbstractProperty::val() has been deprecated.

        if ($valid === false) {
            $this->validator()->error('The date is smaller than the minimum value', 'min');

The call to ValidatorInterface::error() has too many arguments starting with 'min'.

        }
        return $valid;
    }

    /**
     * @return boolean
     */
    public function validateMax()

This method seems to be duplicated in your project.

    {
        $max = $this->getMax();
        if (!$max) {
            return true;
        }
        $valid = ($this->val() <= $max);

The method Charcoal\Property\AbstractProperty::val() has been deprecated.

        if ($valid === false) {
            $this->validator()->error('The date is bigger than the maximum value', 'max');

The call to ValidatorInterface::error() has too many arguments starting with 'max'.

        }
        return $valid;
    }

    /**
     * @see StorablePropertyTrait::sqlType()
     * @return string
     */
    public function sqlType()
    {
        return 'DATETIME';
    }

    /**
     * @see StorablePropertyTrait::sqlPdoType()
     * @return integer
     */
    public function sqlPdoType()
    {
        return PDO::PARAM_STR;
    }

    /**
     * @param  mixed $val Value to convert to DateTime.
     * @throws InvalidArgumentException If the value is not a valid datetime.
     * @return DateTimeInterface|null
     */
    private function dateTimeVal($val)
    {
        if ($val === null ||
            (is_string($val) && ! strlen(trim($val))) ||
            (is_array($val) && ! count(array_filter($val, 'strlen')))
        ) {
            return null;
        }

        if (is_int($val) && $this->isValidTimeStamp($val)) {
            $dateTime = new DateTime();
            $val = $dateTime->setTimestamp($val);
        }

        if (is_string($val)) {
            $val = new DateTime($val);
        }

        if (!($val instanceof DateTimeInterface)) {
            throw new InvalidArgumentException(
                'Val must be a valid date'
            );
        }

        return $val;
    }

    /**
     * @param  integer|string $timestamp Timestamp.
     * @return boolean
     */
    private function isValidTimeStamp($timestamp)
    {
        return (is_int($timestamp))
            && ($timestamp <= PHP_INT_MAX)
            && ($timestamp >= ~PHP_INT_MAX);
    }
}