PHP Academy · Lección

Policies: autorización basada en modelos

Asocie policies a modelos de Eloquent y utilícelas en los controladores.

Policies: autorización basada en modelos es una lección gratuita de PHP Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de PHP Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de PHP Academy incluye 4 lecciones en total.

¿Qué es una Policy?

Una Policy es una clase que organiza la lógica de autorización para un modelo Eloquent específico. Se recomienda utilizar policies cuando tenga varias acciones de autorización para el mismo modelo.

Generar una Policy

Use Artisan para generar una policy. Añada --model para rellenar previamente los métodos estándar.

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

Métodos de una Policy

Cada método corresponde a una acción. Recibe el usuario autenticado y la instancia del modelo.

<?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();
    }
}

Registrar Policies

En Laravel 11 y versiones posteriores, las policies se detectan automáticamente si siguen las convenciones de nomenclatura (modelo Post → PostPolicy). También puede registrarlas manualmente en AuthServiceProvider.

Usar Policies en controladores

Llame a $this->authorize("action", $model); Laravel encuentra automáticamente la policy correspondiente.

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

Policy en Blade

La directiva @can funciona con las policies igual que con los gates.

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

Método before()

El método opcional before() de una policy se ejecuta antes que los demás métodos. Devuelva true para conceder acceso total (por ejemplo, a los administradores).

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

Acción create (sin instancia del modelo)

El método de policy create recibe únicamente el usuario (no el modelo), ya que todavía no existe ninguna instancia.

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

Comprobar Policies manualmente

Use la fachada Gate o el modelo de usuario para comprobar policies directamente.

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

Respuestas de las Policies

Devuelva un objeto Response desde un método de policy para personalizar el mensaje de denegación.

<?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.");
}

Probar Policies

Pruebe las policies actuando como un usuario específico en 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));
}

Resumen

Las policies agrupan la autorización a nivel de modelo. Genérelas con make:policy --model. Use $this->authorize() en los controladores y @can en Blade. Use before() para omitir las comprobaciones para administradores.

Comprobación rápida

¿Qué método de policy recibe únicamente el usuario, sin una instancia del modelo?

Preguntas frecuentes

¿La lección «Policies: autorización basada en modelos» es gratis?

Sí — el texto completo de «Policies: autorización basada en modelos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de PHP Academy, actualiza a CoddyKit PRO. El curso de PHP Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Policies: autorización basada en modelos»?

Asocie policies a modelos de Eloquent y utilícelas en los controladores. Practicas PHP Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar PHP Academy?

No se requiere experiencia previa. PHP Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Policies: autorización basada en modelos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de PHP Academy?

Sí. Cada lección de PHP Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Autenticación con Laravel Breeze
Protección de rutas con middleware
Gates: comprobaciones sencillas de autorización
Policies: autorización basada en modelos

← Volver a PHP Academy