vendor/sulu/sulu/src/Sulu/Bundle/WebsiteBundle/Routing/ContentRouteProvider.php line 104

  1. <?php
  3. /*
  4.  * This file is part of Sulu.
  5.  *
  6.  * (c) Sulu GmbH
  7.  *
  8.  * This source file is subject to the MIT license that is bundled
  9.  * with this source code in the file LICENSE.
  10.  */
  12. namespace Sulu\Bundle\WebsiteBundle\Routing;
  14. use PHPCR\RepositoryException;
  15. use Sulu\Bundle\DocumentManagerBundle\Bridge\DocumentInspector;
  16. use Sulu\Bundle\PageBundle\Document\PageDocument;
  17. use Sulu\Component\Content\Compat\Structure\PageBridge;
  18. use Sulu\Component\Content\Compat\StructureManagerInterface;
  19. use Sulu\Component\Content\Document\Behavior\ExtensionBehavior;
  20. use Sulu\Component\Content\Document\Behavior\ResourceSegmentBehavior;
  21. use Sulu\Component\Content\Document\Behavior\WebspaceBehavior;
  22. use Sulu\Component\Content\Document\RedirectType;
  23. use Sulu\Component\Content\Exception\ResourceLocatorMovedException;
  24. use Sulu\Component\Content\Exception\ResourceLocatorNotFoundException;
  25. use Sulu\Component\Content\Types\ResourceLocator\Strategy\ResourceLocatorStrategyPoolInterface;
  26. use Sulu\Component\DocumentManager\DocumentManagerInterface;
  27. use Sulu\Component\Security\Authorization\PermissionTypes;
  28. use Sulu\Component\Security\Authorization\SecurityCheckerInterface;
  29. use Sulu\Component\Security\Authorization\SecurityCondition;
  30. use Sulu\Component\Webspace\Analyzer\Attributes\RequestAttributes;
  31. use Sulu\Component\Webspace\Analyzer\RequestAnalyzerInterface;
  32. use Sulu\Component\Webspace\Manager\WebspaceManagerInterface;
  33. use Symfony\Cmf\Component\Routing\RouteProviderInterface;
  34. use Symfony\Component\HttpFoundation\Request;
  35. use Symfony\Component\Routing\Exception\RouteNotFoundException;
  36. use Symfony\Component\Routing\Route;
  37. use Symfony\Component\Routing\RouteCollection;
  39. /**
  40.  * The PortalRouteProvider should load the dynamic routes created by Sulu.
  41.  */
  42. class ContentRouteProvider implements RouteProviderInterface
  43. {
  44.     /**
  45.      * @var DocumentManagerInterface
  46.      */
  47.     private $documentManager;
  49.     /**
  50.      * @var DocumentInspector
  51.      */
  52.     private $documentInspector;
  54.     /**
  55.      * @var ResourceLocatorStrategyPoolInterface
  56.      */
  57.     private $resourceLocatorStrategyPool;
  59.     /**
  60.      * @var StructureManagerInterface
  61.      */
  62.     private $structureManager;
  64.     /**
  65.      * @var WebspaceManagerInterface
  66.      */
  67.     private $webspaceManager;
  69.     /**
  70.      * @var RequestAnalyzerInterface
  71.      */
  72.     private $requestAnalyzer;
  74.     /**
  75.      * @var SecurityCheckerInterface|null
  76.      */
  77.     private $securityChecker;
  79.     /**
  80.      * @var array
  81.      */
  82.     private $defaultOptions;
  84.     public function __construct(
  85.         DocumentManagerInterface $documentManager,
  86.         DocumentInspector $documentInspector,
  87.         ResourceLocatorStrategyPoolInterface $resourceLocatorStrategyPool,
  88.         StructureManagerInterface $structureManager,
  89.         WebspaceManagerInterface $webspaceManager,
  90.         RequestAnalyzerInterface $requestAnalyzer,
  91.         SecurityCheckerInterface $securityChecker = null,
  92.         array $defaultOptions = []
  93.     ) {
  94.         $this->documentManager = $documentManager;
  95.         $this->documentInspector = $documentInspector;
  96.         $this->resourceLocatorStrategyPool = $resourceLocatorStrategyPool;
  97.         $this->structureManager = $structureManager;
  98.         $this->webspaceManager = $webspaceManager;
  99.         $this->requestAnalyzer = $requestAnalyzer;
  100.         $this->securityChecker = $securityChecker;
  101.         $this->defaultOptions = $defaultOptions;
  102.     }
  104.     public function getRouteCollectionForRequest(Request $request): RouteCollection
  105.     {
  106.         $collection = new RouteCollection();
  108.         if ('' === $request->getRequestFormat()) {
  109.             return $collection;
  110.         }
  112.         /** @var RequestAttributes $attributes */
  113.         $attributes = $request->attributes->get('_sulu');
  114.         if (!$attributes) {
  115.             return $collection;
  116.         }
  118.         $matchType = $attributes->getAttribute('matchType');
  120.         // no portal information without localization supported
  121.         if (null === $attributes->getAttribute('localization')
  122.             && RequestAnalyzerInterface::MATCH_TYPE_PARTIAL !== $matchType
  123.             && RequestAnalyzerInterface::MATCH_TYPE_REDIRECT !== $matchType
  124.         ) {
  125.             return $collection;
  126.         }
  128.         $resourceLocator = $this->decodePathInfo($attributes->getAttribute('resourceLocator'));
  129.         $prefix = $attributes->getAttribute('resourceLocatorPrefix');
  131.         $pathInfo = $this->decodePathInfo($request->getPathInfo());
  132.         $htmlRedirect = $pathInfo !== $prefix . $resourceLocator
  133.                         && \in_array($request->getRequestFormat(), ['htm', 'html']);
  135.         if ($htmlRedirect
  136.             || RequestAnalyzerInterface::MATCH_TYPE_REDIRECT == $matchType
  137.             || RequestAnalyzerInterface::MATCH_TYPE_PARTIAL == $matchType
  138.         ) {
  139.             return $collection;
  140.         }
  142.         // just show the page
  143.         $portal = $attributes->getAttribute('portal');
  144.         $locale = $attributes->getAttribute('localization')->getLocale();
  145.         $resourceLocatorStrategy = $this->resourceLocatorStrategyPool->getStrategyByWebspaceKey(
  146.             $portal->getWebspace()->getKey()
  147.         );
  149.         try {
  150.             // load content by url ignore ending trailing slash
  151.             /** @var PageDocument $document */
  152.             $document = $this->documentManager->find(
  153.                 $resourceLocatorStrategy->loadByResourceLocator(
  154.                     \rtrim($resourceLocator, '/'),
  155.                     $portal->getWebspace()->getKey(),
  156.                     $locale
  157.                 ),
  158.                 $locale,
  159.                 [
  160.                     'load_ghost_content' => false,
  161.                 ]
  162.             );
  164.             if (!$document->getTitle()) {
  165.                 // If the title is empty the document does not exist in this locale
  166.                 // Necessary because of https://github.com/sulu/sulu/issues/2724, otherwise locale could be checked
  167.                 return $collection;
  168.             }
  170.             if ($this->securityChecker && $portal->getWebspace()->hasWebsiteSecurity()) {
  171.                 $this->securityChecker->checkPermission(
  172.                     new SecurityCondition(
  173.                         'sulu.webspaces.' . $document->getWebspaceName(),
  174.                         $document->getLocale(),
  175.                         \get_class($document),
  176.                         $document->getUuid()
  177.                     ),
  178.                     PermissionTypes::VIEW
  179.                 );
  180.             }
  182.             if (\preg_match('/\/$/', $resourceLocator) && ('/' !== $resourceLocator || $prefix)) {
  183.                 // redirect page to page without slash at the end
  184.                 $url = $prefix . \rtrim($resourceLocator, '/');
  185.                 if ($request->getQueryString()) {
  186.                     $url .= '?' . $request->getQueryString();
  187.                 }
  188.                 $collection->add('redirect_' . \uniqid(), $this->getRedirectRoute($request, $url));
  189.             } elseif (RedirectType::INTERNAL === $document->getRedirectType()) {
  190.                 $redirectTarget = $document->getRedirectTarget();
  192.                 if (!$redirectTarget instanceof ResourceSegmentBehavior || !$redirectTarget instanceof WebspaceBehavior) {
  193.                     return $collection;
  194.                 }
  196.                 $redirectUrl = $this->webspaceManager->findUrlByResourceLocator(
  197.                     $redirectTarget->getResourceSegment(),
  198.                     null,
  199.                     $document->getLocale(),
  200.                     $redirectTarget->getWebspaceName()
  201.                 );
  203.                 if ($request->getQueryString()) {
  204.                     $redirectUrl .= '?' . $request->getQueryString();
  205.                 }
  207.                 $collection->add(
  208.                     $document->getStructureType() . '_' . $document->getUuid(),
  209.                     $this->getRedirectRoute($request, $redirectUrl)
  210.                 );
  211.             } elseif (RedirectType::EXTERNAL === $document->getRedirectType()) {
  212.                 $collection->add(
  213.                     $document->getStructureType() . '_' . $document->getUuid(),
  214.                     $this->getRedirectRoute($request, $document->getRedirectExternal())
  215.                 );
  216.             } elseif (!$this->checkResourceLocator($resourceLocator, $prefix)) {
  217.                 return $collection;
  218.             } else {
  219.                 if ($document instanceof ExtensionBehavior) {
  220.                     $documentSegments = $document->getExtensionsData()['excerpt']['segments'] ?? [];
  221.                     $documentSegmentKey = $documentSegments[$portal->getWebspace()->getKey()] ?? null;
  222.                     $segment = $this->requestAnalyzer->getSegment();
  224.                     if ($segment && $documentSegmentKey && $segment->getKey() !== $documentSegmentKey) {
  225.                         $this->requestAnalyzer->changeSegment($documentSegmentKey);
  226.                     }
  227.                 }
  229.                 // convert the page to a StructureBridge because of BC
  230.                 $metadata = $this->documentInspector->getStructureMetadata($document);
  231.                 if (!$metadata) {
  232.                     return $collection;
  233.                 }
  235.                 /** @var PageBridge $structure */
  236.                 $structure = $this->structureManager->wrapStructure(
  237.                     $this->documentInspector->getMetadata($document)->getAlias(),
  238.                     $metadata
  239.                 );
  240.                 $structure->setDocument($document);
  242.                 // show the page
  243.                 $collection->add(
  244.                     $document->getStructureType() . '_' . $document->getUuid(),
  245.                     $this->getStructureRoute($request, $structure)
  246.                 );
  247.             }
  248.         } catch (ResourceLocatorNotFoundException $exc) {
  249.             // just do not add any routes to the collection
  250.         } catch (ResourceLocatorMovedException $exc) {
  251.             // old url resource was moved
  252.             $collection->add(
  253.                 $exc->getNewResourceLocatorUuid() . '_' . \uniqid(),
  254.                 $this->getRedirectRoute($request, $prefix . $exc->getNewResourceLocator())
  255.             );
  256.         } catch (RepositoryException $exc) {
  257.             // just do not add any routes to the collection
  258.         }
  260.         return $collection;
  261.     }
  263.     /**
  264.      * @param string $name
  265.      */
  266.     public function getRouteByName($name): Route
  267.     {
  268.         throw new RouteNotFoundException();
  269.     }
  271.     public function getRoutesByNames($names = null): iterable
  272.     {
  273.         return [];
  274.     }
  276.     /**
  277.      * Checks if the resource locator is valid.
  278.      * A resource locator with a slash only is not allowed, the only exception is when it is a single language
  279.      * website, where the browser automatically adds the slash.
  280.      *
  281.      * @param string $resourceLocator
  282.      * @param string $resourceLocatorPrefix
  283.      *
  284.      * @return bool
  285.      */
  286.     private function checkResourceLocator($resourceLocator, $resourceLocatorPrefix)
  287.     {
  288.         return !('/' === $resourceLocator && $resourceLocatorPrefix);
  289.     }
  291.     /**
  292.      * @param string $url
  293.      *
  294.      * @return Route
  295.      */
  296.     protected function getRedirectRoute(Request $request, $url)
  297.     {
  298.         $requestFormat = $request->getRequestFormat(null);
  299.         $formatSuffix = $requestFormat ? '.' . $requestFormat : '';
  301.         // redirect to linked page
  302.         return new Route(
  303.             $this->decodePathInfo($request->getPathInfo()),
  304.             [
  305.                 '_controller' => 'sulu_website.redirect_controller::redirectAction',
  306.                 'url' => $url . $formatSuffix,
  307.             ],
  308.             [],
  309.             $this->defaultOptions
  310.         );
  311.     }
  313.     /**
  314.      * @return Route
  315.      */
  316.     protected function getStructureRoute(Request $request, PageBridge $content)
  317.     {
  318.         return new Route(
  319.             $this->decodePathInfo($request->getPathInfo()),
  320.             [
  321.                 '_controller' => $content->getController(),
  322.                 'structure' => $content,
  323.                 'partial' => 'true' === $request->get('partial', 'false'),
  324.             ],
  325.             [],
  326.             $this->defaultOptions
  327.         );
  328.     }
  330.     /**
  331.      * Server encodes the url and symfony does not encode it
  332.      * Symfony decodes this data here https://github.com/symfony/symfony/blob/3.3/src/Symfony/Component/Routing/Matcher/UrlMatcher.php#L91.
  333.      *
  334.      * @param string $pathInfo
  335.      *
  336.      * @return string
  337.      */
  338.     private function decodePathInfo($pathInfo)
  339.     {
  340.         if (null === $pathInfo || '' === $pathInfo) {
  341.             return '';
  342.         }
  344.         return '/' . \ltrim(\rawurldecode($pathInfo), '/');
  345.     }
  346. }