This site uses tracking cookies used for marketing and statistics. Privacy Policy

Laravel

Step by step guide for using Laravel-permissions package from spatie

September 16th, 2022

What is Laravel-permission?

Not every user needs to have an access to all the data in the database. Let’s take the example of a college website. The access to the data and permissions allowed to a teacher will be different from that of a student. Why? Because their roles and responsibilities are different.

Laravel-permission allows you to do the same with your database. It lets you manage users’ roles and permissions in your database. Let’s see how you can do the same step-by-step.

Prefer watching a video instead? No worries! Just follow along with the video below.

Step 1. Install Laravel project

To keep things simple, I am going to show you how to install Laravel using composer provided that you already have WAMP or XAMPP installation and Composer on your computer.

composer create-project laravel/laravel laravel-permission-demo
cd laravel-permission-demo

Once the application is started after you run the above-mentioned command, you have to start Laravel’s local development server. For that, use Artisan CLI’s serve command.

php artisan serve

Now you have to create a new database in PhpMyAdmin and add the database details in the root directory .env file. We are going to use MySQL.

DB_CONNECTION=mysql
DB_HOST=mysql
DB_PORT=3306
DB_DATABASE=laravel_permission_demo
DB_USERNAME=root
DB_PASSWORD=password

Step 2. Install Breeze

What is Breeze?

Whenever you go to any website, you will often see login and signup forms which also reset and confirm passwords, and verify your email. Lararvel Breeze helps you do exactly this with your website in a simple way.

Now, if you want to assign permissions to your users, you need to have a proper login system. So here is how you can install Breeze and publish the authentication views, routes, controllers, and other resources.

composer require laravel/breeze --dev
php artisan breeze:install

Now it’s time to compile the frontend assets of your application. For a new terminal, run: -

npm install
npm run dev

For database migration: -

php artisan migrate

Once your migration users and tables are created in your database, you can see the following.

Now you can check your application’s login and register URLs

For login

http://127.0.0.1:8000/login

For register

http://127.0.0.1:8000/register

Step 3. Install Laravel-permission package

Why do we use Laravel permission?

Not everybody needs to get access to everything in your database. Otherwise, you may be running the risk of jeopardizing your invaluable data. Thus, Laravel permissions give you the power to limit access to data as per the roles of the user. So next we will cover how to install the Laravel-permission package.

I would recommend you to first go and check the prerequisites page for user models. Please also check that you don’t have a file named config/permission.php because this package will publish a file with that name. If you have one, then rename it.

Run this command.

composer require spatie/laravel-permission

You can even manually add the service provider in your config/app.php file. However, it is optional.

'providers' => [
    // ...
    Spatie\Permission\PermissionServiceProvider::class,
];

Now publish the migration and the config/permission.php config file using: -

php artisan vendor:publish --provider="Spatie\Permission\PermissionServiceProvider"

Here I want to point out a couple of things: -

If you want to use teams feature, updates your config/permission.php file and set 'teams' => true. If you want to use a custom foreign key for teams, you should also change teamforeignkey. I also recommend you to check the advanced section of docs on UUID steps if your are using UUIDs.
Clear your config cache as it is a bad practice to do config-caching while developing. For clearing caching configurations locally, use these commands: -

php artisan optimize:clear
 # or
php artisan config:clear

Once the config and migration have been published and configured, create the tables for this package by running: -

php artisan migrate

Add all the required traits to your user model. You can refer to the Basic Usage section of the docs to know how to get started using the feature of this package.

App\Models\User.php

Add this line user.php

use Spatie\Permission\Traits\HasRoles;

After that user HasRoles in class.

- use HasApiTokens, HasFactory, Notifiable;
+ use HasApiTokens, HasFactory, Notifiable , HasRoles;

Step 4: Create permission, roles, and screens

What is a role?

The role is the authority we assign to someone for access to the data. The higher someone’s role is, the more permissions he will get. Usually, we assign roles as per the rank of the user. For example - executives may get the role of super admin to do anything he wants. Here is how you can create permissions, roles, and screens.

First, we will create a database seeder for the super admin user.

php artisan make:seeder BasicPermissionSeeder

Use spatie classes in seeder file.

use Spatie\Permission\Models\Permission;
use Spatie\Permission\Models\Role;
use Spatie\Permission\PermissionRegistrar;

Now, replace this code in database\seeder\BasicPermissionSeeder.php

<?php

namespace Database\Seeders;

// use Illuminate\Database\Console\Seeds\WithoutModelEvents;
use Illuminate\Database\Seeder;
use Spatie\Permission\Models\Permission;
use Spatie\Permission\Models\Role;
use Spatie\Permission\PermissionRegistrar;

class BasicPermissionSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        // Reset cached roles and permissions
        app()[PermissionRegistrar::class]->forgetCachedPermissions();

        // create permissions
        $permissions = [
            'permission list',
            'permission create',
            'permission edit',
            'permission delete',
            'role list',
            'role create',
            'role edit',
            'role delete',
            'user list',
            'user create',
            'user edit',
            'user delete'
         ];
        foreach ($permissions as $permission) {
            Permission::create(['name' => $permission]);
        }
        // create roles and assign existing permissions
        $role1 = Role::create(['name' => 'writer']);
        $role1->givePermissionTo('permission list');
        $role1->givePermissionTo('role list');
        $role1->givePermissionTo('user list');
        $role2 = Role::create(['name' => 'admin']);
        
        foreach ($permissions as $permission) {
            $role2->givePermissionTo($permission);
        }
        $role3 = Role::create(['name' => 'super-admin']);
        // gets all permissions via Gate::before rule; see AuthServiceProvider
        // create demo users
        $user = \App\Models\User::factory()->create([
            'name' => 'Super Admin',
            'email' => 'superadmin@example.com',
        ]);
        $user->assignRole($role3);
        $user = \App\Models\User::factory()->create([
            'name' => 'Admin User',
            'email' => 'admin@example.com',
        ]);
        $user->assignRole($role2);
        $user = \App\Models\User::factory()->create([
            'name' => 'Example User',
            'email' => 'test@example.com',
        ]);
        $user->assignRole($role1);
    }
}

So, just to recap, till now we have created a super admin user, a test user, and an admin user and assigned to each one of them permissions as per role 1, role 2, and role 3 respectively.

Next, you have to run the database seed command to insert data into the database.

php artisan db:seed --class=BasicPermissionSeeder

Grant Super-Admin access

Gate has allowed all the permissions to the super-admin. We are using Laravel’s default password for the super-admin, which is “password”.

Add below a Gate::before checking in your AuthServiceProviderboot function.

use Illuminate\Support\Facades\Gate;

// Implicitly grant "Super-Admin" role all permission checks using can()
Gate::before(function ($user, $ability) {
    if ($user->hasRole(env('APP_SUPER_ADMIN', 'super-admin'))) {
        return true;
    }
});

Add permission check

Now all the users have full access to the application as we have not added permission to check Laravel’s default can function.

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

In Blade directives:

@can('permission create')
...
@endcan

Next, we are going to implement CRUD (screen) for the permission and roles.

Step 5: Permission management CRUD

Follow these steps to create permission CRUD for our Laravel Admin panel.

For the permission

Step 1: Create a model

We are going to start by creating a model for permission CRUD. You can create your model using the make:model Artisan command. It will create a Permission.php file in app/Models folder.

We can also create the models and controllers manually.

php artisan make:model Permission

Next is to extend our permission model with Spatie\\Permission\\Models\\Permission and update the model with the below code.

app/Models/Permission.php

<?php

namespace App\Models;
use Spatie\Permission\Models\Permission as OriginalPermission;

class Permission extends OriginalPermission
{
    protected $fillable = [
        'name',
        'guard_name',
        'updated_at',
        'created_at'
    ];
}

Step 2: Create a controller

The make:controller Artisan command is used to create the controllers.

php artisan make:controller Admin/PermissionController --model=Permission --resource

The --resource option is used to quickly create a controller to handle create, read, update, and delete (“CRUD”) operations.

Step 3: Add routes

Extend controllers in web.php file.

use App\\Http\\Controllers\\Admin\\PermissionController;

Add resource route in web.php. We are using auth middleware and Admin namespace.

Route::prefix('admin')->namespace('App\\Http\\Controllers\\Admin')->middleware(['auth'])->group(function() {
    Route::resource('permission', PermissionController::class);
});

Step 4: Add a link to the navigation

So, we have completed the creation of CRUD for permission. Now add the permission link below the Navigation Links on navigation.blade.php.

resources/views/layouts/navigation.blade.php

<!-- Navigation Links -->
<div class="hidden space-x-8 sm:-my-px sm:ml-10 sm:flex">
     <x-nav-link :href="route('dashboard')" 
		:active="request()->routeIs('dashboard')">
		{{ __('Dashboard') }}
	</x-nav-link>
	<x-nav-link :href="route('permission.index')" 
		:active="request()->routeIs('permission.index')">
		{{ __('Permission') }}
	</x-nav-link>
</div>

For mobile navigation

<!-- Responsive Navigation Menu -->
<div :class="{'block': open, 'hidden': ! open}" class="hidden sm:hidden">
	<div class="pt-2 pb-3 space-y-1">
	<x-responsive-nav-link :href="route('dashboard')" :active="request()->routeIs('dashboard')">			       {{ __('Dashboard') }}
	</x-responsive-nav-link>
	<x-responsive-nav-link :href="route('permission.index')" :active="request()->routeIs('permission.index')">
		{{ __('Permission') }}
	</x-responsive-nav-link>
</div>