PHPackages                             enclave-code/static-auth-manager - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Authentication & Authorization](/categories/authentication)
4. /
5. enclave-code/static-auth-manager

ActiveLibrary[Authentication & Authorization](/categories/authentication)

enclave-code/static-auth-manager
================================

Static manage roles and permission in Laravel

v1.0.1(6y ago)017[3 PRs](https://github.com/EnclaveCode/static-auth-manager/pulls)MITPHPPHP >=7.2

Since Mar 30Pushed 3y agoCompare

[ Source](https://github.com/EnclaveCode/static-auth-manager)[ Packagist](https://packagist.org/packages/enclave-code/static-auth-manager)[ RSS](/packages/enclave-code-static-auth-manager/feed)WikiDiscussions master Synced 1w ago

READMEChangelogDependencies (2)Versions (6)Used By (0)

Laravel StaticAuthManager
=========================

[](#laravel-staticauthmanager)

Manage user permissions and roles in your Laravel application by domain driven rules.

- [Installation](#installation)
- [Usage](#usage)
    - [Using roles](#using-roles)
    - [Using permissions](#using-permissions)
    - [Using Blade directives](#using-blade-directives)
    - [Using middleware](#Middleware)
- [Config](#config)

Example
-------

[](#example)

### Add single role

[](#add-single-role)

```
$user->assignRole('admin');

$user->hasRole('admin'); // true
```

### Add many roles

[](#add-many-roles)

```
$user->assignRole(['admin','user']);

$user->hasRole('admin'); // true
$user->hasRole('user'); // true
```

You can define roles and permissions by code at `config/permission.php`.

```
'role' => [
  'admin' => [
    'news/*', // Allow all paths beginning with news/
  ],
  'editor' => [
    'news/*',
  ],
  'user' => [
    'news/show', // Explicitly allow news/show
  ],
]
```

You can check permissions by

```
$admin->hasPermissionTo('news/delete'); // true
$editor->hasPermissionTo('news/delete'); // false
$user->hasPermissionTo('news/delete'); // false
```

Installation
------------

[](#installation)

```
# Add library
composer require enclave-code/static-auth-manager

# Public vendors
php artisan vendor:publish
```

Older than Laravel 5.5 need a service provider registration.

```
// config/app.php

'providers' => [
  EnclaveCode\StaticAuthManager\Providers\PermissionServiceProvider::class,
];
```

Usage
-----

[](#usage)

### Add trait to model

[](#add-trait-to-model)

```
  use HasRoles;
```

### Using roles

[](#using-roles)

You can define the roles in the `config/permission.php` file.

```
// config/permission.php

'roles' => [
  'role_name' => [],
  'admin' => [],
],
```

#### Assign role/roles

[](#assign-roleroles)

Add a role to a model.

```
$model->assignRole('admin');
```

Add a roles to a model.

```
$model->assignRole(['admin','user']);
```

#### Check role/roles

[](#check-roleroles)

You can check the roles via:

```
$model->hasRole('admin');

$model->getRoles(); // return collection(['admin'])
```

```
$model->hasRole(['admin','user']);

$model->getRoles(); // return collection(['admin','user']);
```

#### Detach role/roles

[](#detach-roleroles)

You can detach the roles via:

```
$model->assignRole(['admin','user']);
$model->detachRole('admin');

$model->getRoles(); // return collection(['user'])
```

### Using permissions

[](#using-permissions)

Permissions are based on the MQTT syntax. Permissions are specified as path. Thus, individual security levels can be mapped and generally released via wildcards.

#### Check permissions

[](#check-permissions)

```
$model->hasPermissionTo('users/show/email');
```

```
$model->hasPermissionTo(['users/show', 'users/edit']);
```

```
$model->hasAnyPermission('users/show/email');
```

```
$model->hasAnyPermission(['users/show', 'users/edit']);
```

#### Configuration

[](#configuration)

- `*` Wildcard for everything following

You can define the role permissions in the `config/permission.php` file.

```
// config/permission.php

'roles' => [
  'role_name' => [
    'users/*'
  ],
  'admin' => [
    'users/create',
  ],
],
```

### Using Blade directives

[](#using-blade-directives)

You can use Blade directives in your views.

#### Role

[](#role)

```
@role('admin')
  Show if user is admin
@endrole
```

```
@unlessrole('admin')
  Show if user is not admin
@endunlessrole
```

#### Permission

[](#permission)

```
@permission('user/edit')
  Show if user has rights to user/edit
@endpermission
```

You can use several permissions too.

```
@permission('user/edit|user/create')
  Show if user has rights to user/edit AND user/create
@endpermission
```

```
@anypermission('user/edit|user/create')
 Show if user has rights to user/edit OR user/create
@endanypermission
```

### Middleware

[](#middleware)

Add the middleware to your `src/Http/Kernel.php`

```
class Kernel extends HttpKernel
{
...
  protected $routeMiddleware = [
    ...
    'permission' => \EnclaveCode\StaticAuthManager\Middleware\HasAnyPermissionMiddleware::class,
    'role' => \EnclaveCode\StaticAuthManager\Middleware\HasRoleMiddleware::class

  ]

}
```

And use it like

```
// If user has 'admin' or 'user' role
Route::group(['middleware' => ['role:admin|user']], function () {
    //
})

// If user has 'admin' role
Route::group(['middleware' => ['role:admin']], function () {
    //
})

// If user has 'user/create'
Route::group(['middleware' => ['permission:create/user']], function () {
    //
})

// If user has 'user/create' or 'user/edit'
Route::group(['middleware' => ['permission:create/user|user/edit']], function () {
    //
})
```

Config
------

[](#config)

Example Config

```