vendor/symfony/validator/Constraints/RangeValidator.php line 29

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Validator\Constraints;
  14. use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
  15. use Symfony\Component\PropertyAccess\PropertyAccess;
  16. use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
  17. use Symfony\Component\Validator\Constraint;
  18. use Symfony\Component\Validator\ConstraintValidator;
  19. use Symfony\Component\Validator\Exception\ConstraintDefinitionException;
  20. use Symfony\Component\Validator\Exception\UnexpectedTypeException;
  22. /**
  23.  * @author Bernhard Schussek <bschussek@gmail.com>
  24.  */
  25. class RangeValidator extends ConstraintValidator
  26. {
  27.     private ?PropertyAccessorInterface $propertyAccessor;
  29.     public function __construct(PropertyAccessorInterface $propertyAccessor = null)
  30.     {
  31.         $this->propertyAccessor = $propertyAccessor;
  32.     }
  34.     public function validate(mixed $value, Constraint $constraint)
  35.     {
  36.         if (!$constraint instanceof Range) {
  37.             throw new UnexpectedTypeException($constraint, Range::class);
  38.         }
  40.         if (null === $value) {
  41.             return;
  42.         }
  44.         $min = $this->getLimit($constraint->minPropertyPath, $constraint->min, $constraint);
  45.         $max = $this->getLimit($constraint->maxPropertyPath, $constraint->max, $constraint);
  47.         if (!is_numeric($value) && !$value instanceof \DateTimeInterface) {
  48.             if ($this->isParsableDatetimeString($min) && $this->isParsableDatetimeString($max)) {
  49.                 $this->context->buildViolation($constraint->invalidDateTimeMessage)
  50.                     ->setParameter('{{ value }}', $this->formatValue($value, self::PRETTY_DATE))
  51.                     ->setCode(Range::INVALID_CHARACTERS_ERROR)
  52.                     ->addViolation();
  53.             } else {
  54.                 $this->context->buildViolation($constraint->invalidMessage)
  55.                     ->setParameter('{{ value }}', $this->formatValue($value, self::PRETTY_DATE))
  56.                     ->setCode(Range::INVALID_CHARACTERS_ERROR)
  57.                     ->addViolation();
  58.             }
  60.             return;
  61.         }
  63.         // Convert strings to DateTimes if comparing another DateTime
  64.         // This allows to compare with any date/time value supported by
  65.         // the DateTime constructor:
  66.         // https://php.net/datetime.formats
  67.         if ($value instanceof \DateTimeInterface) {
  68.             $dateTimeClass = null;
  70.             if (\is_string($min)) {
  71.                 $dateTimeClass = $value instanceof \DateTimeImmutable ? \DateTimeImmutable::class : \DateTime::class;
  73.                 try {
  74.                     $min = new $dateTimeClass($min);
  75.                 } catch (\Exception) {
  76.                     throw new ConstraintDefinitionException(sprintf('The min value "%s" could not be converted to a "%s" instance in the "%s" constraint.', $min, $dateTimeClass, get_debug_type($constraint)));
  77.                 }
  78.             }
  80.             if (\is_string($max)) {
  81.                 $dateTimeClass = $dateTimeClass ?: ($value instanceof \DateTimeImmutable ? \DateTimeImmutable::class : \DateTime::class);
  83.                 try {
  84.                     $max = new $dateTimeClass($max);
  85.                 } catch (\Exception) {
  86.                     throw new ConstraintDefinitionException(sprintf('The max value "%s" could not be converted to a "%s" instance in the "%s" constraint.', $max, $dateTimeClass, get_debug_type($constraint)));
  87.                 }
  88.             }
  89.         }
  91.         $hasLowerLimit = null !== $min;
  92.         $hasUpperLimit = null !== $max;
  94.         if ($hasLowerLimit && $hasUpperLimit && ($value < $min || $value > $max)) {
  95.             $message = $constraint->notInRangeMessage;
  96.             $code = Range::NOT_IN_RANGE_ERROR;
  98.             $violationBuilder = $this->context->buildViolation($message)
  99.                 ->setParameter('{{ value }}', $this->formatValue($value, self::PRETTY_DATE))
  100.                 ->setParameter('{{ min }}', $this->formatValue($min, self::PRETTY_DATE))
  101.                 ->setParameter('{{ max }}', $this->formatValue($max, self::PRETTY_DATE))
  102.                 ->setCode($code);
  104.             if (null !== $constraint->maxPropertyPath) {
  105.                 $violationBuilder->setParameter('{{ max_limit_path }}', $constraint->maxPropertyPath);
  106.             }
  108.             if (null !== $constraint->minPropertyPath) {
  109.                 $violationBuilder->setParameter('{{ min_limit_path }}', $constraint->minPropertyPath);
  110.             }
  112.             $violationBuilder->addViolation();
  114.             return;
  115.         }
  117.         if ($hasUpperLimit && $value > $max) {
  118.             $violationBuilder = $this->context->buildViolation($constraint->maxMessage)
  119.                 ->setParameter('{{ value }}', $this->formatValue($value, self::PRETTY_DATE))
  120.                 ->setParameter('{{ limit }}', $this->formatValue($max, self::PRETTY_DATE))
  121.                 ->setCode(Range::TOO_HIGH_ERROR);
  123.             if (null !== $constraint->maxPropertyPath) {
  124.                 $violationBuilder->setParameter('{{ max_limit_path }}', $constraint->maxPropertyPath);
  125.             }
  127.             if (null !== $constraint->minPropertyPath) {
  128.                 $violationBuilder->setParameter('{{ min_limit_path }}', $constraint->minPropertyPath);
  129.             }
  131.             $violationBuilder->addViolation();
  133.             return;
  134.         }
  136.         if ($hasLowerLimit && $value < $min) {
  137.             $violationBuilder = $this->context->buildViolation($constraint->minMessage)
  138.                 ->setParameter('{{ value }}', $this->formatValue($value, self::PRETTY_DATE))
  139.                 ->setParameter('{{ limit }}', $this->formatValue($min, self::PRETTY_DATE))
  140.                 ->setCode(Range::TOO_LOW_ERROR);
  142.             if (null !== $constraint->maxPropertyPath) {
  143.                 $violationBuilder->setParameter('{{ max_limit_path }}', $constraint->maxPropertyPath);
  144.             }
  146.             if (null !== $constraint->minPropertyPath) {
  147.                 $violationBuilder->setParameter('{{ min_limit_path }}', $constraint->minPropertyPath);
  148.             }
  150.             $violationBuilder->addViolation();
  151.         }
  152.     }
  154.     private function getLimit(?string $propertyPath, mixed $default, Constraint $constraint): mixed
  155.     {
  156.         if (null === $propertyPath) {
  157.             return $default;
  158.         }
  160.         if (null === $object = $this->context->getObject()) {
  161.             return $default;
  162.         }
  164.         try {
  165.             return $this->getPropertyAccessor()->getValue($object, $propertyPath);
  166.         } catch (NoSuchPropertyException $e) {
  167.             throw new ConstraintDefinitionException(sprintf('Invalid property path "%s" provided to "%s" constraint: ', $propertyPath, get_debug_type($constraint)).$e->getMessage(), 0, $e);
  168.         }
  169.     }
  171.     private function getPropertyAccessor(): PropertyAccessorInterface
  172.     {
  173.         return $this->propertyAccessor ??= PropertyAccess::createPropertyAccessor();
  174.     }
  176.     private function isParsableDatetimeString(mixed $boundary): bool
  177.     {
  178.         if (null === $boundary) {
  179.             return true;
  180.         }
  182.         if (!\is_string($boundary)) {
  183.             return false;
  184.         }
  186.         try {
  187.             new \DateTime($boundary);
  188.         } catch (\Exception) {
  189.             return false;
  190.         }
  192.         return true;
  193.     }
  194. }