How to Sequentially Apply Validation Groups
Warning: You are browsing the documentation for Symfony 2.x, which is no longer maintained.
Read the updated version of this page for Symfony 7.2 (the current stable version).
In some cases, you want to validate your groups by steps. To do this, you can
use the GroupSequence
feature. In this case, an object defines a group
sequence, which determines the order groups should be validated.
For example, suppose you have a User
class and want to validate that the
username and the password are different only if all other validation passes
(in order to avoid multiple error messages).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
// src/AppBundle/Entity/User.php
namespace AppBundle\Entity;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Validator\Constraints as Assert;
/**
* @Assert\GroupSequence({"User", "Strict"})
*/
class User implements UserInterface
{
/**
* @Assert\NotBlank
*/
private $username;
/**
* @Assert\NotBlank
*/
private $password;
/**
* @Assert\IsTrue(message="The password cannot match your username", groups={"Strict"})
*/
public function isPasswordSafe()
{
return ($this->username !== $this->password);
}
}
In this example, it will first validate all constraints in the group User
(which is the same as the Default
group). Only if all constraints in
that group are valid, the second group, Strict
, will be validated.
Caution
As you have already seen in How to Apply only a Subset of all Your Validation Constraints (Validation Groups), the Default
group
and the group containing the class name (e.g. User
) were identical.
However, when using Group Sequences, they are no longer identical. The
Default
group will now reference the group sequence, instead of all
constraints that do not belong to any group.
This means that you have to use the {ClassName}
(e.g. User
) group
when specifying a group sequence. When using Default
, you get an
infinite recursion (as the Default
group references the group
sequence, which will contain the Default
group which references the
same group sequence, ...).
You can also define a group sequence in the validation_groups
form option:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
use Symfony\Component\Validator\Constraints\GroupSequence;
use Symfony\Component\Form\AbstractType;
// ...
class MyType extends AbstractType
{
// ...
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults([
'validation_groups' => new GroupSequence(['First', 'Second']),
]);
}
}
Group Sequence Providers
Imagine a User
entity which can be a normal user or a premium user. When
it's a premium user, some extra constraints should be added to the user entity
(e.g. the credit card details). To dynamically determine which groups should
be activated, you can create a Group Sequence Provider. First, create the
entity and a new constraint group called Premium
:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
// src/AppBundle/Entity/User.php
namespace AppBundle\Entity;
use Symfony\Component\Validator\Constraints as Assert;
class User
{
/**
* @Assert\NotBlank
*/
private $name;
/**
* @Assert\CardScheme(
* schemes={"VISA"},
* groups={"Premium"},
* )
*/
private $creditCard;
// ...
}
Now, change the User
class to implement
GroupSequenceProviderInterface and
add the
getGroupSequence(),
method, which should return an array of groups to use:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
// src/AppBundle/Entity/User.php
namespace AppBundle\Entity;
// ...
use Symfony\Component\Validator\GroupSequenceProviderInterface;
class User implements GroupSequenceProviderInterface
{
// ...
public function getGroupSequence()
{
$groups = array('User');
if ($this->isPremium()) {
$groups[] = 'Premium';
}
return $groups;
}
}
At last, you have to notify the Validator component that your User
class
provides a sequence of groups to be validated:
1 2 3 4 5 6 7 8 9 10 11 12
// src/AppBundle/Entity/User.php
namespace AppBundle\Entity;
// ...
/**
* @Assert\GroupSequenceProvider
*/
class User implements GroupSequenceProviderInterface
{
// ...
}