PHPackages                             lake/larke-auth - 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. lake/larke-auth

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

lake/larke-auth
===============

An authorization library that supports access control models like ACL, RBAC, ABAC in Laravel.

v1.5.0(1y ago)16.7k2Apache-2.0PHPPHP ^7.3|^8.0|^8.1|^8.2

Since Nov 1Pushed 1y agoCompare

[ Source](https://github.com/deatil/larke-auth)[ Packagist](https://packagist.org/packages/lake/larke-auth)[ Docs](https://github.com/deatil/larke-auth)[ RSS](/packages/lake-larke-auth/feed)WikiDiscussions main Synced 1w ago

READMEChangelog (7)Dependencies (3)Versions (16)Used By (2)

 Laravel Authorization
=======================

[](#----laravel-authorization)

 **larke-auth is an authorization library for the laravel framework.**

The `code` is from [laravel-authz](https://github.com/php-casbin/laravel-authz)

It's based on [Casbin](https://github.com/php-casbin/php-casbin), an authorization library that supports access control models like ACL, RBAC, ABAC.

All you need to learn to use `Casbin` first.

- [Installation](#installation)
- [Usage](#usage)
    - [Quick start](#quick-start)
    - [Using Enforcer Api](#using-enforcer-api)
    - [Using a middleware](#using-a-middleware)
        - [basic Enforcer Middleware](#basic-enforcer-middleware)
        - [HTTP Request Middleware ( RESTful is also supported )](#http-request-middleware--restful-is-also-supported-)
    - [Multiple enforcers](#multiple-enforcers)
    - [Using artisan commands](#using-artisan-commands)
    - [Cache](#using-cache)
- [Thinks](#thinks)
- [License](#license)

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

[](#installation)

Require this package in the `composer.json` of your Laravel project. This will download the package.

```
composer require lake/larke-auth

```

The `Larke\Auth\ServiceProvider` is `auto-discovered` and registered by default, but if you want to register it yourself:

Add the ServiceProvider in `config/app.php`

```
'providers' => [
    /*
     * Package Service Providers...
     */
    Larke\Auth\ServiceProvider::class,
]
```

The Enforcer facade is also `auto-discovered`, but if you want to add it manually:

Add the Facade in `config/app.php`

```
'aliases' => [
    // ...
    'Enforcer' => Larke\Auth\Facades\Enforcer::class,
]
```

To publish the config, run the vendor publish command:

```
php artisan vendor:publish --tag=larke-auth-config

```

This will create a new model config file named `config/larkeauth-rbac-model.conf.bak` and a new larkeauth config file named `config/larkeauth.php.bak`.

You need copy the file `config/larkeauth-rbac-model.conf.larkeauth` to file `config/larkeauth-rbac-model.conf`

and copy the file `config/larkeauth.php.larkeauth` to file `config/larkeauth.php`

To install auth:

```
php artisan larke-auth:install

```

This will create a new table named `rules`

Usage
-----

[](#usage)

### Quick start

[](#quick-start)

Once installed you can do stuff like this:

```
use Enforcer;

// adds permissions to a user
Enforcer::addPermissionForUser('eve', 'articles', 'read');
// adds a role for a user.
Enforcer::addRoleForUser('eve', 'writer');
// adds permissions to a rule
Enforcer::addPolicy('writer', 'articles','edit');
```

You can check if a user has a permission like this:

```
// to check if a user has permission
if (Enforcer::enforce("eve", "articles", "edit")) {
    // permit eve to edit articles
} else {
    // deny the request, show an error
}
```

### Using Enforcer Api

[](#using-enforcer-api)

It provides a very rich api to facilitate various operations on the Policy:

Gets all roles:

```
Enforcer::getAllRoles(); // ['writer', 'reader']
```

Gets all the authorization rules in the policy.:

```
Enforcer::getPolicy();
```

Gets the roles that a user has.

```
Enforcer::getRolesForUser('eve'); // ['writer']
```

Gets the users that has a role.

```
Enforcer::getUsersForRole('writer'); // ['eve']
```

Determines whether a user has a role.

```
Enforcer::hasRoleForUser('eve', 'writer'); // true or false
```

Adds a role for a user.

```
Enforcer::addRoleForUser('eve', 'writer');
```

Adds a permission for a user or role.

```
// to user
Enforcer::addPermissionForUser('eve', 'articles', 'read');
// to role
Enforcer::addPermissionForUser('writer', 'articles','edit');
```

Deletes a role for a user.

```
Enforcer::deleteRoleForUser('eve', 'writer');
```

Deletes all roles for a user.

```
Enforcer::deleteRolesForUser('eve');
```

Deletes a role.

```
Enforcer::deleteRole('writer');
```

Deletes a permission.

```
Enforcer::deletePermission('articles', 'read'); // returns false if the permission does not exist (aka not affected).
```

Deletes a permission for a user or role.

```
Enforcer::deletePermissionForUser('eve', 'articles', 'read');
```

Deletes permissions for a user or role.

```
// to user
Enforcer::deletePermissionsForUser('eve');
// to role
Enforcer::deletePermissionsForUser('writer');
```

Gets permissions for a user or role.

```
Enforcer::getPermissionsForUser('eve'); // return array
```

Determines whether a user has a permission.

```
Enforcer::hasPermissionForUser('eve', 'articles', 'read');  // true or false
```

See [Casbin API](https://casbin.org/docs/en/management-api) for more APIs.

### Using a middleware

[](#using-a-middleware)

Before,you need create a file:

```