Shlinkio\Shlink\Core\Model\ShortUrlEdit

Complexity

Total Complexity

15

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	hasValidSince()	0	3	1
A	validSince()	0	3	1
A	getOptionalIntFromInputFilter()	0	4	2
A	longUrl()	0	3	1
A	__construct()	0	2	1
A	maxVisits()	0	3	1
A	validateAndInit()	0	16	2
A	hasMaxVisits()	0	3	1
A	fromRawData()	0	5	1
A	hasValidUntil()	0	3	1
A	validUntil()	0	3	1
A	hasLongUrl()	0	3	2

<?php

declare(strict_types=1);

namespace Shlinkio\Shlink\Core\Model;

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

use function array_key_exists;
use function Shlinkio\Shlink\Core\parseDateField;

final class ShortUrlEdit
{
    private bool $longUrlPropWasProvided = false;
    private ?string $longUrl = null;
    private bool $validSincePropWasProvided = false;
    private ?Chronos $validSince = null;
    private bool $validUntilPropWasProvided = false;
    private ?Chronos $validUntil = null;
    private bool $maxVisitsPropWasProvided = false;
    private ?int $maxVisits = null;

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

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

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

        $this->longUrlPropWasProvided = array_key_exists(ShortUrlMetaInputFilter::LONG_URL, $data);
        $this->validSincePropWasProvided = array_key_exists(ShortUrlMetaInputFilter::VALID_SINCE, $data);
        $this->validUntilPropWasProvided = array_key_exists(ShortUrlMetaInputFilter::VALID_UNTIL, $data);
        $this->maxVisitsPropWasProvided = array_key_exists(ShortUrlMetaInputFilter::MAX_VISITS, $data);

        $this->longUrl = $inputFilter->getValue(ShortUrlMetaInputFilter::LONG_URL);
        $this->validSince = parseDateField($inputFilter->getValue(ShortUrlMetaInputFilter::VALID_SINCE));
        $this->validUntil = parseDateField($inputFilter->getValue(ShortUrlMetaInputFilter::VALID_UNTIL));
        $this->maxVisits = $this->getOptionalIntFromInputFilter($inputFilter, ShortUrlMetaInputFilter::MAX_VISITS);
    }

    private function getOptionalIntFromInputFilter(ShortUrlMetaInputFilter $inputFilter, string $fieldName): ?int
    {
        $value = $inputFilter->getValue($fieldName);
        return $value !== null ? (int) $value : null;
    }

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

    public function hasLongUrl(): bool
    {
        return $this->longUrlPropWasProvided && $this->longUrl !== null;
    }

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

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

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

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

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

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