gestion des autorisations d'installation de Laravel

Laravel est un framework de développement PHP très populaire. Il fournit de nombreux outils et composants pratiques, qui peuvent considérablement améliorer l'efficacité du développement. Dans le processus de développement d'applications, la gestion des droits des utilisateurs est souvent nécessaire. Laravel fournit une fonction de gestion des autorisations très pratique qui peut nous aider à mettre en œuvre un contrôle des autorisations rapidement et en toute sécurité.

Cet article présentera l'installation et la configuration de la gestion des autorisations Laravel sous les aspects suivants :

1. Installation des composants de gestion des autorisations Laravel
2. Migration de base de données
3. Authentification de l'utilisateur
4. Gestion des rôles et des autorisations
5. Middleware
6. Protection des itinéraires

1. Installez le composant de gestion des autorisations Laravel

Dans Laravel, nous pouvons installer le composant spatie/laravel-permission via composer pour implémenter la fonction de gestion des autorisations. Nous pouvons exécuter la commande suivante dans le répertoire racine du projet pour installer ce composant :

composer require spatie/laravel-permission

Une fois l'installation terminée, nous devons ajouter le fournisseur de services de ce composant dans le fichier config/app.php :

'providers' => [
    // ...
    SpatiePermissionPermissionServiceProvider::class,
],

At en même temps, dans le même fichier Ajoutez la façade de ce composant dans :

'aliases' => [
    // ...
    'Permission' => SpatiePermissionFacadesPermission::class,
    'Role' => SpatiePermissionFacadesRole::class,
],

2. Migration de base de données

Après avoir installé le composant, nous devons exécuter la migration de base de données pour créer des tables liées aux autorisations. Nous pouvons utiliser la commande artisan pour générer le fichier de migration de la base de données :

php artisan make:migration create_permission_tables

Ensuite, ouvrez le fichier de migration généré et ajoutez le code suivant :

class CreatePermissionTables extends Migration
{
    public function up()
    {
        Schema::create('permissions', function (Blueprint $table) {
            $table->increments('id');
            $table->string('name');
            $table->string('guard_name');
            $table->timestamps();
        });

        Schema::create('roles', function (Blueprint $table) {
            $table->increments('id');
            $table->string('name');
            $table->string('guard_name');
            $table->timestamps();
        });

        Schema::create('model_has_roles', function (Blueprint $table) {
            $table->integer('role_id')->unsigned();
            $table->morphs('model');
            $table->string('model_type')->nullable();
            $table->string('guard_name');
            $table->foreign('role_id')->references('id')->on('roles')
                  ->onDelete('cascade');
            $table->primary(['role_id', 'model_id', 'model_type']);
        });

        Schema::create('model_has_permissions', function (Blueprint $table) {
            $table->integer('permission_id')->unsigned();
            $table->morphs('model');
            $table->string('model_type')->nullable();
            $table->string('guard_name');
            $table->foreign('permission_id')->references('id')->on('permissions')
                  ->onDelete('cascade');
            $table->primary(['permission_id', 'model_id', 'model_type']);
        });

        Schema::create('role_has_permissions', function (Blueprint $table) {
            $table->integer('permission_id')->unsigned();
            $table->integer('role_id')->unsigned();
            $table->string('guard_name');
            $table->foreign('permission_id')->references('id')->on('permissions')
                  ->onDelete('cascade');
            $table->foreign('role_id')->references('id')->on('roles')
                  ->onDelete('cascade');
            $table->primary(['permission_id', 'role_id']);
        });
    }

    public function down()
    {
        Schema::dropIfExists('permissions');
        Schema::dropIfExists('roles');
        Schema::dropIfExists('model_has_roles');
        Schema::dropIfExists('model_has_permissions');
        Schema::dropIfExists('role_has_permissions');
    }
}

Ensuite, nous pouvons exécuter la commande de migration :

php artisan migrate

De cette façon, le fichier associé les tables seront créées dans la base de données.

3. Authentification de l'utilisateur

Ensuite, nous devons implémenter la fonction d'authentification de l'utilisateur dans l'application. Laravel nous a fourni un système d'authentification des utilisateurs très pratique. Il nous suffit d'exécuter la commande suivante :

php artisan make:auth

Cette commande générera une page contenant la connexion de l'utilisateur, l'enregistrement, le changement de mot de passe et d'autres fonctions. Nous pouvons créer et gérer des utilisateurs grâce à ces opérations.

4. Gestion des rôles et des autorisations

Dans la gestion des autorisations Laravel, les rôles et les autorisations sont des concepts très importants. Nous pouvons définir des règles de contrôle d'accès des utilisateurs via des rôles et des autorisations.

1. Création de rôles

Nous pouvons utiliser la façade Rôle pour créer des rôles. Par exemple :

use SpatiePermissionModelsRole;

$role = Role::create(['name' => 'admin']);

Le code ci-dessus créera un rôle nommé "admin".

2. Créer des autorisations

De même, nous pouvons utiliser la façade Autorisation pour créer des autorisations :

use SpatiePermissionModelsPermission;

$permission = Permission::create(['name' => 'create posts']);

Le code ci-dessus créera une autorisation appelée "créer des publications".

3. Accorder des autorisations aux rôles

Maintenant que nous avons des rôles et des autorisations, nous devons également accorder des autorisations aux rôles. Nous pouvons le faire en utilisant la méthode givePermissionTo du rôle :

$role = Role::findByName('admin');
$permission = Permission::findByName('create posts');
$role->givePermissionTo($permission);

4. Vérifiez si l'utilisateur a les autorisations

Maintenant que nous avons défini le rôle et les autorisations, nous pouvons utiliser la méthode can fournie par la gestion des autorisations de Laravel pour vérifier si l'utilisateur dispose des autorisations. Par exemple :

$user->can('create posts');

Le code ci-dessus renverra une valeur booléenne indiquant si l'utilisateur actuel dispose de l'autorisation "créer des publications".

5. Vérifiez si l'utilisateur a un rôle

De même, nous pouvons également utiliser la méthode hasRole pour vérifier si l'utilisateur a un certain rôle. Par exemple :

$user->hasRole('admin');

Le code ci-dessus renverra une valeur booléenne indiquant si l'utilisateur actuel a le rôle "admin".

5. Middleware

Nous pouvons utiliser le middleware de Laravel pour protéger nos routes et nos contrôleurs afin d'obtenir un contrôle des autorisations. Voici l'exemple de code :

Route::group([
    'middleware' => ['role:admin'],
], function () {
    Route::get('/admin', function () {
        //
    });
});

Route::group([
    'middleware' => ['permission:create posts'],
], function () {
    Route::get('/new-post', function () {
        //
    });
});

Le code ci-dessus protégera les routes "/admin" et "/new-post" et autorisera uniquement l'accès aux utilisateurs avec le rôle "admin" et l'autorisation "créer des publications".

6. Protection des routes

Enfin, nous devons protéger nos routes et nos contrôleurs. Nous pouvons utiliser les méthodes can et autoriser pour y parvenir.

public function store(Request $request)
{
    $this->authorize('create', Post::class);

    // ...
}

public function edit(Request $request, Post $post)
{
    if (! $request->user()->can('edit', $post)) {
        abort(403);
    }

    // ...
}

Le code ci-dessus protégera les méthodes de magasin et de modification et autorisera uniquement l'accès aux utilisateurs disposant des autorisations "créer" et "modifier".

Résumé

En général, la gestion des autorisations de Laravel est très pratique et sûre. Nous pouvons implémenter le contrôle des autorisations en installant le composant spatie/laravel-permission et utiliser les nombreuses méthodes et fonctions fournies par Laravel pour gérer les rôles et les autorisations. Grâce au middleware et à la protection des routes, nous pouvons facilement protéger nos applications et restreindre l'accès des utilisateurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!