Как применять группы валидации последовательно

Дата обновления перевода 2024-07-29

Как применять группы валидации последовательно

В некоторых случаях, вам нужно будет валидировать ваши группы пошагово. Чтобы сделать это, вы можете использовать функцию GroupSequence. В этом случае, объект определяет групповую последовательность, которая определяет порядок, в котором нужно валидировать группы.

Например, представьте, что у вас есть класс User и вы хотите валидировать то, отличются ли имя ползователя и пароль только в случае, если вся остальная валидация пройдёт успешно (чтобы избежать множественных сообщений об ошибке).

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
        // src/Entity/User.php
namespace App\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 string $username;

    #[Assert\NotBlank]
    private string $password;

    #[Assert\IsTrue(
        message: 'Пароль не может совпадать с вашим именем пользователя',
        groups: ['Strict'],
    )]
    public function isPasswordSafe(): bool
    {
        return ($this->username !== $this->password);
    }
}
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
        # config/validator/validation.yaml
App\Entity\User:
    group_sequence:
        - User
        - Strict
    getters:
        passwordSafe:
            - 'IsTrue':
                message: 'Пароль не может совпадать с вашим именем пользователя'
                groups: [Strict]
    properties:
        username:
            - NotBlank: ~
        password:
            - NotBlank: ~
    

        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
30
        <!-- config/validator/validation.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping https://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">

    <class name="App\Entity\User">
        <property name="username">
            <constraint name="NotBlank"/>
        </property>

        <property name="password">
            <constraint name="NotBlank"/>
        </property>

        <getter property="passwordSafe">
            <constraint name="IsTrue">
                <option name="message">Пароль не может совпадать с вашим именем пользователя</option>
                <option name="groups">
                    <value>Strict</value>
                </option>
            </constraint>
        </getter>

        <group-sequence>
            <value>User</value>
            <value>Strict</value>
        </group-sequence>
    </class>
</constraint-mapping>
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
        // src/Entity/User.php
namespace App\Entity;

use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Mapping\ClassMetadata;

class User
{
    public static function loadValidatorMetadata(ClassMetadata $metadata): void
    {
        $metadata->addPropertyConstraint('username', new Assert\NotBlank());
        $metadata->addPropertyConstraint('password', new Assert\NotBlank());

        $metadata->addGetterConstraint('passwordSafe', new Assert\IsTrue([
            'message' => 'Пароль не может совпадать с вашим именем пользователя',
            'groups'  => ['Strict'],
        ]));

        $metadata->setGroupSequence(['User', 'Strict']);
    }
}
    

В этом примере, вначале будут валидированы все ограничения в группе User (что то же самое, что и группа Default). Только если все ограничения в этой группе будут валидны, будут валидирована вторая группа - Strict.

Caution

Как вы уже видели в Как применить только подмножество всех ваших ограничений валидации (группы валидации), группа Default и группа, содержащая имя класса (например, User) были идентичны. Однако, при использовании групповой последовательности, они больше не будут идентичными. Группа Default теперь будет ссылаться на групповую последовательность вместо всех ограничений, которые не принадлежат ни одной группе.

Это означает, что вам нужно использовать группу {ClassName} (например, User), при указывании групповой последовательности. При использовании
Default, вы получите бесконечную рекурсию (так как группа Default ссылается на групповую последовательность, содержащую группу Default, которая ссылается на ту же групповую последовательность...).

Caution

Вызов validate() с группой в последовательности (Strict - в предыдущем примере) приведет к валидации только с этой группой, а не со всеми группами в последовательности. Это так, потому что последовательность теперь ссылается на групповую валидацию Default.

Вы также можете определить последовательность группы в опции формы validation_groups:

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
        // src/Form/MyType.php
namespace App\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Validator\Constraints\GroupSequence;
// ...

class MyType extends AbstractType
{
    // ...
    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'validation_groups' => new GroupSequence(['First', 'Second']),
        ]);
    }
}
    

Поставщики групповой последовательности

Представьте сущность User, которая может быть нормальным или премиум пользователем. Если это премиум пользователь, необходимо добавить некоторые дополнительные ограничения к сущности пользователя (например, информацию о кредитной карте). Чтобы динамически определить, какие группы стоит активировать, вы можете создать поставщика групповой последовательности. Для начала, создайте сущеность и новую группу ограничений под названием Premium:

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
        // src/Entity/User.php
namespace App\Entity;

use Symfony\Component\Validator\Constraints as Assert;

class User
{
    #[Assert\NotBlank]
    private string $name;

    #[Assert\CardScheme(
        schemes: [Assert\CardScheme::VISA],
        groups: ['Premium'],
    )]
    private string $creditCard;

    // ...
}
    

        1
2
3
4
5
6
7
8
9
        # config/validator/validation.yaml
App\Entity\User:
    properties:
        name:
            - NotBlank: ~
        creditCard:
            - CardScheme:
                schemes: [VISA]
                groups: [Premium]
    

        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
        <!-- config/validator/validation.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping https://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">

    <class name="App\Entity\User">
        <property name="name">
            <constraint name="NotBlank"/>
        </property>

        <property name="creditCard">
            <constraint name="CardScheme">
                <option name="schemes">
                    <value>VISA</value>
                </option>
                <option name="groups">
                    <value>Premium</value>
                </option>
            </constraint>
        </property>

        <!-- ... -->
    </class>
</constraint-mapping>
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
        // src/Entity/User.php
namespace App\Entity;

use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Mapping\ClassMetadata;

class User
{
    private string $name;
    private string $creditCard;

    // ...

    public static function loadValidatorMetadata(ClassMetadata $metadata): void
    {
        $metadata->addPropertyConstraint('name', new Assert\NotBlank());
        $metadata->addPropertyConstraint('creditCard', new Assert\CardScheme([
            'schemes' => [Assert\CardScheme::VISA],
            'groups'  => ['Premium'],
        ]));
    }
}
    

Теперь, измените класс User, чтобы реализовать GroupSequenceProviderInterface и добавьте метод getGroupSequence(), который должен вернуть массив групп для использования:

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
        // src/Entity/User.php
namespace App\Entity;

// ...
use Symfony\Component\Validator\GroupSequenceProviderInterface;

class User implements GroupSequenceProviderInterface
{
    // ...

    public function getGroupSequence(): array|GroupSequence
    {
        // при возвращении простого массива, если в любой из групп есть нарушение,
        // остальные группы не валидируются. Например, если 'User' неудачна, то
        // 'Premium' и 'Api' не валидируются:
        return ['User', 'Premium', 'Api'];

        // при возвращении встроенного масива, все группы, включенные в каждый массив,
        // валидируются. Например, если 'User' неудачна, 'Premium' также валидируется
        // (и вы получите и ее нарушения), но 'Api' не будет валидирована:
        return [['User', 'Premium'], 'Api'];
    }
}
    

Наконец, вам нужно уведомить компонент валидатор (Validator) о том, что ваш класс User предоставляет последовательность групп для валидации:

        1
2
3
4
5
6
7
8
9
10
        // src/Entity/User.php
namespace App\Entity;

// ...

#[Assert\GroupSequenceProvider]
class User implements GroupSequenceProviderInterface
{
    // ...
}
    

        1
2
3
        # config/validator/validation.yaml
App\Entity\User:
    group_sequence_provider: true
    

        1
2
3
4
5
6
7
8
9
10
11
12
        <!-- config/validator/validation.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping
        https://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">

    <class name="App\Entity\User">
        <group-sequence-provider/>
        <!-- ... -->
    </class>
</constraint-mapping>
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
        // src/Entity/User.php
namespace App\Entity;

// ...
use Symfony\Component\Validator\Mapping\ClassMetadata;

class User implements GroupSequenceProviderInterface
{
    // ...

    public static function loadValidatorMetadata(ClassMetadata $metadata): void
    {
        $metadata->setGroupSequenceProvider(true);
        // ...
    }
}
    

Продвинутый поставщик группы валидации

В предыдущем разделе вы узнали, как изменять последовательность групп динамически в зависимости от состояния вашей сущности. Однако в более продвинутых случаях вам может понадобиться использовать какую-то внешнюю конфигурацию или сервис для определения этой последовательность групп.

Управление инициализацией сущности и ручная установка ее зависимостей может быть громоздкой, а реализация может не соответствовать обязанностям. Чтобы решить эту проблему, вы можете сконфигурировать реализацию GroupProviderInterface вне сущности и даже зарегистрировать группового поставщика как сервис.

Вот как этого можно добиться:

Определите отдельный класс поставщика групп: создайте класс, который реализует GroupProviderInterface и обрабатывает логику динамической последовательности групп;
Сконфигурируйте пользователя с поставщиком: используйте опцию provider внутри атрибута
GroupSequenceProvider, чтобы связать сущность с классом поставщика;
Автомонтирование или ручное тегирование: если автомонтирование включено, ваш пользовательский поставщик будет связан автоматически. В противном случае вы должны тегировать свой сервис вручную с помощью тега validator.group_provider.

        1
2
3
4
5
6
7
8
9
10
11
        // src/Entity/User.php
namespace App\Entity;

// ...
use App\Validator\UserGroupProvider;

#[Assert\GroupSequenceProvider(provider: UserGroupProvider::class)]
class User
{
    // ...
}
    

        1
2
3
        # config/validator/validation.yaml
App\Entity\User:
    group_sequence_provider: App\Validator\UserGroupProvider
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
        <!-- config/validator/validation.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping
        https://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">

    <class name="App\Entity\User">
        <group-sequence-provider>
            <value>App\Validator\UserGroupProvider</value>
        </group-sequence-provider>
        <!-- ... -->
    </class>
</constraint-mapping>
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
        // src/Entity/User.php
namespace App\Entity;

// ...
use App\Validator\UserGroupProvider;
use Symfony\Component\Validator\Mapping\ClassMetadata;

class User
{
    // ...

    public static function loadValidatorMetadata(ClassMetadata $metadata): void
    {
        $metadata->setGroupProvider(UserGroupProvider::class);
        $metadata->setGroupSequenceProvider(true);
        // ...
    }
}
    

При таком подходе можно сохранить чистое разделение между структурой сущности и логикой последовательности групп, что позволяет использовать более сложные сценарии.

Как последовательно применять ограничения в одном свойстве

Иногда вам может захотеться применять ограничения последовательно в одном свойстве. Оганичение Sequentially может решить это за вас более прямым путем, чем использование GroupSequence.