vendor/shopware/core/Framework/DataAbstractionLayer/EntityRepository.php line 247

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer;
  5. use Shopware\Core\Framework\Adapter\Database\ReplicaConnection;
  6. use Shopware\Core\Framework\Context;
  7. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityAggregationResultLoadedEvent;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityIdSearchResultLoadedEvent;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityLoadedEventFactory;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntitySearchedEvent;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntitySearchResultLoadedEvent;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityWrittenContainerEvent;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Read\EntityReaderInterface;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\AggregationResultCollection;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Search\EntityAggregatorInterface;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Search\EntitySearcherInterface;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Search\EntitySearchResult;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Search\IdSearchResult;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Write\CloneBehavior;
  21. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteContext;
  22. use Shopware\Core\Framework\Log\Package;
  23. use Shopware\Core\Framework\Struct\ArrayEntity;
  24. use Shopware\Core\Framework\Uuid\Exception\InvalidUuidException;
  25. use Shopware\Core\Framework\Uuid\Uuid;
  26. use Shopware\Core\Profiling\Profiler;
  27. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  29. /**
  30.  * @final
  31.  */
  32. #[Package('core')]
  33. class EntityRepository
  34. {
  35.     /**
  36.      * @internal
  37.      */
  38.     public function __construct(
  39.         private readonly EntityDefinition $definition,
  40.         private readonly EntityReaderInterface $reader,
  41.         private readonly VersionManager $versionManager,
  42.         private readonly EntitySearcherInterface $searcher,
  43.         private readonly EntityAggregatorInterface $aggregator,
  44.         private readonly EventDispatcherInterface $eventDispatcher,
  45.         private readonly EntityLoadedEventFactory $eventFactory
  46.     ) {
  47.     }
  49.     public function getDefinition(): EntityDefinition
  50.     {
  51.         return $this->definition;
  52.     }
  54.     public function search(Criteria $criteria, Context $context): EntitySearchResult
  55.     {
  56.         if (!$criteria->getTitle()) {
  57.             return $this->_search($criteria, $context);
  58.         }
  60.         return Profiler::trace($criteria->getTitle(), fn () => $this->_search($criteria, $context), 'repository');
  61.     }
  63.     public function aggregate(Criteria $criteria, Context $context): AggregationResultCollection
  64.     {
  65.         $criteria = clone $criteria;
  67.         $result = $this->aggregator->aggregate($this->definition, $criteria, $context);
  69.         $event = new EntityAggregationResultLoadedEvent($this->definition, $result, $context);
  70.         $this->eventDispatcher->dispatch($event, $event->getName());
  72.         return $result;
  73.     }
  75.     public function searchIds(Criteria $criteria, Context $context): IdSearchResult
  76.     {
  77.         $criteria = clone $criteria;
  79.         $this->eventDispatcher->dispatch(new EntitySearchedEvent($criteria, $this->definition, $context));
  81.         $result = $this->searcher->search($this->definition, $criteria, $context);
  83.         $event = new EntityIdSearchResultLoadedEvent($this->definition, $result);
  84.         $this->eventDispatcher->dispatch($event, $event->getName());
  86.         return $result;
  87.     }
  89.     /**
  90.      * @param array<array<string, mixed|null>> $data
  91.      */
  92.     public function update(array $data, Context $context): EntityWrittenContainerEvent
  93.     {
  94.         ReplicaConnection::ensurePrimary();
  96.         $affected = $this->versionManager->update($this->definition, $data, WriteContext::createFromContext($context));
  97.         $event = EntityWrittenContainerEvent::createWithWrittenEvents($affected, $context, []);
  98.         $this->eventDispatcher->dispatch($event);
  100.         return $event;
  101.     }
  103.     /**
  104.      * @param array<array<string, mixed|null>> $data
  105.      */
  106.     public function upsert(array $data, Context $context): EntityWrittenContainerEvent
  107.     {
  108.         ReplicaConnection::ensurePrimary();
  110.         $affected = $this->versionManager->upsert($this->definition, $data, WriteContext::createFromContext($context));
  111.         $event = EntityWrittenContainerEvent::createWithWrittenEvents($affected, $context, []);
  112.         $this->eventDispatcher->dispatch($event);
  114.         return $event;
  115.     }
  117.     /**
  118.      * @param array<array<string, mixed|null>> $data
  119.      */
  120.     public function create(array $data, Context $context): EntityWrittenContainerEvent
  121.     {
  122.         ReplicaConnection::ensurePrimary();
  124.         $affected = $this->versionManager->insert($this->definition, $data, WriteContext::createFromContext($context));
  125.         $event = EntityWrittenContainerEvent::createWithWrittenEvents($affected, $context, []);
  126.         $this->eventDispatcher->dispatch($event);
  128.         return $event;
  129.     }
  131.     /**
  132.      * @param array<array<string, mixed|null>> $ids
  133.      */
  134.     public function delete(array $ids, Context $context): EntityWrittenContainerEvent
  135.     {
  136.         ReplicaConnection::ensurePrimary();
  138.         $affected = $this->versionManager->delete($this->definition, $ids, WriteContext::createFromContext($context));
  139.         $event = EntityWrittenContainerEvent::createWithDeletedEvents($affected->getDeleted(), $context, $affected->getNotFound());
  141.         if ($affected->getWritten()) {
  142.             $updates = EntityWrittenContainerEvent::createWithWrittenEvents($affected->getWritten(), $context, []);
  144.             if ($updates->getEvents() !== null) {
  145.                 $event->addEvent(...$updates->getEvents());
  146.             }
  147.         }
  149.         $this->eventDispatcher->dispatch($event);
  151.         return $event;
  152.     }
  154.     public function createVersion(string $id, Context $context, ?string $name = null, ?string $versionId = null): string
  155.     {
  156.         ReplicaConnection::ensurePrimary();
  158.         if (!$this->definition->isVersionAware()) {
  159.             throw new \RuntimeException(sprintf('Entity %s is not version aware', $this->definition->getEntityName()));
  160.         }
  162.         return $this->versionManager->createVersion($this->definition, $id, WriteContext::createFromContext($context), $name, $versionId);
  163.     }
  165.     public function merge(string $versionId, Context $context): void
  166.     {
  167.         ReplicaConnection::ensurePrimary();
  169.         if (!$this->definition->isVersionAware()) {
  170.             throw new \RuntimeException(sprintf('Entity %s is not version aware', $this->definition->getEntityName()));
  171.         }
  172.         $this->versionManager->merge($versionId, WriteContext::createFromContext($context));
  173.     }
  175.     public function clone(string $id, Context $context, ?string $newId = null, ?CloneBehavior $behavior = null): EntityWrittenContainerEvent
  176.     {
  177.         ReplicaConnection::ensurePrimary();
  179.         $newId ??= Uuid::randomHex();
  180.         if (!Uuid::isValid($newId)) {
  181.             throw new InvalidUuidException($newId);
  182.         }
  184.         $affected = $this->versionManager->clone(
  185.             $this->definition,
  186.             $id,
  187.             $newId,
  188.             $context->getVersionId(),
  189.             WriteContext::createFromContext($context),
  190.             $behavior ?? new CloneBehavior()
  191.         );
  193.         $event = EntityWrittenContainerEvent::createWithWrittenEvents($affected, $context, [], true);
  194.         $this->eventDispatcher->dispatch($event);
  196.         return $event;
  197.     }
  199.     /**
  200.      * @return EntityCollection<Entity>
  201.      */
  202.     private function read(Criteria $criteria, Context $context): EntityCollection
  203.     {
  204.         $criteria = clone $criteria;
  206.         $entities = $this->reader->read($this->definition, $criteria, $context);
  208.         if ($criteria->getFields() === []) {
  209.             $event = $this->eventFactory->create($entities->getElements(), $context);
  210.         } else {
  211.             $event = $this->eventFactory->createPartial($entities->getElements(), $context);
  212.         }
  214.         $this->eventDispatcher->dispatch($event);
  216.         return $entities;
  217.     }
  219.     private function _search(Criteria $criteria, Context $context): EntitySearchResult
  220.     {
  221.         $criteria = clone $criteria;
  222.         $aggregations = null;
  223.         if ($criteria->getAggregations()) {
  224.             $aggregations = $this->aggregate($criteria, $context);
  225.         }
  227.         if (!RepositorySearchDetector::isSearchRequired($this->definition, $criteria)) {
  228.             $this->eventDispatcher->dispatch(
  229.                 new EntitySearchedEvent($criteria, $this->definition, $context)
  230.             );
  231.             $entities = $this->read($criteria, $context);
  233.             return new EntitySearchResult($this->definition->getEntityName(), $entities->count(), $entities, $aggregations, $criteria, $context);
  234.         }
  236.         $ids = $this->searchIds($criteria, $context);
  238.         if (empty($ids->getIds())) {
  239.             /** @var EntityCollection<Entity> $collection */
  240.             $collection = $this->definition->getCollectionClass();
  242.             return new EntitySearchResult($this->definition->getEntityName(), $ids->getTotal(), new $collection(), $aggregations, $criteria, $context);
  243.         }
  245.         $readCriteria = $criteria->cloneForRead($ids->getIds());
  247.         $entities = $this->read($readCriteria, $context);
  249.         $search = $ids->getData();
  251.         /** @var Entity $element */
  252.         foreach ($entities as $element) {
  253.             if (!\array_key_exists($element->getUniqueIdentifier(), $search)) {
  254.                 continue;
  255.             }
  257.             $data = $search[$element->getUniqueIdentifier()];
  258.             unset($data['id']);
  260.             if (empty($data)) {
  261.                 continue;
  262.             }
  264.             $element->addExtension('search', new ArrayEntity($data));
  265.         }
  267.         $result = new EntitySearchResult($this->definition->getEntityName(), $ids->getTotal(), $entities, $aggregations, $criteria, $context);
  268.         $result->addState(...$ids->getStates());
  270.         $event = new EntitySearchResultLoadedEvent($this->definition, $result);
  271.         $this->eventDispatcher->dispatch($event, $event->getName());
  273.         return $result;
  274.     }
  275. }