Inicio » Blog »

1 abril, 2025

Sistemas de Roles en Laravel Basico

Autor: J. Luis

#Laravel

gestionar accesos y permisos en tu proyecto web. Este tutorial cubre la creación de roles como "administrador" y "cliente", asignación automática durante el registro,

Suscríbete a nuestro canal en Youtube

En este post, te mostraré cómo implementar un sistema de roles en Laravel, permitiendo asignar roles directamente durante el registro de usuarios. Esto es útil para aplicaciones donde los usuarios deben tener un rol específico desde el momento en que se registran.

Paso 1: Configuración Inicial

Crear el Proyecto Laravel :

bash

composer create-project laravel/laravel nombre-del-proyecto

Configurar la Base de Datos : Edita el archivo .env y configura las credenciales de tu base de datos:

env

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=nombre_de_tu_base_de_datos
DB_USERNAME=root
DB_PASSWORD=

Ejecutar las Migraciones Iniciales :

bash
```
php artisan migrate
```

Paso 2: Crear Modelos y Migraciones para Roles

Crear el Modelo Role y su Migración :

bash
```
php artisan make:model Role -m
```

Definir los Campos en la Migración de roles : Abre la migración generada (database/migrations/xxxx_xx_xx_create_roles_table.php) y define los campos:

php

public function up()
{
    Schema::create('roles', function (Blueprint $table) {
        $table->id();
        $table->string('nombre')->unique(); // Nombre del rol (e.g., "administrador", "cliente")
        $table->timestamps();
    });
}

Crear la Tabla Pivote role_user : Crea una migración para la tabla pivote:

bash
```
php artisan make:migration create_role_user_table
```

Definir los Campos en la Migración de role_user : Abre la migración generada y define los campos:

php

public function up()
{
    Schema::create('role_user', function (Blueprint $table) {
        $table->id();
        $table->foreignId('user_id')->constrained()->onDelete('cascade');
        $table->foreignId('role_id')->constrained()->onDelete('cascade');
        $table->timestamps();
    });
}

Ejecutar las Migraciones :

bash
```
php artisan migrate
```

Paso 3: Definir Relaciones en los Modelos

Editar el Modelo User : Define la relación con los roles y agrega un método para verificar roles:

php

<?php

namespace App\Models;

use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable
{
    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }

    // Verificar si el usuario tiene un rol específico
    public function hasRole($roleName)
    {
        return $this->roles()->where('nombre', $roleName)->exists();
    }
}

Editar el Modelo Role : Define la relación con los usuarios:

php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Role extends Model
{
    public function users()
    {
        return $this->belongsToMany(User::class);
    }
}

Paso 4: Crear Roles Iniciales con Seeder

Crear un Seeder para Roles :

bash
```
php artisan make:seeder RoleSeeder
```

Agregar Roles Iniciales : Edita el seeder (database/seeders/RoleSeeder.php) y agrega los roles "administrador" y "cliente":

php

<?php

namespace Database\Seeders;

use App\Models\Role;
use Illuminate\Database\Seeder;

class RoleSeeder extends Seeder
{
    public function run()
    {
        Role::create(['nombre' => 'administrador']);
        Role::create(['nombre' => 'cliente']);
    }
}

Registrar el Seeder en DatabaseSeeder.php :

php
```
$this->call(RoleSeeder::class);
```
Ejecutar el Seeder :

bash
```
php artisan db:seed
```

Paso 5: Asignar Roles Durante el Registro

Editar el RegisterController : Abre el archivo app/Http/Controllers/Auth/RegisterController.php y modifica el método create para asignar un rol por defecto al usuario registrado:

php

<?php

namespace App\Http\Controllers\Auth;

use App\Models\User;
use App\Models\Role;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Validator;
use Illuminate\Foundation\Auth\RegistersUsers;

class RegisterController extends Controller
{
    use RegistersUsers;

    protected function create(array $data)
    {
        // Crear el usuario
        $user = User::create([
            'name' => $data['name'],
            'email' => $data['email'],
            'password' => Hash::make($data['password']),
        ]);

        // Asignar el rol "cliente" por defecto
        $role = Role::where('nombre', 'cliente')->first();
        $user->roles()->attach($role);

        return $user;
    }
}

Paso 6: Organizar Rutas por Roles

Definir Rutas Protegidas por Roles : En routes/web.php, organiza las rutas según el rol:

php

use App\Http\Controllers\AdminController;
use App\Http\Controllers\ClienteController;

// Grupo de rutas para administradores
Route::middleware(['auth', 'role:administrador'])->prefix('admin')->group(function () {
    Route::get('/dashboard', [AdminController::class, 'dashboard'])->name('admin.dashboard');
});

// Grupo de rutas para clientes
Route::middleware(['auth', 'role:cliente'])->prefix('cliente')->group(function () {
    Route::get('/dashboard', [ClienteController::class, 'dashboard'])->name('cliente.dashboard');
});

Paso 7: Crear Middleware para Roles

Crear Middleware para Verificar Roles :

bash

php artisan make:middleware EnsureUserRole

Editar el Middleware : Abre el archivo app/Http/Middleware/EnsureUserRole.php y define la lógica:

php

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class EnsureUserRole
{
    public function handle(Request $request, Closure $next, ...$roles): Response
    {
        if(empty($roles)){
            return $next($request);
        }

        if(!$request->user()){
            return redirect('/login');
        }

        foreach($roles as $role){
            if($request->user()->roles->contains('name',$role)){
                return $next($request);
            }
        }

        return redirect('/')->with("error","Acceso denegado");
    }
}

Registrar el Middleware : Agrega el middleware en app/Http/Kernel.php:

php

<?php

use Illuminate\Foundation\Application;
use App\Http\Middleware\EnsureUserRole;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
       $middleware->alias([
            'role'=>EnsureUserRole::class
       ]);
    })
    ->withExceptions(function (Exceptions $exceptions) {
        //
    })->create();

Paso 8: Crear Controladores para Cada Rol

Crear Controladores :

bash

php artisan make:controller AdminController
php artisan make:controller ClienteController

Definir Métodos en los Controladores :

AdminController :

php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class AdminController extends Controller
{
    public function dashboard()
    {
        return view('admin.dashboard');
    }
}

ClienteController :

php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ClienteController extends Controller
{
    public function dashboard()
    {
        return view('cliente.dashboard');
    }
}

Conclusión

Con estos pasos, has implementado un sistema de roles en Laravel que permite asignar roles automáticamente durante el registro y restringir el acceso a ciertas rutas según el rol del usuario. Este enfoque es ideal para aplicaciones donde los usuarios necesitan roles específicos desde el momento en que se registran.

Si tienes preguntas o necesitas ayuda adicional, no dudes en dejar un comentario. 😊

Leido 1882 veces | 0 usuarios

Código fuente no disponible.

Compartir link del tutorial con tus amigos