vendor/shopware/core/Content/Cms/DataResolver/CmsSlotsDataResolver.php line 77

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\Cms\DataResolver;
  5. use Shopware\Core\Content\Cms\Aggregate\CmsSlot\CmsSlotCollection;
  6. use Shopware\Core\Content\Cms\Aggregate\CmsSlot\CmsSlotEntity;
  7. use Shopware\Core\Content\Cms\DataResolver\Element\CmsElementResolverInterface;
  8. use Shopware\Core\Content\Cms\DataResolver\Element\ElementDataCollection;
  9. use Shopware\Core\Content\Cms\DataResolver\ResolverContext\ResolverContext;
  10. use Shopware\Core\Framework\DataAbstractionLayer\DefinitionInstanceRegistry;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Entity;
  12. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  13. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Exception\InconsistentCriteriaIdsException;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Search\EntitySearchResult;
  17. use Shopware\Core\Framework\Log\Package;
  18. use Shopware\Core\Framework\Struct\ArrayEntity;
  19. use Shopware\Core\System\SalesChannel\SalesChannelContext;
  21. #[Package('content')]
  22. class CmsSlotsDataResolver
  23. {
  24.     /**
  25.      * @var CmsElementResolverInterface[]
  26.      */
  27.     private ?array $resolvers = null;
  29.     private ?array $repositories = null;
  31.     /**
  32.      * @internal
  33.      *
  34.      * @param CmsElementResolverInterface[] $resolvers
  35.      */
  36.     public function __construct(
  37.         iterable $resolvers,
  38.         array $repositories,
  39.         private readonly DefinitionInstanceRegistry $definitionRegistry
  40.     ) {
  41.         foreach ($repositories as $entityName => $repository) {
  42.             $this->repositories[$entityName] = $repository;
  43.         }
  45.         foreach ($resolvers as $resolver) {
  46.             $this->resolvers[$resolver->getType()] = $resolver;
  47.         }
  48.     }
  50.     public function resolve(CmsSlotCollection $slots, ResolverContext $resolverContext): CmsSlotCollection
  51.     {
  52.         $slotCriteriaList = [];
  54.         /*
  55.          * Collect criteria objects for each slot from resolver
  56.          *
  57.          * @var CmsSlotEntity
  58.          */
  59.         foreach ($slots as $slot) {
  60.             $resolver = $this->resolvers[$slot->getType()] ?? null;
  61.             if (!$resolver) {
  62.                 continue;
  63.             }
  65.             $collection = $resolver->collect($slot, $resolverContext);
  66.             if ($collection === null) {
  67.                 continue;
  68.             }
  70.             $slotCriteriaList[$slot->getUniqueIdentifier()] = $collection;
  71.         }
  73.         // reduce search requests by combining mergeable criteria objects
  74.         [$directReads, $searches] = $this->optimizeCriteriaObjects($slotCriteriaList);
  76.         // fetch data from storage
  77.         $entities = $this->fetchByIdentifier($directReads, $resolverContext->getSalesChannelContext());
  78.         $searchResults = $this->fetchByCriteria($searches, $resolverContext->getSalesChannelContext());
  80.         // create result for each slot with the requested data
  81.         foreach ($slots as $slotId => $slot) {
  82.             $resolver = $this->resolvers[$slot->getType()] ?? null;
  83.             if (!$resolver) {
  84.                 continue;
  85.             }
  87.             $result = new ElementDataCollection();
  89.             $this->mapSearchResults($result, $slot, $slotCriteriaList, $searchResults);
  90.             $this->mapEntities($result, $slot, $slotCriteriaList, $entities);
  92.             $resolver->enrich($slot, $resolverContext, $result);
  94.             // replace with return value from enrich(), because it's allowed to change the entity type
  95.             $slots->set($slotId, $slot);
  96.         }
  98.         return $slots;
  99.     }
  101.     /**
  102.      * @param string[][] $directReads
  103.      *
  104.      * @throws InconsistentCriteriaIdsException
  105.      *
  106.      * @return EntitySearchResult[]
  107.      */
  108.     private function fetchByIdentifier(array $directReads, SalesChannelContext $context): array
  109.     {
  110.         $entities = [];
  112.         foreach ($directReads as $definitionClass => $ids) {
  113.             $definition = $this->definitionRegistry->get($definitionClass);
  115.             $repository = $this->getSalesChannelApiRepository($definition);
  117.             if ($repository) {
  118.                 $entities[$definitionClass] = $repository->search(new Criteria($ids), $context);
  119.             } else {
  120.                 $repository = $this->getApiRepository($definition);
  121.                 $entities[$definitionClass] = $repository->search(new Criteria($ids), $context->getContext());
  122.             }
  123.         }
  125.         return $entities;
  126.     }
  128.     private function fetchByCriteria(array $searches, SalesChannelContext $context): array
  129.     {
  130.         $searchResults = [];
  132.         /** @var Criteria[] $criteriaObjects */
  133.         foreach ($searches as $definitionClass => $criteriaObjects) {
  134.             foreach ($criteriaObjects as $criteriaHash => $criteria) {
  135.                 $definition = $this->definitionRegistry->get($definitionClass);
  137.                 $repository = $this->getSalesChannelApiRepository($definition);
  139.                 if ($repository) {
  140.                     $result = $repository->search($criteria, $context);
  141.                 } else {
  142.                     $repository = $this->getApiRepository($definition);
  143.                     $result = $repository->search($criteria, $context->getContext());
  144.                 }
  146.                 $searchResults[$criteriaHash] = $result;
  147.             }
  148.         }
  150.         return $searchResults;
  151.     }
  153.     /**
  154.      * @param CriteriaCollection[] $criteriaCollections
  155.      */
  156.     private function optimizeCriteriaObjects(array $criteriaCollections): array
  157.     {
  158.         $directReads = [];
  159.         $searches = [];
  161.         $criteriaCollection = $this->flattenCriteriaCollections($criteriaCollections);
  163.         foreach ($criteriaCollection as $definition => $criteriaObjects) {
  164.             $directReads[$definition] = [[]];
  165.             $searches[$definition] = [];
  167.             /** @var Criteria $criteria */
  168.             foreach ($criteriaObjects as $criteria) {
  169.                 if ($this->canBeMerged($criteria)) {
  170.                     $directReads[$definition][] = $criteria->getIds();
  171.                 } else {
  172.                     $criteriaHash = $this->hash($criteria);
  173.                     $criteria->addExtension('criteriaHash', new ArrayEntity(['hash' => $criteriaHash]));
  174.                     $searches[$definition][$criteriaHash] = $criteria;
  175.                 }
  176.             }
  177.         }
  179.         foreach ($directReads as $definition => $idLists) {
  180.             $directReads[$definition] = array_merge(...$idLists);
  181.         }
  183.         return [
  184.             array_filter($directReads),
  185.             array_filter($searches),
  186.         ];
  187.     }
  189.     private function canBeMerged(Criteria $criteria): bool
  190.     {
  191.         //paginated lists must be an own search
  192.         if ($criteria->getOffset() !== null || $criteria->getLimit() !== null) {
  193.             return false;
  194.         }
  196.         //sortings must be an own search
  197.         if (\count($criteria->getSorting())) {
  198.             return false;
  199.         }
  201.         //queries must be an own search
  202.         if (\count($criteria->getQueries())) {
  203.             return false;
  204.         }
  206.         if ($criteria->getAssociations()) {
  207.             return false;
  208.         }
  210.         if ($criteria->getAggregations()) {
  211.             return false;
  212.         }
  214.         $filters = array_merge(
  215.             $criteria->getFilters(),
  216.             $criteria->getPostFilters()
  217.         );
  219.         // any kind of filters must be an own search
  220.         if (!empty($filters)) {
  221.             return false;
  222.         }
  224.         if (empty($criteria->getIds())) {
  225.             return false;
  226.         }
  228.         return true;
  229.     }
  231.     private function getApiRepository(EntityDefinition $definition): EntityRepository
  232.     {
  233.         return $this->definitionRegistry->getRepository($definition->getEntityName());
  234.     }
  236.     /**
  237.      * @return mixed|null
  238.      */
  239.     private function getSalesChannelApiRepository(EntityDefinition $definition)
  240.     {
  241.         return $this->repositories[$definition->getEntityName()] ?? null;
  242.     }
  244.     private function flattenCriteriaCollections(array $criteriaCollections): array
  245.     {
  246.         $flattened = [];
  248.         $criteriaCollections = array_values($criteriaCollections);
  250.         foreach ($criteriaCollections as $collections) {
  251.             foreach ($collections as $definition => $criteriaObjects) {
  252.                 $flattened[$definition] = array_merge($flattened[$definition] ?? [], array_values($criteriaObjects));
  253.             }
  254.         }
  256.         return $flattened;
  257.     }
  259.     /**
  260.      * @param CriteriaCollection[] $criteriaObjects
  261.      * @param EntitySearchResult[] $searchResults
  262.      */
  263.     private function mapSearchResults(ElementDataCollection $result, CmsSlotEntity $slot, array $criteriaObjects, array $searchResults): void
  264.     {
  265.         if (!isset($criteriaObjects[$slot->getUniqueIdentifier()])) {
  266.             return;
  267.         }
  269.         foreach ($criteriaObjects[$slot->getUniqueIdentifier()] as $criterias) {
  270.             foreach ($criterias as $key => $criteria) {
  271.                 if (!$criteria->hasExtension('criteriaHash')) {
  272.                     continue;
  273.                 }
  275.                 /** @var ArrayEntity $hashArrayEntity */
  276.                 $hashArrayEntity = $criteria->getExtension('criteriaHash');
  277.                 $hash = $hashArrayEntity->get('hash');
  278.                 if (!isset($searchResults[$hash])) {
  279.                     continue;
  280.                 }
  282.                 $result->add($key, $searchResults[$hash]);
  283.             }
  284.         }
  285.     }
  287.     /**
  288.      * @param CriteriaCollection[] $criteriaObjects
  289.      * @param EntitySearchResult[] $entities
  290.      */
  291.     private function mapEntities(ElementDataCollection $result, CmsSlotEntity $slot, array $criteriaObjects, array $entities): void
  292.     {
  293.         if (!isset($criteriaObjects[$slot->getUniqueIdentifier()])) {
  294.             return;
  295.         }
  297.         foreach ($criteriaObjects[$slot->getUniqueIdentifier()] as $definition => $criterias) {
  298.             foreach ($criterias as $key => $criteria) {
  299.                 if (!$this->canBeMerged($criteria)) {
  300.                     continue;
  301.                 }
  303.                 if (!isset($entities[$definition])) {
  304.                     continue;
  305.                 }
  307.                 $ids = $criteria->getIds();
  308.                 $filtered = $entities[$definition]->filter(fn (Entity $entity) => \in_array($entity->getUniqueIdentifier(), $ids, true));
  310.                 $result->add($key, $filtered);
  311.             }
  312.         }
  313.     }
  315.     private function hash(Criteria $criteria): string
  316.     {
  317.         return md5(serialize($criteria));
  318.     }
  319. }