ENTRUST [ Laravel 5 ]


Entrust nos presenta una manera flexible de agregar permisos basados ​​en roles para Laravel 5.

La documentación oficial(en ingles), nos da una vista amplia de lo que podemos hacer con este "paquetazo".

Instalación


Abrimos una consola en la raíz de nuestro proyecto y tipeamos:
composer require zizaco/entrust dev-laravel-5
Luego, en config/app.php al arreglo de 'providers' añadir:
'Zizaco\Entrust\EntrustServiceProvider',
y al arreglo 'aliases' añadir:
'Entrust' => 'Zizaco\Entrust\EntrustFacade',
Ahora veamos como se usa..!!

Configuración


Entrust trae unas configuraciones por defecto (tablas,modelos,etc.), pero si deseas personalizar dichas configuraciones, abriremos una terminal en la raíz de nuestro proyecto y tipeamos:
php artisan vendor:publish
en el archivo config/entrust.php vamos a definir los nombres de nuestras tablas y también de nuestros modelos, en mi caso sera esto:
return array(

    'role' => 'App\Models\Role',

    'roles_table' => 'roles',

    'permission' => 'App\Models\Permission',

    'permissions_table' => 'permissions',

    'permission_role_table' => 'permission_role',

    'role_user_table' => 'role_user',

);
Ahora vamos a generar las migraciones en nuestra terminal tipeamos:
php artisan entrust:migration


Se genera la migración <timestamp>_entrust_setup_tables.php y ahora podemos migrar todo a nuestra base de datos:
php artisan migrate


Después de la migración, cuatro tablas nuevas estarán presentes:

  1. roles - Almacena los roles
  2. permissions - Almacena los permisos
  3. role_user - Almacena las relaciones de muchos-a-muchos entre roles y usuarios
  4. permission_role - Almacena las relaciones de muchos-a-muchos entre roles y permisos

Lo siguiente es crear los modelos que requiere el paquete:

Role


En nuestro archivo de configuración entrust.php definimos los nombres de los modelos, en mi caso cree una carpeta llamada Models. Aquí agregamos el archivo Roles.php

<?php namespace App\Models;

use Zizaco\Entrust\EntrustRole;

class Role extends EntrustRole
{
}

Permission


En la misma carpeta creamos el archivo Permission.php

<?php namespace App;

use Zizaco\Entrust\EntrustPermission;

class Permission extends EntrustPermission
{
}

User


Por ultimo en nuestro modelo User agregamos el trait EntrustUserTrait que trae el paquete.

<?php namespace App;

use Illuminate\Auth\Authenticatable;
use Illuminate\Auth\Passwords\CanResetPassword;
use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
use Illuminate\Contracts\Auth\CanResetPassword as CanResetPasswordContract;
use Illuminate\Database\Eloquent\Model;
use Zizaco\Entrust\Traits\EntrustUserTrait;

class User extends Model implements AuthenticatableContract, CanResetPasswordContract
{

    use Authenticatable, CanResetPassword, EntrustUserTrait; // add this trait to your user model

    ...
}

Esto agrega la relación del usuario con sus roles y también varias funciones para comprobar los permisos de dichos roles.

Aplicación


Veamos como asignamos roles y agregamos permisos:

/**
 * Creamos un Rol
 */
$admin = new \App\Models\Role();
$admin->name = 'admin';
$admin->display_name = 'Administrador de usuarios'; // opcional
$admin->description = 'Se permite al usuario gestionar y editar otros usuarios'; // opcional
$admin->save();

/**
 * Creamos un Usuario
 */
$user = new \App\User();
$user->name = 'John Doe';
$user->email = 'johndoe@doe.com';
$user->password = bcrypt('12345');
$user->save();

/**
 * Asignamos el Rol admin al usuario
 * Usando el alias del paquete
 */
$user->attachRole($admin);// podemos enviar el Rol o el id del Rol

/**
 * O usamos Eloquent
 */
$user->roles()->attach($admin->id); //usamos solamente el id del Rol

/**
 * Creamos permisos
 */
$createPost = new \App\Models\Permission();
$createPost->name = 'create-post';
$createPost->display_name = 'Crear Entradas'; // opcional
// Allow a user to...
$createPost->description = 'crear nuevas entradas del blog'; // opcional
$createPost->save();

$editUser = new \App\Models\Permission();
$editUser->name = 'edit-user';
$editUser->display_name = 'Editar Usuarios'; // opcional
// Allow a user to...
$editUser->description = 'editar los usuarios existentes'; // opcional
$editUser->save();

/**
 * Al Rol admin le asignamos los permisos
 */
$admin->attachPermission($createPost); //esto es equivalente a $admin->perms()->sync(array($createPost->id));
$admin->attachPermissions([$createPost, $editUser]); //esto es equivalente a $admin->perms()->sync(array($createPost->id, $editUser->id));

Revisar Roles y Permisos


Para poder comprobar los roles usaremos:

$user->hasRole('owner');   // false
$user->hasRole('admin');   // true
$user->can('edit-user');   // true
$user->can('create-post'); // true

En nuestro próximo tutorial hablaremos de como implementarlo usando middleware's y también mejoraremos unas cuantas lineas de código.

Saludos y hasta la proxima.

Fuente: Zizaco/entrust - GitHub

7 comentarios:

  1. hola. en que archivo hacer la creación de roles.
    /**
    * Creamos un Rol
    */
    $admin = new \App\Models\Role();
    .
    .
    .
    $admin->save();

    ResponderEliminar
    Respuestas
    1. Hola,
      Puedes usar este método o usar un seed para llenar la tabla de tu base de datos.
      si usas este método puedes poner este código en un controlador o en una ruta.

      Eliminar
  2. Gracias por tomarte el tiempo de traducirla...

    ResponderEliminar
  3. excelente me funciono al pelo :), pregunto como mas lo puedo utilizar aparte de estos ejemplos.

    ResponderEliminar
    Respuestas
    1. Hola, aquí tienes un ejemplo de como implementarlo usando middleware's
      http://matrixdevelopments.blogspot.com/2015/05/implementar-entrust-usando-middlewares.html

      Eliminar
  4. buen dia disculpe como pongo lo de la parte de apliccion todo ese codigo en que parte lo pongo o como lo hago? espero pueda ayudarme porfavor

    ResponderEliminar
    Respuestas
    1. Hola Daniel, si quieres puedes descargar el código completo del proyecto que creamos en nuestro post Implementar Entrust usando middlewares

      Eliminar