Laravel 5.2: Integrate entrust package, create role and permissions and access it

Question

I am totally new in laravel. I install laravel 5.2 . I have done with CRUD in laravel. Now i want to integrate laravel authentication package. so i choose zizaco\entrust.

I follow each steps from doc link. but i don't understand what is wrong. In doc there is not mentioned that in which file i have to add following code.

$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();

and other below code in document.

Even

class User extends Model implements AuthenticatableContract,
                                    AuthorizableContract,
                                    CanResetPasswordContract

Not mentioned about implements class.

i do

use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
use Illuminate\Contracts\Auth\Access\Authorizable as AuthorizableContract;
use Illuminate\Contracts\Auth\CanResetPassword as CanResetPasswordContract;

but i got error

Trait 'App\Authenticatable' not found

New learner can't get where to place code. i search alot but i can't get perfect document which give right direction.

Where to create role,permissions? Anyone please help me.

Answer 1

  1.Install "zizaco/entrust": "5.2.x-dev"
     2.add provider and aliases in app.php
     3.php artisan vendor:publish
     4.php artisan migrate

Now add in user.php

use Illuminate\Auth\Authenticatable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Auth\Passwords\CanResetPassword;
use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
use Illuminate\Contracts\Auth\CanResetPassword as CanResetPasswordContract;
use Zizaco\Entrust\Traits\EntrustUserTrait;


class User extends Model implements AuthenticatableContract, CanResetPasswordContract
{
    use Authenticatable, CanResetPassword, EntrustUserTrait;
}

Next Create a model for Role

 use Zizaco\Entrust\EntrustRole
        class Role extends EntrustRole
        {
            protected $table = 'roles';
            protected $fillable = ['name', 'display_name', 'description']
        }

Now create a model for permmission

use Zizaco\Entrust\EntrustPermission;

class Permission extends EntrustPermission
{
protected $table = 'permissions';
    protected $fillable = ['name', 'display_name', 'description'];
}

Now create a seeding table for roles and permissions

UserTableSeeder.php
    <?php
    use Illuminate\Database\Seeder;
    use App\Permission;
    use App\Role;
    use App\User;
    class UserTableSeeder extends seeder
    {
        public function run()
        {
            Permission::truncate();
            Role::truncate();
            User::truncate();
            \DB::table('role_user')->delete();
            \DB::table('permission_role')->delete();
//create a user          
  $veeru = User::create([
                'name' => 'veeru',
                'email' => 'something@something.com',
                'password' => bcrypt('qwerty'),
            ]);

    //create a role of admin
            $admin = Role::create([
                'name' => 'admin',
                'display_name' => 'Admin',
                'description' => 'Only one and only admin',
            ]);
//create a permission for role
            $manage_users = Permission::create([
                'name' => 'manage-users-roles-and-permissions',
                'display_name' => 'Manage Users,Roles and Permissions',
                'description' => 'Can manage users,roles and permission"s',
            ]);
    //here attaching permission for admin role
            $admin->attachPermission($manage_users);
//here attaching role for user
            $veeru->attachRole($admin);

    //here iam creating another role and permisssion
            $application = Role::create([
                'name' => 'appapirequestlogs',
                'display_name' => 'AppApiRequestLogs',
                'description' => 'This has full control on Application Core Request logs',
            ]);
            $corereq = Permission::create([
                'name' => 'appapireqlogindex',
                'display_name' => 'AppApiReqLogIndex',
                'description' => 'This has control on Application Core Request Logs index only',
            ]);
    here attaching roles and permissions
            $application->attachPermission($corereq);
            $veeru->attachRole($application);
    }

After seeding that create a routes file and controller for roles and permissions

routes.php

Route::group(['middleware' => 'web'], function () {
    Route::group(['prefix' => 'admin'], function () {
        Route::controller('roles', 'RolesController');
        Route::controller('permissions', 'PermissionsController');
        Route::controller('users', 'UsersController');
    });
});

RolesController.php

use App\Permission;
use App\Role;
use Illuminate\Http\Request;
use App\Http\Requests;

class RolesController extends Controller
{
    function __construct()
    {
        $this->middleware('auth');
        $this->middleware('role:admin');
        $this->middleware('permission:manage-users-roles-and-permissions');
    }

    public function getIndex(Request $request)
    {
        $roles = Role::with('perms')->get();
        return view('roles.index', ['roles' => $roles]);
    }

    public function getCreate()
    {
        return view('roles.create');
    }

    public function postCreate(Request $request)
    {
        $role = Role::create([
            'name' => $request->name,
            'display_name' => $request->display_name,
            'description' => $request->description
        ]);
        return redirect()->to('admin/roles/index');
    }

    public function getUpdate($id)
    {
        $role = Role::findOrFail($id);
        return view('roles.update', ['role' => $role]);
    }

    public function postUpdate(Request $request)
    {
        $role = Role::findOrFail($request->get('id'));
        $role->name = $request->get('name');
        $role->display_name = $request->get('display_name');
        $role->description = $request->get('description');
        $role->save();
        return redirect();
    }

    public function getDelete($id)
    {
        $role = Role::findOrFail($id);
        $role->delete();

        return redirect();
    }

    public function getAttach(Request $request)
    {
        $role = Role::where('id', '=', $request->id)->with('perms')->first();
        $permissions_id = $role->perms->pluck('id')->toArray();
        $permissionsNotAttached = Permission::whereNotIn('id', $permissions_id)->get();
        return view('roles.attach', compact('role', 'permissionsNotAttached'));
    }

    public function postAttach(Request $request)
    {
        $role = Role::findOrFail($request->id);
        $permission = Permission::findOrFail($request->permission);
        $role->attachPermission($permission);
        return redirect();
    }

    public function getDetach(Request $request)
    {
        $role = Role::findOrFail($request->role_id);
        $permission = Permission::findOrFail($request->permission_id);
        $role->detachPermission($permission);
        return redirect()->to('/admin/roles/index');

    }
}

Similarly create PermissionsController.php

use App\Http\Requests\PermissionRequest;
use App\Permission;
use App\Http\Requests;


class PermissionsController extends Controller
{
    public function __construct()
    {
        $this->middleware('auth');
        $this->middleware('role:admin');
        $this->middleware('permission:manage-users-roles-and-permissions');
    }

    public function getIndex()
    {
        $permissions = Permission::all();
        return view('permissions.index', ['permissions' => $permissions]);
    }

    public function getCreate()
    {
        return view('permissions.create');
    }

    public function postCreate(Request $request)
    {
        $permission = Permission::create([
            'name' => $request->name,
            'display_name' => $request->display_name,
            'description' => $request->description
        ]);

        return redirect();
    }

    public function getUpdate($id)
    {
        $permission = Permission::findOrFail($id);
        return view('permissions.update', ['permission' => $permission]);
    }

    public function postUpdate(Request $request)
    {
        $permission = Permission::findOrFail($request->get('id'));
        $permission->name = $request->get('name');
        $permission->display_name = $request->get('display_name');
        $permission->description = $request->get('description');
        $permission->save();
        return redirect();
    }

    public function getDelete($id)
    {
        $permission = Permission::findOrFail($id);
        $permission->delete();
        return redirect();
    }


}

Answer 2

After Creating first given process

create roles middleware example CheckRole

<?php

namespace App\Http\Middleware;


use Closure;

class CheckRole
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request $request
     * @param  \Closure $next
     * @param $role
     * @return mixed
     */
    public function handle($request, Closure $next, $role)
    {


        if (\Auth::user()->hasRole($role)) {

            return $next($request);
        } else {
            return response()->view('errors.401');
        }
    }
}

now create Check Permission

<?php namespace App\Http\Middleware;

use Closure;

class CheckPermission
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request $request
     * @param  \Closure $next
     * @param $permission
     * @return mixed
     */
    public function handle($request, Closure $next, $permission)
    {
        if (\Auth::user()->can($permission)) {

            return $next($request);
        } else {
            return response()->view('errors.401');
        }
    }
}

add these middlewares in kernal.php

'role' => CheckRole::class,
        'permission' => CheckPermission::class

Answer 3

Now create a role with a name and add permissions to it. example:

1.create a role name festivals.
2.now create multiple permissions for that
   ->fesindex (only forr index viewing)
   ->fesedit  (only for edit and update)
   ->fesadd   (only for adding)
   ->fesdelete (only for deleting)
3.now attach which permissions you want to give to that role festivals
4.if you want a user to see only index page then
    for role festivals attach only fesindex
5.if you want a user to see index and add a new festival then create a new role for him and add fesindex and fes add 

Now created permissions are placed in your controller

 function __construct(FestivalRepository $repo)
    {
        $this->middleware('auth');
        $this->middleware('permission:fesindex', ['only' => 'getFestivals']);
        $this->middleware('permission:fesedit', ['only' => ['getFestival', 'postUpdateFestival']]);
        $this->middleware('permission:fesadd', ['only' => ['getAddFestival', 'postAddFestival']]);
        $this->middleware('permission:fesapprove', ['only' => 'getChangeStatus']);
        $this->middleware('permission:fesdelete', ['only' => 'getDeleteFestival']);

    }

here getFestivals,getAddFestival etc are methods in controller.