Laravel Permission

https://spatie.be/docs/laravel-permission
Admin
Laravel Permission is a package that allows you to manage user permissions and roles in a database...
Tokens:26,436
Snippets:265
Trust Score:9.3
Update:1 week ago
Show doc for...
Tokens:
Raw
### Initial setup: create Laravel app and install spatie/laravel-permission

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/new-app

Run these commands to create a new Laravel project, configure SQLite, install the spatie/laravel-permission package, publish its config, and add the HasRoles trait to the User model. The commands include optional steps for Git initialization and environment setup.

```bash
cd ~/Sites
laravel new mypermissionsdemo
# (No Starter Kit is needed, but you could go with Livewire or Breeze/Jetstream, with Laravel's Built-In-Auth; or use Bootstrap using laravel/ui described later, below)
# (You might be asked to select a dark-mode-support choice)
# (Choose your desired testing framework: Pest or PHPUnit)
# (If offered, say Yes to initialize a Git repo, so that you can track your code changes)
# (If offered a database selection, choose SQLite, because it is simplest for test scenarios)
# (If prompted, say Yes to run default database migrations)
# (If prompted, say Yes to run npm install and related commands)

cd mypermissionsdemo

# The following git commands are not needed if you Initialized a git repo while "laravel new" was running above:
git init
git add .
git commit -m "Fresh Laravel Install"

# These Environment steps are not needed if you already selected SQLite while "laravel new" was running above:
cp -n .env.example .env
sed -i '' 's/DB_CONNECTION=mysql/DB_CONNECTION=sqlite/' .env
sed -i '' 's/DB_DATABASE=/#DB_DATABASE=/' .env
touch database/database.sqlite

# Package
composer require spatie/laravel-permission
php artisan vendor:publish --provider="Spatie\Permission\PermissionServiceProvider"
git add .
git commit -m "Add Spatie Laravel Permissions package"
php artisan migrate:fresh

# Add `HasRoles` trait to User model
sed -i '' $'s/use HasFactory, Notifiable;/use HasFactory, Notifiable;\n    use \\Spatie\\Permission\\Traits\\HasRoles;/' app/Models/User.php
sed -i '' $'s/use HasApiTokens, HasFactory, Notifiable;/use HasApiTokens, HasFactory, Notifiable;\n    use \\Spatie\\Permission\\Traits\\HasRoles;/' app/Models/User.php
git add . && git commit -m "Add HasRoles trait"
```

--------------------------------

### Setup Laravel auth scaffolding with laravel/ui

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/new-app

If you didn't install a starter kit, run these commands to add Laravel's basic auth scaffolding using laravel/ui. This provides login capability for testing roles and permissions with a demo user.

```bash
composer require laravel/ui --dev
php artisan ui bootstrap --auth
# npm install && npm run build
git add . && git commit -m "Setup auth scaffold"
```

--------------------------------

### Install package via Composer

Source: https://spatie.be/docs/laravel-permission/v8/installation-laravel

Run this command to install the spatie/laravel-permission package via Composer.

```bash
composer require spatie/laravel-permission
```

--------------------------------

### Assign permissions to user and role

Source: https://spatie.be/docs/laravel-permission/v8

Shows how to give a permission directly to a user with givePermissionTo, assign a role with assignRole, and give a permission to a role. Used after installation to set up permissions.

```php
// Adding permissions to a user
$user->givePermissionTo('edit articles');

// Adding permissions via a role
$user->assignRole('writer');

$role->givePermissionTo('edit articles');
```

--------------------------------

### Creating and assigning permissions with subparts

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/wildcard-permissions

Shows how to create permissions with subparts and assign them to users. The first example restricts actions to create, update, and view on posts and users. The second allows those actions on any resource. The third allows any action on posts with IDs 1, 4, and 6.

```php
// user can only do the actions create, update and view on both resources posts and users
Permission::create(['name'=>'posts,users.create,update,view']);
$user->givePermissionTo('posts,users.create,update,view');

// user can do the actions create, update, view on any available resource
Permission::create(['name'=>'*.create,update,view']);
$user->givePermissionTo('*.create,update,view');

// user can do any action on posts with ids 1, 4 and 6 
Permission::create(['name'=>'posts.*.1,4,6']);
$user->givePermissionTo('posts.*.1,4,6');
```

--------------------------------

### Apply Middleware via Static using Method

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/middleware

Apply middleware via static using method, accepting an array or pipe-separated string. Each example shows a different middleware class.

```php
use Spatie\Permission\Middleware\RoleMiddleware;
Route::middleware(RoleMiddleware::using('manager'))
```

```php
use Spatie\Permission\Middleware\PermissionMiddleware;
Route::middleware(
    PermissionMiddleware::using('publish articles|edit articles')
)
```

```php
use Spatie\Permission\Middleware\RoleOrPermissionMiddleware;
Route::middleware(
    RoleOrPermissionMiddleware::using(['manager', 'edit articles'])
)
```

--------------------------------

### Register controller middleware using HasMiddleware interface

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/middleware

Shows how to implement the HasMiddleware interface and use the middleware() method to register controller middleware, including examples with aliases, pipe-separated names, guards, and the using() method.

```php
use Illuminate\Routing\Controllers\HasMiddleware;
use Illuminate\Routing\Controllers\Middleware;

use Spatie\Permission\Middleware\RoleMiddleware;
use Spatie\Permission\Middleware\PermissionMiddleware;

class ArticleController implements HasMiddleware
{
    public static function middleware(): array
    {
        return [
            // examples with aliases, pipe-separated names, guards, etc:
            'role_or_permission:manager|edit articles',
            new Middleware('role:author', only: ['index']),
            new Middleware(RoleMiddleware::using('manager'), except:['show']),
            new Middleware(PermissionMiddleware::using('delete records,api'), only:['destroy']),
        ];
    }
}
```

--------------------------------

### PostPolicy example for Laravel permissions

Source: https://spatie.be/docs/laravel-permission/v8/best-practices/using-policies

A partial PostPolicy example that combines permission checks with application logic. It demonstrates how to use HandlesAuthorization and the can() method to control access to Post model records, including handling null users for visitors and overriding published status for admins.

```php
<?php
namespace App\Policies;

use App\Models\Post;
use App\Models\User;
use Illuminate\Auth\Access\HandlesAuthorization;

class PostPolicy
{
    use HandlesAuthorization;

    public function view(?User $user, Post $post): bool
    {
        if ($post->published) {
            return true;
        }

        // visitors cannot view unpublished items
        if ($user === null) {
            return false;
        }

        // admin overrides published status
        if ($user->can('view unpublished posts')) {
            return true;
        }

        // authors can view their own unpublished posts
        return $user->id == $post->user_id;
    }

    public function create(User $user): bool
    {
        return $user->can('create posts');
    }

    public function update(User $user, Post $post): bool
    {
        if ($user->can('edit all posts')) {
            return true;
        }

        if ($user->can('edit own posts')) {
            return $user->id == $post->user_id;
        }
    }

    public function delete(User $user, Post $post): bool
    {
        if ($user->can('delete any post')) {
            return true;
        }

        if ($user->can('delete own posts')) {
            return $user->id == $post->user_id;
        }
    }
}

```

--------------------------------

### Defining a RolesEnum

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/enums

An example of a BackedEnum for roles. You can implement a label method for custom display values.

```php
namespace App\Enums;

enum RolesEnum: string
{
    // case NAMEINAPP = 'name-in-database';

    case WRITER = 'writer';
    case EDITOR = 'editor';
    case USERMANAGER = 'user-manager';

    // extra helper to allow for greater customization of displayed values, without disclosing the name/value data directly
    public function label(): string
    {
        return match ($this) {
            static::WRITER => 'Writers',
            static::EDITOR => 'Editors',
            static::USERMANAGER => 'User Managers',
        };
    }
}
```

--------------------------------

### Create roles and permissions for specific guards

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/multiple-guards

When creating roles and permissions, specify the guard_name to associate them with a specific guard. If no guard is specified, the first defined guard in auth.guards config is used. This example creates a manager role for the admin guard and two 'publish articles' permissions for different guards.

```php
// Create a manager role for users authenticating with the admin guard:
$role = Role::create(['guard_name' => 'admin', 'name' => 'manager']);

// Define a `publish articles` permission for the admin users belonging to the admin guard
$permission = Permission::create(['guard_name' => 'admin', 'name' => 'publish articles']);

// Define a *different* `publish articles` permission for the regular users belonging to the web guard
$permission = Permission::create(['guard_name' => 'web', 'name' => 'publish articles']);

```

--------------------------------

### Using BackedEnums with Package Methods

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/enums

Demonstrates passing BackedEnum instances to methods for creating, finding, assigning, and checking roles and permissions.

```php
    // Creating
    app(Role::class)->create(['name' => RolesEnum::WRITER]);
    app(Role::class)->findByName(RolesEnum::WRITER);
    app(Role::class)->findOrCreate(RolesEnum::WRITER);

    app(Permission::class)->create(['name' => PermissionsEnum::EDITPOSTS]);
    app(Permission::class)->findByName(PermissionsEnum::EDITPOSTS);
    app(Permission::class)->findOrCreate(PermissionsEnum::EDITPOSTS);

	$user->assignRole(RolesEnum::WRITER);
	$user->removeRole(RolesEnum::EDITOR);

    $role->givePermissionTo(PermissionsEnum::EDITPOSTS);
    $role->revokePermissionTo(PermissionsEnum::EDITPOSTS);

    $user->givePermissionTo(PermissionsEnum::EDITPOSTS);
    $user->revokePermissionTo(PermissionsEnum::EDITPOSTS);

	$user->hasPermissionTo(PermissionsEnum::EDITPOSTS);
	$user->hasAnyPermission([PermissionsEnum::EDITPOSTS, PermissionsEnum::VIEWPOSTS]);
	$user->hasDirectPermission(PermissionsEnum::EDITPOSTS);
    
    $user->hasRole(RolesEnum::WRITER);
    $user->hasAllRoles([RolesEnum::WRITER, RolesEnum::EDITOR]);
    $user->hasExactRoles([RolesEnum::WRITER, RolesEnum::EDITOR, RolesEnum::MANAGER]);
```

--------------------------------

### Run migrations

Source: https://spatie.be/docs/laravel-permission/v8/installation-laravel

Run the database migrations to create the tables for the package.

```bash
php artisan migrate
```

--------------------------------

### Get Permissions For A User

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/basic-usage

Accessing permissions and roles assigned to a user via the HasRoles trait.

```php
// get a list of all permissions directly assigned to the user
$permissionNames = $user->getPermissionNames(); // collection of name strings
$permissions = $user->permissions; // collection of permission objects

// get all permissions for the user, either directly, or from roles, or from both
$permissions = $user->getDirectPermissions();
$permissions = $user->getPermissionsViaRoles();
$permissions = $user->getAllPermissions();

// get the names of the user's roles
$roles = $user->getRoleNames(); // Returns a collection
```

--------------------------------

### Link local repository to GitHub

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/new-app

Use these commands once to connect your local project to a new, empty GitHub repository.

```bash
git remote add origin git@github.com:YOURUSERNAME/REPONAME.git
git push -u origin main
```

--------------------------------

### Create a permission with Permission::create()

Source: https://spatie.be/docs/laravel-permission/v8/best-practices/performance

Standard way to create a permission. On large databases, this may be slower due to package protections.

```php
Permission::create([attributes]);

```

--------------------------------

### Using Laravel's 'can' middleware for permission checks

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/middleware

Use the built-in Laravel middleware 'can' to check a single permission. The example shows both the string-based 'can:publish articles' and the static method Authorize::using('publish articles').

```php
use Illuminate\Support\Facades\Route;

Route::middleware('can:publish articles')->get(...);

// or with static method
use Illuminate\Auth\Middleware\Authorize;
Route::middleware(Authorize::using('publish articles'))->get(...);

```

--------------------------------

### Run Database Seeder

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/new-app

Executes the migration and seeding process using the specified seeder class.

```bash
php artisan migrate:fresh --seed --seeder=PermissionsDemoSeeder
```

--------------------------------

### Use blade directive with a specific guard

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/multiple-guards

Pass the guard name as the second argument to blade directives like @role to check roles against a specific guard. The example shows a conditional block that renders different content based on whether the user has the 'super-admin' role on the 'admin' guard.

```php
@role('super-admin', 'admin')
    I am a super-admin!
@else
    I am not a super-admin...
@endrole

```

--------------------------------

### Enable Wildcard Permissions in Configuration

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/wildcard-permissions

Set the enable_wildcard_permission key to true in the config/permission.php file to activate wildcard functionality.

```php
// config/permission.php
'enable_wildcard_permission' => true,
```

--------------------------------

### Create a role with linked permissions

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/artisan

Creates a role 'writer' for the 'web' guard and links permissions 'create articles' and 'edit articles'.

```bash
php artisan permission:create-role writer web "create articles|edit articles"
```

--------------------------------

### Apply middleware and authorization attributes to controller methods

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/middleware

Shows how to use the Middleware and Authorize attributes to apply middleware or authorization to controller methods, using the RoleMiddleware::using() method.

```php
use Illuminate\Routing\Attributes\Controllers\Middleware;
use Illuminate\Routing\Attributes\Controllers\Authorize;

use Spatie\Permission\Middleware\RoleMiddleware;

class ArticleController
{
    #[Middleware(RoleMiddleware::using('manager'), only: ['index'])]
    public function index()
    {
        // ...
    }

    #[Authorize('publish articles')]
    public function store()
    {
        // ...
    }
}
```

--------------------------------

### Show roles and permissions table

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/artisan

Displays a table of roles and permissions per guard using the permission:show command.

```bash
php artisan permission:show
```

--------------------------------

### Implement Policy before method

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/super-admin

Alternatively, define a before method within specific Policy classes to grant super-admin control. Like the global Gate approach, this must return null if the user does not have the Super Admin role.

```php
use App\Models\User; // could be any Authorizable model

/**
 * Perform pre-authorization checks on the model.
 */
public function before(User $user, string $ability): ?bool
{
    if ($user->hasRole('Super Admin')) {
        return true;
    }
 
    return null; // see the note above in Gate::before about why null must be returned here.
}
```

--------------------------------

### Create a permission with Permission::make() and saveOrFail()

Source: https://spatie.be/docs/laravel-permission/v8/best-practices/performance

Faster alternative to Permission::create() on large databases. Uses make() and saveOrFail() to bypass some protections.

```php
$permission = Permission::make([attributes]); 
$permission->saveOrFail();

```

--------------------------------

### Configure Gate::before in AppServiceProvider

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/super-admin

Use Gate::before in the boot method of AppServiceProvider to implicitly grant all permissions to the 'Super Admin' role. The closure must return null instead of false to avoid interfering with other policies.

```php
use Illuminate	Support	Facades	Gate;
// ...
public function boot(): void
{
    // Implicitly grant "Super Admin" role all permissions
    // This works in the app by using gate-related functions like auth()->user->can() and @can()
    Gate::before(function ($user, $ability) {
        return $user->hasRole('Super Admin') ? true : null;
    });
}
```

--------------------------------

### Publish migration and config file

Source: https://spatie.be/docs/laravel-permission/v8/installation-laravel

Publish the package's migration and config/permission.php file using the artisan vendor:publish command.

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

--------------------------------

### Create a role with guard specified

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/artisan

Creates a role 'writer' for the 'web' guard.

```bash
php artisan permission:create-role writer web
```

--------------------------------

### Enable Teams in config/permission.php

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/teams-permissions

Set the teams option to true in the permission configuration file to enable the feature.

```php
// config/permission.php
'teams' => true,
```

--------------------------------

### Create roles and permissions

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/basic-usage

Roles and permissions are Eloquent models that require a name. Use the Role and Permission models to create them.

```php
use Spatie\Permission\Models\Role;
use Spatie\Permission\Models\Permission;

$role = Role::create(['name' => 'writer']);
$permission = Permission::create(['name' => 'edit articles']);
```

--------------------------------

### Configure permission for Passport

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/passport

Enable the passport client credentials support in the permission configuration file.

```php
// config/permission.php
'use_passport_client_credentials' => true,
```

--------------------------------

### Create roles with team_id (null, specific, or default)

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/teams-permissions

Shows three ways to create roles: with null team_id (global role), with a specific team_id (team role), and without team_id (uses default global team_id).

```php
// with null team_id it creates a global role; global roles can be assigned to any team and they are unique
Role::create(['name' => 'writer', 'team_id' => null]);

// creates a role with team_id = 1; team roles can have the same name on different teams
Role::create(['name' => 'reader', 'team_id' => 1]);

// creating a role without team_id makes the role take the default global team_id
Role::create(['name' => 'reviewer']);
```

--------------------------------

### Apply middleware to route groups and individual routes

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/middleware

Shows how to apply role, permission, and role_or_permission middleware to route groups and individual routes, including specifying a guard and using multiple middleware.

```php
// You can apply middleware to a group of routes:
Route::middleware('role:manager')->group(function () {
    // ...
});

// Or, for individual routes, apply the middleware directly:
Route::middleware('role:manager')->get('/admin', ...);
Route::middleware('permission:publish articles')->get('/articles/create', ...);
Route::middleware('role_or_permission:publish articles')->get('/articles/{id}', ...);

// for a specific guard:
Route::middleware('role:manager,api')->get('/api/admin', ...);

// multiple middleware
Route::middleware([
    'role:manager',
    'permission:publish articles'
])->get('/admin/publish', ...);
```

--------------------------------

### Assigning Super Admin role in Team Model boot method

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/teams-permissions

Use the boot method of your team model to automatically assign a 'Super Admin' role to a specific user when a new team is created. This implementation uses setPermissionsTeamId to scope the assignment to the new team and restores the previous team context afterward.

```php
namespace App\Models;

class YourTeamModel extends \Illuminate\Database\Eloquent\Model
{
    // ...
    public static function boot()
    {
        parent::boot();

        // here assign this team to a global user with global default role
        self::created(function ($model) {
           // temporary: get session team_id for restore at end
           $session_team_id = getPermissionsTeamId();
           // set actual new team_id to package instance
           setPermissionsTeamId($model);
           // get the admin user and assign roles/permissions on new team model
           User::find('your_user_id')->assignRole('Super Admin');
           // restore session team_id to package instance using temporary value stored above
           setPermissionsTeamId($session_team_id);
        });
    }
    // ...
}
```

--------------------------------

### Check for any or all permissions

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/direct-permissions

Use hasAnyPermission or hasAllPermissions to check against an array of permissions.

```php
$user->hasAnyPermission(['edit articles', 'publish articles', 'unpublish articles']);
```

```php
$user->hasAllPermissions(['edit articles', 'publish articles', 'unpublish articles']);
```

--------------------------------

### Implement Super Admin check with Gate::after

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/super-admin

Use this snippet within a service provider to define a global gate interception that grants Super Admin users full access.

```php
// somewhere in a service provider

Gate::after(function ($user, $ability) {
   return $user->hasRole('Super Admin'); // note this returns boolean
});
```

--------------------------------

### Create TeamsPermission Middleware

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/teams-permissions

Implement a middleware to set the global team ID for permissions based on the session or other sources.

```php
namespace App\Http\Middleware;

class TeamsPermission
{
    public function handle($request, \Closure $next){
        if(!empty(auth()->user())){
            // session value set on login
            setPermissionsTeamId(session('team_id'));
        }
        // other custom ways to get team_id
        /*if(!empty(auth('api')->user())){
            // `getTeamIdFromToken()` example of custom method for getting the set team_id 
            setPermissionsTeamId(auth('api')->user()->getTeamIdFromToken());
        }*/
        
        return $next($request);
    }
}
```

--------------------------------

### Commit and push code changes

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/new-app

Run these commands to stage, commit, and push your code changes to the remote repository.

```bash
git add .
git commit -m "Explain what your commit is about here"
git push origin main
```

--------------------------------

### Create PermissionsDemoSeeder.php

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/new-app

Defines initial roles, permissions, and demo users. This seeder clears the permission cache and assigns roles to specific users.

```php
<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use Spatie\Permission\Models\Permission;
use Spatie\Permission\Models\Role;
use Spatie\Permission\PermissionRegistrar;

class PermissionsDemoSeeder extends Seeder
{
    /**
     * Create the initial roles and permissions.
     */
    public function run(): void
    {
        // Reset cached roles and permissions
        app()[PermissionRegistrar::class]->forgetCachedPermissions();

        // create permissions
        Permission::create(['name' => 'edit articles']);
        Permission::create(['name' => 'delete articles']);
        Permission::create(['name' => 'publish articles']);
        Permission::create(['name' => 'unpublish articles']);

        // create roles and assign existing permissions
        $role1 = Role::create(['name' => 'writer']);
        $role1->givePermissionTo('edit articles');
        $role1->givePermissionTo('delete articles');

        $role2 = Role::create(['name' => 'admin']);
        $role2->givePermissionTo('publish articles');
        $role2->givePermissionTo('unpublish articles');

        $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' => 'Example User',
            'email' => 'tester@example.com',
        ]);
        $user->assignRole($role1);

        $user = \App\Models\User::factory()->create([
            'name' => 'Example Admin User',
            'email' => 'admin@example.com',
        ]);
        $user->assignRole($role2);

        $user = \App\Models\User::factory()->create([
            'name' => 'Example Super-Admin User',
            'email' => 'superadmin@example.com',
        ]);
        $user->assignRole($role3);
    }
}
```

--------------------------------

### Create a permission with guard specified

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/artisan

Creates a permission 'edit articles' for the 'web' guard.

```bash
php artisan permission:create-permission "edit articles" web
```

--------------------------------

### Set Migration String Lengths for MySQL

Source: https://spatie.be/docs/laravel-permission/v8/prerequisites

Suggested string length adjustments for migration files to avoid MySQL index key length errors.

```php
    $table->string('name');       // For MyISAM use string('name', 225); // (or 166 for InnoDB with Redundant/Compact row format)
    $table->string('guard_name'); // For MyISAM use string('guard_name', 25);
```

--------------------------------

### Register Middleware Priority in AppServiceProvider

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/teams-permissions

Ensure your custom middleware runs before SubstituteBindings to prevent 404 errors when authorization fails.

```php
use App\Http\Middleware\YourCustomMiddlewareClass;
use Illuminate\Foundation\Http\Kernel;
use Illuminate\Routing\Middleware\SubstituteBindings;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        //
    }

    public function boot(): void
    {
        /** @var Kernel $kernel */
        $kernel = app()->make(Kernel::class);

        $kernel->addToMiddlewarePriorityBefore(
            YourCustomMiddlewareClass::class,
            SubstituteBindings::class,
        );
    }
}
```

--------------------------------

### Create a role with artisan command

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/artisan

Creates a role named 'writer' using the permission:create-role command.

```bash
php artisan permission:create-role writer
```

--------------------------------

### Use pipe-separated roles and permissions for OR logic

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/middleware

Shows how to specify multiple roles or permissions with a pipe character, which is treated as OR, including for a specific guard.

```php
Route::middleware('role:manager|writer')
Route::middleware('permission:publish articles|edit articles')
Route::middleware('role_or_permission:manager|edit articles')

// for a specific guard
Route::middleware('permission:publish articles|edit articles,api')
```

--------------------------------

### Assigning Direct Permissions to a User

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/role-permissions

Demonstrates assigning a role to a user and granting an additional permission directly to that user.

```php
$role = Role::findByName('writer');
$role->givePermissionTo('edit articles');

$user->assignRole('writer');

$user->givePermissionTo('delete articles');
```

--------------------------------

### Sync permissions to a role

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/basic-usage

Use syncPermissions on the role or syncRoles on the permission to sync multiple permissions or roles.

```php
$role->syncPermissions($permissions);
$permission->syncRoles($roles);
```

--------------------------------

### Create a permission with artisan command

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/artisan

Creates a permission named 'edit articles' using the permission:create-permission command.

```bash
php artisan permission:create-permission "edit articles"
```

--------------------------------

### Configure Custom Team Foreign Key

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/teams-permissions

Define a custom foreign key for teams in the permission configuration file if needed.

```php
// config/permission.php
'team_foreign_key' => 'custom_team_id',
```

--------------------------------

### Assign a permission to a role

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/basic-usage

Use either givePermissionTo on the role or assignRole on the permission to associate them.

```php
$role->givePermissionTo($permission);
$permission->assignRole($role);
```

--------------------------------

### Syncing Roles for Users

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/role-permissions

Replace all current roles of a user with a new set of roles.

```php
// All current roles will be removed from the user and replaced by the array given
$user->syncRoles(['writer', 'admin']);
```

--------------------------------

### Check for any permissions by ID

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/direct-permissions

You can pass integers to hasAnyPermission to lookup by permission ID.

```php
$user->hasAnyPermission(['edit articles', 1, 5]);
```

--------------------------------

### Register the extended Client model

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/passport

Tell Passport to use your custom Client model by adding this to the boot method of your AuthServiceProvider.

```php
Passport::useClientModel(\App\Models\Client::class); // Use the namespace of your extended Client.
```

--------------------------------

### Create a role with team ID

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/artisan

Creates a role with a team ID using the --team-id parameter, with and without specifying a guard.

```bash
php artisan permission:create-role --team-id=1 writer
```

```bash
php artisan permission:create-role writer api --team-id=1
```

--------------------------------

### Configure Super-Admin Gate

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/new-app

Adds a Gate::before check to the AuthServiceProvider or AppServiceProvider to implicitly grant all permissions to users with the Super-Admin role.

```php
+  use Illuminate\Support\Facades\Gate;

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

--------------------------------

### Checking Direct Permissions

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/role-permissions

Methods to verify if a user possesses specific, all, or any direct permissions.

```php
// Check if the user has Direct permission
$user->hasDirectPermission('edit articles')

// Check if the user has All direct permissions
$user->hasAllDirectPermissions(['edit articles', 'delete articles']);

// Check if the user has Any permission directly
$user->hasAnyDirectPermission(['create articles', 'delete articles']);
```

--------------------------------

### Assign Wildcard Permissions

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/wildcard-permissions

Assigning a permission with a wildcard allows access to all sub-parts of that permission string.

```php
Permission::create(['name'=>'posts.*']);
$user->givePermissionTo('posts.*');
// is the same as
Permission::create(['name'=>'posts']);
$user->givePermissionTo('posts');
```

--------------------------------

### Manage Role Permissions

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/role-permissions

Methods for assigning, checking, revoking, and syncing permissions for a specific role.

```php
$role->givePermissionTo('edit articles');
```

```php
$role->hasPermissionTo('edit articles');
```

```php
$role->revokePermissionTo('edit articles');
```

```php
$role->syncPermissions(['edit articles', 'delete articles']);
```

--------------------------------

### Flexible Model Assignment Methods

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/role-permissions

Methods accept single models, IDs, arrays, or collections.

```php
$role->assignToModels($user);                  // a single model
$role->assignToModels($user->id);              // a single ID
$role->assignToModels([1, 2, 3]);              // an array of IDs
$role->assignToModels(User::query()->get());   // a Collection
$role->assignToModels([$user1, 5, $user2]);    // mixed
```

--------------------------------

### Assigning Roles to Models

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/role-permissions

Manage role assignments from the role's perspective using assignToModels, removeFromModels, and syncModels.

```php
$role = Role::findByName('writer');

// Give the role to two users at once.
$role->assignToModels([$user1, $user2]);

// Remove it from one user.
$role->removeFromModels($user1);

// Replace every model that currently has this role with a new set.
$role->syncModels([$user2, $user3]);
```

--------------------------------

### Configuring Default Model in permission.php

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/role-permissions

Set the default model class globally in the configuration file.

```php
'models' => [
    // ...
    'default_model' => App\Models\User::class,
],
```

--------------------------------

### Sync direct permissions for a user

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/direct-permissions

Use the syncPermissions method to revoke all existing direct permissions and assign the new set provided in the array.

```php
$user->syncPermissions(['edit articles', 'delete articles']);
```

--------------------------------

### Registering package middleware aliases in bootstrap/app.php

Source: https://spatie.be/docs/laravel-permission/v8/basic-usage/middleware

Register aliases for RoleMiddleware, PermissionMiddleware, and RoleOrPermissionMiddleware in the application's bootstrap/app.php file. This allows using 'role', 'permission', and 'role_or_permission' as middleware aliases throughout the app.

```php
// ...
use Spatie\Permission\Middleware\RoleMiddleware;
use Spatie\Permission\Middleware\PermissionMiddleware;
use Spatie\Permission\Middleware\RoleOrPermissionMiddleware;

return Application::configure(basePath: dirname(__DIR__))
    // ...
    ->withMiddleware(function (Middleware $middleware) {
        $middleware->alias([
            'role' => RoleMiddleware::class,
            'permission' => PermissionMiddleware::class,
            'role_or_permission' => RoleOrPermissionMiddleware::class,
        ]);
    })
    // ...

```
Tokens:
Raw