vendor/sulu/sulu/src/Sulu/Component/Content/SmartContent/PageDataProvider.php line 275

  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\SmartContent;
  14. use PHPCR\ItemNotFoundException;
  15. use PHPCR\SessionInterface;
  16. use ProxyManager\Factory\LazyLoadingValueHolderFactory;
  17. use ProxyManager\Proxy\LazyLoadingInterface;
  18. use Sulu\Bundle\AdminBundle\Metadata\FormMetadata\TypedFormMetadata;
  19. use Sulu\Bundle\AdminBundle\Metadata\MetadataProviderInterface;
  20. use Sulu\Bundle\PageBundle\Admin\PageAdmin;
  21. use Sulu\Bundle\PageBundle\Document\PageDocument;
  22. use Sulu\Bundle\WebsiteBundle\ReferenceStore\ReferenceStoreInterface;
  23. use Sulu\Component\Content\Compat\PropertyParameter;
  24. use Sulu\Component\Content\Query\ContentQueryBuilderInterface;
  25. use Sulu\Component\Content\Query\ContentQueryExecutorInterface;
  26. use Sulu\Component\DocumentManager\DocumentManagerInterface;
  27. use Sulu\Component\Security\Authentication\UserInterface;
  28. use Sulu\Component\Security\Authorization\PermissionTypes;
  29. use Sulu\Component\SmartContent\ArrayAccessItem;
  30. use Sulu\Component\SmartContent\Configuration\Builder;
  31. use Sulu\Component\SmartContent\Configuration\ProviderConfigurationInterface;
  32. use Sulu\Component\SmartContent\DataProviderAliasInterface;
  33. use Sulu\Component\SmartContent\DataProviderInterface;
  34. use Sulu\Component\SmartContent\DataProviderResult;
  35. use Sulu\Component\SmartContent\DatasourceItem;
  36. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  38. /**
  39.  * DataProvider for content.
  40.  */
  41. class PageDataProvider implements DataProviderInterface, DataProviderAliasInterface
  42. {
  43.     /**
  44.      * @var ContentQueryBuilderInterface
  45.      */
  46.     private $contentQueryBuilder;
  48.     /**
  49.      * @var ContentQueryExecutorInterface
  50.      */
  51.     private $contentQueryExecutor;
  53.     /**
  54.      * @var DocumentManagerInterface
  55.      */
  56.     private $documentManager;
  58.     /**
  59.      * @var ProviderConfigurationInterface
  60.      */
  61.     private $configuration;
  63.     /**
  64.      * @var LazyLoadingValueHolderFactory
  65.      */
  66.     private $proxyFactory;
  68.     /**
  69.      * @var SessionInterface
  70.      */
  71.     private $session;
  73.     /**
  74.      * @var ReferenceStoreInterface
  75.      */
  76.     private $referenceStore;
  78.     /**
  79.      * @var bool
  80.      */
  81.     private $showDrafts;
  83.     /**
  84.      * @var array
  85.      */
  86.     private $permissions;
  88.     /*
  89.      * @var bool
  90.      */
  91.     private $hasAudienceTargeting;
  93.     /**
  94.      * @var MetadataProviderInterface|null
  95.      */
  96.     private $formMetadataProvider;
  98.     /**
  99.      * @var TokenStorageInterface|null
  100.      */
  101.     private $tokenStorage;
  103.     /**
  104.      * @var array
  105.      */
  106.     private $enabledTwigAttributes = [];
  108.     public function __construct(
  109.         ContentQueryBuilderInterface $contentQueryBuilder,
  110.         ContentQueryExecutorInterface $contentQueryExecutor,
  111.         DocumentManagerInterface $documentManager,
  112.         LazyLoadingValueHolderFactory $proxyFactory,
  113.         SessionInterface $session,
  114.         ReferenceStoreInterface $referenceStore,
  115.         $showDrafts,
  116.         $permissions,
  117.         bool $hasAudienceTargeting = false,
  118.         MetadataProviderInterface $formMetadataProvider = null,
  119.         TokenStorageInterface $tokenStorage = null,
  120.         array $enabledTwigAttributes = [
  121.             'path' => true,
  122.         ]
  123.     ) {
  124.         $this->contentQueryBuilder = $contentQueryBuilder;
  125.         $this->contentQueryExecutor = $contentQueryExecutor;
  126.         $this->documentManager = $documentManager;
  127.         $this->proxyFactory = $proxyFactory;
  128.         $this->session = $session;
  129.         $this->referenceStore = $referenceStore;
  130.         $this->showDrafts = $showDrafts;
  131.         $this->permissions = $permissions;
  132.         $this->hasAudienceTargeting = $hasAudienceTargeting;
  133.         $this->formMetadataProvider = $formMetadataProvider;
  134.         $this->tokenStorage = $tokenStorage;
  135.         $this->enabledTwigAttributes = $enabledTwigAttributes;
  137.         if (!$formMetadataProvider) {
  138.             @\trigger_error('The usage of the "PageDataProvider" without setting the "FormMetadataProvider" is deprecated. Please inject the "FormMetadataProvider".', \E_USER_DEPRECATED);
  139.         }
  141.         if ($enabledTwigAttributes['path'] ?? true) {
  142.             @\trigger_error('Enabling the "path" parameter is deprecated since sulu/sulu 2.3.', \E_USER_DEPRECATED);
  143.         }
  144.     }
  146.     public function getConfiguration()
  147.     {
  148.         if (!$this->configuration) {
  149.             return $this->initConfiguration();
  150.         }
  152.         return $this->configuration;
  153.     }
  155.     /**
  156.      * Initiate configuration.
  157.      *
  158.      * @return ProviderConfigurationInterface
  159.      */
  160.     private function initConfiguration()
  161.     {
  162.         $builder = Builder::create()
  163.             ->enableTags()
  164.             ->enableCategories()
  165.             ->enableLimit()
  166.             ->enablePagination()
  167.             ->enablePresentAs()
  168.             ->enableDatasource('pages', 'pages', 'column_list')
  169.             ->enableSorting(
  170.                 [
  171.                     ['column' => null, 'title' => 'sulu_admin.default'],
  172.                     ['column' => 'title', 'title' => 'sulu_admin.title'],
  173.                     ['column' => 'published', 'title' => 'sulu_admin.published'],
  174.                     ['column' => 'created', 'title' => 'sulu_admin.created'],
  175.                     ['column' => 'changed', 'title' => 'sulu_admin.changed'],
  176.                     ['column' => 'authored', 'title' => 'sulu_admin.authored'],
  177.                 ]
  178.             )
  179.             ->enableTypes($this->getTypes())
  180.             ->enableView(PageAdmin::EDIT_FORM_VIEW, ['id' => 'id', 'webspace' => 'webspace']);
  182.         if ($this->hasAudienceTargeting) {
  183.             $builder->enableAudienceTargeting();
  184.         }
  186.         $this->configuration = $builder->getConfiguration();
  188.         return $this->configuration;
  189.     }
  191.     public function getDefaultPropertyParameter()
  192.     {
  193.         return [
  194.             'properties' => new PropertyParameter('properties', [], 'collection'),
  195.         ];
  196.     }
  198.     public function resolveDatasource($datasource, array $propertyParameter, array $options)
  199.     {
  200.         $properties = \array_key_exists('properties', $propertyParameter) ?
  201.             $propertyParameter['properties']->getValue() : [];
  203.         $this->contentQueryBuilder->init(
  204.             [
  205.                 'ids' => [$datasource],
  206.                 'properties' => $properties,
  207.                 'published' => false,
  208.             ]
  209.         );
  211.         $result = $this->contentQueryExecutor->execute(
  212.             $options['webspaceKey'],
  213.             [$options['locale']],
  214.             $this->contentQueryBuilder,
  215.             true,
  216.             -1,
  217.             1,
  218.             0,
  219.             false
  220.         );
  222.         if (0 === \count($result)) {
  223.             return;
  224.         }
  226.         return new DatasourceItem($result[0]['id'], $result[0]['title'], $result[0]['url'] ?? null);
  227.     }
  229.     public function resolveDataItems(
  230.         array $filters,
  231.         array $propertyParameter,
  232.         array $options = [],
  233.         $limit = null,
  234.         $page = 1,
  235.         $pageSize = null
  236.     ) {
  237.         list($items, $hasNextPage) = $this->resolveFilters(
  238.             $filters,
  239.             $propertyParameter,
  240.             $options,
  241.             $limit,
  242.             $page,
  243.             $pageSize
  244.         );
  246.         $items = $this->decorateDataItems($items, $options['locale']);
  248.         return new DataProviderResult($items, $hasNextPage);
  249.     }
  251.     public function resolveResourceItems(
  252.         array $filters,
  253.         array $propertyParameter,
  254.         array $options = [],
  255.         $limit = null,
  256.         $page = 1,
  257.         $pageSize = null
  258.     ) {
  259.         list($items, $hasNextPage) = $this->resolveFilters(
  260.             $filters,
  261.             $propertyParameter,
  262.             $options,
  263.             $limit,
  264.             $page,
  265.             $pageSize
  266.         );
  267.         $items = $this->decorateResourceItems($items, $options['locale']);
  269.         return new DataProviderResult($items, $hasNextPage);
  270.     }
  272.     /**
  273.      * Resolves filters.
  274.      */
  275.     private function resolveFilters(
  276.         array $filters,
  277.         array $propertyParameter,
  278.         array $options = [],
  279.         $limit = null,
  280.         $page = 1,
  281.         $pageSize = null
  282.     ) {
  283.         $emptyFilterResult = [[], false];
  285.         if (!\array_key_exists('dataSource', $filters)
  286.             || null === $filters['dataSource']
  287.             || '' === $filters['dataSource']
  288.             || (null !== $limit && $limit < 1)
  289.         ) {
  290.             return $emptyFilterResult;
  291.         }
  293.         try {
  294.             $this->session->getNodeByIdentifier($filters['dataSource']);
  295.         } catch (ItemNotFoundException $e) {
  296.             return $emptyFilterResult;
  297.         }
  299.         $properties = \array_key_exists('properties', $propertyParameter) ?
  300.             $propertyParameter['properties']->getValue() : [];
  302.         $excluded = isset($filters['excluded']) ? $filters['excluded'] : [];
  303.         if (\array_key_exists('exclude_duplicates', $propertyParameter)
  304.             && $propertyParameter['exclude_duplicates']->getValue()
  305.         ) {
  306.             $excluded = \array_merge($excluded, $this->referenceStore->getAll());
  307.         }
  309.         $this->contentQueryBuilder->init(
  310.             [
  311.                 'config' => $filters,
  312.                 'properties' => $properties,
  313.                 'excluded' => $excluded,
  314.                 'published' => !$this->showDrafts,
  315.             ]
  316.         );
  318.         $hasNextPage = false;
  319.         if (null !== $pageSize) {
  320.             $result = $this->loadPaginated($options, $limit, $page, $pageSize);
  321.             $hasNextPage = (\count($result) > $pageSize);
  322.             $items = \array_splice($result, 0, $pageSize);
  323.         } else {
  324.             $items = $this->load($options, $limit);
  325.         }
  327.         return [$items, $hasNextPage];
  328.     }
  330.     /**
  331.      * Load paginated data.
  332.      *
  333.      * @param int $limit
  334.      * @param int $page
  335.      * @param int $pageSize
  336.      *
  337.      * @return array
  338.      */
  339.     private function loadPaginated(array $options, $limit, $page, $pageSize)
  340.     {
  341.         $pageSize = \intval($pageSize);
  342.         $offset = ($page - 1) * $pageSize;
  344.         $position = $pageSize * $page;
  345.         if (null !== $limit && $position >= $limit) {
  346.             $pageSize = $limit - $offset;
  347.             $loadLimit = $pageSize;
  348.         } else {
  349.             $loadLimit = $pageSize + 1;
  350.         }
  352.         return $this->contentQueryExecutor->execute(
  353.             $options['webspaceKey'],
  354.             [$options['locale']],
  355.             $this->contentQueryBuilder,
  356.             true,
  357.             -1,
  358.             $loadLimit,
  359.             $offset,
  360.             false,
  361.             $this->permissions[PermissionTypes::VIEW]
  362.         );
  363.     }
  365.     /**
  366.      * Load data.
  367.      *
  368.      * @param int $limit
  369.      *
  370.      * @return array
  371.      */
  372.     private function load(array $options, $limit)
  373.     {
  374.         return $this->contentQueryExecutor->execute(
  375.             $options['webspaceKey'],
  376.             [$options['locale']],
  377.             $this->contentQueryBuilder,
  378.             true,
  379.             -1,
  380.             $limit,
  381.             null,
  382.             false,
  383.             $this->permissions[PermissionTypes::VIEW]
  384.         );
  385.     }
  387.     /**
  388.      * Decorates result with item class.
  389.      *
  390.      * @param string $locale
  391.      *
  392.      * @return ContentDataItem[]
  393.      */
  394.     private function decorateDataItems(array $data, $locale)
  395.     {
  396.         return \array_map(
  397.             function($item) use ($locale) {
  398.                 return new ContentDataItem($item, $this->getResource($item['id'], $locale));
  399.             },
  400.             $data
  401.         );
  402.     }
  404.     /**
  405.      * Decorates result with item class.
  406.      *
  407.      * @param string $locale
  408.      *
  409.      * @return ArrayAccessItem[]
  410.      */
  411.     private function decorateResourceItems(array $data, $locale)
  412.     {
  413.         return \array_map(
  414.             function($item) use ($locale) {
  415.                 $this->referenceStore->add($item['id']);
  417.                 if (!($this->enabledTwigAttributes['path'] ?? true)) {
  418.                     unset($item['path']);
  419.                 }
  421.                 return new ArrayAccessItem($item['id'], $item, $this->getResource($item['id'], $locale));
  422.             },
  423.             $data
  424.         );
  425.     }
  427.     /**
  428.      * Returns Proxy Document for uuid.
  429.      *
  430.      * @param string $uuid
  431.      * @param string $locale
  432.      *
  433.      * @return object
  434.      */
  435.     private function getResource($uuid, $locale)
  436.     {
  437.         return $this->proxyFactory->createProxy(
  438.             PageDocument::class,
  439.             function(
  440.                 &$wrappedObject,
  441.                 LazyLoadingInterface $proxy,
  442.                 $method,
  443.                 array $parameters,
  444.                 &$initializer
  445.             ) use ($uuid, $locale) {
  446.                 $initializer = null;
  447.                 $wrappedObject = $this->documentManager->find($uuid, $locale);
  449.                 return true;
  450.             }
  451.         );
  452.     }
  454.     /**
  455.      * @return array<int, array<string, string>>
  456.      */
  457.     private function getTypes(): array
  458.     {
  459.         $types = [];
  460.         if ($this->tokenStorage && null !== $this->tokenStorage->getToken() && $this->formMetadataProvider) {
  461.             $user = $this->tokenStorage->getToken()->getUser();
  463.             if (!$user instanceof UserInterface) {
  464.                 return $types;
  465.             }
  467.             /** @var TypedFormMetadata $metadata */
  468.             $metadata = $this->formMetadataProvider->getMetadata('page', $user->getLocale(), []);
  470.             foreach ($metadata->getForms() as $form) {
  471.                 $types[] = ['type' => $form->getName(), 'title' => $form->getTitle()];
  472.             }
  473.         }
  475.         return $types;
  476.     }
  478.     public function getAlias()
  479.     {
  480.         return 'content';
  481.     }
  482. }