vendor/symfony/form/Extension/Validator/Constraints/FormValidator.php line 32

  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\Form\Extension\Validator\Constraints;
  14. use Symfony\Component\Form\FormInterface;
  15. use Symfony\Component\Validator\Constraint;
  16. use Symfony\Component\Validator\Constraints\Composite;
  17. use Symfony\Component\Validator\Constraints\GroupSequence;
  18. use Symfony\Component\Validator\Constraints\Valid;
  19. use Symfony\Component\Validator\ConstraintValidator;
  20. use Symfony\Component\Validator\Exception\UnexpectedTypeException;
  22. /**
  23.  * @author Bernhard Schussek <bschussek@gmail.com>
  24.  */
  25. class FormValidator extends ConstraintValidator
  26. {
  27.     /**
  28.      * @var \SplObjectStorage<FormInterface, array<int, string|string[]|GroupSequence>>
  29.      */
  30.     private \SplObjectStorage $resolvedGroups;
  32.     public function validate(mixed $form, Constraint $formConstraint)
  33.     {
  34.         if (!$formConstraint instanceof Form) {
  35.             throw new UnexpectedTypeException($formConstraint, Form::class);
  36.         }
  38.         if (!$form instanceof FormInterface) {
  39.             return;
  40.         }
  42.         /* @var FormInterface $form */
  43.         $config = $form->getConfig();
  45.         $validator = $this->context->getValidator()->inContext($this->context);
  47.         if ($form->isSubmitted() && $form->isSynchronized()) {
  48.             // Validate the form data only if transformation succeeded
  49.             $groups = $this->getValidationGroups($form);
  51.             if (!$groups) {
  52.                 return;
  53.             }
  55.             $data = $form->getData();
  56.             // Validate the data against its own constraints
  57.             $validateDataGraph = $form->isRoot()
  58.                 && (\is_object($data) || \is_array($data))
  59.                 && (($groups && \is_array($groups)) || ($groups instanceof GroupSequence && $groups->groups))
  60.             ;
  62.             // Validate the data against the constraints defined in the form
  63.             /** @var Constraint[] $constraints */
  64.             $constraints = $config->getOption('constraints', []);
  66.             $hasChildren = $form->count() > 0;
  68.             if ($hasChildren && $form->isRoot()) {
  69.                 $this->resolvedGroups = new \SplObjectStorage();
  70.             }
  72.             if ($groups instanceof GroupSequence) {
  73.                 // Validate the data, the form AND nested fields in sequence
  74.                 $violationsCount = $this->context->getViolations()->count();
  76.                 foreach ($groups->groups as $group) {
  77.                     if ($validateDataGraph) {
  78.                         $validator->atPath('data')->validate($data, null, $group);
  79.                     }
  81.                     if ($groupedConstraints = self::getConstraintsInGroups($constraints, $group)) {
  82.                         $validator->atPath('data')->validate($data, $groupedConstraints, $group);
  83.                     }
  85.                     foreach ($form->all() as $field) {
  86.                         if ($field->isSubmitted()) {
  87.                             // remember to validate this field in one group only
  88.                             // otherwise resolving the groups would reuse the same
  89.                             // sequence recursively, thus some fields could fail
  90.                             // in different steps without breaking early enough
  91.                             $this->resolvedGroups[$field] = (array) $group;
  92.                             $fieldFormConstraint = new Form();
  93.                             $fieldFormConstraint->groups = $group;
  94.                             $this->context->setNode($this->context->getValue(), $field, $this->context->getMetadata(), $this->context->getPropertyPath());
  95.                             $validator->atPath(sprintf('children[%s]', $field->getName()))->validate($field, $fieldFormConstraint, $group);
  96.                         }
  97.                     }
  99.                     if ($violationsCount < $this->context->getViolations()->count()) {
  100.                         break;
  101.                     }
  102.                 }
  103.             } else {
  104.                 if ($validateDataGraph) {
  105.                     $validator->atPath('data')->validate($data, null, $groups);
  106.                 }
  108.                 $groupedConstraints = [];
  110.                 foreach ($constraints as $constraint) {
  111.                     // For the "Valid" constraint, validate the data in all groups
  112.                     if ($constraint instanceof Valid) {
  113.                         if (\is_object($data) || \is_array($data)) {
  114.                             $validator->atPath('data')->validate($data, $constraint, $groups);
  115.                         }
  117.                         continue;
  118.                     }
  120.                     // Otherwise validate a constraint only once for the first
  121.                     // matching group
  122.                     foreach ($groups as $group) {
  123.                         if (\in_array($group, $constraint->groups)) {
  124.                             $groupedConstraints[$group][] = $constraint;
  126.                             // Prevent duplicate validation
  127.                             if (!$constraint instanceof Composite) {
  128.                                 continue 2;
  129.                             }
  130.                         }
  131.                     }
  132.                 }
  134.                 foreach ($groupedConstraints as $group => $constraint) {
  135.                     $validator->atPath('data')->validate($data, $constraint, $group);
  136.                 }
  138.                 foreach ($form->all() as $field) {
  139.                     if ($field->isSubmitted()) {
  140.                         $this->resolvedGroups[$field] = $groups;
  141.                         $this->context->setNode($this->context->getValue(), $field, $this->context->getMetadata(), $this->context->getPropertyPath());
  142.                         $validator->atPath(sprintf('children[%s]', $field->getName()))->validate($field, $formConstraint);
  143.                     }
  144.                 }
  145.             }
  147.             if ($hasChildren && $form->isRoot()) {
  148.                 // destroy storage to avoid memory leaks
  149.                 $this->resolvedGroups = new \SplObjectStorage();
  150.             }
  151.         } elseif (!$form->isSynchronized()) {
  152.             $childrenSynchronized = true;
  154.             /** @var FormInterface $child */
  155.             foreach ($form as $child) {
  156.                 if (!$child->isSynchronized()) {
  157.                     $childrenSynchronized = false;
  158.                     $this->context->setNode($this->context->getValue(), $child, $this->context->getMetadata(), $this->context->getPropertyPath());
  159.                     $validator->atPath(sprintf('children[%s]', $child->getName()))->validate($child, $formConstraint);
  160.                 }
  161.             }
  163.             // Mark the form with an error if it is not synchronized BUT all
  164.             // of its children are synchronized. If any child is not
  165.             // synchronized, an error is displayed there already and showing
  166.             // a second error in its parent form is pointless, or worse, may
  167.             // lead to duplicate errors if error bubbling is enabled on the
  168.             // child.
  169.             // See also https://github.com/symfony/symfony/issues/4359
  170.             if ($childrenSynchronized) {
  171.                 $clientDataAsString = \is_scalar($form->getViewData())
  172.                     ? (string) $form->getViewData()
  173.                     : get_debug_type($form->getViewData());
  175.                 $failure = $form->getTransformationFailure();
  177.                 $this->context->setConstraint($formConstraint);
  178.                 $this->context->buildViolation($failure->getInvalidMessage() ?? $config->getOption('invalid_message'))
  179.                     ->setParameters(array_replace(
  180.                         ['{{ value }}' => $clientDataAsString],
  181.                         $config->getOption('invalid_message_parameters'),
  182.                         $failure->getInvalidMessageParameters()
  183.                     ))
  184.                     ->setInvalidValue($form->getViewData())
  185.                     ->setCode(Form::NOT_SYNCHRONIZED_ERROR)
  186.                     ->setCause($failure)
  187.                     ->addViolation();
  188.             }
  189.         }
  191.         // Mark the form with an error if it contains extra fields
  192.         if (!$config->getOption('allow_extra_fields') && \count($form->getExtraData()) > 0) {
  193.             $this->context->setConstraint($formConstraint);
  194.             $this->context->buildViolation($config->getOption('extra_fields_message', ''))
  195.                 ->setParameter('{{ extra_fields }}', '"'.implode('", "', array_keys($form->getExtraData())).'"')
  196.                 ->setPlural(\count($form->getExtraData()))
  197.                 ->setInvalidValue($form->getExtraData())
  198.                 ->setCode(Form::NO_SUCH_FIELD_ERROR)
  199.                 ->addViolation();
  200.         }
  201.     }
  203.     /**
  204.      * Returns the validation groups of the given form.
  205.      *
  206.      * @return string|GroupSequence|array<string|GroupSequence>
  207.      */
  208.     private function getValidationGroups(FormInterface $form): string|GroupSequence|array
  209.     {
  210.         // Determine the clicked button of the complete form tree
  211.         $clickedButton = null;
  213.         if (method_exists($form, 'getClickedButton')) {
  214.             $clickedButton = $form->getClickedButton();
  215.         }
  217.         if (null !== $clickedButton) {
  218.             $groups = $clickedButton->getConfig()->getOption('validation_groups');
  220.             if (null !== $groups) {
  221.                 return self::resolveValidationGroups($groups, $form);
  222.             }
  223.         }
  225.         do {
  226.             $groups = $form->getConfig()->getOption('validation_groups');
  228.             if (null !== $groups) {
  229.                 return self::resolveValidationGroups($groups, $form);
  230.             }
  232.             if (isset($this->resolvedGroups[$form])) {
  233.                 return $this->resolvedGroups[$form];
  234.             }
  236.             $form = $form->getParent();
  237.         } while (null !== $form);
  239.         return [Constraint::DEFAULT_GROUP];
  240.     }
  242.     /**
  243.      * Post-processes the validation groups option for a given form.
  244.      *
  245.      * @param string|GroupSequence|array<string|GroupSequence>|callable $groups The validation groups
  246.      *
  247.      * @return GroupSequence|array<string|GroupSequence>
  248.      */
  249.     private static function resolveValidationGroups(string|GroupSequence|array|callable $groups, FormInterface $form): GroupSequence|array
  250.     {
  251.         if (!\is_string($groups) && \is_callable($groups)) {
  252.             $groups = $groups($form);
  253.         }
  255.         if ($groups instanceof GroupSequence) {
  256.             return $groups;
  257.         }
  259.         return (array) $groups;
  260.     }
  262.     private static function getConstraintsInGroups(array $constraints, string|array $group): array
  263.     {
  264.         $groups = (array) $group;
  266.         return array_filter($constraints, static function (Constraint $constraint) use ($groups) {
  267.             foreach ($groups as $group) {
  268.                 if (\in_array($group, $constraint->groups, true)) {
  269.                     return true;
  270.                 }
  271.             }
  273.             return false;
  274.         });
  275.     }
  276. }