How to use Laravel to implement user rights management functions

How to use Laravel to implement user rights management functions

With the development of web applications, user rights management has become more and more important in many projects. Laravel, as a popular PHP framework, provides many powerful tools and functions for handling user rights management. This article will introduce how to use Laravel to implement user rights management functions and provide specific code examples.

1. Database design

First, we need to design a database model to store the relationship between users, roles and permissions. To simplify the operation, we will use Laravel's own migration tool to create database tables. Open the command line tool and switch to the project root directory, enter the following command to create the migration file:

php artisan make:migration create_roles_table --create=roles
php artisan make:migration create_permissions_table --create=permissions
php artisan make:migration create_role_user_table --create=role_user
php artisan make:migration create_permission_role_table --create=permission_role

Then find the generated migration files in the database/migrations directory, and edit them. The following is sample code:

// roles表迁移文件
public function up()
{
    Schema::create('roles', function (Blueprint $table) {
        $table->increments('id');
        $table->string('name')->unique();
        $table->timestamps();
    });
}

// permissions表迁移文件
public function up()
{
    Schema::create('permissions', function (Blueprint $table) {
        $table->increments('id');
        $table->string('name')->unique();
        $table->timestamps();
    });
}

// role_user关联表迁移文件
public function up()
{
    Schema::create('role_user', function (Blueprint $table) {
        $table->integer('role_id')->unsigned();
        $table->integer('user_id')->unsigned();
        $table->foreign('role_id')->references('id')->on('roles');
        $table->foreign('user_id')->references('id')->on('users');
    });
}

// permission_role关联表迁移文件
public function up()
{
    Schema::create('permission_role', function (Blueprint $table) {
        $table->integer('permission_id')->unsigned();
        $table->integer('role_id')->unsigned();
        $table->foreign('permission_id')->references('id')->on('permissions');
        $table->foreign('role_id')->references('id')->on('roles');
    });
}

After completing editing the migration file, run the following command to perform the migration:

php artisan migrate

2. Create model and relationship

Connect Next, we need to create Laravel models to map database tables and establish relationships between them. Open the command line tool and enter the following command to generate the model file:

php artisan make:model Role
php artisan make:model Permission

Then open the generated model file and add the following code:

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

    public function permissions()
    {
        return $this->belongsToMany(Permission::class);
    }
}

// Permission模型
class Permission extends Model
{
    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }
}

3. Add user association

Open the User model file and add the following method to the class:

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

public function hasRole($role)
{
    if (is_string($role)) {
        return $this->roles->contains('name', $role);
    }

    return !! $role->intersect($this->roles)->count();
}

public function assignRole($role)
{
    return $this->roles()->save(
        Role::whereName($role)->firstOrFail()
    );
}

In the code, the Role model is created using the belongsToMany method The many-to-many relationship with the User model, the hasRole method is used to determine whether the user has a certain role, and the assignRole method is used to assign a role to the user .

4. Add Permission Association

In the Role model, we have defined multiple pairs with the Permission model There are many relationships, so existing methods can be used directly.

5. Middleware configuration

Laravel provides middleware functions to control routing permissions. We need to configure middleware to restrict user access. Open the app/Http/Kernel.php file and add the following code in the $routeMiddleware array:

'role' => AppHttpMiddlewareRoleMiddleware::class,
'permission' => AppHttpMiddlewarePermissionMiddleware::class,

6. Create middleware

In the command line tool, enter the following command to generate the middleware file:

php artisan make:middleware RoleMiddleware
php artisan make:middleware PermissionMiddleware

Then open the generated middleware file and add the following code:

// RoleMiddleware
class RoleMiddleware
{
    public function handle($request, Closure $next, $role)
    {
        if (! $request->user()->hasRole($role)) {
            abort(403, 'Unauthorized');
        }

        return $next($request);
    }
}

// PermissionMiddleware
class PermissionMiddleware
{
    public function handle($request, Closure $next, $permission)
    {
        if (! $request->user()->hasPermissionTo($permission)) {
            abort(403, 'Unauthorized');
        }

        return $next($request);
    }
}

In the code, RoleMiddlewareChecks whether the user has the specified role, PermissionMiddlewareChecks whether the user has the specified permissions.

7. Using middleware

Now, you can use the middleware we defined to restrict access on routes that require permission control. In the routing file, use the middleware method and pass in the middleware name, as in the following example:

Route::get('/admin', function () {
    // 限制只有拥有admin角色的用户才能访问
})->middleware('role:admin');

Route::get('/delete-user', function () {
    // 限制只有拥有delete-user权限的用户才能访问
})->middleware('permission:delete-user');

So far, we have implemented the function of using Laravel for user rights management, and passed the middleware Access rights are restricted by the software. Through the use of database models, relationships, middleware and other functions, flexible management and control of users, roles and permissions are achieved.

Summary:

User rights management is an integral part of web applications, and Laravel provides us with powerful tools and functions to achieve this need. This article demonstrates how to use Laravel to implement user rights management functions through detailed steps such as database design, model association, and middleware configuration, and provides specific code examples. I hope this article will be helpful to you when managing user rights.

The above is the detailed content of How to use Laravel to implement user rights management functions. For more information, please follow other related articles on the PHP Chinese website!