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

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. * @param StaticPageResolver $staticPageResolver
  79. */
  80. public function __construct(
  81. Document\Service $documentService,
  82. SiteResolver $siteResolver,
  83. RequestHelper $requestHelper,
  84. Config $config,
  85. StaticPageResolver $staticPageResolver
  86. ) {
  87. $this->documentService = $documentService;
  88. $this->siteResolver = $siteResolver;
  89. $this->requestHelper = $requestHelper;
  90. $this->config = $config;
  91. $this->staticPageResolver = $staticPageResolver;
  92. }
  94. public function setForceHandleUnpublishedDocuments(bool $handle)
  95. {
  96. $this->forceHandleUnpublishedDocuments = $handle;
  97. }
  99. /**
  100. * @return array
  101. */
  102. public function getDirectRouteDocumentTypes()
  103. {
  104. if (empty($this->directRouteDocumentTypes)) {
  105. $routingConfig = \Pimcore\Config::getSystemConfiguration('routing');
  106. $this->directRouteDocumentTypes = $routingConfig['direct_route_document_types'];
  107. }
  109. return $this->directRouteDocumentTypes;
  110. }
  112. /**
  113. * @deprecated will be removed in Pimcore 11
  114. *
  115. * @param string $type
  116. */
  117. public function addDirectRouteDocumentType($type)
  118. {
  119. if (!in_array($type, $this->getDirectRouteDocumentTypes())) {
  120. $this->directRouteDocumentTypes[] = $type;
  121. }
  122. }
  124. /**
  125. * {@inheritdoc}
  126. */
  127. public function getRouteByName(string $name)
  128. {
  129. if (preg_match('/^document_(\d+)$/', $name, $match)) {
  130. $document = Document::getById((int) $match[1]);
  132. if ($this->isDirectRouteDocument($document)) {
  133. return $this->buildRouteForDocument($document);
  134. }
  135. }
  137. throw new RouteNotFoundException(sprintf("Route for name '%s' was not found", $name));
  138. }
  140. /**
  141. * {@inheritdoc}
  142. */
  143. public function matchRequest(RouteCollection $collection, DynamicRequestContext $context)
  144. {
  145. $document = Document::getByPath($context->getPath());
  147. // check for a pretty url inside a site
  148. if (!$document && $this->siteResolver->isSiteRequest($context->getRequest())) {
  149. $site = $this->siteResolver->getSite($context->getRequest());
  151. $sitePrettyDocId = $this->documentService->getDao()->getDocumentIdByPrettyUrlInSite($site, $context->getOriginalPath());
  152. if ($sitePrettyDocId) {
  153. if ($sitePrettyDoc = Document::getById($sitePrettyDocId)) {
  154. $document = $sitePrettyDoc;
  156. // TODO set pretty path via siteResolver?
  157. // undo the modification of the path by the site detection (prefixing with site root path)
  158. // this is not necessary when using pretty-urls and will cause problems when validating the
  159. // prettyUrl later (redirecting to the prettyUrl in the case the page was called by the real path)
  160. $context->setPath($context->getOriginalPath());
  161. }
  162. }
  163. }
  165. // check for a parent hardlink with children
  166. if (!$document instanceof Document) {
  167. $hardlinkedParentDocument = $this->documentService->getNearestDocumentByPath($context->getPath(), true);
  168. if ($hardlinkedParentDocument instanceof Document\Hardlink) {
  169. if ($hardLinkedDocument = Document\Hardlink\Service::getChildByPath($hardlinkedParentDocument, $context->getPath())) {
  170. $document = $hardLinkedDocument;
  171. }
  172. }
  173. }
  175. if ($document && $document instanceof Document) {
  176. if ($route = $this->buildRouteForDocument($document, $context)) {
  177. $collection->add($route->getRouteKey(), $route);
  178. }
  179. }
  180. }
  182. /**
  183. * Build a route for a document. Context is only set from match mode, not when generating URLs.
  184. *
  185. * @param Document $document
  186. * @param DynamicRequestContext|null $context
  187. *
  188. * @return DocumentRoute|null
  189. */
  190. public function buildRouteForDocument(Document $document, DynamicRequestContext $context = null)
  191. {
  192. // check for direct hardlink
  193. if ($document instanceof Document\Hardlink) {
  194. $document = Document\Hardlink\Service::wrap($document);
  196. if (!$document) {
  197. return null;
  198. }
  199. }
  201. $route = new DocumentRoute($document->getFullPath());
  202. $route->setOption('utf8', true);
  204. // coming from matching -> set route path the currently matched one
  205. if (null !== $context) {
  206. $route->setPath($context->getOriginalPath());
  207. }
  209. $route->setDefault('_locale', $document->getProperty('language'));
  210. $route->setDocument($document);
  212. if ($this->isDirectRouteDocument($document)) {
  213. /** @var Document\PageSnippet $document */
  214. $route = $this->handleDirectRouteDocument($document, $route, $context);
  215. } elseif ($document->getType() === 'link') {
  216. /** @var Document\Link $document */
  217. $route = $this->handleLinkDocument($document, $route);
  218. }
  220. return $route;
  221. }
  223. /**
  224. * Handle route params for link document
  225. *
  226. * @param Document\Link $document
  227. * @param DocumentRoute $route
  228. *
  229. * @return DocumentRoute
  230. */
  231. private function handleLinkDocument(Document\Link $document, DocumentRoute $route)
  232. {
  233. $route->setDefault('_controller', 'Symfony\Bundle\FrameworkBundle\Controller\RedirectController::urlRedirectAction');
  234. $route->setDefault('path', $document->getHref());
  235. $route->setDefault('permanent', true);
  237. return $route;
  238. }
  240. /**
  241. * Handle direct route documents (not link)
  242. *
  243. * @param Document\PageSnippet $document
  244. * @param DocumentRoute $route
  245. * @param DynamicRequestContext|null $context
  246. *
  247. * @return DocumentRoute|null
  248. */
  249. private function handleDirectRouteDocument(
  250. Document\PageSnippet $document,
  251. DocumentRoute $route,
  252. DynamicRequestContext $context = null
  253. ) {
  254. // if we have a request in context, we're currently in match mode (not generating URLs) -> only match when frontend request by admin
  255. try {
  256. $request = $context ? $context->getRequest() : $this->requestHelper->getMainRequest();
  257. $isAdminRequest = $this->requestHelper->isFrontendRequestByAdmin($request);
  258. } catch (\LogicException $e) {
  259. // catch logic exception here - when the exception fires, it is no admin request
  260. $isAdminRequest = false;
  261. }
  263. // abort if document is not published and the request is no admin request
  264. // and matching unpublished documents was not forced
  265. if (!$document->isPublished()) {
  266. if (!($isAdminRequest || $this->forceHandleUnpublishedDocuments)) {
  267. return null;
  268. }
  269. }
  271. if (!$isAdminRequest && null !== $context) {
  272. // check for redirects (pretty URL, SEO) when not in admin mode and while matching (not generating route)
  273. if ($redirectRoute = $this->handleDirectRouteRedirect($document, $route, $context)) {
  274. return $redirectRoute;
  275. }
  277. // set static page context
  278. if ($document instanceof Page && $document->getStaticGeneratorEnabled()) {
  279. $this->staticPageResolver->setStaticPageContext($context->getRequest());
  280. }
  281. }
  283. // Use latest version, if available, when the request is admin request
  284. // so then route should be built based on latest Document settings
  285. // https://github.com/pimcore/pimcore/issues/9644
  286. if ($isAdminRequest) {
  287. $latestVersion = $document->getLatestVersion();
  288. if ($latestVersion) {
  289. $latestDoc = $latestVersion->loadData();
  290. if ($latestDoc instanceof Document\PageSnippet) {
  291. $document = $latestDoc;
  292. }
  293. }
  294. }
  296. return $this->buildRouteForPageSnippetDocument($document, $route);
  297. }
  299. /**
  300. * Handle document redirects (pretty url, SEO without trailing slash)
  301. *
  302. * @param Document\PageSnippet $document
  303. * @param DocumentRoute $route
  304. * @param DynamicRequestContext|null $context
  305. *
  306. * @return DocumentRoute|null
  307. */
  308. private function handleDirectRouteRedirect(
  309. Document\PageSnippet $document,
  310. DocumentRoute $route,
  311. DynamicRequestContext $context = null
  312. ) {
  313. $redirectTargetUrl = $context->getOriginalPath();
  315. // check for a pretty url, and if the document is called by that, otherwise redirect to pretty url
  316. if ($document instanceof Document\Page && !$document instanceof Document\Hardlink\Wrapper\WrapperInterface) {
  317. if ($prettyUrl = $document->getPrettyUrl()) {
  318. if (rtrim(strtolower($prettyUrl), ' /') !== rtrim(strtolower($context->getOriginalPath()), '/')) {
  319. $redirectTargetUrl = $prettyUrl;
  320. }
  321. }
  322. }
  324. // check for a trailing slash in path, if exists, redirect to this page without the slash
  325. // the only reason for this is: SEO, Analytics, ... there is no system specific reason, pimcore would work also with a trailing slash without problems
  326. // use $originalPath because of the sites
  327. // only do redirecting with GET requests
  328. if ($context->getRequest()->getMethod() === 'GET') {
  329. if (($this->config['documents']['allow_trailing_slash'] ?? null) === 'no') {
  330. if ($redirectTargetUrl !== '/' && substr($redirectTargetUrl, -1) === '/') {
  331. $redirectTargetUrl = rtrim($redirectTargetUrl, '/');
  332. }
  333. }
  335. // only allow the original key of a document to be the URL (lowercase/uppercase)
  336. if ($redirectTargetUrl !== '/' && rtrim($redirectTargetUrl, '/') !== rawurldecode($document->getFullPath())) {
  337. $redirectTargetUrl = $document->getFullPath();
  338. }
  339. }
  341. if (null !== $redirectTargetUrl && $redirectTargetUrl !== $context->getOriginalPath()) {
  342. $route->setDefault('_controller', 'Symfony\Bundle\FrameworkBundle\Controller\RedirectController::urlRedirectAction');
  343. $route->setDefault('path', $redirectTargetUrl);
  344. $route->setDefault('permanent', true);
  346. return $route;
  347. }
  349. return null;
  350. }
  352. /**
  353. * Handle page snippet route (controller, action, view)
  354. *
  355. * @param Document\PageSnippet $document
  356. * @param DocumentRoute $route
  357. *
  358. * @return DocumentRoute
  359. */
  360. private function buildRouteForPageSnippetDocument(Document\PageSnippet $document, DocumentRoute $route)
  361. {
  362. $route->setDefault('_controller', $document->getController());
  364. if ($document->getTemplate()) {
  365. $route->setDefault('_template', $document->getTemplate());
  366. }
  368. return $route;
  369. }
  371. /**
  372. * Check if document is can be used to generate a route
  373. *
  374. * @param Document|null $document
  375. *
  376. * @return bool
  377. */
  378. private function isDirectRouteDocument($document)
  379. {
  380. if ($document instanceof Document\PageSnippet) {
  381. if (in_array($document->getType(), $this->getDirectRouteDocumentTypes())) {
  382. return true;
  383. }
  384. }
  386. return false;
  387. }
  388. }