ONGR\RouterBundle\Routing\SeoUrlMatcher

Complexity

Total Complexity

29

Size/Duplication

Total Lines	262
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes	10
Bugs	2	Features	2

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	setSeoUrlMapper()	0	4	1
C	match()	0	53	11
A	doRedirect()	0	4	1
A	getLink()	0	11	2
A	getUrlHash()	0	4	1
A	getSearch()	0	20	3
A	getDocumentByUrl()	0	13	3
A	ensurePrefixSlash()	0	8	2
A	getSeoUrlMapper()	0	4	1
A	getTypeMap()	0	4	1
A	getEsManager()	0	4	1
A	getCachedMatcher()	0	4	1

<?php

/*
 * This file is part of the ONGR package.
 *
 * (c) NFQ Technologies UAB <info@nfq.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ONGR\RouterBundle\Routing;

use ONGR\ElasticsearchDSL\Query\BoolQuery;
use ONGR\ElasticsearchDSL\Query\MatchQuery;
use ONGR\ElasticsearchDSL\Query\NestedQuery;
use ONGR\ElasticsearchDSL\Query\TermQuery;
use ONGR\ElasticsearchDSL\Search;
use ONGR\ElasticsearchBundle\Service\Manager;
use ONGR\RouterBundle\Document\SeoAwareTrait;
use ONGR\RouterBundle\Service\SeoUrlMapper;
use Symfony\Bundle\FrameworkBundle\Routing\RedirectableUrlMatcher;
use Symfony\Component\Routing\Exception\ResourceNotFoundException;

/**
 * URL matcher with extended functionality for document matching.
 */
class SeoUrlMatcher extends RedirectableUrlMatcher
{
    const SCHEME_HTTP = 'http';

    /**
     * @var RedirectableUrlMatcher
     */
    protected $cachedMatcher = null;

    /**
     * @var Manager
     */
    protected $esManager = null;

    /**
     * @var array
     */
    protected $typeMap = null;

    /**
     * @var bool
     */
    protected $allowHttps = false;

    /**
     * @var string
     */
    protected $urlKey = null;

    /**
     * @var SeoUrlMapper
     */
    protected $seoUrlMapper;

    /**
     * @param RedirectableUrlMatcher $parentMatcher Parent matcher that is called when this matcher fails.
     * @param Manager                $esManager     ES manager.
     * @param array                  $typeMap       Type map.
     * @param bool                   $allowHttps    Is https allowed.
     * @param string                 $urlKey        Url key to search routes with.
     */
    public function __construct($parentMatcher, $esManager, $typeMap, $allowHttps = false, $urlKey = null)
    {
        $this->cachedMatcher = $parentMatcher;
        $this->esManager = $esManager;
        $this->typeMap = array_change_key_case($typeMap, CASE_LOWER);
        $this->allowHttps = $allowHttps;
        $this->urlKey = $urlKey;
    }

    /**
     * Sets SEO URL mapper.
     *
     * @param SeoUrlMapper $seoUrlMapper SEO URL mapper.
     */
    public function setSeoUrlMapper($seoUrlMapper)
    {
        $this->seoUrlMapper = $seoUrlMapper;
    }

    /**
     * {@inheritdoc}
     */
    public function match($pathinfo)
    {
        $url = ltrim(rawurldecode($pathinfo), '/');
        $requestedUrlOriginal = $url;

        /** @var RequestContext $context */
        $context = $this->getCachedMatcher()->getContext();

        if (!$this->allowHttps && $context->getScheme() != self::SCHEME_HTTP) {
            throw new ResourceNotFoundException('Non-http urls are not processed');
        }

        $result = $this->getDocumentByUrl($url);

        if ($result !== null) {
            /** @var SeoAwareTrait $document */
            list($documentName, $document) = $result;
            list($documentSeoKey, $documentLink) = $this->getLink($document, $url);

            // Url doesn't exist.
            $urls = $document->getUrls();

It seems like getUrls() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            if (count($urls) === 0 && $documentLink === false) {
                throw new ResourceNotFoundException();
            }

            if (is_array($document->getExpiredUrls())

It seems like getExpiredUrls() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                && in_array($this->getUrlHash($url), $document->getExpiredUrls())

It seems like getExpiredUrls() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ) {
                if ($documentSeoKey === false) {
                    return $this->doRedirect(
                        $this->ensurePrefixSlash($documentLink),

It seems like $documentLink defined by $this->getLink($document, $url) on line 108 can also be of type boolean; however, ONGR\RouterBundle\Routing\SeoUrlMatcher::ensurePrefixSlash() does only seem to accept string, maybe add an additional type check?

                        $this->getTypeMap()[$documentName]['_route'],
                        (!$this->allowHttps) ? self::SCHEME_HTTP : null
                    );
                }
            }

            // Force redirect to original link, if links are not identical (lowercase, trailing slash).
            if ($requestedUrlOriginal !== $documentLink) {
                return $this->doRedirect($documentLink, $this->getTypeMap()[$documentName]['_route']);

It seems like $documentLink defined by $this->getLink($document, $url) on line 108 can also be of type boolean; however, ONGR\RouterBundle\Routing\SeoUrlMatcher::doRedirect() does only seem to accept string, maybe add an additional type check?

            }

            return array_merge(
                $this->getTypeMap()[$documentName],
                [
                    'document' => $document,
                    'seoKey' => $documentSeoKey,
                ]
            );
        }

        throw new ResourceNotFoundException();
    }

    /**
     * Cached matcher redirect.
     *
     * @param string $link   URL.
     * @param string $route  Route name.
     * @param string $scheme Scheme to use. E.g. 'http' or 'https'.
     *
     * @return array
     */
    protected function doRedirect($link, $route, $scheme = self::SCHEME_HTTP)
    {
        return $this->getCachedMatcher()->redirect($this->ensurePrefixSlash($link), $route, $scheme);
    }

    /**
     * Hacky solution to get seo key and url.
     *
     * @param SeoAwareTrait $document Document.

The type SeoAwareTrait for parameter $document is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     * @param string        $url      Url.
     *
     * @return array
     * @throws \LogicException
     */
    protected function getLink($document, $url)
    {
        if (!$this->getSeoUrlMapper()) {
            throw new \LogicException('Seo url mapper is not set.');
        }

        $documentSeoKey = $this->getSeoUrlMapper()->checkDocumentUrlExists($document, $url);
        $documentLink = $this->getSeoUrlMapper()->getLinkByKey($document, $documentSeoKey);

It seems like $documentSeoKey defined by $this->getSeoUrlMapper()->checkDocumentUrlExists($document, $url) on line 174 can also be of type boolean; however, ONGR\RouterBundle\Service\SeoUrlMapper::getLinkByKey() does only seem to accept string, maybe add an additional type check?

        return [$documentSeoKey, $documentLink];
    }

    /**
     * Generates hash for given url.
     *
     * @param string $url URL string.
     *
     * @return string
     */
    protected function getUrlHash($url)
    {
        return md5(strtolower($url));
    }

    /**
     * Returns search instance that is used to search for documents in Elasticsearch.
     *
     * @param string $url URL.
     *
     * @return Search
     */
    protected function getSearch($url)
    {
        $search = new Search();

        if (!$url) {
            return $search;
        }

        $bool = new BoolQuery();
        $bool->add(new MatchQuery('urls.url', $url), BoolQuery::SHOULD);

        if ($this->urlKey != null) {
            $bool->add(new TermQuery('urls.key', $this->urlKey), BoolQuery::SHOULD);
        }

        $search->addQuery(new NestedQuery('urls', $bool), BoolQuery::SHOULD);
        $search->addQuery(new TermQuery('expired_urls', $this->getUrlHash($url)), BoolQuery::SHOULD);

        return $search;
    }

    /**
     * Returns document by URL.
     *
     * @param string $url URL.
     *
     * @return array|null
     * @throws \Exception Search type not found.
     */
    private function getDocumentByUrl($url)
    {
        $repository = $this->getEsManager()->getRepository([]);

array() is of type array, but the function expects a string.

        $out = [];

        /** @var SeoAwareTrait $document */
        foreach ($repository->execute($this->getSearch($url)) as $document) {
            $mapping = $this->getEsManager()->getMetadataCollector()->getDocumentMapping($document);
            $type = $mapping['type'];

$type is not used, you could remove the assignment.

        }

        return empty($out) ? null : $out;
    }

    /**
     * Helper method to ensure that link has slash prefix.
     *
     * @param string $link Link.
     *
     * @return string Link with slash prefix.
     */
    private function ensurePrefixSlash($link)
    {
        if (substr($link, 0, 1) != '/') {
            $link = '/' . $link;
        }

        return $link;
    }

    /**
     * @return SeoUrlMapper
     */
    public function getSeoUrlMapper()
    {
        return $this->seoUrlMapper;
    }

    /**
     * @return array
     */
    public function getTypeMap()
    {
        return $this->typeMap;
    }

    /**
     * @return Manager
     */
    public function getEsManager()
    {
        return $this->esManager;
    }

    /**
     * @return RedirectableUrlMatcher
     */
    public function getCachedMatcher()
    {
        return $this->cachedMatcher;
    }
}