ShortUrl::matchesCriteria() - Code Metrics - Inspection of "[WIP] Feature/multiple domains" - shlinkio/shlink - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#500)

by Alejandro

created 2019-10-01 20:05 UTC

ShortUrl::matchesCriteria() B

↳ Parent: ShortUrl

Complexity

Conditions	9
Paths	5

Size

Total Lines	22
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	9.2363

Importance

Changes

Metric	Value
cc	9
eloc	13
c	0
b	0
f	0
nc	5
nop	2
dl	0
loc	22
ccs	12
cts	14
cp	0.8571
crap	9.2363
rs	8.0555

<?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\Model\ShortUrlMeta;
use Zend\Diactoros\Uri;

use function array_reduce;
use function count;
use function Functional\contains;
use function Functional\invoke;

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;

    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->shortCode = $meta->getCustomSlug() ?? ''; // TODO logic to calculate short code should be passed somehow
        $this->domain = $this->domainToEntity($meta->getDomain(), $domainResolver ?? new SimpleDomainResolver());
    }

    private function domainToEntity(?string $domain, DomainResolverInterface $domainResolver): ?Domain
    {
        return $domainResolver->resolveDomain($domain);
    }

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

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

    // TODO Short code is currently calculated based on the ID, so a setter is needed
    public function setShortCode(string $shortCode): self
    {
        $this->shortCode = $shortCode;
        return $this;
    }

    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();
        }
    }

    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->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 (#500)

ShortUrl::matchesCriteria() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like