ShortUrl::getShortCode() - Code Metrics - Inspection of "Feature/improved shortcodes" - shlinkio/shlink - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#506)

by Alejandro
created 2019-10-11 09:42 UTC
ShortUrl::getShortCode() A

↳ Parent: ShortUrl
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	1
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	1
cts	1
cp	1
crap	1
rs	10
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace Shlinkio\Shlink\Core\Entity;

use Cake\Chronos\Chronos;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Shlinkio\Shlink\Common\Entity\AbstractEntity;
use Shlinkio\Shlink\Core\Domain\Resolver\DomainResolverInterface;
use Shlinkio\Shlink\Core\Domain\Resolver\SimpleDomainResolver;
use Shlinkio\Shlink\Core\Exception\ShortCodeCannotBeRegeneratedException;
use Shlinkio\Shlink\Core\Model\ShortUrlMeta;
use Zend\Diactoros\Uri;

use function array_reduce;
use function count;
use function Functional\contains;
use function Functional\invoke;
use function Shlinkio\Shlink\Core\generateRandomShortCode;

class ShortUrl extends AbstractEntity
{
    /** @var string */
    private $longUrl;
    /** @var string */
    private $shortCode;
    /** @var Chronos */
    private $dateCreated;
    /** @var Collection|Visit[] */
    private $visits;
    /** @var Collection|Tag[] */
    private $tags;
    /** @var Chronos|null */
    private $validSince;
    /** @var Chronos|null */
    private $validUntil;
    /** @var integer|null */
    private $maxVisits;
    /** @var Domain|null */
    private $domain;
    /** @var bool */
    private $customSlugWasProvided;

    public function __construct(
        string $longUrl,
        ?ShortUrlMeta $meta = null,
        ?DomainResolverInterface $domainResolver = null
    ) {
        $meta = $meta ?? ShortUrlMeta::createEmpty();

        $this->longUrl = $longUrl;
        $this->dateCreated = Chronos::now();
        $this->visits = new ArrayCollection();
        $this->tags = new ArrayCollection();
        $this->validSince = $meta->getValidSince();
        $this->validUntil = $meta->getValidUntil();
        $this->maxVisits = $meta->getMaxVisits();
        $this->customSlugWasProvided = $meta->hasCustomSlug();
        $this->shortCode = $meta->getCustomSlug() ?? generateRandomShortCode();
        $this->domain = ($domainResolver ?? new SimpleDomainResolver())->resolveDomain($meta->getDomain());
    }

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

    public function getShortCode(): string
    {
        return $this->shortCode;
    }

    public function getDateCreated(): Chronos
    {
        return $this->dateCreated;
    }

    /**
     * @return Collection|Tag[]
     */
    public function getTags(): Collection
    {
        return $this->tags;
    }

    /**
     * @param Collection|Tag[] $tags
     */
    public function setTags(Collection $tags): self
    {
        $this->tags = $tags;
        return $this;
    }

    public function updateMeta(ShortUrlMeta $shortCodeMeta): void
    {
        if ($shortCodeMeta->hasValidSince()) {
            $this->validSince = $shortCodeMeta->getValidSince();
        }
        if ($shortCodeMeta->hasValidUntil()) {
            $this->validUntil = $shortCodeMeta->getValidUntil();
        }
        if ($shortCodeMeta->hasMaxVisits()) {
            $this->maxVisits = $shortCodeMeta->getMaxVisits();
        }
    }

    /**
     * @throws ShortCodeCannotBeRegeneratedException
     */
    public function regenerateShortCode(): self
    {
        // In ShortUrls where a custom slug was provided, do nothing
        if ($this->customSlugWasProvided) {
            throw ShortCodeCannotBeRegeneratedException::forShortUrlWithCustomSlug();
        }

        // The short code can be regenerated only on ShortUrl which have not been persisted yet
        if ($this->id !== null) {
            throw ShortCodeCannotBeRegeneratedException::forShortUrlAlreadyPersisted();
        }

        $this->shortCode = generateRandomShortCode();
        return $this;
    }

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

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

    public function getVisitsCount(): int
    {
        return count($this->visits);
    }

    /**
     * @param Collection|Visit[] $visits
     * @return ShortUrl
     * @internal
     */
    public function setVisits(Collection $visits): self
    {
        $this->visits = $visits;
        return $this;
    }

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

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

    public function toString(array $domainConfig): string
    {
        return (string) (new Uri())->withPath($this->shortCode)
                                   ->withScheme($domainConfig['schema'] ?? 'http')
                                   ->withHost($this->resolveDomain($domainConfig['hostname'] ?? ''));
    }

    private function resolveDomain(string $fallback = ''): string
    {
        if ($this->domain === null) {
            return $fallback;
        }

        return $this->domain->getAuthority();
    }

    public function matchesCriteria(ShortUrlMeta $meta, array $tags): bool
    {
        if ($meta->hasMaxVisits() && $meta->getMaxVisits() !== $this->maxVisits) {
            return false;
        }
        if ($meta->hasDomain() && $meta->getDomain() !== $this->resolveDomain()) {
            return false;
        }
        if ($meta->hasValidSince() && ! $meta->getValidSince()->eq($this->validSince)) {
        if ($meta->hasValidSince() && ! $meta->getValidSince()->eq(/** @scrutinizer ignore-type */ $this->validSince)) {
            return false;
        }
        if ($meta->hasValidUntil() && ! $meta->getValidUntil()->eq($this->validUntil)) {
            return false;
        }

        $shortUrlTags = invoke($this->getTags(), '__toString');
        $hasAllTags = count($shortUrlTags) === count($tags) && array_reduce(
            $tags,
            function (bool $hasAllTags, string $tag) use ($shortUrlTags) {
                return $hasAllTags && contains($shortUrlTags, $tag);
            },
            true
        );

        return $hasAllTags;
    }
}

shlinkio / shlink

Pull Request — master (#506)

ShortUrl::getShortCode() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
