App\Http\Controllers\AclController

Complexity

Total Complexity

31

Size/Duplication

Total Lines	288
Duplicated Lines	0 %

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	editPermission()	0	5	1
A	deleteUser()	0	20	2
B	updateUser()	0	32	4
A	deleteRole()	0	17	2
A	editUser()	0	5	1
B	storeRole()	0	24	3
A	userIndex()	0	5	1
A	deletePermission()	0	6	1
B	updateRole()	0	42	5
A	storePermission()	0	10	1
A	roleIndex()	0	5	1
B	storeUser()	0	24	2
A	createUser()	0	3	1
A	createRole()	0	5	1
A	createPermission()	0	3	1
A	permissionIndex()	0	5	1
A	editRole()	0	7	1
A	updatePermission()	0	12	1

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Carbon\Carbon;
use Auth;
use Validator;
use DB;
use App\User;
use App\Role;
use App\Role_user;
use App\Permission;
use App\Permission_role;
use App\Http\Requests;
use App\Lubus;
use App\Http\Controllers\Controller;

class AclController extends Controller
{
	public function __construct()
    {
        $this->middleware('auth');
    }

    /**
     * CRUD functions for Users 
     */

    public function userIndex()
    {
    	$users = User::excludeArchive()->paginate(10);

    	return view('user.userIndex',compact('users'));
    }

    public function createUser()
    {
    	return view('user.createUser');
    }

    public function storeUser(Request $request)
    {
    	$this->validate($request, ['name' => 'required|max:255',
						           'email' => 'required|email|max:255|unique:mst_users',
						           'password' => 'required|confirmed|min:6']);

    	$user = User::create(['name' => $request['name'],
                      		  'email' => $request['email'],
                      		  'password' => bcrypt($request['password']),
                			  'status'=> $request->status]);

        $user->save();

        // Adding Photo
        if($request->hasFile('photo'))
        {
          $user->addMedia($request->file('photo'))->usingFileName('staff_'.$user->id.$request->photo->getClientOriginalExtension())->toCollection('staff');

It seems like $request->file('photo') can also be of type array; however, parameter $file of App\User::addMedia() does only seem to accept Symfony\Component\HttpFoundation\File\UploadedFile|string, maybe add an additional type check?

        }
        $user->save();

    	$user->attachRole($request->role_id);

    	flash()->success('User was successfully created');
    	return redirect('user');
    }

    public function editUser($id)
    {
    	$user = User::findOrFail($id);

    	return view('user.editUser', compact('user'));
    }

    public function updateUser($id, Request $request)
    {
    	$user = User::findOrFail($id);

    	$user->name = $request->name;
    	$user->email = $request->email;

    	if(!empty($request->password))
        {
            $this->validate($request, ['password' => 'required|string|min:6|confirmed']);
            $user->password = bcrypt($request->password);
        }

        $user->status = $request->status;

        $user->update();

        if($request->hasFile('photo'))
        {
          $user->clearMediaCollection('staff');
          $user->addMedia($request->file('photo'))->usingFileName('staff_'.$user->id.$request->photo->getClientOriginalExtension())->toCollection('staff');
        }
        $user->save();

        if ($user->role_user->role->id != $request->role_id) 
        {
            Role_user::where('user_id',$user->id)->where('role_id',$user->role_user->role_id)->delete();
            $user->attachRole($request->role_id);
        }
    	
    	flash()->success('User details were successfully updated');
    	return redirect('user');
    }

    public function deleteUser($id)
    {
    	DB::beginTransaction();
    	try 
    	{
    		Role_user::where('user_id',$id)->delete();
    		$user = User::findOrFail($id);
            $user->clearMediaCollection('staff');
            $user->status = \constStatus::Archive;
            $user->save();

    		DB::commit();
    		flash()->success('User was successfully deleted');
    		return redirect('user');
    	} 
    	catch (Exception $e) 

The type App\Http\Controllers\Exception was not found. Did you mean Exception? If so, make sure to prefix the type with \.

    	{
    		DB::rollback();
    		flash()->error('User was not deleted');
    		return redirect('user');
    	}
    }


    /**
     * CRUD functions for Roles 
     */

    public function roleIndex()
    {
    	$roles = Role::excludeGymie()->get();

    	return view('user.roleIndex',compact('roles'));
    }

    public function createRole()
    {
    	$permissions = Permission::all();

    	return view('user.createRole',compact('permissions'));
    }

    public function storeRole(Request $request)
    {
    	DB::beginTransaction();
    	try 
    	{
    		$role = Role::create(['name' => $request->name,
		    					  'display_name' => $request->display_name,
		    					  'description' => $request->description,
    					 		 ]);

    		if ($request->has('permissions')) 
    		{
    			$role->attachPermissions($request->permissions);
    		}

    		DB::commit();
    		flash()->success('Role was successfully created');
    		return redirect('role');
    	} 
    	catch (Exception $e) 
    	{
    		DB::rollback();
    		flash()->error('Role was not created');
    		return redirect('role');
    	}
    }

    public function editRole($id)
    {
    	$role = Role::findOrFail($id);
    	$permissions = Permission::all();
    	$permission_role = Permission_role::where('role_id',$id)->get();

    	return view('user.editRole', compact('role','permissions','permission_role'));
    }

    public function updateRole($id, Request $request)
    {
    	DB::beginTransaction();
    	try 
    	{
    		//Updating Role
    		$role = Role::findOrFail($id);
    		
    		$role->update(['name' => $request->name,
    					   'display_name' => $request->display_name,
    					   'description' => $request->description,
				 		  ]);

    		//Updating permissions for the role
    		$DBpermissions = Permission_role::where('role_id',$id)->select('permission_id')->lists('permission_id');
    		$ClientPermissions = collect($request->permissions);
    
    		$addPermissions = $ClientPermissions->diff($DBpermissions);
    		$deletePermissions = $DBpermissions->diff($ClientPermissions);

    		if ($addPermissions->count()) 
    		{
    			$role->attachPermissions($addPermissions);
    		}

    		if ($deletePermissions->count()) 
    		{
    			foreach ($deletePermissions as $deletePermission) 
    			{
    				Permission_role::where('role_id',$id)->where('permission_id',$deletePermission)->delete();
    			}
    		}
    		    		    		
    		DB::commit();
    		flash()->success('Role was successfully updated');
    		return redirect('role');
    	} 
    	catch (Exception $e) 
    	{
    		DB::rollback();
    		flash()->error('Role was not updated');
    		return redirect('role');
    	}
    }

    public function deleteRole($id)
    {
    	DB::beginTransaction();
    	try 
    	{
    		Permission_role::where('role_id',$id)->delete();
    		Role::where('id',$id)->delete();

    		DB::commit();
    		flash()->success('Role was successfully deleted');
    		return redirect('role');
    	} 
    	catch (Exception $e) 
    	{
    		DB::rollback();
    		flash()->error('Role was not deleted');
    		return redirect('role');
    	}
    }

    /**
     * CRUD functions for Permissions 
     */

    public function permissionIndex()
    {
    	$permissions = Permission::all();

    	return view('user.permissionIndex',compact('permissions'));
    }

    public function createPermission()
    {
    	return view('user.createPermission');
    }

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

    	flash()->success('Permission was successfully created');
    	return redirect('permission');
    }

    public function editPermission($id)
    {
    	$permission = Permission::findOrFail($id);

    	return view('user.editPermission', compact('permission'));
    }

    public function updatePermission($id, Request $request)
    {
    	$permission = Permission::findOrFail($id);

    	$permission->update(['name' => $request->name,
						    'display_name' => $request->display_name,
						    'description' => $request->description,
						    'group_key' => $request->group_key,
						    ]);

    	flash()->success('Permission was successfully updated');
    	return redirect('permission');
    }

    public function deletePermission($id)
    {
    	Permission::findOrFail($id)->delete();

    	flash()->success('Permission was successfully deleted');
    	return redirect('permission');
    }
}