Laravel
Validation

Paramètres

Exemple de base

Vous pouvez valider les données de demande à l'aide de la méthode validate (disponible dans le contrôleur de base, fournie par le trait ValidatesRequests ).

Si les règles passent, votre code continuera à s'exécuter normalement; cependant, si la validation échoue, une réponse d'erreur contenant les erreurs de validation sera automatiquement renvoyée:

• pour les demandes de formulaire HTML typiques, l'utilisateur sera redirigé vers la page précédente, le formulaire conservant les valeurs soumises
• pour les requêtes qui attendent une réponse JSON, une réponse HTTP avec le code 422 sera générée

Par exemple, dans votre UserController , vous pouvez enregistrer un nouvel utilisateur dans la méthode store , ce qui nécessite une validation avant l'enregistrement.

/**
 * @param  Request  $request
 * @return Response
 */
public function store(Request $request) {
    $this->validate($request, [
        'name' => 'required',
        'email' => 'email|unique:users|max:255'
    ],
    // second array of validation messages can be passed here
    [
        'name.required' => 'Please provide a valid name!',
        'email.required' => 'Please provide a valid email!',
    ]);

    // The validation passed
}

Dans l'exemple ci-dessus, nous validons que le champ de name existe avec une valeur non vide. Deuxièmement, nous vérifions que le champ de email a un format de courrier électronique valide, est unique dans la table de base de données "users" et a une longueur maximale de 255 caractères.

Le | Le caractère (pipe) combine différentes règles de validation pour un champ.

Parfois, vous souhaiterez peut-être arrêter l'exécution des règles de validation sur un attribut après le premier échec de validation. Pour ce faire, assignez la règle de bail à l'attribut:

$this->validate($request, [
    'name' => 'bail|required',
    'email' => 'email|unique:users|max:255'
]);

La liste complète des règles de validation disponibles se trouve dans la section des paramètres ci-dessous .

Validation de tableau

La validation des champs d'entrée de formulaire de tableau est très simple.

Supposons que vous deviez valider chaque nom, email et nom de père dans un tableau donné. Vous pouvez faire ce qui suit:

$validator = \Validator::make($request->all(), [
    'name.*'       => 'required', 
    'email.*'      => 'email|unique:users',
    'fatherName.*' => 'required'
]);

if ($validator->fails()) {
    return back()->withInput()->withErrors($validator->errors());
}

Laravel affiche les messages par défaut pour la validation. Toutefois, si vous souhaitez des messages personnalisés pour les champs basés sur des tableaux, vous pouvez ajouter le code suivant:

[
    'name.*' => [
        'required' => 'Name field is required',
    ],
    'email.*' => [
        'unique'   => 'Unique Email is required',
    ],
    'fatherName.*' => [
        'required' => 'Father Name required',
    ]
]

Votre code final ressemblera à ceci:

$validator = \Validator::make($request->all(), [
    'name.*'       => 'required', 
    'email.*'      => 'email|unique:users',
    'fatherName.*' => 'required',
], [
    'name.*'       => 'Name Required',
    'email.*'      => 'Unique Email is required',
    'fatherName.*' => 'Father Name required',
]);

if ($validator->fails()) {
    return back()->withInput()->withErrors($validator->errors());
}

Autres approches de validation

1) Validation de la demande de formulaire

Vous pouvez créer une "demande de formulaire" pouvant contenir la logique d'autorisation, les règles de validation et les messages d'erreur pour une demande particulière dans votre application.

La commande CLI de make:request Artisan génère la classe et la place dans le répertoire app/Http/Requests :

php artisan make:request StoreBlogPostRequest

La méthode authorize peut être remplacée par la logique d'autorisation pour cette requête:

public function authorize()
{        
    return $this->user()->can('post');
}

La méthode rules peut être remplacée par les règles spécifiques à cette requête:

public function rules()
{
    return [
        'title' => 'required|unique:posts|max:255',
        'body' => 'required',
    ];
}

La méthode des messages peut être remplacée par les messages spécifiques à cette requête:

public function messages()
{
    return [
        'title.required' => 'A title is required',
        'title.unique' => 'There is another post with the same title',
        'title.max' => 'The title may not exceed :max characters',
        'body.required' => 'A message is required',
    ];
}

Pour valider la requête, il suffit d'indiquer la classe de requête spécifique sur la méthode de contrôleur correspondante. Si la validation échoue, une réponse d'erreur sera renvoyée.

public function store(StoreBlogPostRequest $request)
{
    // validation passed
}

2) Création manuelle de validateurs

Pour plus de flexibilité, vous pouvez créer un validateur manuellement et gérer directement la validation échouée:

<?php    
namespace App\Http\Controllers;

use Validator;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class PostController extends Controller
{
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|unique:posts|max:255',
            'body' => 'required',
        ]);

        if ($validator->fails()) {
            return redirect('post/create')
                    ->withErrors($validator)
                    ->withInput();
        }

        // Store the blog post...
    }
}

2) Création fluide de règles

De temps en temps, vous pourriez avoir besoin de créer des règles uniques à la volée, travailler avec la méthode boot() dans un fournisseur de services peut être exagéré, à partir de Laravel 5.4, vous pouvez créer de nouvelles règles avec la classe Rule .

Par exemple, nous allons travailler avec UserRequest pour savoir quand vous voulez insérer ou mettre à jour un utilisateur. Pour l'instant, nous voulons un nom et l'adresse e-mail doit être unique. Le problème avec l’utilisation de la règle unique est que si vous modifiez un utilisateur, il se peut qu’il conserve le même courrier électronique. Vous devez donc exclure l’utilisateur actuel de la règle. L'exemple suivant montre comment vous pouvez facilement le faire en utilisant la nouvelle classe Rule .

<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Http\Request;
use Illuminate\Validation\Rule;

class UserRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules(Request $request)
    {
        $id = $request->route()->getParameter('user');

        return [
            'name'           =>  'required',
            
            // Notice the value is an array and not a string like usual
            'email'         =>  [
                'required',
                Rule::unique('users')->ignore($id)
            ]
        ];
    }
}

Classe de demande de formulaire unique pour POST, PUT, PATCH

Suivant l'exemple de 'Validation de demande de formulaire' , la même classe de demande peut être utilisée pour POST , PUT , PATCH ce qui vous PATCH de créer une autre classe en utilisant les mêmes validations / similaires. Cela est pratique si vous avez des attributs uniques dans votre table.

/**
 * Get the validation rules that apply to the request.
 *
 * @return array
 */
public function rules() {
    switch($this->method()) {
        case 'GET':
        case 'DELETE':
            return [];
        case 'POST':
            return [
                'name'     => 'required|max:75|unique',
                'category' => 'required',
                'price'    => 'required|between:0,1000',
            ];
        case 'PUT':
        case 'PATCH':
            return [
                'name'     => 'required|max:75|unique:product,name,' . $this->product,
                'category' => 'required',
                'price'    => 'required|between:0,1000',
            ];
        default:break;
    }
}

En partant du haut, notre instruction switch va examiner le type de méthode de la requête ( GET , DELETE , POST , PUT , PATCH ).

Selon la méthode, renverra le tableau de règles défini. Si vous avez un champ unique, tel que le champ name de l'exemple, vous devez spécifier un identifiant particulier pour que la validation soit ignorée.

'field_name' => 'unique:table_name,column_name,' . $idToIgnore`

Si vous avez une clé primaire étiquetée autrement que id , vous spécifiez la colonne clé primaire comme quatrième paramètre.

'field_name' => 'unique:table_name,column_name,' . $idToIgnore . ',primary_key_column'

Dans cet exemple, nous utilisons PUT et transmettons à la route ( admin/products/{product} ) la valeur de l'ID du produit. Donc, $this->product sera égal à l' id à ignorer.

Maintenant, vos règles de validation PUT|PATCH et POST ne doivent pas nécessairement être identiques. Définissez votre logique en fonction de vos besoins. Cette technique vous permet de réutiliser les messages personnalisés que vous avez peut-être définis dans la classe de demande de formulaire personnalisée.

Messages d'erreur

Personnalisation des messages d'erreur

Les fichiers /resources/lang/[lang]/validation.php contiennent les messages d'erreur à utiliser par le validateur. Vous pouvez les modifier selon vos besoins.

La plupart d'entre eux ont des espaces réservés qui seront automatiquement remplacés lors de la génération du message d'erreur.

Par exemple, dans 'required' => 'The :attribute field is required.' , l'espace réservé :attribute sera remplacé par le nom du champ (vous pouvez également personnaliser la valeur d'affichage de chaque champ du tableau d' attributes du même fichier).

Exemple

configuration du message:

'required' => 'Please inform your :attribute.',
//...
'attributes => [
    'email' => 'E-Mail address'
]

règles:

`email' => `required`

message d'erreur résultant:

"S'il vous plaît informer votre adresse e-mail."

Personnalisation des messages d'erreur dans une classe Request

La classe Request a accès à une méthode messages() qui devrait renvoyer un tableau. Elle peut être utilisée pour remplacer les messages sans avoir à entrer dans les fichiers lang. Par exemple, si nous avons une validation personnalisée file_exists vous pouvez envoyer des messages comme ci-dessous.

class SampleRequest extends Request {

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules()
    {
        return [
            'image' =>  'required|file_exists'
        ];
    }

    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    public function messages()
    {
        return [
            'image.file_exists' =>  'That file no longer exists or is invalid'
        ];
    }

}

Affichage des messages d'erreur

Les erreurs de validation sont flashées sur la session et sont également disponibles dans la variable $errors , qui est automatiquement partagée avec toutes les vues.

Exemple d'affichage des erreurs dans une vue Blade:

@if (count($errors) > 0)
    <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    </div>
@endif

Règles de validation personnalisées

Si vous souhaitez créer une règle de validation personnalisée, vous pouvez le faire par exemple dans la méthode de boot d'un fournisseur de services, via la façade Validator.

<?php
namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use Validator;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Validator::extend('starts_with', function($attribute, $value, $parameters, $validator) {
            return \Illuminate\Support\Str::startsWith($value, $parameters[0]);
        });

        Validator::replacer('starts_with', function($message, $attribute, $rule, $parameters) {
            return str_replace(':needle', $parameters[0], $message);
        });
    }
}

La méthode extend prend une chaîne qui sera le nom de la règle et une fonction qui à son tour recevra le nom de l'attribut, la valeur en cours de validation, un tableau des paramètres de la règle et l'instance du validateur, et devrait indiquer si la validation passe. Dans cet exemple, nous vérifions si la chaîne de valeur commence par une sous-chaîne donnée.

Le message d'erreur pour cette règle personnalisée peut être défini comme d'habitude dans le fichier /resources/lang/[lang]/validation.php et peut contenir des espaces réservés, par exemple, pour les valeurs de paramètres:

'starts_with' => 'The :attribute must start with :needle.'

La méthode replacer prend une chaîne qui est le nom de la règle et une fonction qui à son tour recevra le message d'origine (avant remplacement), le nom de l'attribut, le nom de la règle et un tableau des paramètres de la règle. et devrait retourner le message après avoir remplacé les espaces réservés selon les besoins.

Utilisez cette règle comme toute autre:

$this->validate($request, [
    'phone_number' => 'required|starts_with:+'
]);