vendor/sulu/sulu/src/Sulu/Component/SmartContent/ContentType.php line 212

  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\SmartContent;
  14. use PHPCR\NodeInterface;
  15. use Sulu\Bundle\AudienceTargetingBundle\TargetGroup\TargetGroupStoreInterface;
  16. use Sulu\Bundle\TagBundle\Tag\TagManagerInterface;
  17. use Sulu\Bundle\WebsiteBundle\ReferenceStore\ReferenceStoreInterface;
  18. use Sulu\Component\Category\Request\CategoryRequestHandlerInterface;
  19. use Sulu\Component\Content\Compat\PropertyInterface;
  20. use Sulu\Component\Content\Compat\PropertyParameter;
  21. use Sulu\Component\Content\ComplexContentType;
  22. use Sulu\Component\Content\ContentTypeExportInterface;
  23. use Sulu\Component\Tag\Request\TagRequestHandlerInterface;
  24. use Sulu\Component\Util\ArrayableInterface;
  25. use Sulu\Component\Webspace\Analyzer\RequestAnalyzerInterface;
  26. use Symfony\Component\HttpFoundation\RequestStack;
  28. /**
  29.  * Content type for smart selection.
  30.  */
  31. class ContentType extends ComplexContentType implements ContentTypeExportInterface
  32. {
  33.     /**
  34.      * @var TagManagerInterface
  35.      */
  36.     private $tagManager;
  38.     /**
  39.      * @var DataProviderPoolInterface
  40.      */
  41.     private $dataProviderPool;
  43.     /**
  44.      * @var RequestStack
  45.      */
  46.     private $requestStack;
  48.     /**
  49.      * Contains cached values.
  50.      *
  51.      * @var array
  52.      */
  53.     private $cache = [];
  55.     /**
  56.      * @var TagRequestHandlerInterface
  57.      */
  58.     private $tagRequestHandler;
  60.     /**
  61.      * @var CategoryRequestHandlerInterface
  62.      */
  63.     private $categoryRequestHandler;
  65.     /**
  66.      * @var TargetGroupStoreInterface
  67.      */
  68.     private $targetGroupStore;
  70.     /**
  71.      * @var ReferenceStoreInterface
  72.      */
  73.     private $tagReferenceStore;
  75.     /**
  76.      * @var ReferenceStoreInterface
  77.      */
  78.     private $categoryReferenceStore;
  80.     /**
  81.      * @var RequestAnalyzerInterface
  82.      */
  83.     private $requestAnalyzer;
  85.     public function __construct(
  86.         DataProviderPoolInterface $dataProviderPool,
  87.         TagManagerInterface $tagManager,
  88.         RequestStack $requestStack,
  89.         TagRequestHandlerInterface $tagRequestHandler,
  90.         CategoryRequestHandlerInterface $categoryRequestHandler,
  91.         ReferenceStoreInterface $tagReferenceStore,
  92.         ReferenceStoreInterface $categoryReferenceStore,
  93.         TargetGroupStoreInterface $targetGroupStore = null,
  94.         RequestAnalyzerInterface $requestAnalyzer
  95.     ) {
  96.         $this->dataProviderPool = $dataProviderPool;
  97.         $this->tagManager = $tagManager;
  98.         $this->requestStack = $requestStack;
  99.         $this->tagRequestHandler = $tagRequestHandler;
  100.         $this->categoryRequestHandler = $categoryRequestHandler;
  101.         $this->tagReferenceStore = $tagReferenceStore;
  102.         $this->categoryReferenceStore = $categoryReferenceStore;
  103.         $this->targetGroupStore = $targetGroupStore;
  104.         $this->requestAnalyzer = $requestAnalyzer;
  105.     }
  107.     public function read(
  108.         NodeInterface $node,
  109.         PropertyInterface $property,
  110.         $webspaceKey,
  111.         $languageCode,
  112.         $segmentKey
  113.     ) {
  114.         $data = $node->getPropertyValueWithDefault($property->getName(), '{}');
  115.         if (\is_string($data)) {
  116.             $data = \json_decode($data, true);
  117.         }
  119.         if (!empty($data['tags'])) {
  120.             $data['tags'] = $this->tagManager->resolveTagIds($data['tags']);
  121.         }
  123.         $property->setValue($data);
  124.     }
  126.     public function write(
  127.         NodeInterface $node,
  128.         PropertyInterface $property,
  129.         $userId,
  130.         $webspaceKey,
  131.         $languageCode,
  132.         $segmentKey
  133.     ) {
  134.         $value = $property->getValue();
  135.         if ($value instanceof ArrayableInterface) {
  136.             $value = $value->toArray();
  137.         }
  139.         $this->resolveTags($value, 'tags');
  140.         $this->resolveTags($value, 'websiteTags');
  142.         $node->setProperty($property->getName(), \json_encode($value));
  143.     }
  145.     public function remove(
  146.         NodeInterface $node,
  147.         PropertyInterface $property,
  148.         $webspaceKey,
  149.         $languageCode,
  150.         $segmentKey
  151.     ) {
  152.         if ($node->hasProperty($property->getName())) {
  153.             $node->getProperty($property->getName())->remove();
  154.         }
  155.     }
  157.     public function getDefaultParams(PropertyInterface $property = null)
  158.     {
  159.         $provider = $this->getProvider($property);
  160.         $configuration = $provider->getConfiguration();
  162.         $defaults = [
  163.             'provider' => new PropertyParameter('provider', 'pages'),
  164.             'alias' => null,
  165.             'page_parameter' => new PropertyParameter('page_parameter', 'p'),
  166.             'tags_parameter' => new PropertyParameter('tags_parameter', 'tags'),
  167.             'categories_parameter' => new PropertyParameter('categories_parameter', 'categories'),
  168.             'website_tags_operator' => new PropertyParameter('website_tags_operator', 'OR'),
  169.             'website_categories_operator' => new PropertyParameter('website_categories_operator', 'OR'),
  170.             'sorting' => new PropertyParameter('sorting', $configuration->getSorting(), 'collection'),
  171.             'types' => new PropertyParameter('types', $configuration->getTypes(), 'collection'),
  172.             'present_as' => new PropertyParameter('present_as', [], 'collection'),
  173.             'category_root' => new PropertyParameter('category_root', null),
  174.             'display_options' => new PropertyParameter(
  175.                 'display_options',
  176.                 [
  177.                     'tags' => new PropertyParameter('tags', true),
  178.                     'categories' => new PropertyParameter('categories', true),
  179.                     'sorting' => new PropertyParameter('sorting', true),
  180.                     'types' => new PropertyParameter('types', true),
  181.                     'limit' => new PropertyParameter('limit', true),
  182.                     'presentAs' => new PropertyParameter('presentAs', true),
  183.                 ],
  184.                 'collection'
  185.             ),
  186.             'has' => [
  187.                 'datasource' => $configuration->hasDatasource(),
  188.                 'tags' => $configuration->hasTags(),
  189.                 'categories' => $configuration->hasCategories(),
  190.                 'sorting' => $configuration->hasSorting(),
  191.                 'types' => $configuration->hasTypes(),
  192.                 'limit' => $configuration->hasLimit(),
  193.                 'presentAs' => $configuration->hasPresentAs(),
  194.                 'audienceTargeting' => $configuration->hasAudienceTargeting(),
  195.             ],
  196.             'datasourceResourceKey' => $configuration->getDatasourceResourceKey(),
  197.             'datasourceAdapter' => $configuration->getDatasourceAdapter(),
  198.             'exclude_duplicates' => new PropertyParameter('exclude_duplicates', false),
  199.         ];
  201.         if ($provider instanceof DataProviderAliasInterface) {
  202.             $defaults['alias'] = $provider->getAlias();
  203.         }
  205.         return \array_merge(
  206.             parent::getDefaultParams(),
  207.             $defaults,
  208.             $provider->getDefaultPropertyParameter()
  209.         );
  210.     }
  212.     public function getContentData(PropertyInterface $property)
  213.     {
  214.         // check memoize
  215.         $hash = \spl_object_hash($property);
  216.         if (\array_key_exists($hash, $this->cache)) {
  217.             return $this->cache[$hash];
  218.         }
  220.         /** @var PropertyParameter[] $params */
  221.         $params = \array_merge(
  222.             $this->getDefaultParams($property),
  223.             $property->getParams()
  224.         );
  226.         // prepare filters
  227.         $filters = $property->getValue();
  229.         $filters['excluded'] = [$property->getStructure()->getUuid()];
  231.         // default value of tags/category is an empty array
  232.         if (!\array_key_exists('tags', $filters) || null === $filters['tags']) {
  233.             $filters['tags'] = [];
  234.         }
  235.         if (!\array_key_exists('categories', $filters) || null === $filters['categories']) {
  236.             $filters['categories'] = [];
  237.         }
  239.         // extends selected filter with requested tags
  240.         $filters['websiteTags'] = $this->tagRequestHandler->getTags($params['tags_parameter']->getValue());
  241.         $filters['websiteTagsOperator'] = $params['website_tags_operator']->getValue();
  243.         // extends selected filter with requested categories
  244.         $filters['websiteCategories'] = $this->categoryRequestHandler->getCategories(
  245.             $params['categories_parameter']->getValue()
  246.         );
  247.         $filters['websiteCategoriesOperator'] = $params['website_categories_operator']->getValue();
  249.         if ($this->targetGroupStore && isset($filters['audienceTargeting']) && $filters['audienceTargeting']) {
  250.             $filters['targetGroupId'] = $this->targetGroupStore->getTargetGroupId();
  251.         }
  253.         $segment = $this->requestAnalyzer->getSegment();
  254.         if ($segment) {
  255.             $filters['segmentKey'] = $segment->getKey();
  256.         }
  258.         // resolve tags to id
  259.         $this->resolveTags($filters, 'tags');
  261.         // resolve website tags to id
  262.         $this->resolveTags($filters, 'websiteTags');
  264.         foreach (\array_merge($filters['tags'], $filters['websiteTags']) as $item) {
  265.             $this->tagReferenceStore->add($item);
  266.         }
  268.         foreach (\array_merge($filters['categories'], $filters['websiteCategories']) as $item) {
  269.             $this->categoryReferenceStore->add($item);
  270.         }
  272.         // get provider
  273.         $provider = $this->getProvider($property);
  274.         $configuration = $provider->getConfiguration();
  276.         // prepare pagination, limitation and options
  277.         $page = 1;
  278.         $limit = (\array_key_exists('limitResult', $filters) && $configuration->hasLimit()) ?
  279.             $filters['limitResult'] : null;
  280.         $options = [
  281.             'webspaceKey' => $this->requestAnalyzer->getWebspace()->getKey(),
  282.             'locale' => $property->getStructure()->getLanguageCode(),
  283.         ];
  285.         if (isset($params['max_per_page']) && $configuration->hasPagination()) {
  286.             // is paginated
  287.             $page = $this->getCurrentPage($params['page_parameter']->getValue());
  288.             $pageSize = \intval($params['max_per_page']->getValue());
  290.             // resolve paginated filters
  291.             $data = $provider->resolveResourceItems(
  292.                 $filters,
  293.                 $params,
  294.                 $options,
  295.                 !empty($limit) ? \intval($limit) : null,
  296.                 $page,
  297.                 $pageSize
  298.             );
  299.         } else {
  300.             $data = $provider->resolveResourceItems(
  301.                 $filters,
  302.                 $params,
  303.                 $options,
  304.                 !empty($limit) ? \intval($limit) : null,
  305.                 1
  306.             );
  307.         }
  309.         // append view data
  310.         $filters['page'] = $page;
  311.         $filters['hasNextPage'] = $data->getHasNextPage();
  312.         $filters['paginated'] = $configuration->hasPagination();
  313.         $property->setValue($filters);
  315.         // save result in cache
  316.         return $this->cache[$hash] = $data->getItems();
  317.     }
  319.     public function getViewData(PropertyInterface $property)
  320.     {
  321.         /** @var PropertyParameter[] $params */
  322.         $params = \array_merge(
  323.             $this->getDefaultParams($property),
  324.             $property->getParams()
  325.         );
  327.         $this->getContentData($property);
  328.         $config = $property->getValue();
  330.         $config = \array_merge(
  331.             [
  332.                 'dataSource' => null,
  333.                 'includeSubFolders' => null,
  334.                 'category' => null,
  335.                 'tags' => [],
  336.                 'sortBy' => null,
  337.                 'sortMethod' => null,
  338.                 'presentAs' => null,
  339.                 'limitResult' => null,
  340.                 'page' => null,
  341.                 'hasNextPage' => null,
  342.                 'paginated' => false,
  343.                 'categoryRoot' => $params['category_root']->getValue(),
  344.                 'categoriesParameter' => $params['categories_parameter']->getValue(),
  345.                 'tagsParameter' => $params['tags_parameter']->getValue(),
  346.             ],
  347.             $config
  348.         );
  350.         return $config;
  351.     }
  353.     /**
  354.      * Returns provider for given property.
  355.      *
  356.      * @return DataProviderInterface
  357.      */
  358.     private function getProvider(PropertyInterface $property)
  359.     {
  360.         $params = $property->getParams();
  362.         $providerAlias = 'pages';
  363.         if (\array_key_exists('provider', $params)) {
  364.             $providerAlias = $params['provider']->getValue();
  365.         }
  367.         return $this->dataProviderPool->get($providerAlias);
  368.     }
  370.     /**
  371.      * Determine current page from current request.
  372.      *
  373.      * @param string $pageParameter
  374.      *
  375.      * @return int
  376.      */
  377.     private function getCurrentPage($pageParameter)
  378.     {
  379.         if (null === $this->requestStack->getCurrentRequest()) {
  380.             return 1;
  381.         }
  383.         $page = $this->requestStack->getCurrentRequest()->get($pageParameter, 1);
  385.         if ($page <= 1) {
  386.             $page = 1;
  387.         }
  389.         if ($page > \PHP_INT_MAX) {
  390.             return \PHP_INT_MAX;
  391.         }
  393.         return (int) $page;
  394.     }
  396.     public function exportData($propertyValue)
  397.     {
  398.         if (\is_string($propertyValue)) {
  399.             return $propertyValue;
  400.         }
  402.         if (\is_array($propertyValue)) {
  403.             return \json_encode($propertyValue);
  404.         }
  406.         return '';
  407.     }
  409.     public function importData(
  410.         NodeInterface $node,
  411.         PropertyInterface $property,
  412.         $value,
  413.         $userId,
  414.         $webspaceKey,
  415.         $languageCode,
  416.         $segmentKey = null
  417.     ) {
  418.         $property->setValue(\json_decode($value, true));
  419.         $this->write($node, $property, $userId, $webspaceKey, $languageCode, $segmentKey);
  420.     }
  422.     /**
  423.      * @param mixed[] $value
  424.      * @param string $key
  425.      */
  426.     protected function resolveTags(&$value, $key)
  427.     {
  428.         if (isset($value[$key])) {
  429.             $ids = [];
  430.             $names = [];
  431.             foreach ($value[$key] as $tag) {
  432.                 if (\is_numeric($tag)) {
  433.                     $ids[] = $tag;
  434.                 } else {
  435.                     $names[] = $tag;
  436.                 }
  437.             }
  439.             if (!empty($names)) {
  440.                 foreach ($this->tagManager->resolveTagNames($names) as $id) {
  441.                     $ids[] = $id;
  442.                 }
  443.             }
  445.             $value[$key] = $ids;
  446.         }
  447.     }
  448. }