🔑Autorización avanzada con Policies y Gates

       

 

🔑 Autorización avanzada con Policies y Gates

 

   

Controlando el acceso a acciones y modelos

   

      En Laravel, la **Autenticación** verifica quién es el usuario (login), mientras que la **Autorización** determina lo que el usuario puede hacer. Aunque vimos los roles básicos, la autorización avanzada a nivel de aplicación (ej. "¿Puede este usuario editar *este* post?") se maneja de forma elegante con **Policies** y **Gates**. Estas herramientas son fundamentales para mantener una aplicación segura y con permisos escalables.    

 

    

   

🚪 Gates (Puertas)

   

      Los **Gates** son la forma más simple de definir reglas de autorización. Son funciones de *closure* o de *callback* que definen una capacidad específica, típicamente usada para permisos que no están ligados a un modelo de Eloquent (ej. "acceder al panel de administración").    

   

Ejemplo Visual: Gate para 'es-admin'

   

      Los Gates se definen en el archivo **`App\Providers\AuthServiceProvider.php`**.    

   

     

        Definición de Gate (AuthServiceProvider.php)              

     

// Dentro del método boot()
Gate::define('es-admin', function ($user) {
    return $user->rol === 'administrador';
});

   

   

      Luego se verifica el Gate en cualquier parte de tu código:    

   

     

        Uso del Gate              

     

// En un Controlador o Vista:
if (Gate::allows('es-admin')) {
    // El usuario es administrador
}

// En Blade:
@can('es-admin')
    Panel de Administración
@endcan

   

 

 

   

🛡️ Policies (Políticas): Autorización basada en Modelos

   

      Las **Policies** son clases que organizan la lógica de autorización para un modelo específico (ej. **`PostPolicy`** para el modelo **`Post`**). Son la herramienta recomendada por Laravel para la mayoría de las verificaciones de permisos relacionadas con Eloquent.    

   

Creación y Estructura de una Policy

   

      Puedes crear una Policy con Artisan:    

   

     

        Comando Artisan              

     

php artisan make:policy PostPolicy --model=Post

   

   

      Esta clase contendrá métodos como `viewAny`, `view`, `create`, `update`, `delete`, etc.    

 

 

   

✍️ Ejemplo de Uso de Policy: Editar un Post

   

      Definiremos una regla simple: un usuario solo puede editar su propio post.    

   

Definición de la Policy (`PostPolicy.php`)

   

     

        Método update en PostPolicy              

     

public function update(User $user, Post $post): bool
{
    // Retorna true si el ID del usuario actual es igual
    // al ID del usuario que creó el post.
    return $user->id === $post->user_id;
}

   

   

      **Uso en el Controlador:** Usamos el método `authorize()` para delegar la verificación a la Policy. Si falla, Laravel automáticamente lanza una excepción 403.    

   

     

        Uso en un Controlador              

     

public function edit(Post $post)
{
    // Verifica si el usuario actual (Auth::user()) puede 'update' este $post.
    $this->authorize('update', $post);

    return view('posts.edit', compact('post'));
}

   

 

    

   

🧑‍💻 Resumen: ¿Cuándo usar cada uno?

   

     
• **Gates:** Usar para permisos generales, de alto nivel, que no están ligados a una instancia de modelo específica (ej. `acceder-dashboard`, `ver-reportes-generales`).
     
• **Policies:** Usar para la mayoría de las acciones CRUD (**C**rear, **R**eer, **U**pdate, **D**elete) que afectan a un modelo Eloquent (ej. `editar(Post $post)`, `borrar(Comment $comment)`).
   

 

 

          🏠 Volver al Índice               Siguiente: Pruebas de Unidad y Pruebas de Característica a fondo 🔬