vendor/sulu/sulu/src/Sulu/Component/Content/Types/ResourceLocator/Mapper/PhpcrMapper.php line 242

  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\Component\Content\Types\ResourceLocator\Mapper;
  14. use PHPCR\ItemExistsException;
  15. use PHPCR\NodeInterface;
  16. use PHPCR\PathNotFoundException;
  17. use PHPCR\PropertyInterface;
  18. use PHPCR\Util\PathHelper;
  19. use Sulu\Bundle\DocumentManagerBundle\Bridge\DocumentInspector;
  20. use Sulu\Component\Content\Document\Behavior\ResourceSegmentBehavior;
  21. use Sulu\Component\Content\Exception\ResourceLocatorAlreadyExistsException;
  22. use Sulu\Component\Content\Exception\ResourceLocatorMovedException;
  23. use Sulu\Component\Content\Exception\ResourceLocatorNotFoundException;
  24. use Sulu\Component\Content\Types\ResourceLocator\ResourceLocatorInformation;
  25. use Sulu\Component\DocumentManager\DocumentManagerInterface;
  26. use Sulu\Component\PHPCR\SessionManager\SessionManagerInterface;
  28. /**
  29.  * Manages resource-locators in phpcr.
  30.  */
  31. class PhpcrMapper implements ResourceLocatorMapperInterface
  32. {
  33.     public function __construct(
  34.         private SessionManagerInterface $sessionManager,
  35.         private DocumentManagerInterface $documentManager,
  36.         private DocumentInspector $documentInspector,
  37.     ) {
  38.     }
  40.     public function save(ResourceSegmentBehavior $document)
  41.     {
  42.         $path = $document->getResourceSegment();
  44.         $webspaceKey = $this->documentInspector->getWebspace($document);
  45.         $locale = $this->documentInspector->getOriginalLocale($document);
  46.         $segmentKey = null;
  47.         $webspaceRouteRootPath = $this->getWebspaceRouteNodeBasePath($webspaceKey, $locale, $segmentKey);
  49.         try {
  50.             $routeNodePath = $this->loadByContent(
  51.                 $this->documentInspector->getNode($document),
  52.                 $webspaceKey,
  53.                 $locale,
  54.                 $segmentKey
  55.             );
  57.             $routeDocument = $this->documentManager->find(
  58.                 $webspaceRouteRootPath . $routeNodePath,
  59.                 $locale,
  60.                 ['rehydrate' => false]
  61.             );
  62.             $routeDocumentPath = $webspaceRouteRootPath . $routeNodePath;
  63.         } catch (ResourceLocatorNotFoundException $e) {
  64.             $routeDocument = $this->documentManager->create('route');
  65.             $routeDocumentPath = $webspaceRouteRootPath . $path;
  66.         }
  68.         $routeDocument->setTargetDocument($document);
  70.         try {
  71.             $this->documentManager->persist(
  72.                 $routeDocument,
  73.                 $locale,
  74.                 [
  75.                     'path' => $routeDocumentPath,
  76.                     'auto_create' => true,
  77.                     'override' => true,
  78.                 ]
  79.             );
  80.             $this->documentManager->publish($routeDocument, $locale);
  81.         } catch (ItemExistsException $e) {
  82.             throw new ResourceLocatorAlreadyExistsException($document->getResourceSegment(), $routeDocumentPath, $e);
  83.         }
  84.     }
  86.     public function loadByContent(NodeInterface $contentNode, $webspaceKey, $languageCode, $segmentKey = null)
  87.     {
  88.         $result = $this->iterateRouteNodes(
  89.             $contentNode,
  90.             function($resourceLocator, NodeInterface $node) {
  91.                 if (false === $node->getPropertyValue('sulu:history') && false !== $resourceLocator) {
  92.                     return $resourceLocator;
  93.                 }
  95.                 return false;
  96.             },
  97.             $webspaceKey,
  98.             $languageCode,
  99.             $segmentKey
  100.         );
  102.         if (null !== $result) {
  103.             return $result;
  104.         }
  106.         throw new ResourceLocatorNotFoundException();
  107.     }
  109.     /**
  110.      * Iterates over all route nodes assigned by the given node, and executes the callback on it.
  111.      *
  112.      * @param callable $callback will be called foreach route node (stops and return value if not false)
  113.      * @param string $webspaceKey
  114.      * @param string $languageCode
  115.      * @param string $segmentKey
  116.      *
  117.      * @return NodeInterface|null
  118.      */
  119.     private function iterateRouteNodes(
  120.         NodeInterface $node,
  121.         $callback,
  122.         $webspaceKey,
  123.         $languageCode,
  124.         $segmentKey = null
  125.     ) {
  126.         if ($node->isNew()) {
  127.             return null;
  128.         }
  130.         $routePath = $this->sessionManager->getRoutePath($webspaceKey, $languageCode);
  132.         // search for references with name 'content'
  133.         foreach ($node->getReferences('sulu:content') as $ref) {
  134.             if ($ref instanceof PropertyInterface) {
  135.                 $routeNode = $ref->getParent();
  136.                 if (0 !== \strpos($routeNode->getPath(), $routePath)) {
  137.                     continue;
  138.                 }
  140.                 $resourceLocator = $this->getResourceLocator(
  141.                     $ref->getParent()->getPath(),
  142.                     $webspaceKey,
  143.                     $languageCode,
  144.                     $segmentKey
  145.                 );
  147.                 $result = $callback($resourceLocator, $routeNode);
  148.                 if (false !== $result) {
  149.                     return $result;
  150.                 }
  151.             }
  152.         }
  154.         return null;
  155.     }
  157.     public function loadByContentUuid($uuid, $webspaceKey, $languageCode, $segmentKey = null)
  158.     {
  159.         $session = $this->sessionManager->getSession();
  160.         $contentNode = $session->getNodeByIdentifier($uuid);
  162.         return $this->loadByContent($contentNode, $webspaceKey, $languageCode, $segmentKey);
  163.     }
  165.     public function loadHistoryByContentUuid($uuid, $webspaceKey, $languageCode, $segmentKey = null)
  166.     {
  167.         // get content node
  168.         $session = $this->sessionManager->getSession();
  169.         $contentNode = $session->getNodeByIdentifier($uuid);
  171.         // get current path node
  172.         $pathNode = $this->iterateRouteNodes(
  173.             $contentNode,
  174.             function($resourceLocator, NodeInterface $node) {
  175.                 if (false === $node->getPropertyValue('sulu:history') && false !== $resourceLocator) {
  176.                     return $node;
  177.                 } else {
  178.                     return false;
  179.                 }
  180.             },
  181.             $webspaceKey,
  182.             $languageCode,
  183.             $segmentKey
  184.         );
  186.         // iterate over history of path node
  187.         $result = [];
  189.         if (!$pathNode) {
  190.             return $result;
  191.         }
  193.         $this->iterateRouteNodes(
  194.             $pathNode,
  195.             function($resourceLocator, NodeInterface $node) use (&$result) {
  196.                 if (false !== $resourceLocator) {
  197.                     // add resourceLocator
  198.                     $result[] = new ResourceLocatorInformation(
  199.                         //backward compability
  200.                         $resourceLocator,
  201.                         $node->getPropertyValueWithDefault('sulu:created', new \DateTime()),
  202.                         $node->getIdentifier()
  203.                     );
  204.                 }
  206.                 return false;
  207.             },
  208.             $webspaceKey,
  209.             $languageCode,
  210.             $segmentKey
  211.         );
  213.         // sort history descending
  214.         \usort(
  215.             $result,
  216.             function(ResourceLocatorInformation $item1, ResourceLocatorInformation $item2) {
  217.                 return $item1->getCreated() < $item2->getCreated();
  218.             }
  219.         );
  221.         return $result;
  222.     }
  224.     public function loadByResourceLocator($resourceLocator, $webspaceKey, $languageCode, $segmentKey = null)
  225.     {
  226.         $resourceLocator = \ltrim($resourceLocator, '/');
  228.         $path = \sprintf(
  229.             '%s/%s',
  230.             $this->getWebspaceRouteNodeBasePath($webspaceKey, $languageCode, $segmentKey),
  231.             $resourceLocator
  232.         );
  234.         try {
  235.             if ('' !== $resourceLocator) {
  236.                 if (!PathHelper::assertValidAbsolutePath($path, false, false)) {
  237.                     throw new ResourceLocatorNotFoundException(\sprintf('Path "%s" not found', $path));
  238.                 }
  240.                 // get requested resource locator route node
  241.                 $route = $this->sessionManager->getSession()->getNode($path);
  242.             } else {
  243.                 // get home page route node
  244.                 $route = $this->getWebspaceRouteNode($webspaceKey, $languageCode, $segmentKey);
  245.             }
  246.         } catch (PathNotFoundException $e) {
  247.             throw new ResourceLocatorNotFoundException(\sprintf('Path "%s" not found', $path), 0, $e);
  248.         }
  250.         if ($route->hasProperty('sulu:content') && $route->hasProperty('sulu:history')) {
  251.             if (!$route->getPropertyValue('sulu:history')) {
  252.                 /** @var NodeInterface $content */
  253.                 $content = $route->getPropertyValue('sulu:content');
  255.                 return $content->getIdentifier();
  256.             } else {
  257.                 // get path from history node
  258.                 /** @var NodeInterface $realPath */
  259.                 $realPath = $route->getPropertyValue('sulu:content');
  261.                 $locator = $this->getResourceLocator($realPath->getPath(), $webspaceKey, $languageCode, $segmentKey);
  262.                 if (false === $locator) {
  263.                     throw new ResourceLocatorNotFoundException(\sprintf(
  264.                         'Couldn\'t generate resource locator for path: %s',
  265.                         $realPath->getPath()
  266.                     ));
  267.                 }
  269.                 throw new ResourceLocatorMovedException($locator, $realPath->getIdentifier());
  270.             }
  271.         } else {
  272.             throw new ResourceLocatorNotFoundException(\sprintf(
  273.                 'Route has "%s" does not have either the "sulu:content" or "sulu:history" properties',
  274.                 $route->getPath()
  275.             ));
  276.         }
  277.     }
  279.     public function unique($path, $webspaceKey, $languageCode, $segmentKey = null)
  280.     {
  281.         $routes = $this->getWebspaceRouteNode($webspaceKey, $languageCode, $segmentKey);
  283.         return $this->isUnique($routes, $path);
  284.     }
  286.     public function getUniquePath($path, $webspaceKey, $languageCode, $segmentKey = null/*, $uuid = null*/)
  287.     {
  288.         $uuid = null;
  290.         if (\func_num_args() >= 5) {
  291.             $uuid = \func_get_arg(4);
  292.         }
  294.         $routes = $this->getWebspaceRouteNode($webspaceKey, $languageCode, $segmentKey);
  296.         if ($this->isUnique($routes, $path, $uuid)) {
  297.             // path is already unique
  298.             return $path;
  299.         } else {
  300.             // append -
  301.             $path .= '-';
  302.             // init counter
  303.             $i = 1;
  304.             // while $path-$i is not unique raise counter
  305.             while (!$this->isUnique($routes, $path . $i, $uuid)) {
  306.                 ++$i;
  307.             }
  309.             // result is unique
  310.             return $path . $i;
  311.         }
  312.     }
  314.     public function deleteById($id, $languageCode, $segmentKey = null)
  315.     {
  316.         $routeDocument = $this->documentManager->find($id, $languageCode);
  317.         $this->documentManager->remove($routeDocument);
  318.     }
  320.     public function getParentPath($uuid, $webspaceKey, $languageCode, $segmentKey = null)
  321.     {
  322.         $session = $this->sessionManager->getSession();
  323.         $contentNode = $session->getNodeByIdentifier($uuid);
  324.         $parentNode = $contentNode->getParent();
  326.         try {
  327.             return $this->loadByContent($parentNode, $webspaceKey, $languageCode, $segmentKey);
  328.         } catch (ResourceLocatorNotFoundException $ex) {
  329.             // parent node don´t have a resource locator
  330.             return;
  331.         }
  332.     }
  334.     /**
  335.      * Check if path is unique from given $root node.
  336.      *
  337.      * @param NodeInterface $root route node
  338.      * @param string $path requested path
  339.      *
  340.      * @return bool path is unique
  341.      */
  342.     private function isUnique(NodeInterface $root, $path, $uuid = null)
  343.     {
  344.         $path = \ltrim($path, '/');
  346.         if (!$root->hasNode($path)) {
  347.             return true;
  348.         }
  350.         if (!$uuid) {
  351.             return false;
  352.         }
  354.         $route = $root->getNode($path);
  356.         return $route->hasProperty('sulu:content')
  357.             && $route->getPropertyValue('sulu:content')->getIdentifier() === $uuid;
  358.     }
  360.     /**
  361.      * Returns base node of routes from phpcr.
  362.      *
  363.      * @param string $webspaceKey current session
  364.      * @param string $languageCode
  365.      * @param string $segmentKey
  366.      *
  367.      * @return NodeInterface base node of routes
  368.      */
  369.     private function getWebspaceRouteNode($webspaceKey, $languageCode, $segmentKey)
  370.     {
  371.         return $this->sessionManager->getRouteNode($webspaceKey, $languageCode, $segmentKey);
  372.     }
  374.     /**
  375.      * Returns base path of routes from phpcr.
  376.      *
  377.      * @param string $webspaceKey current session
  378.      * @param string $languageCode
  379.      * @param string $segmentKey
  380.      *
  381.      * @return string
  382.      */
  383.     private function getWebspaceRouteNodeBasePath($webspaceKey, $languageCode, $segmentKey)
  384.     {
  385.         return $this->sessionManager->getRoutePath($webspaceKey, $languageCode, $segmentKey);
  386.     }
  388.     /**
  389.      * Returns resource-locator.
  390.      *
  391.      * @param string $path
  392.      * @param string $webspaceKey
  393.      * @param string $languageCode
  394.      * @param string $segmentKey
  395.      *
  396.      * @return string|false
  397.      */
  398.     private function getResourceLocator($path, $webspaceKey, $languageCode, $segmentKey)
  399.     {
  400.         $basePath = $this->getWebspaceRouteNodeBasePath($webspaceKey, $languageCode, $segmentKey);
  401.         if ($path === $basePath) {
  402.             return '/';
  403.         }
  405.         if (false !== \strpos($path, $basePath . '/')) {
  406.             $result = \str_replace($basePath . '/', '/', $path);
  407.             if (0 === \strpos($result, '/')) {
  408.                 return $result;
  409.             }
  410.         }
  412.         return false;
  413.     }
  414. }