vendor/sulu/sulu/src/Sulu/Component/SmartContent/Orm/BaseDataProvider.php line 148

  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\Orm;
  14. use JMS\Serializer\SerializationContext;
  15. use Sulu\Bundle\WebsiteBundle\ReferenceStore\ReferenceStoreInterface;
  16. use Sulu\Component\Content\Compat\PropertyParameter;
  17. use Sulu\Component\Security\Authorization\PermissionTypes;
  18. use Sulu\Component\Serializer\ArraySerializerInterface;
  19. use Sulu\Component\SmartContent\ArrayAccessItem;
  20. use Sulu\Component\SmartContent\Configuration\Builder;
  21. use Sulu\Component\SmartContent\Configuration\BuilderInterface;
  22. use Sulu\Component\SmartContent\Configuration\ProviderConfiguration;
  23. use Sulu\Component\SmartContent\Configuration\ProviderConfigurationInterface;
  24. use Sulu\Component\SmartContent\DataProviderInterface;
  25. use Sulu\Component\SmartContent\DataProviderResult;
  26. use Sulu\Component\SmartContent\ItemInterface;
  27. use Sulu\Component\Webspace\Analyzer\RequestAnalyzerInterface;
  28. use Symfony\Component\Security\Core\Security;
  30. /**
  31.  * Provides basic functionality for contact and account providers.
  32.  */
  33. abstract class BaseDataProvider implements DataProviderInterface
  34. {
  35.     /**
  36.      * Creates a new configuration object.
  37.      *
  38.      * @return BuilderInterface
  39.      */
  40.     protected static function createConfigurationBuilder()
  41.     {
  42.         return Builder::create();
  43.     }
  45.     /**
  46.      * @var DataProviderRepositoryInterface
  47.      */
  48.     protected $repository;
  50.     /**
  51.      * @var ProviderConfigurationInterface
  52.      */
  53.     protected $configuration;
  55.     /**
  56.      * @var ArraySerializerInterface
  57.      */
  58.     private $serializer;
  60.     /**
  61.      * @var ReferenceStoreInterface
  62.      */
  63.     private $referenceStore;
  65.     /**
  66.      * @var ?Security
  67.      */
  68.     private $security;
  70.     /**
  71.      * @var ?RequestAnalyzerInterface
  72.      */
  73.     private $requestAnalyzer;
  75.     /**
  76.      * @var ?array
  77.      */
  78.     private $permissions;
  80.     public function __construct(
  81.         DataProviderRepositoryInterface $repository,
  82.         ArraySerializerInterface $serializer,
  83.         ReferenceStoreInterface $referenceStore = null,
  84.         Security $security = null,
  85.         RequestAnalyzerInterface $requestAnalyzer = null,
  86.         $permissions = null
  87.     ) {
  88.         $this->repository = $repository;
  89.         $this->serializer = $serializer;
  90.         $this->referenceStore = $referenceStore;
  91.         $this->security = $security;
  92.         $this->requestAnalyzer = $requestAnalyzer;
  93.         $this->permissions = $permissions;
  94.     }
  96.     public function getDefaultPropertyParameter()
  97.     {
  98.         return [];
  99.     }
  101.     public function getConfiguration()
  102.     {
  103.         return $this->configuration;
  104.     }
  106.     public function resolveDatasource($datasource, array $propertyParameter, array $options)
  107.     {
  108.         return;
  109.     }
  111.     public function resolveDataItems(
  112.         array $filters,
  113.         array $propertyParameter,
  114.         array $options = [],
  115.         $limit = null,
  116.         $page = 1,
  117.         $pageSize = null
  118.     ) {
  119.         list($result, $hasNextPage) = $this->resolveFilters(
  120.             $filters,
  121.             $options['locale'],
  122.             $limit,
  123.             $page,
  124.             $pageSize,
  125.             $this->getOptions($propertyParameter, $options)
  126.         );
  128.         return new DataProviderResult($this->decorateDataItems($result), $hasNextPage);
  129.     }
  131.     public function resolveResourceItems(
  132.         array $filters,
  133.         array $propertyParameter,
  134.         array $options = [],
  135.         $limit = null,
  136.         $page = 1,
  137.         $pageSize = null
  138.     ) {
  139.         list($result, $hasNextPage) = $this->resolveFilters(
  140.             $filters,
  141.             $options['locale'],
  142.             $limit,
  143.             $page,
  144.             $pageSize,
  145.             $this->getOptions($propertyParameter, $options)
  146.         );
  148.         return new DataProviderResult($this->decorateResourceItems($result, $options['locale']), $hasNextPage);
  149.     }
  151.     /**
  152.      * Resolves filters.
  153.      *
  154.      * @param string $locale
  155.      * @param int|null $limit
  156.      * @param int $page
  157.      * @param int|null $pageSize
  158.      * @param array $options
  159.      *
  160.      * @return array
  161.      */
  162.     private function resolveFilters(
  163.         array $filters,
  164.         $locale,
  165.         $limit = null,
  166.         $page = 1,
  167.         $pageSize = null,
  168.         $options = []
  169.     ) {
  170.         $webspace = $this->requestAnalyzer ? $this->requestAnalyzer->getWebspace() : null;
  172.         $result = $this->repository->findByFilters(
  173.             $filters,
  174.             $page,
  175.             $pageSize,
  176.             $limit,
  177.             $locale,
  178.             $options,
  179.             $this->security && $webspace && $webspace->hasWebsiteSecurity() ? $this->security->getUser() : null,
  180.             $webspace && $webspace->hasWebsiteSecurity() && $this->permissions
  181.                 ? $this->permissions[PermissionTypes::VIEW]
  182.                 : null
  183.         );
  185.         $hasNextPage = false;
  186.         if (null !== $pageSize && \count($result) > $pageSize) {
  187.             $hasNextPage = true;
  188.             $result = \array_splice($result, 0, $pageSize);
  189.         }
  191.         return [$result, $hasNextPage];
  192.     }
  194.     /**
  195.      * Initiate configuration.
  196.      *
  197.      * @return ProviderConfigurationInterface
  198.      *
  199.      * @deprecated use self::createConfigurationBuilder instead
  200.      */
  201.     protected function initConfiguration($tags, $categories, $limit, $presentAs, $paginated, $sorting)
  202.     {
  203.         $configuration = new ProviderConfiguration();
  204.         $configuration->setTags($tags);
  205.         $configuration->setCategories($categories);
  206.         $configuration->setLimit($limit);
  207.         $configuration->setPresentAs($presentAs);
  208.         $configuration->setPaginated($paginated);
  209.         $configuration->setSorting($sorting);
  211.         return $configuration;
  212.     }
  214.     /**
  215.      * Decorates result as resource item.
  216.      *
  217.      * @param string $locale
  218.      *
  219.      * @return ArrayAccessItem[]
  220.      */
  221.     protected function decorateResourceItems(array $data, $locale)
  222.     {
  223.         return \array_map(
  224.             function($item) {
  225.                 $itemData = $this->serializer->serialize($item, $this->getSerializationContext());
  226.                 $id = $this->getIdForItem($item);
  228.                 if ($this->referenceStore) {
  229.                     $this->referenceStore->add($id);
  230.                 }
  232.                 return new ArrayAccessItem($id, $itemData, $item);
  233.             },
  234.             $data
  235.         );
  236.     }
  238.     /**
  239.      * Returns id for given entity.
  240.      *
  241.      * @param object $entity
  242.      *
  243.      * @return int
  244.      */
  245.     protected function getIdForItem($entity)
  246.     {
  247.         return $entity->getId();
  248.     }
  250.     /**
  251.      * Creates serialization context. Can be used to add own groups.
  252.      *
  253.      * @return SerializationContext
  254.      */
  255.     protected function getSerializationContext()
  256.     {
  257.         return SerializationContext::create()->setSerializeNull(true);
  258.     }
  260.     /**
  261.      * Returns additional options for query creation.
  262.      *
  263.      * @param PropertyParameter[] $propertyParameter
  264.      *
  265.      * @return array
  266.      */
  267.     protected function getOptions(
  268.         array $propertyParameter,
  269.         array $options = []
  270.     ) {
  271.         return [];
  272.     }
  274.     /**
  275.      * Decorates result as data item.
  276.      *
  277.      * @return ItemInterface[]
  278.      */
  279.     abstract protected function decorateDataItems(array $data);
  280. }