PageRouter.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\Routing;
 
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\UriInterface;
use Symfony\Component\Routing\Exception\MissingMandatoryParametersException;
use Symfony\Component\Routing\Exception\ResourceNotFoundException;
use ‪TYPO3\CMS\Core\Context\Context;
use ‪TYPO3\CMS\Core\Context\LanguageAspectFactory;
use ‪TYPO3\CMS\Core\Domain\Page;
use ‪TYPO3\CMS\Core\Domain\Repository\PageRepository;
use ‪TYPO3\CMS\Core\Exception\SiteNotFoundException;
use ‪TYPO3\CMS\Core\Http\Uri;
use ‪TYPO3\CMS\Core\Routing\Aspect\AspectFactory;
use ‪TYPO3\CMS\Core\Routing\Aspect\MappableProcessor;
use ‪TYPO3\CMS\Core\Routing\Aspect\StaticMappableAspectInterface;
use ‪TYPO3\CMS\Core\Routing\Enhancer\DecoratingEnhancerInterface;
use ‪TYPO3\CMS\Core\Routing\Enhancer\EnhancerFactory;
use ‪TYPO3\CMS\Core\Routing\Enhancer\EnhancerInterface;
use ‪TYPO3\CMS\Core\Routing\Enhancer\InflatableEnhancerInterface;
use ‪TYPO3\CMS\Core\Routing\Enhancer\ResultingInterface;
use ‪TYPO3\CMS\Core\Routing\Enhancer\RoutingEnhancerInterface;
use ‪TYPO3\CMS\Core\Site\Entity\Site;
use ‪TYPO3\CMS\Core\Site\Entity\SiteLanguage;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Frontend\Page\CacheHashCalculator;
 
class ‪PageRouter implements ‪RouterInterface
{
    protected ‪Site ‪$site;
    protected ‪EnhancerFactory ‪$enhancerFactory;
    protected ‪AspectFactory ‪$aspectFactory;
    protected ‪CacheHashCalculator ‪$cacheHashCalculator;
    protected ‪Context ‪$context;
    protected ‪RequestContextFactory ‪$requestContextFactory;
 
    public function ‪__construct(‪Site ‪$site, ‪Context ‪$context = null)
    {
        $this->site = ‪$site;
        $this->context = ‪$context ?? GeneralUtility::makeInstance(Context::class);
        $this->enhancerFactory = GeneralUtility::makeInstance(EnhancerFactory::class);
        $this->aspectFactory = GeneralUtility::makeInstance(AspectFactory::class, $this->context);
        $this->cacheHashCalculator = GeneralUtility::makeInstance(CacheHashCalculator::class);
        $this->requestContextFactory = GeneralUtility::makeInstance(RequestContextFactory::class);
    }
 
    public function ‪matchRequest(ServerRequestInterface $request, ‪RouteResultInterface $previousResult = null): ‪RouteResultInterface
    {
        if ($previousResult === null) {
            throw new ‪RouteNotFoundException('No previous result given. Cannot find a page for an empty route part', 1555303496);
        }
 
        $candidateProvider = $this->‪getSlugCandidateProvider($this->context);
 
        // Legacy URIs (?id=12345) takes precedence, no matter if a route is given
        $requestId = (int)($request->getQueryParams()['id'] ?? 0);
        if ($requestId > 0) {
            if (!empty($pageId = $candidateProvider->getRealPageIdForPageIdAsPossibleCandidate($requestId))) {
                return new ‪PageArguments(
                    (int)$pageId,
                    (string)($request->getQueryParams()['type'] ?? '0'),
                    [],
                    [],
                    $request->getQueryParams()
                );
            }
            throw new ‪RouteNotFoundException('The requested page does not exist.', 1557839801);
        }
 
        $urlPath = $previousResult->getTail();
        $language = $previousResult->getLanguage();
        // Keep possible existing "/" at the end (no trim, just ltrim), even though the page slug might not
        // contain a "/" at the end. This way we find page candidates where pages MIGHT have a trailing slash
        // and pages with slugs that do not have a trailing slash
        // $pageCandidates will contain more records than expected, which is important here, as the ->match() method
        // will handle this then.
        // The prepended slash will ensure that the root page of the site tree will also be fetched
        $prefixedUrlPath = '/' . ltrim($urlPath, '/');
 
        $pageCandidates = $candidateProvider->getCandidatesForPath($prefixedUrlPath, $language);
 
        // Stop if there are no candidates
        if (empty($pageCandidates)) {
            throw new ‪RouteNotFoundException('No page candidates found for path "' . $prefixedUrlPath . '"', 1538389999);
        }
 
        $fullCollection = new ‪RouteCollection();
        foreach ($pageCandidates ?? [] as $page) {
            $pageIdForDefaultLanguage = (int)($page['l10n_parent'] ?: $page['uid']);
            $pagePath = $page['slug'];
            $pageCollection = new ‪RouteCollection();
            $defaultRouteForPage = new ‪Route(
                $pagePath,
                [],
                [],
                ['utf8' => true, '_page' => $page]
            );
            $pageCollection->add('default', $defaultRouteForPage);
            $enhancers = $this->‪getEnhancersForPage($pageIdForDefaultLanguage, $language);
            foreach ($enhancers as $enhancer) {
                if ($enhancer instanceof ‪DecoratingEnhancerInterface) {
                    $enhancer->decorateForMatching($pageCollection, $urlPath);
                }
            }
            foreach ($enhancers as $enhancer) {
                if ($enhancer instanceof ‪RoutingEnhancerInterface) {
                    $enhancer->enhanceForMatching($pageCollection);
                }
            }
 
            $collectionPrefix = 'page_' . $page['uid'];
            // Pages with a MountPoint Parameter means that they have a different context, and should be treated
            // as a separate instance
            if (isset($page['MPvar'])) {
                $collectionPrefix .= '_MP_' . str_replace(',', '', $page['MPvar']);
            }
            $pageCollection->addNamePrefix($collectionPrefix . '_');
            $fullCollection->addCollection($pageCollection);
            // set default route flag after all routes have been processed
            $defaultRouteForPage->setOption('_isDefault', true);
        }
 
        $matcher = new ‪PageUriMatcher($fullCollection);
        try {
            $result = $matcher->match($prefixedUrlPath);
            $matchedRoute = $fullCollection->get($result['_route']);
            // Only use route if page language variant matches current language, otherwise handle it as route not found.
            if ($this->‪isRouteReallyValidForLanguage($matchedRoute, $language)) {
                return $this->‪buildPageArguments($matchedRoute, $result, $request->getQueryParams());
            }
        } catch (ResourceNotFoundException $e) {
            if (str_ends_with($prefixedUrlPath, '/')) {
                // Second try, look for /my-page even though the request was called via /my-page/ and the slash
                // was not part of the slug, but let's then check again
                try {
                    $result = $matcher->match(rtrim($prefixedUrlPath, '/'));
                    $matchedRoute = $fullCollection->get($result['_route']);
                    // Only use route if page language variant matches current language, otherwise
                    // handle it as route not found.
                    if ($this->‪isRouteReallyValidForLanguage($matchedRoute, $language)) {
                        return $this->‪buildPageArguments($matchedRoute, $result, $request->getQueryParams());
                    }
                } catch (ResourceNotFoundException $e) {
                    // Do nothing
                }
            } else {
                // Second try, look for /my-page/ even though the request was called via /my-page and the slash
                // was part of the slug, but let's then check again
                try {
                    $result = $matcher->match($prefixedUrlPath . '/');
                    $matchedRoute = $fullCollection->get($result['_route']);
                    // Only use route if page language variant matches current language, otherwise
                    // handle it as route not found.
                    if ($this->‪isRouteReallyValidForLanguage($matchedRoute, $language)) {
                        return $this->‪buildPageArguments($matchedRoute, $result, $request->getQueryParams());
                    }
                } catch (ResourceNotFoundException $e) {
                    // Do nothing
                }
            }
        }
        throw new ‪RouteNotFoundException('No route found for path "' . $urlPath . '"', 1538389998);
    }
 
    public function ‪generateUri($route, array $parameters = [], string $fragment = '', string $type = ''): UriInterface
    {
        // Resolve language
        $language = null;
        $languageOption = $parameters['_language'] ?? null;
        unset($parameters['_language']);
        if ($languageOption instanceof ‪SiteLanguage) {
            $language = $languageOption;
        } elseif ($languageOption !== null) {
            $language = $this->site->getLanguageById((int)$languageOption);
        }
        if ($language === null) {
            $language = $this->site->getDefaultLanguage();
        }
 
        $pageId = 0;
        if ($route instanceof Page) {
            $pageId = $route->getPageId();
        } elseif (is_array($route)) {
            $pageId = (int)$route['uid'];
        } elseif (is_scalar($route)) {
            $pageId = (int)$route;
        }
 
        ‪$context = clone ‪$this->context;
        ‪$context->‪setAspect('language', ‪LanguageAspectFactory::createFromSiteLanguage($language));
        $pageRepository = GeneralUtility::makeInstance(PageRepository::class, ‪$context);
 
        if ($route instanceof Page) {
            $page = $route->toArray();
        } elseif (is_array($route)
            // Check 3rd party input $route for basic requirements
            && isset($route['uid'], $route['sys_language_uid'], $route['l10n_parent'], $route['slug'])
            && (int)$route['sys_language_uid'] === $language->getLanguageId()
            && ((int)$route['l10n_parent'] === 0 || ($route['_PAGES_OVERLAY'] ?? false))
        ) {
            $page = $route;
        } else {
            $page = $pageRepository->getPage($pageId, true);
        }
        $pagePath = $page['slug'] ?? '';
 
        if ($parameters['MP'] ?? '') {
            $mountPointPairs = explode(',', $parameters['MP']);
            $pagePath = $this->‪resolveMountPointParameterIntoPageSlug(
                $pageId,
                $pagePath,
                $mountPointPairs,
                $pageRepository
            );
            // If the MountPoint page has a different site, the link needs to be generated
            // with the base of the MountPoint page, this is especially relevant for cross-domain linking
            // Because the language contains the full base, it is retrieved in this case.
            try {
                [, $mountPointPage] = explode('-', (string)reset($mountPointPairs));
                ‪$site = GeneralUtility::makeInstance(SiteMatcher::class)
                    ->matchByPageId((int)$mountPointPage);
                $language = ‪$site->‪getLanguageById($language->getLanguageId());
            } catch (SiteNotFoundException $e) {
                // No alternative site found, use the existing one
            }
            // Store the MP parameter in the page record, so it could be used for any enhancers
            $page['MPvar'] = $parameters['MP'];
            unset($parameters['MP']);
        }
 
        $originalParameters = $parameters;
        $collection = new RouteCollection();
        $defaultRouteForPage = new Route(
            '/' . ltrim($pagePath, '/'),
            [],
            [],
            ['utf8' => true, '_page' => $page]
        );
        $collection->add('default', $defaultRouteForPage);
 
        // cHash is never considered because cHash is built by this very method.
        unset($originalParameters['cHash']);
        $enhancers = $this->‪getEnhancersForPage($pageId, $language);
        foreach ($enhancers as $enhancer) {
            if ($enhancer instanceof RoutingEnhancerInterface) {
                $enhancer->enhanceForGeneration($collection, $originalParameters);
            }
        }
        foreach ($enhancers as $enhancer) {
            if ($enhancer instanceof DecoratingEnhancerInterface) {
                $enhancer->decorateForGeneration($collection, $originalParameters);
            }
        }
 
        $mappableProcessor = new MappableProcessor();
        $requestContext = $this->requestContextFactory->fromSiteLanguage($language);
        $generator = new UrlGenerator($collection, $requestContext);
        $generator->injectMappableProcessor($mappableProcessor);
        // set default route flag after all routes have been processed
        $defaultRouteForPage->setOption('_isDefault', true);
        $allRoutes = GeneralUtility::makeInstance(RouteSorter::class)
            ->withRoutes($collection->all())
            ->withOriginalParameters($originalParameters)
            ->sortRoutesForGeneration()
            ->getRoutes();
        $matchedRoute = null;
        $pageRouteResult = null;
        $uri = null;
        // map our reference type to symfony's custom paths
        $referenceType = $type === static::ABSOLUTE_PATH ? UrlGenerator::ABSOLUTE_PATH : UrlGenerator::ABSOLUTE_URL;
        foreach ($allRoutes as $routeName => $route) {
            try {
                $parameters = $originalParameters;
                if ($route->hasOption('deflatedParameters')) {
                    $parameters = $route->getOption('deflatedParameters');
                }
                $mappableProcessor->generate($route, $parameters);
                // ABSOLUTE_URL is used as default fallback
                $urlAsString = $generator->generate($routeName, $parameters, $referenceType);
                $uri = new Uri($urlAsString);
                $matchedRoute = $collection->get($routeName);
                // fetch potential applied defaults for later cHash generation
                // (even if not applied in route, it will be exposed during resolving)
                $appliedDefaults = $matchedRoute->getOption('_appliedDefaults') ?? [];
                parse_str($uri->getQuery(), $remainingQueryParameters);
                $enhancer = $route->getEnhancer();
                if ($enhancer instanceof InflatableEnhancerInterface) {
                    $remainingQueryParameters = $enhancer->inflateParameters($remainingQueryParameters);
                }
                $pageRouteResult = $this->‪buildPageArguments($route, array_merge($appliedDefaults, $parameters), $remainingQueryParameters);
                break;
            } catch (MissingMandatoryParametersException $e) {
                // no match
            }
        }
 
        if (!$uri instanceof UriInterface) {
            throw new InvalidRouteArgumentsException('Uri could not be built for page "' . $pageId . '"', 1538390230);
        }
 
        if ($pageRouteResult && $pageRouteResult->areDirty()) {
            // for generating URLs this should(!) never happen
            // if it does happen, generator logic has flaws
            throw new InvalidRouteArgumentsException('Route arguments are dirty', 1537613247);
        }
 
        if ($matchedRoute && $pageRouteResult && !empty($pageRouteResult->getDynamicArguments())) {
            $cacheHash = $this->‪generateCacheHash($pageId, $pageRouteResult);
 
            $queryArguments = $pageRouteResult->getQueryArguments();
            if (!empty($cacheHash)) {
                $queryArguments['cHash'] = $cacheHash;
            }
            $uri = $uri->withQuery(http_build_query($queryArguments, '', '&', PHP_QUERY_RFC3986));
        }
        if ($fragment) {
            $uri = $uri->withFragment($fragment);
        }
        return $uri;
    }
 
    protected function ‪resolveMountPointParameterIntoPageSlug(
        int $pageId,
        string $pagePath,
        array $mountPointPairs,
        ‪PageRepository $pageRepository
    ): string {
        // Handle recursive mount points
        $prefixesToRemove = [];
        $slugPrefixesToAdd = [];
        foreach ($mountPointPairs as $mountPointPair) {
            [$mountRoot, $mountedPage] = GeneralUtility::intExplode('-', (string)$mountPointPair);
            $mountPageInformation = $pageRepository->‪getMountPointInfo($mountedPage);
            if ($mountPageInformation) {
                if ($pageId === $mountedPage) {
                    continue;
                }
                // Get slugs in the translated page
                $mountedPage = $pageRepository->‪getPage($mountedPage);
                $mountRoot = $pageRepository->‪getPage($mountRoot);
                $slugPrefix = $mountedPage['slug'] ?? '';
                if ($slugPrefix === '/') {
                    $slugPrefix = '';
                }
                $prefixToRemove = $mountRoot['slug'] ?? '';
                if ($prefixToRemove === '/') {
                    $prefixToRemove = '';
                }
                $prefixesToRemove[] = $prefixToRemove;
                $slugPrefixesToAdd[] = $slugPrefix;
            }
        }
        $slugPrefixesToAdd = array_reverse($slugPrefixesToAdd);
        $prefixesToRemove = array_reverse($prefixesToRemove);
        foreach ($prefixesToRemove as $prefixToRemove) {
            // Slug prefixes are taken from the beginning of the array, where as the parts to be removed
            // Are taken from the end.
            $replacement = array_shift($slugPrefixesToAdd);
            if ($prefixToRemove !== '' && str_starts_with($pagePath, $prefixToRemove)) {
                $pagePath = substr($pagePath, strlen($prefixToRemove));
            }
            $pagePath = $replacement . ($pagePath !== '/' ? '/' . ltrim($pagePath, '/') : '');
        }
        return $pagePath;
    }
 
    protected function ‪getEnhancersForPage(int $pageId, ‪SiteLanguage $language): array
    {
        $enhancers = [];
        foreach ($this->site->getConfiguration()['routeEnhancers'] ?? [] as $enhancerConfiguration) {
            // Check if there is a restriction to page Ids.
            if (is_array($enhancerConfiguration['limitToPages'] ?? null) && !in_array($pageId, $enhancerConfiguration['limitToPages'])) {
                continue;
            }
            $enhancerType = $enhancerConfiguration['type'] ?? '';
            $enhancer = $this->enhancerFactory->create($enhancerType, $enhancerConfiguration);
            if (!empty($enhancerConfiguration['aspects'] ?? null)) {
                $aspects = $this->aspectFactory->createAspects(
                    $enhancerConfiguration['aspects'],
                    $language,
                    $this->site
                );
                $enhancer->setAspects($aspects);
            }
            $enhancers[] = $enhancer;
        }
        return $enhancers;
    }
 
    protected function ‪generateCacheHash(int $pageId, ‪PageArguments $arguments): string
    {
        return $this->cacheHashCalculator->calculateCacheHash(
            $this->‪getCacheHashParameters($pageId, $arguments)
        );
    }
 
    protected function ‪getCacheHashParameters(int $pageId, ‪PageArguments $arguments): array
    {
        $hashParameters = $arguments->getDynamicArguments();
        $hashParameters['id'] = $pageId;
        $uri = http_build_query($hashParameters, '', '&', PHP_QUERY_RFC3986);
        return $this->cacheHashCalculator->getRelevantParameters($uri);
    }
 
    protected function ‪buildPageArguments(‪Route $route, array $results, array $remainingQueryParameters = []): ‪PageArguments
    {
        // only use parameters that actually have been processed
        // (thus stripping internals like _route, _controller, ...)
        $routeArguments = $this->‪filterProcessedParameters($route, $results);
        // assert amount of "static" mappers is not too "dynamic"
        $this->‪assertMaximumStaticMappableAmount($route, array_keys($routeArguments));
        // delegate result handling to enhancer
        $enhancer = $route->‪getEnhancer();
        if ($enhancer instanceof ‪ResultingInterface) {
            // forward complete(!) results, not just filtered parameters
            return $enhancer->buildResult($route, $results, $remainingQueryParameters);
        }
        $page = $route->getOption('_page');
        if ((int)($page['l10n_parent'] ?? 0) > 0) {
            $pageId = (int)$page['l10n_parent'];
        } elseif ((int)($page['t3ver_oid'] ?? 0) > 0) {
            $pageId = (int)$page['t3ver_oid'];
        } else {
            $pageId = (int)($page['uid'] ?? 0);
        }
        $type = $this->‪resolveType($route, $remainingQueryParameters);
        // See PageSlugCandidateProvider where this is added.
        if ($page['MPvar'] ?? '') {
            $routeArguments['MP'] = $page['MPvar'];
        }
        return new ‪PageArguments($pageId, $type, $routeArguments, [], $remainingQueryParameters);
    }
 
    protected function ‪resolveType(‪Route $route, array &$remainingQueryParameters): string
    {
        $type = $remainingQueryParameters['type'] ?? 0;
        $decoratedParameters = $route->getOption('_decoratedParameters');
        if (isset($decoratedParameters['type'])) {
            $type = $decoratedParameters['type'];
            unset($decoratedParameters['type']);
            $remainingQueryParameters = array_replace_recursive(
                $remainingQueryParameters,
                $decoratedParameters
            );
        }
        return (string)$type;
    }
 
    protected function ‪assertMaximumStaticMappableAmount(‪Route $route, array $variableNames = [])
    {
        // empty when only values of route defaults where used
        if (empty($variableNames)) {
            return;
        }
        $mappers = $route->‪filterAspects(
            [StaticMappableAspectInterface::class, \Countable::class],
            $variableNames
        );
        if (empty($mappers)) {
            return;
        }
 
        $multipliers = array_map('count', $mappers);
        $product = array_product($multipliers);
        if ($product > 10000) {
            throw new \OverflowException(
                'Possible range of all mappers is larger than 10000 items',
                1537696772
            );
        }
    }
 
    protected function ‪filterProcessedParameters(‪Route $route, $results): array
    {
        return array_intersect_key(
            $results,
            array_flip($route->compile()->getPathVariables())
        );
    }
 
    protected function ‪getSlugCandidateProvider(‪Context ‪$context): ‪PageSlugCandidateProvider
    {
        return GeneralUtility::makeInstance(
            PageSlugCandidateProvider::class,
            ‪$context,
            $this->site,
            $this->enhancerFactory
        );
    }
 
    protected function ‪isRouteReallyValidForLanguage(‪Route $route, ‪SiteLanguage $siteLanguage): bool
    {
        $page = $route->getOption('_page');
        $languageIdField = ‪$GLOBALS['TCA']['pages']['ctrl']['languageField'] ?? '';
        if ($languageIdField === '') {
            return true;
        }
        $languageId = (int)($page[$languageIdField] ?? 0);
        if ($siteLanguage->‪getLanguageId() === 0 || $siteLanguage->‪getLanguageId() === $languageId) {
            // default language site request or if page record is same language then siteLanguage, page record
            // is valid to use as page resolving candidate and need no further overlay checks.
            return true;
        }
        $pageIdInDefaultLanguage = (int)($languageId > 0 ? $page['l10n_parent'] : $page['uid']);
        $pageRepository = GeneralUtility::makeInstance(PageRepository::class, $this->context);
        $localizedPage = $pageRepository->getPageOverlay($pageIdInDefaultLanguage, $siteLanguage->‪getLanguageId());
        if (!$localizedPage) {
            // no page language overlay found, which means that either language page is not published and no logged
            // in backend user OR there is no language overlay for that page at all. Thus using page record to build
            // as page resolving candidate is valid.
            return true;
        }
        // we found a valid page overlay, which means that current record is not the valid page for the current
        // siteLanguage. To avoid resolving page with multiple slugs for a siteLanguage path, we flag this invalid.
        return false;
    }
}