flipbox\craft\interval\fields\Interval

Complexity

Total Complexity

25

Size/Duplication

Total Lines	231
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

0%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	displayName()	0	4	1
A	getContentColumnType()	0	4	1
A	getInputHtml()	0	43	4
A	getStaticHtml()	0	4	1
A	serializeValue()	0	7	1
A	getSearchKeywords()	0	4	1
A	normalizeValue()	0	24	5
A	getTableAttributeHtml()	0	6	1
A	isValueEmpty()	0	4	2
A	toHumanTimeDurationWithDefault()	0	8	2
A	toDateIntervalFromSeconds()	0	17	3
A	toDateIntervalFromHumanReadable()	0	33	3

<?php

/**
 * @copyright  Copyright (c) Flipbox Digital Limited
 * @license    https://flipboxfactory.com/software/interval/license
 * @link       https://www.flipboxfactory.com/software/interval/
 */

namespace flipbox\craft\interval\fields;

use Craft;
use craft\base\ElementInterface;
use craft\base\Field;
use craft\base\PreviewableFieldInterface;
use craft\enums\PeriodType;
use craft\helpers\ArrayHelper;
use flipbox\craft\interval\helpers\DateIntervalHelper;
use craft\helpers\StringHelper;
use DateInterval;
use yii\db\Schema;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 1.0.0
 */
class Interval extends Field implements PreviewableFieldInterface
{

    /**
     * The default value
     *
     * @var int
     */
    public $defaultAmount = 0;

    /**
     * The default period
     *
     * @var int
     */
    public $defaultPeriod = PeriodType::Days;

    /**
     * @inheritdoc
     */
    public static function displayName(): string
    {
        return Craft::t('interval', 'Interval');
    }

    /**
     * @inheritdoc
     */
    public function getContentColumnType(): string
    {
        return Schema::TYPE_BIGINT;
    }

    /**
     * @inheritdoc
     * @throws \Twig\Error\LoaderError
     * @throws \Twig\Error\RuntimeError
     * @throws \Twig\Error\SyntaxError
     */
    public function getInputHtml($value, ElementInterface $element = null): string
    {
        // Is inverted
        $invert = $value->invert;

        // Remove invert flag
        $value->invert = 0;

        $amount = '';
        $period = '';

        if (!$this->isFresh($element) && $humanInterval = $this->toHumanTimeDurationWithDefault($value)) {
            list($amount, $period) = explode(
                ' ',
                $humanInterval
            );
        }

        // Ensure plural
        $period = StringHelper::removeRight($period, 's') . 's';

        // If invert adjust amount
        if ($invert) {
            $amount = $amount * -1;
        }

        return Craft::$app->getView()->renderTemplate(
            'interval/_components/fieldtypes/Interval/input',
            [
                'field' => $this,
                'amount' => $amount,
                'period' => $period,
                'periods' => [
                    '' => '',
                    PeriodType::Seconds => Craft::t('interval', 'Seconds'),
                    PeriodType::Minutes => Craft::t('interval', 'Minutes'),
                    PeriodType::Hours => Craft::t('interval', 'Hours'),
                    PeriodType::Days => Craft::t('interval', 'Days'),
                    PeriodType::Years => Craft::t('interval', 'Years'),
                ]
            ]
        );
    }

    /**
     * @inheritdoc
     */
    public function getStaticHtml($value, ElementInterface $element): string
    {
        return $this->getTableAttributeHtml($value, $element);
    }

    /**
     * @inheritdoc
     */
    public function serializeValue($value, ElementInterface $element = null)
    {
        return parent::serializeValue(
            DateIntervalHelper::intervalToSeconds($value),
            $element
        );
    }

    /**
     * @inheritdoc
     */
    public function getSearchKeywords($value, ElementInterface $element): string
    {
        return $this->getTableAttributeHtml($value, $element);
    }

    /**
     * @inheritdoc
     */
    public function normalizeValue($value, ElementInterface $element = null)
    {
        // Seconds
        if (is_numeric($value)) {
            return $this->toDateIntervalFromSeconds($value);
        }

        // Human readable
        if (is_string($value)) {
            return DateInterval::createFromDateString($value);
        }

        // Human readable (array)
        if (is_array($value)) {
            return $this->toDateIntervalFromHumanReadable($value);
        }

        // Fresh -> use default
        if ($this->isFresh($element)) {
            DateIntervalHelper::secondsToInterval($this->defaultAmount);
        }

        return DateIntervalHelper::secondsToInterval(0);
    }

    /**
     * @param mixed $value
     * @param ElementInterface $element
     * @return string
     */
    public function getTableAttributeHtml($value, ElementInterface $element): string
    {
        return StringHelper::toTitleCase(
            $this->toHumanTimeDurationWithDefault($value)
        );
    }

    /**
     * @inheritdoc
     */
    public function isValueEmpty($value, ElementInterface $element): bool
    {
        return parent::isValueEmpty($value, $element) || DateIntervalHelper::intervalToSeconds($value) === 0;
    }

    /**
     * @param DateInterval $dateInterval
     * @return string
     */
    private function toHumanTimeDurationWithDefault(DateInterval $dateInterval): string
    {
        if (DateIntervalHelper::intervalToSeconds($dateInterval) === 0) {
            return '0 ' . $this->defaultPeriod;
        }

        return DateIntervalHelper::humanDurationFromInterval($dateInterval);
    }

    /**
     * @param int $seconds
     * @return \DateInterval
     */
    private function toDateIntervalFromSeconds(int $seconds)
    {
        $invert = false;

        if ($seconds < 0) {
            $invert = true;
            $seconds = $seconds * -1;
        }

        $dateInterval = DateIntervalHelper::secondsToInterval($seconds);

        if ($invert) {
            $dateInterval->invert = 1;
        }

        return $dateInterval;
    }

    /**
     * @param array $interval
     * @return DateInterval
     */
    private function toDateIntervalFromHumanReadable(array $interval = ['amount' => 0, 'period' => ''])
    {
        $invert = false;

        $amount = (int)ArrayHelper::getValue($interval, 'amount');

        if ($amount < 0) {
            $invert = true;
            $amount = $amount * -1;
        }

        $period = ArrayHelper::getValue(
            $interval,
            'period',
            $this->defaultPeriod
        );

        $dateInterval = DateInterval::createFromDateString(
            StringHelper::toString(
                [
                    $amount,
                    $period
                ],
                ' '
            )
        );

        if ($invert) {
            $dateInterval->invert = 1;
        }

        return $dateInterval;
    }
}