vendor/shopware/core/Content/Rule/DataAbstractionLayer/RuleAreaUpdater.php line 84

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