Shlinkio\Shlink\Core\Service\UrlShortener

Complexity

Total Complexity

15

Size/Duplication

Total Lines	182
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

96.43%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
B	urlToShortCode()	0	43	5
A	__construct()	0	13	2
A	checkUrlExists()	0	10	2
A	convertAutoincrementIdToShortCode()	0	14	2
B	shortCodeToUrl()	0	26	4

<?php
namespace Shlinkio\Shlink\Core\Service;

use Acelaya\ZsmAnnotatedServices\Annotation\Inject;
use Doctrine\Common\Cache\Cache;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\ORMException;
use GuzzleHttp\ClientInterface;
use GuzzleHttp\Exception\GuzzleException;
use Psr\Http\Message\UriInterface;
use Shlinkio\Shlink\Common\Exception\RuntimeException;
use Shlinkio\Shlink\Core\Entity\ShortUrl;
use Shlinkio\Shlink\Core\Exception\InvalidShortCodeException;
use Shlinkio\Shlink\Core\Exception\InvalidUrlException;
use Shlinkio\Shlink\Core\Util\TagManagerTrait;

class UrlShortener implements UrlShortenerInterface
{
    use TagManagerTrait;

    const DEFAULT_CHARS = '123456789bcdfghjkmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ';

    /**
     * @var ClientInterface
     */
    private $httpClient;
    /**
     * @var EntityManagerInterface
     */
    private $em;
    /**
     * @var string
     */
    private $chars;
    /**
     * @var Cache
     */
    private $cache;
    /**
     * @var bool
     */
    private $isUrlExistsValidation;

    /**
     * UrlShortener constructor.
     * @param ClientInterface $httpClient
     * @param EntityManagerInterface $em
     * @param Cache $cache
     * @param bool $isUrlExistsValidation
     * @param string $chars
     *
     * @Inject({
     *     "httpClient",
     *      "em",
     *      Cache::class,
     *      "config.url_shortener.validate_url",
     *      "config.url_shortener.shortcode_chars"
     * })
     */
    public function __construct(
        ClientInterface $httpClient,
        EntityManagerInterface $em,
        Cache $cache,
        $isUrlExistsValidation,
        $chars = self::DEFAULT_CHARS
    ) {
        $this->httpClient = $httpClient;
        $this->em = $em;
        $this->chars = empty($chars) ? self::DEFAULT_CHARS : $chars;
        $this->cache = $cache;
        $this->isUrlExistsValidation = $isUrlExistsValidation;
    }

    /**
     * Creates and persists a unique shortcode generated for provided url
     *
     * @param UriInterface $url
     * @param string[] $tags
     * @return string
     * @throws InvalidUrlException
     * @throws RuntimeException
     */
    public function urlToShortCode(UriInterface $url, array $tags = [])
    {
        // If the url already exists in the database, just return its short code
        $shortUrl = $this->em->getRepository(ShortUrl::class)->findOneBy([
            'originalUrl' => $url,
        ]);
        if (isset($shortUrl)) {
            return $shortUrl->getShortCode();
        }

        // Check if the validation of url is enabled in the config
        if (true === $this->isUrlExistsValidation) {
            // Check that the URL exists
            $this->checkUrlExists($url);
        }

        // Transactionally insert the short url, then generate the short code and finally update the short code
        try {
            $this->em->beginTransaction();

            // First, create the short URL with an empty short code
            $shortUrl = new ShortUrl();
            $shortUrl->setOriginalUrl($url);
            $this->em->persist($shortUrl);
            $this->em->flush();

            // Generate the short code and persist it
            $shortCode = $this->convertAutoincrementIdToShortCode($shortUrl->getId());
            $shortUrl->setShortCode($shortCode)
                     ->setTags($this->tagNamesToEntities($this->em, $tags));
            $this->em->flush();

            $this->em->commit();
            return $shortCode;
        } catch (ORMException $e) {
            if ($this->em->getConnection()->isTransactionActive()) {
                $this->em->rollback();
                $this->em->close();
            }

            throw new RuntimeException('An error occurred while persisting the short URL', -1, $e);
        }
    }

    /**
     * Tries to perform a GET request to provided url, returning true on success and false on failure
     *
     * @param UriInterface $url
     * @return bool
     */
    protected function checkUrlExists(UriInterface $url)
    {
        try {
            $this->httpClient->request('GET', $url, ['allow_redirects' => [
                'max' => 15,
            ]]);
        } catch (GuzzleException $e) {
            throw InvalidUrlException::fromUrl($url, $e);

$e is of type object<GuzzleHttp\Exception\GuzzleException>, but the function expects a null|object<Exception>.

        }
    }

    /**
     * Generates the unique shortcode for an autoincrement ID
     *
     * @param int $id
     * @return string
     */
    protected function convertAutoincrementIdToShortCode($id)
    {
        $id = intval($id) + 200000; // Increment the Id so that the generated shortcode is not too short
        $length = strlen($this->chars);
        $code = '';

        while ($id > 0) {
            // Determine the value of the next higher character in the short code and prepend it
            $code = $this->chars[intval(fmod($id, $length))] . $code;
            $id = floor($id / $length);
        }

        return $this->chars[intval($id)] . $code;
    }

    /**
     * Tries to find the mapped URL for provided short code. Returns null if not found
     *
     * @param string $shortCode
     * @return string|null
     * @throws InvalidShortCodeException
     */
    public function shortCodeToUrl($shortCode)
    {
        $cacheKey = sprintf('%s_longUrl', $shortCode);
        // Check if the short code => URL map is already cached
        if ($this->cache->contains($cacheKey)) {
            return $this->cache->fetch($cacheKey);
        }

        // Validate short code format
        if (! preg_match('|[' . $this->chars . "]+|", $shortCode)) {
            throw InvalidShortCodeException::fromCharset($shortCode, $this->chars);
        }

        /** @var ShortUrl $shortUrl */
        $shortUrl = $this->em->getRepository(ShortUrl::class)->findOneBy([
            'shortCode' => $shortCode,
        ]);
        // Cache the shortcode
        if (isset($shortUrl)) {
            $url = $shortUrl->getOriginalUrl();
            $this->cache->save($cacheKey, $url);
            return $url;
        }

        return null;
    }
}