Une façon intelligente de gérer la validation des demandes dans Laravel

Laravel est le framework PHP pour Web Craftsman. Cela nous aide à créer des applications et des API puissantes. Comme beaucoup d'entre vous le savent, il existe de nombreuses façons de valider les requêtes dans Laravel. La gestion de la validation des demandes est une partie très importante de toute application. Laravel possède des fonctionnalités intéressantes qui gèrent très bien ce problème.

Démarrage

La plupart d'entre nous sont habitués à utiliser des validateurs dans les contrôleurs. Il s'agit de la manière la plus courante de gérer la validation des demandes entrantes.

Voici à quoi ressemble notre validateur UserController

<?php
namespace App\Http\Controllers\API\v1\Users;
use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use App\Entities\Models\User;
class UserController extends Controller
{
    public function store(Request $request)
    {
        // validate incoming request
        $validator = Validator::make($request->all(), [
           &#39;email&#39; => &#39;required|email|unique:users&#39;,
           &#39;name&#39; => &#39;required|string|max:50&#39;,
           &#39;password&#39; => &#39;required&#39;
       ]);
       if ($validator->fails()) {
            Session::flash(&#39;error&#39;, $validator->messages()->first());
            return redirect()->back()->withInput();
       }
       // finally store our user
    }
}

Validation dans le contrôleur

Validation des requêtes entrantes dans le contrôleur sans aucun problème, mais ce n'est pas le meilleure approche et votre contrôleur aura l’air en désordre. À mon avis, c'est une mauvaise pratique. Le contrôleur ne doit traiter qu’une seule demande de gestionnaire de la route et renvoyer une réponse appropriée.

L'écriture d'une logique de validation dans le contrôleur brisera le principe de responsabilité unique. Nous savons tous que les exigences changent avec le temps, et chaque fois que les exigences changent, vos responsabilités de classe changeront également. Par conséquent, avoir beaucoup de responsabilités dans une seule classe rend la gestion très difficile.

Laravel a des requêtes de formulaire, une classe de requêtes distincte qui contient une logique de validation. Pour en créer un, vous pouvez utiliser la commande Artisan.

php artisan make : request UserStoreRequest

Cela créera une nouvelle classe Request appHttpRequestUserRequest

<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class UserStoreRequest 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()
    {
        return [
            &#39;email&#39; => &#39;required|email|unique:users&#39;,
            &#39;name&#39; => &#39;required|string|max:50&#39;,
            &#39;password&#39; => &#39;required&#39;
        ];
    }
     /**
     * Custom message for validation
     *
     * @return array
     */
    public function messages()
    {
        return [
            &#39;email.required&#39; => &#39;Email is required!&#39;,
            &#39;name.required&#39; => &#39;Name is required!&#39;,
            &#39;password.required&#39; => &#39;Password is required!&#39;
        ];
    }
}

La classe Laravel Form Request a deux méthodes par défaut auth() et Rules(). Vous pouvez exécuter n'importe quelle logique d'autorisation dans la méthode auth(), que l'utilisateur actuel soit ou non autorisé à demander. Dans la méthode Rules(), vous pouvez écrire toutes les règles de validation. Il existe également une méthode messages() pour transmettre votre propre tableau de messages de validation.

Modifiez maintenant notre UserController pour utiliser notre UserStoreRequest. Vous pouvez saisir l'invite de notre classe de requête et elle analysera et validera automatiquement avant d'appeler notre fonction de contrôleur.

<?php
namespace App\Http\Controllers\API\v1\Users;
use App\Http\Controllers\Controller;
use App\Http\Requests\UserStoreRequest;
class UserController extends Controller
{
    public function store(UserStoreRequest $request)
    {
        // Will return only validated data
        $validated = $request->validated();
    }
}

Notre contrôleur est donc désormais mince et facile à entretenir. Désormais, notre contrôleur n'a plus à se soucier d'aucune logique de validation. Nous avons notre propre classe de validation avec une seule responsabilité : gérer la validation et laisser le contrôleur y travailler.

Si la vérification échoue, elle redirigera l'utilisateur vers l'emplacement précédent et affichera une erreur. En fonction de votre type de demande, un message d'erreur clignotera dans la session. Si la requête est AJAX, une réponse sera renvoyée avec un code d'état 422 et une erreur au format JSON.

Retour

Protégez votre application et vos utilisateurs en nettoyant les entrées. Utilisez un nettoyeur dans votre application et cela garantira que les données sont toujours bien formatées et cohérentes. Dans de nombreux cas, la validation échoue en raison d’erreurs de formatage stupides.

Le numéro de téléphone mobile saisi par l'utilisateur est le +99-9999-999999 ou le +99-(9999)-(999999). Il s'agit d'une erreur très courante et nous ne pouvons pas forcer nos utilisateurs à saisir à nouveau les mêmes informations.

Quelques autres exemples seraient si l'utilisateur saisit un e-mail sous la forme Foo@Bar.COM ou FOO@Bar.com. Ou entrez le prénom et le nom comme FOO **bAR ou foo bar**

Sanitizer contient des méthodes pour transformer et filtrer les données dans un format commun avant de les transmettre au validateur.

J'utilise le package Waavi/Sanitizer qui contient de nombreux filtres.

Waavi / Nettoyage des données

Créons la classe abstraite BaseFormRequest pour la demande de formulaire et utilisons le trait SanitizesInput ici.

<?php
namespace App\Http\Requests;
use Illuminate\Contracts\Validation\Validator;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Http\Exceptions\HttpResponseException;
use Illuminate\Http\JsonResponse;
use Waavi\Sanitizer\Laravel\SanitizesInput;
abstract class BaseFormRequest extends FormRequest
{
    use ApiResponse, SanitizesInput;
    /**
     * For more sanitizer rule check https://github.com/Waavi/Sanitizer
     */
    public function validateResolved()
    {
        {
            $this->sanitize();
            parent::validateResolved();
        }
    }
    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    abstract public function rules();
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    abstract public function authorize();
}

Nous pouvons donc maintenant écrire le contenu sous UserStoreRequest. Étendez vos requêtes de formulaire à partir de notre classe de base afin que nous n'ayons pas à inclure de traits dans toutes les classes de requêtes.

<?php
namespace App\Http\Requests;
class UserStoreRequest extends BaseFormRequest
{
    /**
     * 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()
    {
        return [
            &#39;email&#39; => &#39;required|email|unique:users&#39;,
            &#39;name&#39; => &#39;required|string|max:50&#39;,
            &#39;password&#39; => &#39;required&#39;
        ];
    }
    public function messages()
    {
        return [
            &#39;email.required&#39; => &#39;Email is required!&#39;,
            &#39;name.required&#39; => &#39;Name is required!&#39;,
            &#39;password.required&#39; => &#39;Password is required!&#39;
        ];
    }
    /**
     *  Filters to be applied to the input.
     *
     * @return array
     */
    public function filters()
    {
        return [
            &#39;email&#39; => &#39;trim|lowercase&#39;,
            &#39;name&#39; => &#39;trim|capitalize|escape&#39;
        ];
    }
}

SanitizesInputtrait fournit une méthode filters() pour formater les données de notre requête avant de les fournir au validateur. La méthode filters() renvoie un tableau de filtres valides. Ici, nous convertissons l'e-mail de l'utilisateur en minuscules et coupons de la même manière que nous avons converti le nom en majuscules et échappons à toutes les balises HTML.

Vous pouvez en savoir plus sur les filtres disponibles ici.

Conclusion

Tout d'abord, il semble qu'il ne soit pas nécessaire de faire des classes de requêtes séparées pour tout le monde. Mais imaginez mettre toute la logique de validation dans le même contrôleur. C'est comme un mauvais cauchemar : lorsqu'il s'agit de gérer votre code, à quel point est-ce pire si quelqu'un d'autre doit le gérer ? .

Merci d'avoir lu.

J’aimerais connaître votre avis à ce sujet. Si vous avez des questions ou des suggestions, veuillez laisser un commentaire ci-dessous.

Bonne journée.

Pour plus d'articles techniques liés à Laravel, veuillez visiter la colonne Tutoriel d'introduction au framework Laravel pour apprendre !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!