src/Core/Content/Cms/DataResolver/CmsSlotsDataResolver.php line 118

  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(iterable $resolvers, array $repositories, private readonly DefinitionInstanceRegistry $definitionRegistry)
  37.     {
  38.         foreach ($repositories as $entityName => $repository) {
  39.             $this->repositories[$entityName] = $repository;
  40.         }
  42.         foreach ($resolvers as $resolver) {
  43.             $this->resolvers[$resolver->getType()] = $resolver;
  44.         }
  45.     }
  47.     public function resolve(CmsSlotCollection $slots, ResolverContext $resolverContext): CmsSlotCollection
  48.     {
  49.         $slotCriteriaList = [];
  51.         /*
  52.          * Collect criteria objects for each slot from resolver
  53.          *
  54.          * @var CmsSlotEntity
  55.          */
  56.         foreach ($slots as $slot) {
  57.             $resolver = $this->resolvers[$slot->getType()] ?? null;
  58.             if (!$resolver) {
  59.                 continue;
  60.             }
  62.             $collection = $resolver->collect($slot, $resolverContext);
  63.             if ($collection === null) {
  64.                 continue;
  65.             }
  67.             $slotCriteriaList[$slot->getUniqueIdentifier()] = $collection;
  68.         }
  70.         // reduce search requests by combining mergeable criteria objects
  71.         [$directReads, $searches] = $this->optimizeCriteriaObjects($slotCriteriaList);
  73.         // fetch data from storage
  74.         $entities = $this->fetchByIdentifier($directReads, $resolverContext->getSalesChannelContext());
  75.         $searchResults = $this->fetchByCriteria($searches, $resolverContext->getSalesChannelContext());
  77.         // create result for each slot with the requested data
  78.         foreach ($slots as $slotId => $slot) {
  79.             $resolver = $this->resolvers[$slot->getType()] ?? null;
  80.             if (!$resolver) {
  81.                 continue;
  82.             }
  84.             $result = new ElementDataCollection();
  86.             $this->mapSearchResults($result, $slot, $slotCriteriaList, $searchResults);
  87.             $this->mapEntities($result, $slot, $slotCriteriaList, $entities);
  89.             $resolver->enrich($slot, $resolverContext, $result);
  91.             // replace with return value from enrich(), because it's allowed to change the entity type
  92.             $slots->set($slotId, $slot);
  93.         }
  95.         return $slots;
  96.     }
  98.     /**
  99.      * @param string[][] $directReads
  100.      *
  101.      * @throws InconsistentCriteriaIdsException
  102.      *
  103.      * @return EntitySearchResult[]
  104.      */
  105.     private function fetchByIdentifier(array $directReads, SalesChannelContext $context): array
  106.     {
  107.         $entities = [];
  109.         foreach ($directReads as $definitionClass => $ids) {
  110.             $definition = $this->definitionRegistry->get($definitionClass);
  112.             $repository = $this->getSalesChannelApiRepository($definition);
  114.             if ($repository) {
  115.                 $entities[$definitionClass] = $repository->search(new Criteria($ids), $context);
  116.             } else {
  117.                 $repository = $this->getApiRepository($definition);
  118.                 $entities[$definitionClass] = $repository->search(new Criteria($ids), $context->getContext());
  119.             }
  120.         }
  122.         return $entities;
  123.     }
  125.     private function fetchByCriteria(array $searches, SalesChannelContext $context): array
  126.     {
  127.         $searchResults = [];
  129.         /** @var Criteria[] $criteriaObjects */
  130.         foreach ($searches as $definitionClass => $criteriaObjects) {
  131.             foreach ($criteriaObjects as $criteriaHash => $criteria) {
  132.                 $definition = $this->definitionRegistry->get($definitionClass);
  134.                 $repository = $this->getSalesChannelApiRepository($definition);
  136.                 if ($repository) {
  137.                     $result = $repository->search($criteria, $context);
  138.                 } else {
  139.                     $repository = $this->getApiRepository($definition);
  140.                     $result = $repository->search($criteria, $context->getContext());
  141.                 }
  143.                 $searchResults[$criteriaHash] = $result;
  144.             }
  145.         }
  147.         return $searchResults;
  148.     }
  150.     /**
  151.      * @param CriteriaCollection[] $criteriaCollections
  152.      */
  153.     private function optimizeCriteriaObjects(array $criteriaCollections): array
  154.     {
  155.         $directReads = [];
  156.         $searches = [];
  158.         $criteriaCollection = $this->flattenCriteriaCollections($criteriaCollections);
  160.         foreach ($criteriaCollection as $definition => $criteriaObjects) {
  161.             $directReads[$definition] = [[]];
  162.             $searches[$definition] = [];
  164.             /** @var Criteria $criteria */
  165.             foreach ($criteriaObjects as $criteria) {
  166.                 if ($this->canBeMerged($criteria)) {
  167.                     $directReads[$definition][] = $criteria->getIds();
  168.                 } else {
  169.                     $criteriaHash = $this->hash($criteria);
  170.                     $criteria->addExtension('criteriaHash', new ArrayEntity(['hash' => $criteriaHash]));
  171.                     $searches[$definition][$criteriaHash] = $criteria;
  172.                 }
  173.             }
  174.         }
  176.         foreach ($directReads as $definition => $idLists) {
  177.             $directReads[$definition] = array_merge(...$idLists);
  178.         }
  180.         return [
  181.             array_filter($directReads),
  182.             array_filter($searches),
  183.         ];
  184.     }
  186.     private function canBeMerged(Criteria $criteria): bool
  187.     {
  188.         //paginated lists must be an own search
  189.         if ($criteria->getOffset() !== null || $criteria->getLimit() !== null) {
  190.             return false;
  191.         }
  193.         //sortings must be an own search
  194.         if (\count($criteria->getSorting())) {
  195.             return false;
  196.         }
  198.         //queries must be an own search
  199.         if (\count($criteria->getQueries())) {
  200.             return false;
  201.         }
  203.         if ($criteria->getAssociations()) {
  204.             return false;
  205.         }
  207.         if ($criteria->getAggregations()) {
  208.             return false;
  209.         }
  211.         $filters = array_merge(
  212.             $criteria->getFilters(),
  213.             $criteria->getPostFilters()
  214.         );
  216.         // any kind of filters must be an own search
  217.         if (!empty($filters)) {
  218.             return false;
  219.         }
  221.         if (empty($criteria->getIds())) {
  222.             return false;
  223.         }
  225.         return true;
  226.     }
  228.     private function getApiRepository(EntityDefinition $definition): EntityRepository
  229.     {
  230.         return $this->definitionRegistry->getRepository($definition->getEntityName());
  231.     }
  233.     /**
  234.      * @return mixed|null
  235.      */
  236.     private function getSalesChannelApiRepository(EntityDefinition $definition)
  237.     {
  238.         return $this->repositories[$definition->getEntityName()] ?? null;
  239.     }
  241.     private function flattenCriteriaCollections(array $criteriaCollections): array
  242.     {
  243.         $flattened = [];
  245.         $criteriaCollections = array_values($criteriaCollections);
  247.         foreach ($criteriaCollections as $collections) {
  248.             foreach ($collections as $definition => $criteriaObjects) {
  249.                 $flattened[$definition] = array_merge($flattened[$definition] ?? [], array_values($criteriaObjects));
  250.             }
  251.         }
  253.         return $flattened;
  254.     }
  256.     /**
  257.      * @param CriteriaCollection[] $criteriaObjects
  258.      * @param EntitySearchResult[] $searchResults
  259.      */
  260.     private function mapSearchResults(ElementDataCollection $result, CmsSlotEntity $slot, array $criteriaObjects, array $searchResults): void
  261.     {
  262.         if (!isset($criteriaObjects[$slot->getUniqueIdentifier()])) {
  263.             return;
  264.         }
  266.         foreach ($criteriaObjects[$slot->getUniqueIdentifier()] as $criterias) {
  267.             foreach ($criterias as $key => $criteria) {
  268.                 if (!$criteria->hasExtension('criteriaHash')) {
  269.                     continue;
  270.                 }
  272.                 /** @var ArrayEntity $hashArrayEntity */
  273.                 $hashArrayEntity = $criteria->getExtension('criteriaHash');
  274.                 $hash = $hashArrayEntity->get('hash');
  275.                 if (!isset($searchResults[$hash])) {
  276.                     continue;
  277.                 }
  279.                 $result->add($key, $searchResults[$hash]);
  280.             }
  281.         }
  282.     }
  284.     /**
  285.      * @param CriteriaCollection[] $criteriaObjects
  286.      * @param EntitySearchResult[] $entities
  287.      */
  288.     private function mapEntities(ElementDataCollection $result, CmsSlotEntity $slot, array $criteriaObjects, array $entities): void
  289.     {
  290.         if (!isset($criteriaObjects[$slot->getUniqueIdentifier()])) {
  291.             return;
  292.         }
  294.         foreach ($criteriaObjects[$slot->getUniqueIdentifier()] as $definition => $criterias) {
  295.             foreach ($criterias as $key => $criteria) {
  296.                 if (!$this->canBeMerged($criteria)) {
  297.                     continue;
  298.                 }
  300.                 if (!isset($entities[$definition])) {
  301.                     continue;
  302.                 }
  304.                 $ids = $criteria->getIds();
  305.                 $filtered = $entities[$definition]->filter(fn (Entity $entity) => \in_array($entity->getUniqueIdentifier(), $ids, true));
  307.                 $result->add($key, $filtered);
  308.             }
  309.         }
  310.     }
  312.     private function hash(Criteria $criteria): string
  313.     {
  314.         return md5(serialize($criteria));
  315.     }
  316. }