vendor/shopware/core/Content/Rule/RuleValidator.php line 59

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\Rule;
  5. use Shopware\Core\Content\Rule\Aggregate\RuleCondition\RuleConditionCollection;
  6. use Shopware\Core\Content\Rule\Aggregate\RuleCondition\RuleConditionDefinition;
  7. use Shopware\Core\Content\Rule\Aggregate\RuleCondition\RuleConditionEntity;
  8. use Shopware\Core\Framework\App\Aggregate\AppScriptCondition\AppScriptConditionEntity;
  9. use Shopware\Core\Framework\Context;
  10. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Exception\UnsupportedCommandTypeException;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\DeleteCommand;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\InsertCommand;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\UpdateCommand;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\WriteCommand;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Write\Validation\PreWriteValidationEvent;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteException;
  19. use Shopware\Core\Framework\Log\Package;
  20. use Shopware\Core\Framework\Rule\Collector\RuleConditionRegistry;
  21. use Shopware\Core\Framework\Rule\Exception\InvalidConditionException;
  22. use Shopware\Core\Framework\Rule\ScriptRule;
  23. use Shopware\Core\Framework\Uuid\Uuid;
  24. use Shopware\Core\Framework\Validation\WriteConstraintViolationException;
  25. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  26. use Symfony\Component\Validator\Constraint;
  27. use Symfony\Component\Validator\ConstraintViolation;
  28. use Symfony\Component\Validator\ConstraintViolationInterface;
  29. use Symfony\Component\Validator\ConstraintViolationList;
  30. use Symfony\Component\Validator\Validator\ValidatorInterface;
  32. /**
  33.  * @internal
  34.  */
  35. #[Package('business-ops')]
  36. class RuleValidator implements EventSubscriberInterface
  37. {
  38.     /**
  39.      * @internal
  40.      */
  41.     public function __construct(
  42.         private readonly ValidatorInterface $validator,
  43.         private readonly RuleConditionRegistry $ruleConditionRegistry,
  44.         private readonly EntityRepository $ruleConditionRepository,
  45.         private readonly EntityRepository $appScriptConditionRepository
  46.     ) {
  47.     }
  49.     public static function getSubscribedEvents(): array
  50.     {
  51.         return [
  52.             PreWriteValidationEvent::class => 'preValidate',
  53.         ];
  54.     }
  56.     /**
  57.      * @throws UnsupportedCommandTypeException
  58.      */
  59.     public function preValidate(PreWriteValidationEvent $event): void
  60.     {
  61.         $writeException = $event->getExceptions();
  62.         $commands = $event->getCommands();
  63.         $updateQueue = [];
  65.         foreach ($commands as $command) {
  66.             if ($command->getDefinition()->getClass() !== RuleConditionDefinition::class) {
  67.                 continue;
  68.             }
  70.             if ($command instanceof DeleteCommand) {
  71.                 continue;
  72.             }
  74.             if ($command instanceof InsertCommand) {
  75.                 $this->validateCondition(null, $command, $writeException, $event->getContext());
  77.                 continue;
  78.             }
  80.             if ($command instanceof UpdateCommand) {
  81.                 $updateQueue[] = $command;
  83.                 continue;
  84.             }
  86.             throw new UnsupportedCommandTypeException($command);
  87.         }
  89.         if (!empty($updateQueue)) {
  90.             $this->validateUpdateCommands($updateQueue, $writeException, $event->getContext());
  91.         }
  92.     }
  94.     private function validateCondition(
  95.         ?RuleConditionEntity $condition,
  96.         WriteCommand $command,
  97.         WriteException $writeException,
  98.         Context $context
  99.     ): void {
  100.         $payload = $command->getPayload();
  101.         $violationList = new ConstraintViolationList();
  103.         $type = $this->getConditionType($condition, $payload);
  104.         if ($type === null) {
  105.             return;
  106.         }
  108.         try {
  109.             $ruleInstance = $this->ruleConditionRegistry->getRuleInstance($type);
  110.         } catch (InvalidConditionException) {
  111.             $violation = $this->buildViolation(
  112.                 'This {{ value }} is not a valid condition type.',
  113.                 ['{{ value }}' => $type],
  114.                 '/type',
  115.                 'CONTENT__INVALID_RULE_TYPE_EXCEPTION'
  116.             );
  117.             $violationList->add($violation);
  118.             $writeException->add(new WriteConstraintViolationException($violationList, $command->getPath()));
  120.             return;
  121.         }
  123.         $value = $this->getConditionValue($condition, $payload);
  124.         $ruleInstance->assign($value);
  126.         if ($ruleInstance instanceof ScriptRule) {
  127.             $this->setScriptConstraints($ruleInstance, $condition, $payload, $context);
  128.         }
  130.         $this->validateConsistence(
  131.             $ruleInstance->getConstraints(),
  132.             $value,
  133.             $violationList
  134.         );
  136.         if ($violationList->count() > 0) {
  137.             $writeException->add(new WriteConstraintViolationException($violationList, $command->getPath()));
  138.         }
  139.     }
  141.     /**
  142.      * @param array<mixed> $payload
  143.      */
  144.     private function getConditionType(?RuleConditionEntity $condition, array $payload): ?string
  145.     {
  146.         $type = $condition !== null ? $condition->getType() : null;
  147.         if (\array_key_exists('type', $payload)) {
  148.             $type = $payload['type'];
  149.         }
  151.         return $type;
  152.     }
  154.     /**
  155.      * @param array<mixed> $payload
  156.      *
  157.      * @return array<mixed>
  158.      */
  159.     private function getConditionValue(?RuleConditionEntity $condition, array $payload): array
  160.     {
  161.         $value = $condition !== null ? $condition->getValue() : [];
  162.         if (isset($payload['value']) && $payload['value'] !== null) {
  163.             $value = json_decode((string) $payload['value'], true, 512, \JSON_THROW_ON_ERROR);
  164.         }
  166.         return $value ?? [];
  167.     }
  169.     /**
  170.      * @param array<string, array<Constraint>> $fieldValidations
  171.      * @param array<mixed> $payload
  172.      */
  173.     private function validateConsistence(array $fieldValidations, array $payload, ConstraintViolationList $violationList): void
  174.     {
  175.         foreach ($fieldValidations as $fieldName => $validations) {
  176.             $violationList->addAll(
  177.                 $this->validator->startContext()
  178.                     ->atPath('/value/' . $fieldName)
  179.                     ->validate($payload[$fieldName] ?? null, $validations)
  180.                     ->getViolations()
  181.             );
  182.         }
  184.         foreach ($payload as $fieldName => $_value) {
  185.             if (!\array_key_exists($fieldName, $fieldValidations) && $fieldName !== '_name') {
  186.                 $violationList->add(
  187.                     $this->buildViolation(
  188.                         'The property "{{ fieldName }}" is not allowed.',
  189.                         ['{{ fieldName }}' => $fieldName],
  190.                         '/value/' . $fieldName
  191.                     )
  192.                 );
  193.             }
  194.         }
  195.     }
  197.     /**
  198.      * @param array<UpdateCommand> $commandQueue
  199.      */
  200.     private function validateUpdateCommands(
  201.         array $commandQueue,
  202.         WriteException $writeException,
  203.         Context $context
  204.     ): void {
  205.         $conditions = $this->getSavedConditions($commandQueue, $context);
  207.         foreach ($commandQueue as $command) {
  208.             $id = Uuid::fromBytesToHex($command->getPrimaryKey()['id']);
  209.             $condition = $conditions->get($id);
  211.             $this->validateCondition($condition, $command, $writeException, $context);
  212.         }
  213.     }
  215.     /**
  216.      * @param array<UpdateCommand> $commandQueue
  217.      */
  218.     private function getSavedConditions(array $commandQueue, Context $context): RuleConditionCollection
  219.     {
  220.         $ids = array_map(function ($command) {
  221.             $uuidBytes = $command->getPrimaryKey()['id'];
  223.             return Uuid::fromBytesToHex($uuidBytes);
  224.         }, $commandQueue);
  226.         $criteria = new Criteria($ids);
  227.         $criteria->setLimit(null);
  229.         /** @var RuleConditionCollection $entities */
  230.         $entities = $this->ruleConditionRepository->search($criteria, $context)->getEntities();
  232.         return $entities;
  233.     }
  235.     /**
  236.      * @param array<int|string> $parameters
  237.      */
  238.     private function buildViolation(
  239.         string $messageTemplate,
  240.         array $parameters,
  241.         ?string $propertyPath = null,
  242.         ?string $code = null
  243.     ): ConstraintViolationInterface {
  244.         return new ConstraintViolation(
  245.             str_replace(array_keys($parameters), array_values($parameters), $messageTemplate),
  246.             $messageTemplate,
  247.             $parameters,
  248.             null,
  249.             $propertyPath,
  250.             null,
  251.             null,
  252.             $code
  253.         );
  254.     }
  256.     /**
  257.      * @param array<mixed> $payload
  258.      */
  259.     private function setScriptConstraints(
  260.         ScriptRule $ruleInstance,
  261.         ?RuleConditionEntity $condition,
  262.         array $payload,
  263.         Context $context
  264.     ): void {
  265.         $script = null;
  266.         if (isset($payload['script_id'])) {
  267.             $scriptId = Uuid::fromBytesToHex($payload['script_id']);
  268.             $script = $this->appScriptConditionRepository->search(new Criteria([$scriptId]), $context)->get($scriptId);
  269.         } elseif ($condition && $condition->getAppScriptCondition()) {
  270.             $script = $condition->getAppScriptCondition();
  271.         }
  273.         if (!$script instanceof AppScriptConditionEntity || !\is_array($script->getConstraints())) {
  274.             return;
  275.         }
  277.         $ruleInstance->setConstraints($script->getConstraints());
  278.     }
  279. }