Implementar un sistema de roles básico en Laravel desde cero

En este tutorial te enseñaremos cómo implementar un sistema de roles en un proyecto básico de autenticación en Laravel. Utilizaremos los roles más comunes, como admin y lector, para proteger las rutas y garantizar que solo los usuarios con los permisos adecuados puedan acceder a ciertas secciones de la aplicación.

📝 Tabla de Contenidos:

1. Paso 1: Crear el modelo Role, migración y seeder.
2. Paso 2: Agregar el campo role_id a la tabla de usuarios.
3. Paso 3: Crear el Middleware CheckRole.
4. Paso 4: Registrar el Middleware en bootstrap/app.php.
5. Paso 5: Asignar un rol a los usuarios al registrarse.
6. Paso 6: Proteger las rutas con roles.
7. Paso 7: Realizar pruebas.

III.- AGREGAR ROLES

En Laravel, existen varias maneras de agregar roles a los usuarios. Vamos a cubrir tres enfoques principales:

1. Role como tipo ENUM en la tabla de usuarios.
2. Relación uno a muchos entre user y role.
3. Tabla intermedia userrole para relaciones muchos a muchos.

En este tutorial, implementaremos la relación uno a muchos entre los modelos User y Role, lo que es más sencillo para un sistema de autenticación básico.

Relación entre User y Role

• User:

  • id
  • name
  • email
  • password
  • active
  • role_id
  • belongsTo(Role)

• Role:

  • id
  • name
  • hasMany(User)

🛠 Paso 1: Crear el modelo Role, migración y seeder

Primero, necesitamos crear el modelo Role con su migración y seeder.

Comandos:

php artisan make:model Role -m
php artisan make:seeder RoleSeeder

Migración (database/migrations/xxxx_xx_xx_create_roles_table.php):

public function up()
{
    Schema::create('roles', function (Blueprint $table) {
        $table->id();
        $table->string('name'); // Admin, Lector, etc.
        $table->timestamps();
    });
}

Seeder (database/seeders/RoleSeeder.php):

public function run()
{
    \App\Models\Role::create(['name' => 'admin']);
    \App\Models\Role::create(['name' => 'lector']);
}

Ejecuta las migraciones y el seeder:

php artisan migrate
php artisan db:seed --class=RoleSeeder

🛠 Paso 2: Agregar role_id a users

Ahora, agregamos el campo role_id a la tabla users para vincular cada usuario con un rol específico.

Comando:

php artisan make:migration add_role_id_to_users_table --table=users

Migración (database/migrations/xxxx_xx_xx_add_role_id_to_users_table.php):

public function up()
{
    Schema::table('users', function (Blueprint $table) {
        $table->unsignedBigInteger('role_id')->default(2); // Default to 'lector'
        $table->foreign('role_id')->references('id')->on('roles');
    });
}

Ejecuta las migraciones:

php artisan migrate 

🛠 Paso 3: Crear Middleware CheckRole

El siguiente paso es crear un Middleware que verifique el rol del usuario y permita el acceso solo a los usuarios con el rol adecuado.

Comando:

php artisan make:middleware CheckRole 

Middleware (app/Http/Middleware/CheckRole.php):

public function handle(Request $request, Closure $next, ...$roles)
{
    $user = $request->user();
    if (!$user || !in_array($user->role->name, $roles)) {
        abort(403, 'No autorizado');
    }
    return $next($request);
}

🛠 Paso 4: Registrar el Middleware en bootstrap/app.php

Para que Laravel reconozca el Middleware, debemos registrarlo en el archivo app/Http/Kernel.php.

En el archivo Kernel.php:

protected $routeMiddleware = [
    // otros middlewares
    'role' => \App\Http\Middleware\CheckRole::class,
];

🛠 Paso 5: Asignar un Rol al Registrar un Usuario

Ahora, cuando un usuario se registre, asignamos un rol automáticamente. Modificamos el método register en AuthController.

Modificación en AuthController.php:

public function register(Request $request)
{
    $request->validate([
        'name' => 'required',
        'email' => 'required|email|unique:users',
        'password' => 'required|min:8|confirmed',
    ]);

    // Asignar el rol de 'lector' por defecto
    $role = Role::where('name', 'lector')->first();

    $user = User::create([
        'name' => $request->name,
        'email' => $request->email,
        'password' => Hash::make($request->password),
        'role_id' => $role->id,
    ]);

    Auth::login($user);

    return redirect()->intended('dashboard');
}

🛠 Paso 6: Proteger las Rutas con Roles

Finalmente, protegemos las rutas según el rol del usuario. Usamos el Middleware role.

Ejemplo de rutas protegidas:

Route::get('/admin/dashboard', function () {
    return view('admin.dashboard');
})->middleware(['auth', 'role:admin']);

Route::get('/lector/dashboard', function () {
    return view('lector.dashboard');
})->middleware(['auth', 'role:lector']);

🛠 Paso 7: Test

Para probar que todo funciona correctamente:

1. Registra un usuario y verifica que se le asigna el rol correcto.

2. Inicia sesión y verifica que, según el rol, se te redirija a la página correspondiente (admin o lector).

3. Intenta acceder a una ruta protegida por rol para asegurar que solo los usuarios con el rol adecuado puedan acceder.

Tutorial de Autenticación Básico en Laravel sin paquetes

• Implementacion de un login básico sin paquetes
• Implementacion de un register básico sin paquetes
• Implementacion de roles sin paquetes

Leido 912 veces | 1 usuarios