vendor/pimcore/pimcore/lib/Routing/Dynamic/DocumentRouteHandler.php line 175

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /**
  6.  * Pimcore
  7.  *
  8.  * This source file is available under two different licenses:
  9.  * - GNU General Public License version 3 (GPLv3)
  10.  * - Pimcore Commercial License (PCL)
  11.  * Full copyright and license information is available in
  12.  * LICENSE.md which is distributed with this source code.
  13.  *
  14.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  15.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  16.  */
  18. namespace Pimcore\Routing\Dynamic;
  20. use Pimcore\Config;
  21. use Pimcore\Http\Request\Resolver\SiteResolver;
  22. use Pimcore\Http\Request\Resolver\StaticPageResolver;
  23. use Pimcore\Http\RequestHelper;
  24. use Pimcore\Model\Document;
  25. use Pimcore\Model\Document\Page;
  26. use Pimcore\Routing\DocumentRoute;
  27. use Symfony\Component\Routing\Exception\RouteNotFoundException;
  28. use Symfony\Component\Routing\RouteCollection;
  30. /**
  31.  * @internal
  32.  */
  33. final class DocumentRouteHandler implements DynamicRouteHandlerInterface
  34. {
  35.     /**
  36.      * @var Document\Service
  37.      */
  38.     private $documentService;
  40.     /**
  41.      * @var SiteResolver
  42.      */
  43.     private $siteResolver;
  45.     /**
  46.      * @var RequestHelper
  47.      */
  48.     private $requestHelper;
  50.     /**
  51.      * Determines if unpublished documents should be matched, even when not in admin mode. This
  52.      * is mainly needed for maintencance jobs/scripts.
  53.      *
  54.      * @var bool
  55.      */
  56.     private $forceHandleUnpublishedDocuments = false;
  58.     /**
  59.      * @var array
  60.      */
  61.     private $directRouteDocumentTypes = [];
  63.     /**
  64.      * @var Config
  65.      */
  66.     private $config;
  68.     /**
  69.      * @var StaticPageResolver
  70.      */
  71.     private StaticPageResolver $staticPageResolver;
  73.     /**
  74.      * @param Document\Service $documentService
  75.      * @param SiteResolver $siteResolver
  76.      * @param RequestHelper $requestHelper
  77.      * @param Config $config
  78.      */
  79.     public function __construct(
  80.         Document\Service $documentService,
  81.         SiteResolver $siteResolver,
  82.         RequestHelper $requestHelper,
  83.         Config $config,
  84.         StaticPageResolver $staticPageResolver
  85.     ) {
  86.         $this->documentService = $documentService;
  87.         $this->siteResolver = $siteResolver;
  88.         $this->requestHelper = $requestHelper;
  89.         $this->config = $config;
  90.         $this->staticPageResolver = $staticPageResolver;
  91.     }
  93.     public function setForceHandleUnpublishedDocuments(bool $handle)
  94.     {
  95.         $this->forceHandleUnpublishedDocuments = $handle;
  96.     }
  98.     /**
  99.      * @return array
  100.      */
  101.     public function getDirectRouteDocumentTypes()
  102.     {
  103.         if (empty($this->directRouteDocumentTypes)) {
  104.             $routingConfig = \Pimcore\Config::getSystemConfiguration('routing');
  105.             $this->directRouteDocumentTypes = $routingConfig['direct_route_document_types'];
  106.         }
  108.         return $this->directRouteDocumentTypes;
  109.     }
  111.     /**
  112.      * @deprecated will be removed in Pimcore 11
  113.      *
  114.      * @param string $type
  115.      */
  116.     public function addDirectRouteDocumentType($type)
  117.     {
  118.         if (!in_array($type, $this->getDirectRouteDocumentTypes())) {
  119.             $this->directRouteDocumentTypes[] = $type;
  120.         }
  121.     }
  123.     /**
  124.      * {@inheritdoc}
  125.      */
  126.     public function getRouteByName(string $name)
  127.     {
  128.         if (preg_match('/^document_(\d+)$/', $name, $match)) {
  129.             $document = Document::getById($match[1]);
  131.             if ($this->isDirectRouteDocument($document)) {
  132.                 return $this->buildRouteForDocument($document);
  133.             }
  134.         }
  136.         throw new RouteNotFoundException(sprintf("Route for name '%s' was not found", $name));
  137.     }
  139.     /**
  140.      * {@inheritdoc}
  141.      */
  142.     public function matchRequest(RouteCollection $collection, DynamicRequestContext $context)
  143.     {
  144.         $document = Document::getByPath($context->getPath());
  146.         // check for a pretty url inside a site
  147.         if (!$document && $this->siteResolver->isSiteRequest($context->getRequest())) {
  148.             $site = $this->siteResolver->getSite($context->getRequest());
  150.             $sitePrettyDocId = $this->documentService->getDao()->getDocumentIdByPrettyUrlInSite($site, $context->getOriginalPath());
  151.             if ($sitePrettyDocId) {
  152.                 if ($sitePrettyDoc = Document::getById($sitePrettyDocId)) {
  153.                     $document = $sitePrettyDoc;
  155.                     // TODO set pretty path via siteResolver?
  156.                     // undo the modification of the path by the site detection (prefixing with site root path)
  157.                     // this is not necessary when using pretty-urls and will cause problems when validating the
  158.                     // prettyUrl later (redirecting to the prettyUrl in the case the page was called by the real path)
  159.                     $context->setPath($context->getOriginalPath());
  160.                 }
  161.             }
  162.         }
  164.         // check for a parent hardlink with children
  165.         if (!$document instanceof Document) {
  166.             $hardlinkedParentDocument = $this->documentService->getNearestDocumentByPath($context->getPath(), true);
  167.             if ($hardlinkedParentDocument instanceof Document\Hardlink) {
  168.                 if ($hardLinkedDocument = Document\Hardlink\Service::getChildByPath($hardlinkedParentDocument, $context->getPath())) {
  169.                     $document = $hardLinkedDocument;
  170.                 }
  171.             }
  172.         }
  174.         if ($document && $document instanceof Document) {
  175.             if ($route = $this->buildRouteForDocument($document, $context)) {
  176.                 $collection->add($route->getRouteKey(), $route);
  177.             }
  178.         }
  179.     }
  181.     /**
  182.      * Build a route for a document. Context is only set from match mode, not when generating URLs.
  183.      *
  184.      * @param Document $document
  185.      * @param DynamicRequestContext|null $context
  186.      *
  187.      * @return DocumentRoute|null
  188.      */
  189.     public function buildRouteForDocument(Document $document, DynamicRequestContext $context = null)
  190.     {
  191.         // check for direct hardlink
  192.         if ($document instanceof Document\Hardlink) {
  193.             $document = Document\Hardlink\Service::wrap($document);
  195.             if (!$document) {
  196.                 return null;
  197.             }
  198.         }
  200.         $route = new DocumentRoute($document->getFullPath());
  201.         $route->setOption('utf8', true);
  203.         // coming from matching -> set route path the currently matched one
  204.         if (null !== $context) {
  205.             $route->setPath($context->getOriginalPath());
  206.         }
  208.         $route->setDefault('_locale', $document->getProperty('language'));
  209.         $route->setDocument($document);
  211.         if ($this->isDirectRouteDocument($document)) {
  212.             /** @var Document\PageSnippet $document */
  213.             $route = $this->handleDirectRouteDocument($document, $route, $context);
  214.         } elseif ($document->getType() === 'link') {
  215.             /** @var Document\Link $document */
  216.             $route = $this->handleLinkDocument($document, $route);
  217.         }
  219.         return $route;
  220.     }
  222.     /**
  223.      * Handle route params for link document
  224.      *
  225.      * @param Document\Link $document
  226.      * @param DocumentRoute $route
  227.      *
  228.      * @return DocumentRoute
  229.      */
  230.     private function handleLinkDocument(Document\Link $document, DocumentRoute $route)
  231.     {
  232.         $route->setDefault('_controller', 'Symfony\Bundle\FrameworkBundle\Controller\RedirectController::urlRedirectAction');
  233.         $route->setDefault('path', $document->getHref());
  234.         $route->setDefault('permanent', true);
  236.         return $route;
  237.     }
  239.     /**
  240.      * Handle direct route documents (not link)
  241.      *
  242.      * @param Document\PageSnippet $document
  243.      * @param DocumentRoute $route
  244.      * @param DynamicRequestContext|null $context
  245.      *
  246.      * @return DocumentRoute|null
  247.      */
  248.     private function handleDirectRouteDocument(
  249.         Document\PageSnippet $document,
  250.         DocumentRoute $route,
  251.         DynamicRequestContext $context = null
  252.     ) {
  253.         // if we have a request we're currently in match mode (not generating URLs) -> only match when frontend request by admin
  254.         try {
  255.             $request = null;
  256.             if ($context) {
  257.                 $request = $context->getRequest();
  258.             }
  259.             $isAdminRequest = $this->requestHelper->isFrontendRequestByAdmin($request);
  260.         } catch (\LogicException $e) {
  261.             // catch logic exception here - when the exception fires, it is no admin request
  262.             $isAdminRequest = false;
  263.         }
  265.         // abort if document is not published and the request is no admin request
  266.         // and matching unpublished documents was not forced
  267.         if (!$document->isPublished()) {
  268.             if (!($isAdminRequest || $this->forceHandleUnpublishedDocuments)) {
  269.                 return null;
  270.             }
  271.         }
  273.         if (!$isAdminRequest && null !== $context) {
  274.             // check for redirects (pretty URL, SEO) when not in admin mode and while matching (not generating route)
  275.             if ($redirectRoute = $this->handleDirectRouteRedirect($document, $route, $context)) {
  276.                 return $redirectRoute;
  277.             }
  279.             // set static page context
  280.             if ($document instanceof Page && $document->getStaticGeneratorEnabled()) {
  281.                 $this->staticPageResolver->setStaticPageContext($context->getRequest());
  282.             }
  283.         }
  285.         // Use latest version, if available, when the request is admin request
  286.         // so then route should be built based on latest Document settings
  287.         // https://github.com/pimcore/pimcore/issues/9644
  288.         if ($isAdminRequest) {
  289.             $latestVersion = $document->getLatestVersion();
  290.             if ($latestVersion) {
  291.                 $latestDoc = $latestVersion->loadData();
  292.                 if ($latestDoc instanceof Document\PageSnippet) {
  293.                     $document = $latestDoc;
  294.                 }
  295.             }
  296.         }
  298.         return $this->buildRouteForPageSnippetDocument($document, $route);
  299.     }
  301.     /**
  302.      * Handle document redirects (pretty url, SEO without trailing slash)
  303.      *
  304.      * @param Document\PageSnippet $document
  305.      * @param DocumentRoute $route
  306.      * @param DynamicRequestContext|null $context
  307.      *
  308.      * @return DocumentRoute|null
  309.      */
  310.     private function handleDirectRouteRedirect(
  311.         Document\PageSnippet $document,
  312.         DocumentRoute $route,
  313.         DynamicRequestContext $context = null
  314.     ) {
  315.         $redirectTargetUrl = $context->getOriginalPath();
  317.         // check for a pretty url, and if the document is called by that, otherwise redirect to pretty url
  318.         if ($document instanceof Document\Page && !$document instanceof Document\Hardlink\Wrapper\WrapperInterface) {
  319.             if ($prettyUrl = $document->getPrettyUrl()) {
  320.                 if (rtrim(strtolower($prettyUrl), ' /') !== rtrim(strtolower($context->getOriginalPath()), '/')) {
  321.                     $redirectTargetUrl = $prettyUrl;
  322.                 }
  323.             }
  324.         }
  326.         // check for a trailing slash in path, if exists, redirect to this page without the slash
  327.         // the only reason for this is: SEO, Analytics, ... there is no system specific reason, pimcore would work also with a trailing slash without problems
  328.         // use $originalPath because of the sites
  329.         // only do redirecting with GET requests
  330.         if ($context->getRequest()->getMethod() === 'GET') {
  331.             if (($this->config['documents']['allow_trailing_slash'] ?? null) === 'no') {
  332.                 if ($redirectTargetUrl !== '/' && substr($redirectTargetUrl, -1) === '/') {
  333.                     $redirectTargetUrl = rtrim($redirectTargetUrl, '/');
  334.                 }
  335.             }
  337.             // only allow the original key of a document to be the URL (lowercase/uppercase)
  338.             if ($redirectTargetUrl !== '/' && rtrim($redirectTargetUrl, '/') !== rawurldecode($document->getFullPath())) {
  339.                 $redirectTargetUrl = $document->getFullPath();
  340.             }
  341.         }
  343.         if (null !== $redirectTargetUrl && $redirectTargetUrl !== $context->getOriginalPath()) {
  344.             $route->setDefault('_controller', 'Symfony\Bundle\FrameworkBundle\Controller\RedirectController::urlRedirectAction');
  345.             $route->setDefault('path', $redirectTargetUrl);
  346.             $route->setDefault('permanent', true);
  348.             return $route;
  349.         }
  351.         return null;
  352.     }
  354.     /**
  355.      * Handle page snippet route (controller, action, view)
  356.      *
  357.      * @param Document\PageSnippet $document
  358.      * @param DocumentRoute $route
  359.      *
  360.      * @return DocumentRoute
  361.      */
  362.     private function buildRouteForPageSnippetDocument(Document\PageSnippet $document, DocumentRoute $route)
  363.     {
  364.         $route->setDefault('_controller', $document->getController());
  366.         if ($document->getTemplate()) {
  367.             $route->setDefault('_template', $document->getTemplate());
  368.         }
  370.         return $route;
  371.     }
  373.     /**
  374.      * Check if document is can be used to generate a route
  375.      *
  376.      * @param Document\PageSnippet $document
  377.      *
  378.      * @return bool
  379.      */
  380.     private function isDirectRouteDocument($document)
  381.     {
  382.         if ($document instanceof Document\PageSnippet) {
  383.             if (in_array($document->getType(), $this->getDirectRouteDocumentTypes())) {
  384.                 return true;
  385.             }
  386.         }
  388.         return false;
  389.     }
  390. }