src/Core/Content/Rule/DataAbstractionLayer/RuleAreaUpdater.php line 79

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\Rule\DataAbstractionLayer;
  5. use Doctrine\DBAL\Connection;
  6. use Shopware\Core\Checkout\Cart\CachedRuleLoader;
  7. use Shopware\Core\Content\Rule\RuleDefinition;
  8. use Shopware\Core\Framework\Adapter\Cache\CacheInvalidator;
  9. use Shopware\Core\Framework\DataAbstractionLayer\CompiledFieldCollection;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\EntityDefinitionQueryHelper;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\QueryBuilder;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\FetchModeHelper;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\RetryableQuery;
  14. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityWrittenContainerEvent;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityWrittenEvent;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Field\AssociationField;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Field\FkField;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\RuleAreas;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToManyAssociationField;
  21. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToOneAssociationField;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Field\OneToManyAssociationField;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Field\OneToOneAssociationField;
  24. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\ChangeSetAware;
  25. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\DeleteCommand;
  26. use Shopware\Core\Framework\DataAbstractionLayer\Write\Validation\PreWriteValidationEvent;
  27. use Shopware\Core\Framework\Log\Package;
  28. use Shopware\Core\Framework\Rule\Collector\RuleConditionRegistry;
  29. use Shopware\Core\Framework\Uuid\Uuid;
  30. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  32. /**
  33.  * @internal
  34.  */
  35. #[Package('business-ops')]
  36. class RuleAreaUpdater implements EventSubscriberInterface
  37. {
  38.     /**
  39.      * @internal
  40.      */
  41.     public function __construct(private readonly Connection $connection, private readonly RuleDefinition $definition, private readonly RuleConditionRegistry $conditionRegistry, private readonly CacheInvalidator $cacheInvalidator)
  42.     {
  43.     }
  45.     public static function getSubscribedEvents(): array
  46.     {
  47.         return [
  48.             PreWriteValidationEvent::class => 'triggerChangeSet',
  49.             EntityWrittenContainerEvent::class => 'onEntityWritten',
  50.         ];
  51.     }
  53.     public function triggerChangeSet(PreWriteValidationEvent $event): void
  54.     {
  55.         $associatedEntities = $this->getAssociationEntities();
  57.         foreach ($event->getCommands() as $command) {
  58.             $definition = $command->getDefinition();
  59.             $entity = $definition->getEntityName();
  61.             if (!$command instanceof ChangeSetAware || !\in_array($entity, $associatedEntities, true)) {
  62.                 continue;
  63.             }
  65.             if ($command instanceof DeleteCommand) {
  66.                 $command->requestChangeSet();
  68.                 continue;
  69.             }
  71.             foreach ($this->getForeignKeyFields($definition) as $field) {
  72.                 if ($command->hasField($field->getStorageName())) {
  73.                     $command->requestChangeSet();
  74.                 }
  75.             }
  76.         }
  77.     }
  79.     public function onEntityWritten(EntityWrittenContainerEvent $event): void
  80.     {
  81.         $associationFields = $this->getAssociationFields();
  82.         $ruleIds = [];
  84.         foreach ($event->getEvents() ?? [] as $nestedEvent) {
  85.             if (!$nestedEvent instanceof EntityWrittenEvent) {
  86.                 continue;
  87.             }
  89.             $definition = $this->getAssociationDefinitionByEntity($associationFields, $nestedEvent->getEntityName());
  91.             if (!$definition) {
  92.                 continue;
  93.             }
  95.             $ruleIds = $this->hydrateRuleIds($this->getForeignKeyFields($definition), $nestedEvent, $ruleIds);
  96.         }
  98.         if (empty($ruleIds)) {
  99.             return;
  100.         }
  102.         $this->update(Uuid::fromBytesToHexList(array_unique(array_filter($ruleIds))));
  104.         $this->cacheInvalidator->invalidate([CachedRuleLoader::CACHE_KEY]);
  105.     }
  107.     /**
  108.      * @param list<string> $ids
  109.      */
  110.     public function update(array $ids): void
  111.     {
  112.         $associationFields = $this->getAssociationFields();
  114.         $areas = $this->getAreas($ids, $associationFields);
  116.         $update = new RetryableQuery(
  117.             $this->connection,
  118.             $this->connection->prepare('UPDATE `rule` SET `areas` = :areas WHERE `id` = :id')
  119.         );
  121.         /** @var array<string, string[]> $associations */
  122.         foreach ($areas as $id => $associations) {
  123.             $areas = [];
  125.             foreach ($associations as $propertyName => $match) {
  126.                 if ((bool) $match === false) {
  127.                     continue;
  128.                 }
  130.                 if ($propertyName === 'flowCondition') {
  131.                     $areas = array_unique(array_merge($areas, [RuleAreas::FLOW_CONDITION_AREA]));
  133.                     continue;
  134.                 }
  136.                 $field = $associationFields->get($propertyName);
  138.                 if (!$field || !$flag = $field->getFlag(RuleAreas::class)) {
  139.                     continue;
  140.                 }
  142.                 $areas = array_unique(array_merge($areas, $flag instanceof RuleAreas ? $flag->getAreas() : []));
  143.             }
  145.             $update->execute([
  146.                 'areas' => json_encode(array_values($areas), \JSON_THROW_ON_ERROR),
  147.                 'id' => Uuid::fromHexToBytes($id),
  148.             ]);
  149.         }
  150.     }
  152.     /**
  153.      * @param FkField[] $fields
  154.      * @param string[] $ruleIds
  155.      *
  156.      * @return string[]
  157.      */
  158.     private function hydrateRuleIds(array $fields, EntityWrittenEvent $nestedEvent, array $ruleIds): array
  159.     {
  160.         foreach ($nestedEvent->getWriteResults() as $result) {
  161.             $changeSet = $result->getChangeSet();
  162.             $payload = $result->getPayload();
  164.             foreach ($fields as $field) {
  165.                 if ($changeSet && $changeSet->hasChanged($field->getStorageName())) {
  166.                     $ruleIds[] = $changeSet->getBefore($field->getStorageName());
  167.                     $ruleIds[] = $changeSet->getAfter($field->getStorageName());
  168.                 }
  170.                 if ($changeSet) {
  171.                     continue;
  172.                 }
  174.                 if (!empty($payload[$field->getPropertyName()])) {
  175.                     $ruleIds[] = Uuid::fromHexToBytes($payload[$field->getPropertyName()]);
  176.                 }
  177.             }
  178.         }
  180.         return $ruleIds;
  181.     }
  183.     /**
  184.      * @param list<string> $ids
  185.      *
  186.      * @return array<string, string[][]>
  187.      */
  188.     private function getAreas(array $ids, CompiledFieldCollection $associationFields): array
  189.     {
  190.         $query = new QueryBuilder($this->connection);
  191.         $query->select('LOWER(HEX(`rule`.`id`)) AS array_key')
  192.             ->from('rule')
  193.             ->andWhere('`rule`.`id` IN (:ids)');
  195.         /** @var AssociationField $associationField */
  196.         foreach ($associationFields->getElements() as $associationField) {
  197.             $this->addSelect($query, $associationField);
  198.         }
  199.         $this->addFlowConditionSelect($query);
  201.         $query->setParameter(
  202.             'ids',
  203.             Uuid::fromHexToBytesList($ids),
  204.             Connection::PARAM_STR_ARRAY
  205.         )->setParameter(
  206.             'flowTypes',
  207.             $this->conditionRegistry->getFlowRuleNames(),
  208.             Connection::PARAM_STR_ARRAY
  209.         );
  211.         return FetchModeHelper::groupUnique($query->executeQuery()->fetchAllAssociative());
  212.     }
  214.     private function addSelect(QueryBuilder $query, AssociationField $associationField): void
  215.     {
  216.         $template = 'EXISTS(%s) AS %s';
  217.         $propertyName = $associationField->getPropertyName();
  219.         if ($associationField instanceof OneToOneAssociationField || $associationField instanceof ManyToOneAssociationField) {
  220.             $template = 'IF(%s.%s IS NOT NULL, 1, 0) AS %s';
  221.             $query->addSelect(sprintf($template, '`rule`', $this->escape($associationField->getStorageName()), $propertyName));
  223.             return;
  224.         }
  226.         if ($associationField instanceof ManyToManyAssociationField) {
  227.             $mappingTable = $this->escape($associationField->getMappingDefinition()->getEntityName());
  228.             $mappingLocalColumn = $this->escape($associationField->getMappingLocalColumn());
  229.             $localColumn = $this->escape($associationField->getLocalField());
  231.             $subQuery = (new QueryBuilder($this->connection))
  232.                 ->select('1')
  233.                 ->from($mappingTable)
  234.                 ->andWhere(sprintf('%s = `rule`.%s', $mappingLocalColumn, $localColumn));
  236.             $query->addSelect(sprintf($template, $subQuery->getSQL(), $propertyName));
  238.             return;
  239.         }
  241.         if ($associationField instanceof OneToManyAssociationField) {
  242.             $referenceTable = $this->escape($associationField->getReferenceDefinition()->getEntityName());
  243.             $referenceColumn = $this->escape($associationField->getReferenceField());
  244.             $localColumn = $this->escape($associationField->getLocalField());
  246.             $subQuery = (new QueryBuilder($this->connection))
  247.                 ->select('1')
  248.                 ->from($referenceTable)
  249.                 ->andWhere(sprintf('%s = `rule`.%s', $referenceColumn, $localColumn));
  251.             $query->addSelect(sprintf($template, $subQuery->getSQL(), $propertyName));
  252.         }
  253.     }
  255.     private function addFlowConditionSelect(QueryBuilder $query): void
  256.     {
  257.         $subQuery = (new QueryBuilder($this->connection))
  258.             ->select('1')
  259.             ->from('rule_condition')
  260.             ->andWhere('`rule_id` = `rule`.`id`')
  261.             ->andWhere('`type` IN (:flowTypes)');
  263.         $query->addSelect(sprintf('EXISTS(%s) AS flowCondition', $subQuery->getSQL()));
  264.     }
  266.     private function escape(string $string): string
  267.     {
  268.         return EntityDefinitionQueryHelper::escape($string);
  269.     }
  271.     private function getAssociationFields(): CompiledFieldCollection
  272.     {
  273.         return $this->definition
  274.             ->getFields()
  275.             ->filterByFlag(RuleAreas::class);
  276.     }
  278.     /**
  279.      * @return FkField[]
  280.      */
  281.     private function getForeignKeyFields(EntityDefinition $definition): array
  282.     {
  283.         /** @var FkField[] $fields */
  284.         $fields = $definition->getFields()->filterInstance(FkField::class)->filter(fn (FkField $fk): bool => $fk->getReferenceDefinition()->getEntityName() === $this->definition->getEntityName())->getElements();
  286.         return $fields;
  287.     }
  289.     /**
  290.      * @return string[]
  291.      */
  292.     private function getAssociationEntities(): array
  293.     {
  294.         return $this->getAssociationFields()->filter(fn (AssociationField $associationField): bool => $associationField instanceof OneToManyAssociationField)->map(fn (AssociationField $field): string => $field->getReferenceDefinition()->getEntityName());
  295.     }
  297.     private function getAssociationDefinitionByEntity(CompiledFieldCollection $collection, string $entityName): ?EntityDefinition
  298.     {
  299.         /** @var AssociationField|null $field */
  300.         $field = $collection->filter(function (AssociationField $associationField) use ($entityName): bool {
  301.             if (!$associationField instanceof OneToManyAssociationField) {
  302.                 return false;
  303.             }
  305.             return $associationField->getReferenceDefinition()->getEntityName() === $entityName;
  306.         })->first();
  308.         return $field ? $field->getReferenceDefinition() : null;
  309.     }
  310. }