PHP code example of lucas-quinn-guru / cerberus

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

lucas-quinn-guru / cerberus example snippets

LucasQuinnGuru\Cerberus\CerberusServiceProvider::class,

'Cerberus'   => LucasQuinnGuru\Cerberus\CerberusFacade::class,

'providers' => [
    'users' => [
        'driver' => 'eloquent',
        'model' => Namespace\Of\Your\User\Model\User::class,
        'table' => 'users',
    ],
],

    'role' => \LucasQuinnGuru\Cerberus\Middleware\CerberusRole::class,
    'permission' => \LucasQuinnGuru\Cerberus\Middleware\CerberusPermission::class,
    'ability' => \LucasQuinnGuru\Cerberus\Middleware\CerberusAbility::class,

 namespace App;

use LucasQuinnGuru\Cerberus\CerberusRole;

class Role extends CerberusRole
{
}

 namespace App;

use LucasQuinnGuru\Cerberus\CerberusPermission;

class Permission extends CerberusPermission
{
}

use LucasQuinnGuru\Cerberus\Traits\CerberusUserTrait;

class User extends Eloquent
{
    use CerberusUserTrait; // add this trait to your user model

    ...
}

$role = Role::findOrFail(1); // Pull back a given role

// Regular Delete
$role->delete(); // This will work no matter what

// Force Delete
$role->users()->sync([]); // Delete relationship data
$role->perms()->sync([]); // Delete relationship data

$role->forceDelete(); // Now force delete will work regardless of whether the pivot table has cascading delete

$owner = new Role();
$owner->name         = 'owner';
$owner->display_name = 'Project Owner'; // optional
$owner->description  = 'User is the owner of a given project'; // optional
$owner->save();

$admin = new Role();
$admin->name         = 'admin';
$admin->display_name = 'User Administrator'; // optional
$admin->description  = 'User is allowed to manage and edit other users'; // optional
$admin->save();

$user = User::where('username', '=', 'michele')->first();

// role attach alias
$user->attachRole($admin); // parameter can be an Role object, array, or id

// or eloquent's original technique
$user->roles()->attach($admin->id); // id only

$createPost = new Permission();
$createPost->name         = 'create-post';
$createPost->display_name = 'Create Posts'; // optional
// Allow a user to...
$createPost->description  = 'create new blog posts'; // optional
$createPost->save();

$editUser = new Permission();
$editUser->name         = 'edit-user';
$editUser->display_name = 'Edit Users'; // optional
// Allow a user to...
$editUser->description  = 'edit existing users'; // optional
$editUser->save();

$admin->attachPermission($createPost);
// equivalent to $admin->perms()->sync(array($createPost->id));

$owner->attachPermissions(array($createPost, $editUser));
// equivalent to $owner->perms()->sync(array($createPost->id, $editUser->id));

$user->hasRole('owner');   // false
$user->hasRole('admin');   // true
$user->can('edit-user');   // false
$user->can('create-post'); // true

$user->hasRole(['owner', 'admin']);       // true
$user->can(['edit-user', 'create-post']); // true

$user->hasRole(['owner', 'admin']);             // true
$user->hasRole(['owner', 'admin'], true);       // false, user does not have admin role
$user->can(['edit-user', 'create-post']);       // true
$user->can(['edit-user', 'create-post'], true); // false, user does not have edit-user permission

Cerberus::hasRole('role-name');
Cerberus::can('permission-name');

// is identical to

Auth::user()->hasRole('role-name');
Auth::user()->can('permission-name');

// match any admin permission
$user->can("admin.*"); // true

// match any permission about users
$user->can("*_users"); // true

$user->ability(array('admin', 'owner'), array('create-post', 'edit-user'));

// or

$user->ability('admin,owner', 'create-post,edit-user');

$options = array(
    'validate_all' => true | false (Default: false),
    'return_type'  => boolean | array | both (Default: boolean)
);

$options = array(
    'validate_all' => true,
    'return_type' => 'both'
);

list($validate, $allValidations) = $user->ability(
    array('admin', 'owner'),
    array('create-post', 'edit-user'),
    $options
);

var_dump($validate);
// bool(false)

var_dump($allValidations);
// array(4) {
//     ['role'] => bool(true)
//     ['role_2'] => bool(false)
//     ['create-post'] => bool(true)
//     ['edit-user'] => bool(false)
// }

Cerberus::ability('admin,owner', 'create-post,edit-user');

// is identical to

Auth::user()->ability('admin,owner', 'create-post,edit-user');

@role('admin')
    <p>This is visible to users with the admin role. Gets translated to 
    \Cerberus::role('admin')</p>
@endrole

@permission('manage-admins')
    <p>This is visible to users with the given permissions. Gets translated to 
    \Cerberus::can('manage-admins'). The @can directive is already taken by core 
    laravel authorization package, hence the @permission directive instead.</p>
@endpermission

@ability('admin,owner', 'create-post,edit-user')
    <p>This is visible to users with the given abilities. Gets translated to 
    \Cerberus::ability('admin,owner', 'create-post,edit-user')</p>
@endability

Route::group(['prefix' => 'admin', 'middleware' => ['role:admin']], function() {
    Route::get('/', 'AdminController@welcome');
    Route::get('/manage', ['middleware' => ['permission:manage-admins'], 'uses' => 'AdminController@manageAdmins']);
});

'middleware' => ['role:admin|root']

'middleware' => ['role:owner', 'role:writer']

'middleware' => ['ability:admin|owner,create-post|edit-user,true']

// only users with roles that have the 'manage_posts' permission will be able to access any route within admin/post
Cerberus::routeNeedsPermission('admin/post*', 'create-post');

// only owners will have access to routes within admin/advanced
Cerberus::routeNeedsRole('admin/advanced*', 'owner');

// optionally the second parameter can be an array of permissions or roles
// user would need to match all roles or permissions for that route
Cerberus::routeNeedsPermission('admin/post*', array('create-post', 'edit-comment'));
Cerberus::routeNeedsRole('admin/advanced*', array('owner','writer'));

Cerberus::routeNeedsRole('admin/advanced*', 'owner', Redirect::to('/home'));

// if a user has 'create-post', 'edit-comment', or both they will have access
Cerberus::routeNeedsPermission('admin/post*', array('create-post', 'edit-comment'), null, false);

// if a user is a member of 'owner', 'writer', or both they will have access
Cerberus::routeNeedsRole('admin/advanced*', array('owner','writer'), null, false);

// if a user is a member of 'owner', 'writer', or both, or user has 'create-post', 'edit-comment' they will have access
// if the 4th parameter is true then the user must be a member of Role and must have Permission
Cerberus::routeNeedsRoleOrPermission(
    'admin/advanced*',
    array('owner', 'writer'),
    array('create-post', 'edit-comment'),
    null,
    false
);

Route::filter('manage_posts', function()
{
    // check the current user
    if (!Cerberus::can('create-post')) {
        return Redirect::to('admin');
    }
});

// only users with roles that have the 'manage_posts' permission will be able to access any admin/post route
Route::when('admin/post*', 'manage_posts');

Route::filter('owner_role', function()
{
    // check the current user
    if (!Cerberus::hasRole('Owner')) {
        App::abort(403);
    }
});

// only owners will have access to routes within admin/advanced
Route::when('admin/advanced*', 'owner_role');

shell
php artisan vendor:publish

bash
php artisan cerberus:migration

bash
php artisan migrate

bash
composer dump-autoload

'role' => 'Custom\Namespace\Role'

'permission' => 'Custom\Namespace\permission'