vendor/sulu/sulu/src/Sulu/Component/Content/Repository/ContentRepository.php line 596

  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\Repository;
  14. use Jackalope\Query\QOM\PropertyValue;
  15. use Jackalope\Query\Row;
  16. use PHPCR\ItemNotFoundException;
  17. use PHPCR\Query\QOM\QueryObjectModelConstantsInterface;
  18. use PHPCR\Query\QOM\QueryObjectModelFactoryInterface;
  19. use PHPCR\SessionInterface;
  20. use PHPCR\Util\PathHelper;
  21. use PHPCR\Util\QOM\QueryBuilder;
  22. use Sulu\Bundle\SecurityBundle\System\SystemStoreInterface;
  23. use Sulu\Component\Content\Compat\LocalizationFinderInterface;
  24. use Sulu\Component\Content\Compat\Structure;
  25. use Sulu\Component\Content\Compat\StructureManagerInterface;
  26. use Sulu\Component\Content\Compat\StructureType;
  27. use Sulu\Component\Content\Document\Behavior\SecurityBehavior;
  28. use Sulu\Component\Content\Document\RedirectType;
  29. use Sulu\Component\Content\Document\Subscriber\SecuritySubscriber;
  30. use Sulu\Component\Content\Document\WorkflowStage;
  31. use Sulu\Component\Content\Repository\Mapping\MappingInterface;
  32. use Sulu\Component\DocumentManager\PropertyEncoder;
  33. use Sulu\Component\Localization\Localization;
  34. use Sulu\Component\PHPCR\SessionManager\SessionManagerInterface;
  35. use Sulu\Component\Security\Authentication\UserInterface;
  36. use Sulu\Component\Security\Authorization\AccessControl\DescendantProviderInterface;
  37. use Sulu\Component\Util\SuluNodeHelper;
  38. use Sulu\Component\Webspace\Manager\WebspaceManagerInterface;
  40. /**
  41.  * Content repository which query content with sql2 statements.
  42.  */
  43. class ContentRepository implements ContentRepositoryInterface, DescendantProviderInterface
  44. {
  45.     private static $nonFallbackProperties = [
  46.         'uuid',
  47.         'state',
  48.         'order',
  49.         'created',
  50.         'creator',
  51.         'changed',
  52.         'changer',
  53.         'published',
  54.         'shadowOn',
  55.         'shadowBase',
  56.     ];
  58.     /**
  59.      * @var SessionManagerInterface
  60.      */
  61.     private $sessionManager;
  63.     /**
  64.      * @var PropertyEncoder
  65.      */
  66.     private $propertyEncoder;
  68.     /**
  69.      * @var WebspaceManagerInterface
  70.      */
  71.     private $webspaceManager;
  73.     /**
  74.      * @var SessionInterface
  75.      */
  76.     private $session;
  78.     /**
  79.      * @var QueryObjectModelFactoryInterface
  80.      */
  81.     private $qomFactory;
  83.     /**
  84.      * @var LocalizationFinderInterface
  85.      */
  86.     private $localizationFinder;
  88.     /**
  89.      * @var StructureManagerInterface
  90.      */
  91.     private $structureManager;
  93.     /**
  94.      * @var SuluNodeHelper
  95.      */
  96.     private $nodeHelper;
  98.     /**
  99.      * @var array
  100.      */
  101.     private $permissions;
  103.     /**
  104.      * @var SystemStoreInterface
  105.      */
  106.     private $systemStore;
  108.     public function __construct(
  109.         SessionManagerInterface $sessionManager,
  110.         PropertyEncoder $propertyEncoder,
  111.         WebspaceManagerInterface $webspaceManager,
  112.         LocalizationFinderInterface $localizationFinder,
  113.         StructureManagerInterface $structureManager,
  114.         SuluNodeHelper $nodeHelper,
  115.         SystemStoreInterface $systemStore,
  116.         array $permissions
  117.     ) {
  118.         $this->sessionManager = $sessionManager;
  119.         $this->propertyEncoder = $propertyEncoder;
  120.         $this->webspaceManager = $webspaceManager;
  121.         $this->localizationFinder = $localizationFinder;
  122.         $this->structureManager = $structureManager;
  123.         $this->nodeHelper = $nodeHelper;
  124.         $this->systemStore = $systemStore;
  125.         $this->permissions = $permissions;
  127.         $this->session = $sessionManager->getSession();
  128.         $this->qomFactory = $this->session->getWorkspace()->getQueryManager()->getQOMFactory();
  129.     }
  131.     /**
  132.      * Find content by uuid.
  133.      *
  134.      * @param string $uuid
  135.      * @param string $locale
  136.      * @param string $webspaceKey
  137.      * @param MappingInterface $mapping Includes array of property names
  138.      * @param UserInterface $user
  139.      *
  140.      * @return Content|null
  141.      */
  142.     public function find($uuid, $locale, $webspaceKey, MappingInterface $mapping, UserInterface $user = null)
  143.     {
  144.         $locales = $this->getLocalesByWebspaceKey($webspaceKey);
  145.         $queryBuilder = $this->getQueryBuilder($locale, $locales, $user);
  146.         $queryBuilder->where(
  147.             $this->qomFactory->comparison(
  148.                 new PropertyValue('node', 'jcr:uuid'),
  149.                 '=',
  150.                 $this->qomFactory->literal($uuid)
  151.             )
  152.         );
  153.         $this->appendMapping($queryBuilder, $mapping, $locale, $locales);
  155.         $queryResult = $queryBuilder->execute();
  157.         $rows = \iterator_to_array($queryResult->getRows());
  158.         if (1 !== \count($rows)) {
  159.             throw new ItemNotFoundException();
  160.         }
  162.         $resultPermissions = $this->resolveResultPermissions($rows, $user);
  163.         $permissions = empty($resultPermissions) ? [] : \current($resultPermissions);
  165.         return $this->resolveContent(\current($rows), $locale, $locales, $mapping, $user, $permissions);
  166.     }
  168.     public function findByParentUuid(
  169.         $uuid,
  170.         $locale,
  171.         $webspaceKey,
  172.         MappingInterface $mapping,
  173.         UserInterface $user = null
  174.     ) {
  175.         $path = $this->resolvePathByUuid($uuid);
  177.         if (!$webspaceKey) {
  178.             // TODO find a better solution than this (e.g. reuse logic from DocumentInspector and preferably in the PageController)
  179.             $webspaceKey = \explode('/', $path)[2];
  180.         }
  182.         $locales = $this->getLocalesByWebspaceKey($webspaceKey);
  183.         $queryBuilder = $this->getQueryBuilder($locale, $locales, $user);
  184.         $queryBuilder->where($this->qomFactory->childNode('node', $path));
  185.         $this->appendMapping($queryBuilder, $mapping, $locale, $locales);
  187.         return $this->resolveQueryBuilder($queryBuilder, $locale, $locales, $mapping, $user);
  188.     }
  190.     public function findByWebspaceRoot($locale, $webspaceKey, MappingInterface $mapping, UserInterface $user = null)
  191.     {
  192.         $locales = $this->getLocalesByWebspaceKey($webspaceKey);
  193.         $queryBuilder = $this->getQueryBuilder($locale, $locales, $user);
  194.         $queryBuilder->where(
  195.             $this->qomFactory->childNode('node', $this->sessionManager->getContentPath($webspaceKey))
  196.         );
  197.         $this->appendMapping($queryBuilder, $mapping, $locale, $locales);
  199.         return $this->resolveQueryBuilder($queryBuilder, $locale, $locales, $mapping, $user);
  200.     }
  202.     public function findParentsWithSiblingsByUuid(
  203.         $uuid,
  204.         $locale,
  205.         $webspaceKey,
  206.         MappingInterface $mapping,
  207.         UserInterface $user = null
  208.     ) {
  209.         $path = $this->resolvePathByUuid($uuid);
  210.         if (empty($webspaceKey)) {
  211.             $webspaceKey = $this->nodeHelper->extractWebspaceFromPath($path);
  212.         }
  214.         $contentPath = $this->sessionManager->getContentPath($webspaceKey);
  216.         $locales = $this->getLocalesByWebspaceKey($webspaceKey);
  217.         $queryBuilder = $this->getQueryBuilder($locale, $locales, $user)
  218.             ->orderBy($this->qomFactory->propertyValue('node', 'jcr:path'))
  219.             ->where($this->qomFactory->childNode('node', $path));
  221.         while (PathHelper::getPathDepth($path) > PathHelper::getPathDepth($contentPath)) {
  222.             $path = PathHelper::getParentPath($path);
  223.             $queryBuilder->orWhere($this->qomFactory->childNode('node', $path));
  224.         }
  226.         $mapping->addProperties(['order']);
  227.         $this->appendMapping($queryBuilder, $mapping, $locale, $locales);
  229.         $result = $this->resolveQueryBuilder($queryBuilder, $locale, $locales, $mapping, $user);
  231.         return $this->generateTreeByPath($result, $uuid);
  232.     }
  234.     public function findByPaths(
  235.         array $paths,
  236.         $locale,
  237.         MappingInterface $mapping,
  238.         UserInterface $user = null
  239.     ) {
  240.         $locales = $this->getLocales();
  241.         $queryBuilder = $this->getQueryBuilder($locale, $locales, $user);
  243.         foreach ($paths as $path) {
  244.             $queryBuilder->orWhere(
  245.                 $this->qomFactory->sameNode('node', $path)
  246.             );
  247.         }
  248.         $this->appendMapping($queryBuilder, $mapping, $locale, $locales);
  250.         return $this->resolveQueryBuilder($queryBuilder, $locale, $locales, $mapping, $user);
  251.     }
  253.     public function findByUuids(
  254.         array $uuids,
  255.         $locale,
  256.         MappingInterface $mapping,
  257.         UserInterface $user = null
  258.     ) {
  259.         if (0 === \count($uuids)) {
  260.             return [];
  261.         }
  263.         $locales = $this->getLocales();
  264.         $queryBuilder = $this->getQueryBuilder($locale, $locales, $user);
  266.         foreach ($uuids as $uuid) {
  267.             $queryBuilder->orWhere(
  268.                 $this->qomFactory->comparison(
  269.                     $queryBuilder->qomf()->propertyValue('node', 'jcr:uuid'),
  270.                     QueryObjectModelConstantsInterface::JCR_OPERATOR_EQUAL_TO,
  271.                     $queryBuilder->qomf()->literal($uuid)
  272.                 )
  273.             );
  274.         }
  275.         $this->appendMapping($queryBuilder, $mapping, $locale, $locales);
  277.         $result = $this->resolveQueryBuilder($queryBuilder, $locale, $locales, $mapping, $user);
  279.         \usort($result, function($a, $b) use ($uuids) {
  280.             return \array_search($a->getId(), $uuids) < \array_search($b->getId(), $uuids) ? -1 : 1;
  281.         });
  283.         return $result;
  284.     }
  286.     public function findAll($locale, $webspaceKey, MappingInterface $mapping, UserInterface $user = null)
  287.     {
  288.         $contentPath = $this->sessionManager->getContentPath($webspaceKey);
  290.         $locales = $this->getLocalesByWebspaceKey($webspaceKey);
  291.         $queryBuilder = $this->getQueryBuilder($locale, $locales, $user)
  292.             ->where($this->qomFactory->descendantNode('node', $contentPath))
  293.             ->orWhere($this->qomFactory->sameNode('node', $contentPath));
  295.         $this->appendMapping($queryBuilder, $mapping, $locale, $locales);
  297.         return $this->resolveQueryBuilder($queryBuilder, $locale, $locales, $mapping, $user);
  298.     }
  300.     public function findAllByPortal($locale, $portalKey, MappingInterface $mapping, UserInterface $user = null)
  301.     {
  302.         $webspaceKey = $this->webspaceManager->findPortalByKey($portalKey)->getWebspace()->getKey();
  304.         $contentPath = $this->sessionManager->getContentPath($webspaceKey);
  306.         $locales = $this->getLocalesByPortalKey($portalKey);
  307.         $queryBuilder = $this->getQueryBuilder($locale, $locales, $user)
  308.             ->where($this->qomFactory->descendantNode('node', $contentPath))
  309.             ->orWhere($this->qomFactory->sameNode('node', $contentPath));
  311.         $this->appendMapping($queryBuilder, $mapping, $locale, $locales);
  313.         return $this->resolveQueryBuilder($queryBuilder, $locale, $locales, $mapping, $user);
  314.     }
  316.     public function findDescendantIdsById($id)
  317.     {
  318.         $queryBuilder = $this->getQueryBuilder();
  319.         $queryBuilder->where(
  320.             $this->qomFactory->comparison(
  321.                 new PropertyValue('node', 'jcr:uuid'),
  322.                 '=',
  323.                 $this->qomFactory->literal($id)
  324.             )
  325.         );
  327.         $result = \iterator_to_array($queryBuilder->execute());
  329.         if (0 === \count($result)) {
  330.             return [];
  331.         }
  333.         $path = $result[0]->getPath();
  335.         $descendantQueryBuilder = $this->getQueryBuilder()
  336.             ->where($this->qomFactory->descendantNode('node', $path));
  338.         return \array_map(
  339.             function(Row $row) {
  340.                 return $row->getNode()->getIdentifier();
  341.             },
  342.             \iterator_to_array($descendantQueryBuilder->execute())
  343.         );
  344.     }
  346.     /**
  347.      * Generates a content-tree with paths of given content array.
  348.      *
  349.      * @param Content[] $contents
  350.      *
  351.      * @return Content[]
  352.      */
  353.     private function generateTreeByPath(array $contents, $uuid)
  354.     {
  355.         $childrenByPath = [];
  357.         foreach ($contents as $content) {
  358.             $path = PathHelper::getParentPath($content->getPath());
  359.             if (!isset($childrenByPath[$path])) {
  360.                 $childrenByPath[$path] = [];
  361.             }
  363.             $order = $content['order'];
  364.             while (isset($childrenByPath[$path][$order])) {
  365.                 ++$order;
  366.             }
  368.             $childrenByPath[$path][$order] = $content;
  369.         }
  371.         foreach ($contents as $content) {
  372.             if (!isset($childrenByPath[$content->getPath()])) {
  373.                 if ($content->getId() === $uuid) {
  374.                     $content->setChildren([]);
  375.                 }
  377.                 continue;
  378.             }
  380.             \ksort($childrenByPath[$content->getPath()]);
  382.             $content->setChildren(\array_values($childrenByPath[$content->getPath()]));
  383.         }
  385.         if (!\array_key_exists('/', $childrenByPath) || !\is_array($childrenByPath['/'])) {
  386.             return [];
  387.         }
  389.         \ksort($childrenByPath['/']);
  391.         return \array_values($childrenByPath['/']);
  392.     }
  394.     /**
  395.      * Resolve path for node with given uuid.
  396.      *
  397.      * @param string $uuid
  398.      *
  399.      * @return string
  400.      *
  401.      * @throws ItemNotFoundException
  402.      */
  403.     private function resolvePathByUuid($uuid)
  404.     {
  405.         $queryBuilder = new QueryBuilder($this->qomFactory);
  407.         $queryBuilder
  408.             ->select('node', 'jcr:uuid', 'uuid')
  409.             ->from($this->qomFactory->selector('node', 'nt:unstructured'))
  410.             ->where(
  411.                 $this->qomFactory->comparison(
  412.                     $this->qomFactory->propertyValue('node', 'jcr:uuid'),
  413.                     '=',
  414.                     $this->qomFactory->literal($uuid)
  415.                 )
  416.             );
  418.         $rows = $queryBuilder->execute();
  420.         if (1 !== \count(\iterator_to_array($rows->getRows()))) {
  421.             throw new ItemNotFoundException();
  422.         }
  424.         return $rows->getRows()->current()->getPath();
  425.     }
  427.     /**
  428.      * Resolves query results to content.
  429.      *
  430.      * @param string $locale
  431.      * @param UserInterface $user
  432.      *
  433.      * @return Content[]
  434.      */
  435.     private function resolveQueryBuilder(
  436.         QueryBuilder $queryBuilder,
  437.         $locale,
  438.         $locales,
  439.         MappingInterface $mapping,
  440.         UserInterface $user = null
  441.     ) {
  442.         $result = \iterator_to_array($queryBuilder->execute());
  444.         $permissions = $this->resolveResultPermissions($result, $user);
  446.         return \array_values(
  447.             \array_filter(
  448.                 \array_map(
  449.                     function(Row $row, $index) use ($mapping, $locale, $locales, $user, $permissions) {
  450.                         return $this->resolveContent(
  451.                             $row,
  452.                             $locale,
  453.                             $locales,
  454.                             $mapping,
  455.                             $user,
  456.                             $permissions[$index] ?? []
  457.                         );
  458.                     },
  459.                     $result,
  460.                     \array_keys($result)
  461.                 )
  462.             )
  463.         );
  464.     }
  466.     private function resolveResultPermissions(array $result, UserInterface $user = null)
  467.     {
  468.         $permissions = [];
  470.         foreach ($result as $index => $row) {
  471.             $permissions[$index] = [];
  473.             $jsonPermission = $row->getValue(SecuritySubscriber::SECURITY_PERMISSION_PROPERTY);
  475.             if (!$jsonPermission) {
  476.                 continue;
  477.             }
  479.             $rowPermissions = \json_decode($jsonPermission, true);
  481.             foreach ($rowPermissions as $roleId => $rolePermissions) {
  482.                 foreach ($this->permissions as $permissionKey => $permission) {
  483.                     $permissions[$index][$roleId][$permissionKey] = false;
  484.                 }
  486.                 foreach ($rolePermissions as $rolePermission) {
  487.                     $permissions[$index][$roleId][$rolePermission] = true;
  488.                 }
  489.             }
  490.         }
  492.         return $permissions;
  493.     }
  495.     /**
  496.      * Returns QueryBuilder with basic select and where statements.
  497.      *
  498.      * @param string $locale
  499.      * @param string[] $locales
  500.      * @param UserInterface $user
  501.      *
  502.      * @return QueryBuilder
  503.      */
  504.     private function getQueryBuilder($locale = null, $locales = [], UserInterface $user = null)
  505.     {
  506.         $queryBuilder = new QueryBuilder($this->qomFactory);
  508.         $queryBuilder
  509.             ->select('node', 'jcr:uuid', 'uuid')
  510.             ->addSelect('node', $this->getPropertyName('nodeType', $locale), 'nodeType')
  511.             ->addSelect('node', $this->getPropertyName('internal_link', $locale), 'internalLink')
  512.             ->addSelect('node', $this->getPropertyName('state', $locale), 'state')
  513.             ->addSelect('node', $this->getPropertyName('shadow-on', $locale), 'shadowOn')
  514.             ->addSelect('node', $this->getPropertyName('shadow-base', $locale), 'shadowBase')
  515.             ->addSelect('node', $this->propertyEncoder->systemName('order'), 'order')
  516.             ->from($this->qomFactory->selector('node', 'nt:unstructured'))
  517.             ->orderBy($this->qomFactory->propertyValue('node', 'sulu:order'));
  519.         $this->appendSingleMapping($queryBuilder, 'template', $locales);
  520.         $this->appendSingleMapping($queryBuilder, 'shadow-on', $locales);
  521.         $this->appendSingleMapping($queryBuilder, 'state', $locales);
  523.         $queryBuilder->addSelect(
  524.             'node',
  525.             SecuritySubscriber::SECURITY_PERMISSION_PROPERTY,
  526.             SecuritySubscriber::SECURITY_PERMISSION_PROPERTY
  527.         );
  529.         return $queryBuilder;
  530.     }
  532.     private function getPropertyName($propertyName, $locale)
  533.     {
  534.         if ($locale) {
  535.             return $this->propertyEncoder->localizedContentName($propertyName, $locale);
  536.         }
  538.         return $this->propertyEncoder->contentName($propertyName);
  539.     }
  541.     /**
  542.      * Returns array of locales for given webspace key.
  543.      *
  544.      * @param string $webspaceKey
  545.      *
  546.      * @return string[]
  547.      */
  548.     private function getLocalesByWebspaceKey($webspaceKey)
  549.     {
  550.         $webspace = $this->webspaceManager->findWebspaceByKey($webspaceKey);
  552.         return \array_map(
  553.             function(Localization $localization) {
  554.                 return $localization->getLocale();
  555.             },
  556.             $webspace->getAllLocalizations()
  557.         );
  558.     }
  560.     /**
  561.      * Returns array of locales for given portal key.
  562.      *
  563.      * @param string $portalKey
  564.      *
  565.      * @return string[]
  566.      */
  567.     private function getLocalesByPortalKey($portalKey)
  568.     {
  569.         $portal = $this->webspaceManager->findPortalByKey($portalKey);
  571.         return \array_map(
  572.             function(Localization $localization) {
  573.                 return $localization->getLocale();
  574.             },
  575.             $portal->getLocalizations()
  576.         );
  577.     }
  579.     /**
  580.      * Returns array of locales for webspaces.
  581.      *
  582.      * @return string[]
  583.      */
  584.     private function getLocales()
  585.     {
  586.         return $this->webspaceManager->getAllLocales();
  587.     }
  589.     /**
  590.      * Append mapping selects to given query-builder.
  591.      *
  592.      * @param MappingInterface $mapping Includes array of property names
  593.      * @param string $locale
  594.      * @param string[] $locales
  595.      */
  596.     private function appendMapping(QueryBuilder $queryBuilder, MappingInterface $mapping, $locale, $locales)
  597.     {
  598.         if ($mapping->onlyPublished()) {
  599.             $queryBuilder->andWhere(
  600.                 $this->qomFactory->comparison(
  601.                     $this->qomFactory->propertyValue(
  602.                         'node',
  603.                         $this->propertyEncoder->localizedSystemName('state', $locale)
  604.                     ),
  605.                     '=',
  606.                     $this->qomFactory->literal(WorkflowStage::PUBLISHED)
  607.                 )
  608.             );
  609.         }
  611.         $properties = $mapping->getProperties();
  612.         foreach ($properties as $propertyName) {
  613.             $this->appendSingleMapping($queryBuilder, $propertyName, $locales);
  614.         }
  616.         if ($mapping->resolveUrl()) {
  617.             $this->appendUrlMapping($queryBuilder, $locales);
  618.         }
  619.     }
  621.     /**
  622.      * Append mapping selects for a single property to given query-builder.
  623.      *
  624.      * @param string $propertyName
  625.      * @param string[] $locales
  626.      */
  627.     private function appendSingleMapping(QueryBuilder $queryBuilder, $propertyName, $locales)
  628.     {
  629.         foreach ($locales as $locale) {
  630.             $alias = \sprintf('%s%s', $locale, \str_replace('-', '_', \ucfirst($propertyName)));
  632.             $queryBuilder->addSelect(
  633.                 'node',
  634.                 $this->propertyEncoder->localizedContentName($propertyName, $locale),
  635.                 $alias
  636.             );
  637.         }
  638.     }
  640.     /**
  641.      * Append mapping for url to given query-builder.
  642.      *
  643.      * @param string[] $locales
  644.      */
  645.     private function appendUrlMapping(QueryBuilder $queryBuilder, $locales)
  646.     {
  647.         $structures = $this->structureManager->getStructures(Structure::TYPE_PAGE);
  648.         $urlNames = [];
  650.         foreach ($structures as $structure) {
  651.             if (!$structure->hasTag('sulu.rlp')) {
  652.                 continue;
  653.             }
  655.             $propertyName = $structure->getPropertyByTagName('sulu.rlp')->getName();
  657.             if (!\in_array($propertyName, $urlNames)) {
  658.                 $this->appendSingleMapping($queryBuilder, $propertyName, $locales);
  659.                 $urlNames[] = $propertyName;
  660.             }
  661.         }
  662.     }
  664.     /**
  665.      * Resolve a single result row to a content object.
  666.      *
  667.      * @param string $locale
  668.      * @param string $locales
  669.      *
  670.      * @return Content|null
  671.      */
  672.     private function resolveContent(
  673.         Row $row,
  674.         $locale,
  675.         $locales,
  676.         MappingInterface $mapping,
  677.         UserInterface $user = null,
  678.         array $permissions
  679.     ) {
  680.         $webspaceKey = $this->nodeHelper->extractWebspaceFromPath($row->getPath());
  682.         $originalLocale = $locale;
  683.         $availableLocales = $this->resolveAvailableLocales($row);
  684.         $ghostLocale = $this->localizationFinder->findAvailableLocale(
  685.             $webspaceKey,
  686.             $availableLocales,
  687.             $locale
  688.         );
  689.         if (null === $ghostLocale) {
  690.             $ghostLocale = \reset($availableLocales);
  691.         }
  693.         $type = null;
  694.         if ($row->getValue('shadowOn')) {
  695.             if (!$mapping->shouldHydrateShadow()) {
  696.                 return null;
  697.             }
  698.             $type = StructureType::getShadow($row->getValue('shadowBase'));
  699.         } elseif (null !== $ghostLocale && $ghostLocale !== $originalLocale) {
  700.             if (!$mapping->shouldHydrateGhost()) {
  701.                 return null;
  702.             }
  703.             $locale = $ghostLocale;
  704.             $type = StructureType::getGhost($locale);
  705.         }
  707.         if (
  708.             RedirectType::INTERNAL === $row->getValue('nodeType')
  709.             && $mapping->followInternalLink()
  710.             && '' !== $row->getValue('internalLink')
  711.             && $row->getValue('internalLink') !== $row->getValue('uuid')
  712.         ) {
  713.             // TODO collect all internal link contents and query once
  714.             return $this->resolveInternalLinkContent($row, $locale, $webspaceKey, $mapping, $type, $user);
  715.         }
  717.         $shadowBase = null;
  718.         if ($row->getValue('shadowOn')) {
  719.             $shadowBase = $row->getValue('shadowBase');
  720.         }
  722.         $data = [];
  723.         foreach ($mapping->getProperties() as $item) {
  724.             $data[$item] = $this->resolveProperty($row, $item, $locale, $shadowBase);
  725.         }
  727.         $content = new Content(
  728.             $originalLocale,
  729.             $webspaceKey,
  730.             $row->getValue('uuid'),
  731.             $this->resolvePath($row, $webspaceKey),
  732.             $row->getValue('state'),
  733.             $row->getValue('nodeType'),
  734.             $this->resolveHasChildren($row), $this->resolveProperty($row, 'template', $locale, $shadowBase),
  735.             $data,
  736.             $permissions,
  737.             $type
  738.         );
  739.         $content->setRow($row);
  741.         if (!$content->getTemplate() || !$this->structureManager->getStructure($content->getTemplate())) {
  742.             $content->setBrokenTemplate();
  743.         }
  745.         if ($mapping->resolveUrl()) {
  746.             $url = $this->resolveUrl($row, $locale);
  747.             /** @var array<string, string|null> $urls */
  748.             $urls = [];
  749.             \array_walk(
  750.                 $locales,
  751.                 /** @var array<string, string|null> $urls */
  752.                 function($locale) use (&$urls, $row) {
  753.                     $urls[$locale] = $this->resolveUrl($row, $locale);
  754.                 }
  755.             );
  757.             $content->setUrl($url);
  758.             $content->setUrls($urls);
  759.         }
  761.         if ($mapping->resolveConcreteLocales()) {
  762.             $locales = $this->resolveAvailableLocales($row);
  763.             $content->setContentLocales($locales);
  764.         }
  766.         return $content;
  767.     }
  769.     /**
  770.      * Resolves all available localizations for given row.
  771.      *
  772.      * @return string[]
  773.      */
  774.     private function resolveAvailableLocales(Row $row)
  775.     {
  776.         $locales = [];
  777.         foreach ($row->getValues() as $key => $value) {
  778.             if (\preg_match('/^node.([a-zA-Z_]*?)Template/', $key, $matches) && '' !== $value
  779.                 && !$row->getValue(\sprintf('node.%sShadow_on', $matches[1]))
  780.             ) {
  781.                 $locales[] = $matches[1];
  782.             }
  783.         }
  785.         return $locales;
  786.     }
  788.     /**
  789.      * Resolve a single result row which is an internal link to a content object.
  790.      *
  791.      * @param string $locale
  792.      * @param string $webspaceKey
  793.      * @param MappingInterface $mapping Includes array of property names
  794.      * @param StructureType $type
  795.      * @param UserInterface $user
  796.      *
  797.      * @return Content|null
  798.      */
  799.     public function resolveInternalLinkContent(
  800.         Row $row,
  801.         $locale,
  802.         $webspaceKey,
  803.         MappingInterface $mapping,
  804.         StructureType $type = null,
  805.         UserInterface $user = null
  806.     ) {
  807.         $linkedContent = $this->find($row->getValue('internalLink'), $locale, $webspaceKey, $mapping);
  808.         if (null === $linkedContent) {
  809.             return null;
  810.         }
  812.         $data = $linkedContent->getData();
  814.         // return value of source node instead of link destination for title and non-fallback-properties
  815.         $sourceNodeValueProperties = self::$nonFallbackProperties;
  816.         $sourceNodeValueProperties[] = 'title';
  817.         $properties = \array_intersect($sourceNodeValueProperties, \array_keys($data));
  818.         foreach ($properties as $property) {
  819.             $data[$property] = $this->resolveProperty($row, $property, $locale);
  820.         }
  822.         $resultPermissions = $this->resolveResultPermissions([$row], $user);
  823.         $permissions = empty($resultPermissions) ? [] : \current($resultPermissions);
  825.         $content = new Content(
  826.             $locale,
  827.             $webspaceKey,
  828.             $row->getValue('uuid'),
  829.             $this->resolvePath($row, $webspaceKey),
  830.             $row->getValue('state'),
  831.             $row->getValue('nodeType'),
  832.             $this->resolveHasChildren($row), $this->resolveProperty($row, 'template', $locale),
  833.             $data,
  834.             $permissions,
  835.             $type
  836.         );
  838.         if ($mapping->resolveUrl()) {
  839.             $content->setUrl($linkedContent->getUrl());
  840.             $content->setUrls($linkedContent->getUrls());
  841.         }
  843.         if (!$content->getTemplate() || !$this->structureManager->getStructure($content->getTemplate())) {
  844.             $content->setBrokenTemplate();
  845.         }
  847.         return $content;
  848.     }
  850.     /**
  851.      * Resolve a property and follow shadow locale if it has one.
  852.      *
  853.      * @param string $name
  854.      * @param string $locale
  855.      * @param string $shadowLocale
  856.      */
  857.     private function resolveProperty(Row $row, $name, $locale, $shadowLocale = null)
  858.     {
  859.         if (\array_key_exists(\sprintf('node.%s', $name), $row->getValues())) {
  860.             return $row->getValue($name);
  861.         }
  863.         if (null !== $shadowLocale && !\in_array($name, self::$nonFallbackProperties)) {
  864.             $locale = $shadowLocale;
  865.         }
  867.         $name = \sprintf('%s%s', $locale, \str_replace('-', '_', \ucfirst($name)));
  869.         try {
  870.             return $row->getValue($name);
  871.         } catch (ItemNotFoundException $e) {
  872.             // the default value of a non existing property in jackalope is an empty string
  873.             return '';
  874.         }
  875.     }
  877.     /**
  878.      * Resolve url property.
  879.      *
  880.      * @param string $locale
  881.      *
  882.      * @return string|null
  883.      */
  884.     private function resolveUrl(Row $row, $locale)
  885.     {
  886.         if (WorkflowStage::PUBLISHED !== $this->resolveProperty($row, $locale . 'State', $locale)) {
  887.             return null;
  888.         }
  890.         $template = $this->resolveProperty($row, 'template', $locale);
  891.         if (empty($template)) {
  892.             return null;
  893.         }
  895.         $structure = $this->structureManager->getStructure($template);
  896.         if (!$structure || !$structure->hasTag('sulu.rlp')) {
  897.             return null;
  898.         }
  900.         $propertyName = $structure->getPropertyByTagName('sulu.rlp')->getName();
  902.         return $this->resolveProperty($row, $propertyName, $locale);
  903.     }
  905.     /**
  906.      * Resolves path for given row.
  907.      *
  908.      * @param string $webspaceKey
  909.      *
  910.      * @return string
  911.      */
  912.     private function resolvePath(Row $row, $webspaceKey)
  913.     {
  914.         return '/' . \ltrim(\str_replace($this->sessionManager->getContentPath($webspaceKey), '', $row->getPath()), '/');
  915.     }
  917.     /**
  918.      * Resolve property has-children with given node.
  919.      *
  920.      * @return bool
  921.      */
  922.     private function resolveHasChildren(Row $row)
  923.     {
  924.         $queryBuilder = new QueryBuilder($this->qomFactory);
  926.         $queryBuilder
  927.             ->select('node', 'jcr:uuid', 'uuid')
  928.             ->from($this->qomFactory->selector('node', 'nt:unstructured'))
  929.             ->where($this->qomFactory->childNode('node', $row->getPath()))
  930.             ->setMaxResults(1);
  932.         $result = $queryBuilder->execute();
  934.         return \count(\iterator_to_array($result->getRows())) > 0;
  935.     }
  937.     public function supportsDescendantType(string $type): bool
  938.     {
  939.         try {
  940.             $class = new \ReflectionClass($type);
  941.         } catch (\ReflectionException $e) {
  942.             // in case the class does not exist there is no support
  943.             return false;
  944.         }
  946.         return $class->implementsInterface(SecurityBehavior::class);
  947.     }
  948. }