vendor/shopware/core/Framework/Validation/HappyPathValidator.php line 51

  1. <?php
  3. declare(strict_types=1);
  5. namespace Shopware\Core\Framework\Validation;
  7. use Shopware\Core\Framework\Log\Package;
  8. use Shopware\Core\Framework\Validation\Constraint\Uuid;
  9. use Symfony\Component\Validator\Constraint;
  10. use Symfony\Component\Validator\Constraints\Collection;
  11. use Symfony\Component\Validator\Constraints\GroupSequence;
  12. use Symfony\Component\Validator\Constraints\Length;
  13. use Symfony\Component\Validator\Constraints\NotBlank;
  14. use Symfony\Component\Validator\Constraints\NotNull;
  15. use Symfony\Component\Validator\Constraints\Optional;
  16. use Symfony\Component\Validator\Constraints\Range;
  17. use Symfony\Component\Validator\Constraints\Type;
  18. use Symfony\Component\Validator\ConstraintViolationList;
  19. use Symfony\Component\Validator\ConstraintViolationListInterface;
  20. use Symfony\Component\Validator\Context\ExecutionContextInterface;
  21. use Symfony\Component\Validator\Mapping\MetadataInterface;
  22. use Symfony\Component\Validator\Validator\ContextualValidatorInterface;
  23. use Symfony\Component\Validator\Validator\ValidatorInterface;
  25. #[Package('core
  26. calling into the validator machinery has a considerable overhead. Doing that thousands of time is notable.
  27. this validator implements a subset of the functionality and calls into the real validator if needed.')]
  28. class HappyPathValidator implements ValidatorInterface
  29. {
  30.     /**
  31.      * @internal
  32.      */
  33.     public function __construct(private readonly ValidatorInterface $inner)
  34.     {
  35.     }
  37.     /**
  38.      * @param Constraint|Constraint[]|null $constraints
  39.      */
  40.     public function validate(mixed $value, Constraint|array $constraints = null, string|GroupSequence|array $groups = null): ConstraintViolationListInterface
  41.     {
  42.         if ($constraints === null) {
  43.             return $this->inner->validate($value, $constraints, $groups);
  44.         }
  46.         $constraints = \is_array($constraints) ? $constraints : [$constraints];
  48.         foreach ($constraints as $constraint) {
  49.             // if one of our checks fails, we call the real validator
  50.             if (!$this->validateConstraint($value, $constraint)) {
  51.                 return $this->inner->validate($value, $constraints, $groups);
  52.             }
  53.         }
  55.         return new ConstraintViolationList();
  56.     }
  58.     public function getMetadataFor(mixed $value): MetadataInterface
  59.     {
  60.         return $this->inner->getMetadataFor($value);
  61.     }
  63.     public function hasMetadataFor(mixed $value): bool
  64.     {
  65.         return $this->inner->hasMetadataFor($value);
  66.     }
  68.     public function validateProperty(object $object, string $propertyName, string|GroupSequence|array $groups = null): ConstraintViolationListInterface
  69.     {
  70.         return $this->inner->validateProperty($object, $propertyName, $groups);
  71.     }
  73.     public function validatePropertyValue(object|string $objectOrClass, string $propertyName, mixed $value, string|GroupSequence|array $groups = null): ConstraintViolationListInterface
  74.     {
  75.         return $this->inner->validatePropertyValue($objectOrClass, $propertyName, $value, $groups);
  76.     }
  78.     public function startContext(): ContextualValidatorInterface
  79.     {
  80.         return $this->inner->startContext();
  81.     }
  83.     public function inContext(ExecutionContextInterface $context): ContextualValidatorInterface
  84.     {
  85.         return $this->inner->inContext($context);
  86.     }
  88.     /**
  89.      * @param Constraint|Constraint[]|null $constraint
  90.      */
  91.     private function normalizeValueIfRequired(mixed $value, Constraint|array|null $constraint): mixed
  92.     {
  93.         if (!$constraint instanceof Constraint) {
  94.             return $value;
  95.         }
  97.         if (!\property_exists($constraint, 'normalizer')) {
  98.             return $value;
  99.         }
  101.         if (empty($constraint->normalizer)) {
  102.             return $value;
  103.         }
  105.         $normalizer = $constraint->normalizer;
  107.         if (!\is_callable($normalizer)) {
  108.             return $value;
  109.         }
  111.         /** @var callable(mixed): mixed $normalizer */
  112.         return $normalizer($value);
  113.     }
  115.     /**
  116.      * @param Constraint|Constraint[]|null $constraint
  117.      */
  118.     private function validateConstraint(mixed $value, Constraint|array|null $constraint): bool
  119.     {
  120.         // apply defined normalizers to check $value from constraint if defined
  121.         $value = $this->normalizeValueIfRequired(
  122.             $value,
  123.             $constraint
  124.         );
  126.         switch (true) {
  127.             case $constraint instanceof Uuid:
  128.                 if ($value !== null && \is_string($value) && !\Shopware\Core\Framework\Uuid\Uuid::isValid($value)) {
  129.                     return false;
  130.                 }
  132.                 break;
  133.             case $constraint instanceof NotBlank:
  134.                 if ($value === false || (empty($value) && $value !== '0')) {
  135.                     return false;
  136.                 }
  138.                 break;
  139.             case $constraint instanceof NotNull:
  140.                 if ($value === null) {
  141.                     return false;
  142.                 }
  144.                 break;
  145.             case $constraint instanceof Type:
  146.                 $types = (array) $constraint->type;
  148.                 foreach ($types as $type) {
  149.                     $type = strtolower((string) $type);
  150.                     $type = $type === 'boolean' ? 'bool' : $type;
  151.                     $isFunction = 'is_' . $type;
  152.                     $ctypeFunction = 'ctype_' . $type;
  154.                     if (\function_exists($isFunction)) {
  155.                         if (\is_callable($isFunction) && !$isFunction($value)) { /* @phpstan-ignore-line */
  156.                             return false;
  157.                         }
  158.                     } elseif (\function_exists($ctypeFunction)) {
  159.                         if (\is_callable($ctypeFunction) && !$ctypeFunction($value)) { /* @phpstan-ignore-line */
  160.                             return false;
  161.                         }
  162.                     } elseif (!$value instanceof $type) {
  163.                         return false;
  164.                     }
  165.                 }
  167.                 break;
  168.             case $constraint instanceof Length:
  169.                 if (!\is_string($value)) {
  170.                     return false;
  171.                 }
  172.                 $length = mb_strlen($value);
  174.                 if ($constraint->max !== null && $length > $constraint->max) {
  175.                     return false;
  176.                 }
  178.                 if ($constraint->min !== null && $length < $constraint->min) {
  179.                     return false;
  180.                 }
  182.                 break;
  183.             case $constraint instanceof Range:
  184.                 if (!is_numeric($value)) {
  185.                     return false;
  186.                 }
  188.                 if ($constraint->min === null && $constraint->max !== null) {
  189.                     if ($value > $constraint->max) {
  190.                         return false;
  191.                     }
  192.                 } elseif ($constraint->min !== null && $constraint->max === null) {
  193.                     if ($value < $constraint->min) {
  194.                         return false;
  195.                     }
  196.                 } elseif ($constraint->min !== null && $constraint->max !== null) {
  197.                     if ($value < $constraint->min || $value > $constraint->max) {
  198.                         return false;
  199.                     }
  200.                 }
  202.                 break;
  204.             case $constraint instanceof Collection:
  205.                 foreach ($constraint->fields as $field => $fieldConstraint) {
  206.                     \assert($fieldConstraint instanceof Constraint);
  207.                     // bug fix issue #2779
  208.                     $existsInArray = \is_array($value) && \array_key_exists($field, $value);
  209.                     $existsInArrayAccess = $value instanceof \ArrayAccess && $value->offsetExists($field);
  211.                     if (($existsInArray || $existsInArrayAccess) && property_exists($fieldConstraint, 'constraints')) {
  212.                         if ((is_countable($fieldConstraint->constraints) ? \count($fieldConstraint->constraints) : 0) > 0) {
  213.                             /** @var array<mixed>|\ArrayAccess<string|int, mixed> $value */
  214.                             if (!$this->validateConstraint($value[$field], $fieldConstraint->constraints)) {
  215.                                 return false;
  216.                             }
  217.                         }
  218.                     } elseif (!$fieldConstraint instanceof Optional && !$constraint->allowMissingFields) {
  219.                         return false;
  220.                     }
  222.                     if (!$constraint->allowExtraFields && is_iterable($value)) {
  223.                         foreach ($value as $f => $_) {
  224.                             if (!isset($constraint->fields[$f])) {
  225.                                 return false;
  226.                             }
  227.                         }
  228.                     }
  229.                 }
  231.                 break;
  232.                 // unknown constraint
  233.             default:
  234.                 return false;
  235.         }
  237.         return true;
  238.     }
  239. }