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

  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.     /**
  34.      * @var SessionManagerInterface
  35.      */
  36.     private $sessionManager;
  38.     /**
  39.      * @var DocumentManagerInterface
  40.      */
  41.     private $documentManager;
  43.     /**
  44.      * @var DocumentInspector
  45.      */
  46.     private $documentInspector;
  48.     public function __construct(
  49.         SessionManagerInterface $sessionManager,
  50.         DocumentManagerInterface $documentManager,
  51.         DocumentInspector $documentInspector
  52.     ) {
  53.         $this->sessionManager = $sessionManager;
  54.         $this->documentManager = $documentManager;
  55.         $this->documentInspector = $documentInspector;
  56.     }
  58.     public function save(ResourceSegmentBehavior $document)
  59.     {
  60.         $path = $document->getResourceSegment();
  62.         $webspaceKey = $this->documentInspector->getWebspace($document);
  63.         $locale = $this->documentInspector->getOriginalLocale($document);
  64.         $segmentKey = null;
  65.         $webspaceRouteRootPath = $this->getWebspaceRouteNodeBasePath($webspaceKey, $locale, $segmentKey);
  67.         try {
  68.             $routeNodePath = $this->loadByContent(
  69.                 $this->documentInspector->getNode($document),
  70.                 $webspaceKey,
  71.                 $locale,
  72.                 $segmentKey
  73.             );
  75.             $routeDocument = $this->documentManager->find(
  76.                 $webspaceRouteRootPath . $routeNodePath,
  77.                 $locale,
  78.                 ['rehydrate' => false]
  79.             );
  80.             $routeDocumentPath = $webspaceRouteRootPath . $routeNodePath;
  81.         } catch (ResourceLocatorNotFoundException $e) {
  82.             $routeDocument = $this->documentManager->create('route');
  83.             $routeDocumentPath = $webspaceRouteRootPath . $path;
  84.         }
  86.         $routeDocument->setTargetDocument($document);
  88.         try {
  89.             $this->documentManager->persist(
  90.                 $routeDocument,
  91.                 $locale,
  92.                 [
  93.                     'path' => $routeDocumentPath,
  94.                     'auto_create' => true,
  95.                     'override' => true,
  96.                 ]
  97.             );
  98.             $this->documentManager->publish($routeDocument, $locale);
  99.         } catch (ItemExistsException $e) {
  100.             throw new ResourceLocatorAlreadyExistsException($document->getResourceSegment(), $routeDocumentPath, $e);
  101.         }
  102.     }
  104.     public function loadByContent(NodeInterface $contentNode, $webspaceKey, $languageCode, $segmentKey = null)
  105.     {
  106.         $result = $this->iterateRouteNodes(
  107.             $contentNode,
  108.             function($resourceLocator, NodeInterface $node) {
  109.                 if (false === $node->getPropertyValue('sulu:history') && false !== $resourceLocator) {
  110.                     return $resourceLocator;
  111.                 }
  113.                 return false;
  114.             },
  115.             $webspaceKey,
  116.             $languageCode,
  117.             $segmentKey
  118.         );
  120.         if (null !== $result) {
  121.             return $result;
  122.         }
  124.         throw new ResourceLocatorNotFoundException();
  125.     }
  127.     /**
  128.      * Iterates over all route nodes assigned by the given node, and executes the callback on it.
  129.      *
  130.      * @param callable $callback will be called foreach route node (stops and return value if not false)
  131.      * @param string $webspaceKey
  132.      * @param string $languageCode
  133.      * @param string $segmentKey
  134.      *
  135.      * @return NodeInterface
  136.      */
  137.     private function iterateRouteNodes(
  138.         NodeInterface $node,
  139.         $callback,
  140.         $webspaceKey,
  141.         $languageCode,
  142.         $segmentKey = null
  143.     ) {
  144.         if ($node->isNew()) {
  145.             return null;
  146.         }
  148.         $routePath = $this->sessionManager->getRoutePath($webspaceKey, $languageCode);
  150.         // search for references with name 'content'
  151.         foreach ($node->getReferences('sulu:content') as $ref) {
  152.             if ($ref instanceof PropertyInterface) {
  153.                 $routeNode = $ref->getParent();
  154.                 if (0 !== \strpos($routeNode->getPath(), $routePath)) {
  155.                     continue;
  156.                 }
  158.                 $resourceLocator = $this->getResourceLocator(
  159.                     $ref->getParent()->getPath(),
  160.                     $webspaceKey,
  161.                     $languageCode,
  162.                     $segmentKey
  163.                 );
  165.                 $result = $callback($resourceLocator, $routeNode);
  166.                 if (false !== $result) {
  167.                     return $result;
  168.                 }
  169.             }
  170.         }
  172.         return null;
  173.     }
  175.     public function loadByContentUuid($uuid, $webspaceKey, $languageCode, $segmentKey = null)
  176.     {
  177.         $session = $this->sessionManager->getSession();
  178.         $contentNode = $session->getNodeByIdentifier($uuid);
  180.         return $this->loadByContent($contentNode, $webspaceKey, $languageCode, $segmentKey);
  181.     }
  183.     public function loadHistoryByContentUuid($uuid, $webspaceKey, $languageCode, $segmentKey = null)
  184.     {
  185.         // get content node
  186.         $session = $this->sessionManager->getSession();
  187.         $contentNode = $session->getNodeByIdentifier($uuid);
  189.         // get current path node
  190.         $pathNode = $this->iterateRouteNodes(
  191.             $contentNode,
  192.             function($resourceLocator, NodeInterface $node) {
  193.                 if (false === $node->getPropertyValue('sulu:history') && false !== $resourceLocator) {
  194.                     return $node;
  195.                 } else {
  196.                     return false;
  197.                 }
  198.             },
  199.             $webspaceKey,
  200.             $languageCode,
  201.             $segmentKey
  202.         );
  204.         // iterate over history of path node
  205.         $result = [];
  207.         if (!$pathNode) {
  208.             return $result;
  209.         }
  211.         $this->iterateRouteNodes(
  212.             $pathNode,
  213.             function($resourceLocator, NodeInterface $node) use (&$result) {
  214.                 if (false !== $resourceLocator) {
  215.                     // add resourceLocator
  216.                     $result[] = new ResourceLocatorInformation(
  217.                         //backward compability
  218.                         $resourceLocator,
  219.                         $node->getPropertyValueWithDefault('sulu:created', new \DateTime()),
  220.                         $node->getIdentifier()
  221.                     );
  222.                 }
  224.                 return false;
  225.             },
  226.             $webspaceKey,
  227.             $languageCode,
  228.             $segmentKey
  229.         );
  231.         // sort history descending
  232.         \usort(
  233.             $result,
  234.             function(ResourceLocatorInformation $item1, ResourceLocatorInformation $item2) {
  235.                 return $item1->getCreated() < $item2->getCreated();
  236.             }
  237.         );
  239.         return $result;
  240.     }
  242.     public function loadByResourceLocator($resourceLocator, $webspaceKey, $languageCode, $segmentKey = null)
  243.     {
  244.         $resourceLocator = \ltrim($resourceLocator, '/');
  246.         $path = \sprintf(
  247.             '%s/%s',
  248.             $this->getWebspaceRouteNodeBasePath($webspaceKey, $languageCode, $segmentKey),
  249.             $resourceLocator
  250.         );
  252.         try {
  253.             if ('' !== $resourceLocator) {
  254.                 if (!PathHelper::assertValidAbsolutePath($path, false, false)) {
  255.                     throw new ResourceLocatorNotFoundException(\sprintf('Path "%s" not found', $path));
  256.                 }
  258.                 // get requested resource locator route node
  259.                 $route = $this->sessionManager->getSession()->getNode($path);
  260.             } else {
  261.                 // get home page route node
  262.                 $route = $this->getWebspaceRouteNode($webspaceKey, $languageCode, $segmentKey);
  263.             }
  264.         } catch (PathNotFoundException $e) {
  265.             throw new ResourceLocatorNotFoundException(\sprintf('Path "%s" not found', $path), null, $e);
  266.         }
  268.         if ($route->hasProperty('sulu:content') && $route->hasProperty('sulu:history')) {
  269.             if (!$route->getPropertyValue('sulu:history')) {
  270.                 /** @var NodeInterface $content */
  271.                 $content = $route->getPropertyValue('sulu:content');
  273.                 return $content->getIdentifier();
  274.             } else {
  275.                 // get path from history node
  276.                 /** @var NodeInterface $realPath */
  277.                 $realPath = $route->getPropertyValue('sulu:content');
  279.                 throw new ResourceLocatorMovedException(
  280.                     $this->getResourceLocator($realPath->getPath(), $webspaceKey, $languageCode, $segmentKey),
  281.                     $realPath->getIdentifier()
  282.                 );
  283.             }
  284.         } else {
  285.             throw new ResourceLocatorNotFoundException(\sprintf(
  286.                 'Route has "%s" does not have either the "sulu:content" or "sulu:history" properties',
  287.                 $route->getPath()
  288.             ));
  289.         }
  290.     }
  292.     public function unique($path, $webspaceKey, $languageCode, $segmentKey = null)
  293.     {
  294.         $routes = $this->getWebspaceRouteNode($webspaceKey, $languageCode, $segmentKey);
  296.         return $this->isUnique($routes, $path);
  297.     }
  299.     public function getUniquePath($path, $webspaceKey, $languageCode, $segmentKey = null/*, $uuid = null*/)
  300.     {
  301.         $uuid = null;
  303.         if (\func_num_args() >= 5) {
  304.             $uuid = \func_get_arg(4);
  305.         }
  307.         $routes = $this->getWebspaceRouteNode($webspaceKey, $languageCode, $segmentKey);
  309.         if ($this->isUnique($routes, $path, $uuid)) {
  310.             // path is already unique
  311.             return $path;
  312.         } else {
  313.             // append -
  314.             $path .= '-';
  315.             // init counter
  316.             $i = 1;
  317.             // while $path-$i is not unique raise counter
  318.             while (!$this->isUnique($routes, $path . $i, $uuid)) {
  319.                 ++$i;
  320.             }
  322.             // result is unique
  323.             return $path . $i;
  324.         }
  325.     }
  327.     public function deleteById($id, $languageCode, $segmentKey = null)
  328.     {
  329.         $routeDocument = $this->documentManager->find($id, $languageCode);
  330.         $this->documentManager->remove($routeDocument);
  331.     }
  333.     public function getParentPath($uuid, $webspaceKey, $languageCode, $segmentKey = null)
  334.     {
  335.         $session = $this->sessionManager->getSession();
  336.         $contentNode = $session->getNodeByIdentifier($uuid);
  337.         $parentNode = $contentNode->getParent();
  339.         try {
  340.             return $this->loadByContent($parentNode, $webspaceKey, $languageCode, $segmentKey);
  341.         } catch (ResourceLocatorNotFoundException $ex) {
  342.             // parent node don´t have a resource locator
  343.             return;
  344.         }
  345.     }
  347.     /**
  348.      * Check if path is unique from given $root node.
  349.      *
  350.      * @param NodeInterface $root route node
  351.      * @param string $path requested path
  352.      *
  353.      * @return bool path is unique
  354.      */
  355.     private function isUnique(NodeInterface $root, $path, $uuid = null)
  356.     {
  357.         $path = \ltrim($path, '/');
  359.         if (!$root->hasNode($path)) {
  360.             return true;
  361.         }
  363.         if (!$uuid) {
  364.             return false;
  365.         }
  367.         $route = $root->getNode($path);
  369.         return $route->hasProperty('sulu:content')
  370.             && $route->getPropertyValue('sulu:content')->getIdentifier() === $uuid;
  371.     }
  373.     /**
  374.      * Returns base node of routes from phpcr.
  375.      *
  376.      * @param string $webspaceKey current session
  377.      * @param string $languageCode
  378.      * @param string $segmentKey
  379.      *
  380.      * @return NodeInterface base node of routes
  381.      */
  382.     private function getWebspaceRouteNode($webspaceKey, $languageCode, $segmentKey)
  383.     {
  384.         return $this->sessionManager->getRouteNode($webspaceKey, $languageCode, $segmentKey);
  385.     }
  387.     /**
  388.      * Returns base path of routes from phpcr.
  389.      *
  390.      * @param string $webspaceKey current session
  391.      * @param string $languageCode
  392.      * @param string $segmentKey
  393.      *
  394.      * @return string
  395.      */
  396.     private function getWebspaceRouteNodeBasePath($webspaceKey, $languageCode, $segmentKey)
  397.     {
  398.         return $this->sessionManager->getRoutePath($webspaceKey, $languageCode, $segmentKey);
  399.     }
  401.     /**
  402.      * Returns the abspath.
  403.      *
  404.      * @param string $relPath
  405.      * @param string $webspaceKey
  406.      * @param string $languageCode
  407.      * @param string $segmentKey
  408.      *
  409.      * @return string
  410.      */
  411.     private function getPath($relPath, $webspaceKey, $languageCode, $segmentKey)
  412.     {
  413.         $basePath = $this->getWebspaceRouteNodeBasePath($webspaceKey, $languageCode, $segmentKey);
  415.         return '/' . \ltrim($basePath, '/') . ('' !== $relPath ? '/' . \ltrim($relPath, '/') : '');
  416.     }
  418.     /**
  419.      * Returns resource-locator.
  420.      *
  421.      * @param string $path
  422.      * @param string $webspaceKey
  423.      * @param string $languageCode
  424.      * @param string $segmentKey
  425.      *
  426.      * @return string
  427.      */
  428.     private function getResourceLocator($path, $webspaceKey, $languageCode, $segmentKey)
  429.     {
  430.         $basePath = $this->getWebspaceRouteNodeBasePath($webspaceKey, $languageCode, $segmentKey);
  431.         if ($path === $basePath) {
  432.             return '/';
  433.         }
  435.         if (false !== \strpos($path, $basePath . '/')) {
  436.             $result = \str_replace($basePath . '/', '/', $path);
  437.             if (0 === \strpos($result, '/')) {
  438.                 return $result;
  439.             }
  440.         }
  442.         return false;
  443.     }
  444. }