0Pricing
PHP Academy · Leçon

Policies : autorisation fondée sur les modèles

Associer des policies aux modèles Eloquent et les utiliser dans les contrôleurs.

Policies : autorisation fondée sur les modèles est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Qu’est-ce qu’une politique ?

Une politique est une classe qui organise la logique d’autorisation pour un modèle Eloquent spécifique. Les politiques sont recommandées lorsque plusieurs actions d’autorisation concernent le même modèle.

Générer une politique

Utilisez Artisan pour générer une politique. Ajoutez --model pour préremplir les méthodes standard.

$ php artisan make:policy PostPolicy --model=Post

Méthodes des politiques

Chaque méthode correspond à une action. Elle reçoit l’utilisateur authentifié et l’instance du modèle.

<?php
class PostPolicy
{
    public function view(?User $user, Post $post): bool
    {
        return $post->is_published || $user?->id === $post->user_id;
    }

    public function update(User $user, Post $post): bool
    {
        return $user->id === $post->user_id;
    }

    public function delete(User $user, Post $post): bool
    {
        return $user->id === $post->user_id || $user->isAdmin();
    }
}

Enregistrer les politiques

Dans Laravel 11 et les versions ultérieures, les politiques sont découvertes automatiquement si elles respectent les conventions de nommage (modèle Post → PostPolicy). Vous pouvez également les enregistrer manuellement dans AuthServiceProvider.

Utiliser les politiques dans les contrôleurs

Appelez $this->authorize("action", $model) — Laravel trouve automatiquement la politique correspondante.

<?php
public function update(Request $request, Post $post): RedirectResponse
{
    $this->authorize("update", $post);
    $post->update($request->validated());
    return redirect()->route("posts.show", $post);
}

Politique dans Blade

La directive @can fonctionne avec les politiques comme avec les gardes.

@can('update', $post)
    <a href="/posts/{{ $post->id }}/edit">Edit</a>
@endcan

Méthode before()

La méthode facultative before() d’une politique s’exécute avant les autres méthodes. Retournez true pour accorder un accès complet, par exemple aux administrateurs.

<?php
public function before(User $user, string $ability): ?bool
{
    if ($user->isAdmin()) return true;
    return null; // continue to specific method
}

Action de création (sans instance de modèle)

La méthode de politique create reçoit uniquement l’utilisateur (et aucun modèle), puisqu’aucune instance n’existe encore.

<?php
public function create(User $user): bool
{
    return $user->hasVerifiedEmail();
}

Vérifier manuellement les politiques

Utilisez la façade Gate ou le modèle utilisateur pour vérifier directement les politiques.

<?php
Gate::allows("update", $post);    // true/false
$user->can("update", $post);      // true/false
$user->cannot("delete", $post);   // true/false

Réponses des politiques

Retournez un objet Response depuis une méthode de politique pour personnaliser le message de refus.

<?php
use Illuminate\Auth\Access\Response;

public function publish(User $user, Post $post): Response
{
    return $user->isEditor()
        ? Response::allow()
        : Response::deny("Only editors can publish posts.");
}

Tester les politiques

Testez les politiques en agissant au nom d’un utilisateur précis dans PHPUnit.

<?php
public function test_owner_can_delete_post(): void
{
    $user = User::factory()->create();
    $post = Post::factory()->create(["user_id" => $user->id]);
    $this->assertTrue($user->can("delete", $post));
}

Résumé

Les politiques regroupent l’autorisation au niveau des modèles. Générez-les avec make:policy --model. Utilisez $this->authorize() dans les contrôleurs et @can dans Blade. Utilisez before() pour contourner les vérifications au profit des administrateurs.

Vérification rapide

Quelle méthode de politique reçoit uniquement l’utilisateur, sans instance de modèle ?

Questions Fréquemment Posées

La leçon « Policies : autorisation fondée sur les modèles » est-elle gratuite ?

Oui — le texte complet de « Policies : autorisation fondée sur les modèles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Policies : autorisation fondée sur les modèles » ?

Associer des policies aux modèles Eloquent et les utiliser dans les contrôleurs. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Policies : autorisation fondée sur les modèles » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Authentification avec Laravel Breeze
  2. Protéger les routes avec des intergiciels
  3. Gates : contrôles d’autorisation simples
  4. Policies : autorisation fondée sur les modèles
← Retour à PHP Academy