Shlinkio\Shlink\Core\Model\ShortUrlMeta

Complexity

Total Complexity

22

Size/Duplication

Total Lines	156
Duplicated Lines	0 %

Test Coverage

Coverage

98.18%

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	2	1
A	createFromParams()	0	20	1
A	parseDateField()	0	11	4
A	createEmpty()	0	3	1
A	validate()	0	14	3
A	getDomain()	0	3	1
A	getMaxVisits()	0	3	1
A	getValidSince()	0	3	1
A	hasDomain()	0	3	1
A	hasMaxVisits()	0	3	1
A	getCustomSlug()	0	3	1
A	createFromRawData()	0	5	1
A	findIfExists()	0	3	1
A	getValidUntil()	0	3	1
A	hasValidSince()	0	3	1
A	hasValidUntil()	0	3	1
A	hasCustomSlug()	0	3	1

<?php

declare(strict_types=1);

namespace Shlinkio\Shlink\Core\Model;

use Cake\Chronos\Chronos;
use DateTimeInterface;
use Shlinkio\Shlink\Core\Exception\ValidationException;
use Shlinkio\Shlink\Core\Validation\ShortUrlMetaInputFilter;

final class ShortUrlMeta
{
    /** @var Chronos|null */
    private $validSince;
    /** @var Chronos|null */
    private $validUntil;
    /** @var string|null */
    private $customSlug;
    /** @var int|null */
    private $maxVisits;
    /** @var bool|null */
    private $findIfExists;
    /** @var string|null */
    private $domain;

    // Force named constructors
    private function __construct()
    {
    }

    public static function createEmpty(): self
    {
        return new self();
    }

    /**
     * @param array $data
     * @throws ValidationException
     */
    public static function createFromRawData(array $data): self
    {
        $instance = new self();
        $instance->validate($data);
        return $instance;
    }

    /**
     * @param string|Chronos|null $validSince
     * @param string|Chronos|null $validUntil
     * @param string|null $customSlug
     * @param int|null $maxVisits
     * @param bool|null $findIfExists
     * @param string|null $domain
     * @throws ValidationException
     */
    public static function createFromParams(
        $validSince = null,
        $validUntil = null,
        $customSlug = null,
        $maxVisits = null,
        $findIfExists = null,
        $domain = null
    ): self {
        // We do not type hint the arguments because that will be done by the validation process and we would get a
        // type error if any of them do not match
        $instance = new self();
        $instance->validate([
            ShortUrlMetaInputFilter::VALID_SINCE => $validSince,
            ShortUrlMetaInputFilter::VALID_UNTIL => $validUntil,
            ShortUrlMetaInputFilter::CUSTOM_SLUG => $customSlug,
            ShortUrlMetaInputFilter::MAX_VISITS => $maxVisits,
            ShortUrlMetaInputFilter::FIND_IF_EXISTS => $findIfExists,
            ShortUrlMetaInputFilter::DOMAIN => $domain,
        ]);
        return $instance;
    }

    /**
     * @param array $data
     * @throws ValidationException
     */
    private function validate(array $data): void
    {
        $inputFilter = new ShortUrlMetaInputFilter($data);
        if (! $inputFilter->isValid()) {
            throw ValidationException::fromInputFilter($inputFilter);
        }

        $this->validSince = $this->parseDateField($inputFilter->getValue(ShortUrlMetaInputFilter::VALID_SINCE));
        $this->validUntil = $this->parseDateField($inputFilter->getValue(ShortUrlMetaInputFilter::VALID_UNTIL));
        $this->customSlug = $inputFilter->getValue(ShortUrlMetaInputFilter::CUSTOM_SLUG);

It seems like $inputFilter->getValue(Shlinkio\Shlink\Core\Validation\ShortUrlMetaInputFilter::CUSTOM_SLUG) can also be of type array. However, the property $customSlug is declared as type null|string. Maybe add an additional type check?

        $this->maxVisits = $inputFilter->getValue(ShortUrlMetaInputFilter::MAX_VISITS);

It seems like $inputFilter->getValue(Shlinkio\Shlink\Core\Validation\ShortUrlMetaInputFilter::MAX_VISITS) can also be of type array. However, the property $maxVisits is declared as type integer|null. Maybe add an additional type check?

        $this->maxVisits = $this->maxVisits !== null ? (int) $this->maxVisits : null;
        $this->findIfExists = $inputFilter->getValue(ShortUrlMetaInputFilter::FIND_IF_EXISTS);

It seems like $inputFilter->getValue(Shlinkio\Shlink\Core\Validation\ShortUrlMetaInputFilter::FIND_IF_EXISTS) can also be of type array. However, the property $findIfExists is declared as type boolean|null. Maybe add an additional type check?

        $this->domain = $inputFilter->getValue(ShortUrlMetaInputFilter::DOMAIN);

It seems like $inputFilter->getValue(Shlinkio\Shlink\Core\Validation\ShortUrlMetaInputFilter::DOMAIN) can also be of type array. However, the property $domain is declared as type null|string. Maybe add an additional type check?

    }

    /**
     * @param string|DateTimeInterface|Chronos|null $date
     */
    private function parseDateField($date): ?Chronos
    {
        if ($date === null || $date instanceof Chronos) {
            return $date;
        }

        if ($date instanceof DateTimeInterface) {
            return Chronos::instance($date);
        }

        return Chronos::parse($date);
    }

    public function getValidSince(): ?Chronos
    {
        return $this->validSince;
    }

    public function hasValidSince(): bool
    {
        return $this->validSince !== null;
    }

    public function getValidUntil(): ?Chronos
    {
        return $this->validUntil;
    }

    public function hasValidUntil(): bool
    {
        return $this->validUntil !== null;
    }

    public function getCustomSlug(): ?string
    {
        return $this->customSlug;
    }

    public function hasCustomSlug(): bool
    {
        return $this->customSlug !== null;
    }

    public function getMaxVisits(): ?int
    {
        return $this->maxVisits;
    }

    public function hasMaxVisits(): bool
    {
        return $this->maxVisits !== null;
    }

    public function findIfExists(): bool
    {
        return (bool) $this->findIfExists;
    }

    public function hasDomain(): bool
    {
        return $this->domain !== null;
    }

    public function getDomain(): ?string
    {
        return $this->domain;
    }
}