PermissionController::groups() - Code Metrics - Inspection of ":heavy_plus_sign: Adding laravel-nova." - BBS-Lab/nova-permission - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 04617a...36d859 )

by Mikaël

created 2019-11-21 10:29 UTC

PermissionController::groups() B

↳ Parent: PermissionController

Complexity

Conditions	3
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	62
rs	8.829
c	0
b	0
f	0
cc	3
nc	1
nop	1

How to fix Long Method

<?php

namespace BBSLab\NovaPermission\Http\Controllers;

use BBSLab\NovaPermission\Actions\GenerateResourcePermissionsAction;
use BBSLab\NovaPermission\Http\Requests\AttachRequest;
use BBSLab\NovaPermission\Http\Requests\PermissionByAuthorizableRequest;
use BBSLab\NovaPermission\Http\Requests\PermissionByGroupRequest;
use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
use Illuminate\Http\Request;
use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use Laravel\Nova\Nova;
use Spatie\Permission\PermissionRegistrar;

class PermissionController
{
    /** @var \BBSLab\NovaPermission\Contracts\Role */
    protected $roleModel;

    /** @var \BBSLab\NovaPermission\Contracts\Permission */
    protected $permissionModel;

    /**
     * Create new PermissionController instance.
     *
     * @param  \Spatie\Permission\PermissionRegistrar  $registrar
     */
    public function __construct(PermissionRegistrar $registrar)
    {
        $this->roleModel = $registrar->getRoleClass();
        $this->permissionModel = $registrar->getPermissionClass();
    }

    protected function getRoles(): Collection
    {
        return $this->roleModel->newQuery()
            ->select('id', 'name', 'guard_name')
            ->where('override_permission', '=', false)
            ->orderBy('name')
            ->get();
    }

    /**
     * Get the permission groups.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function groups(Request $request)
    {
        $search = trim($request->query('search'));

        $roles = $this->getRoles();

        $groups = $this->permissionModel->newQuery()
            ->select('group', 'authorizable_id', 'authorizable_type', 'guard_name')
            ->distinct()
            ->whereNull(['authorizable_id', 'authorizable_id'])
            ->when(! empty($search), function ($query) use ($search) {
                return $query->where(function ($query) use ($search) {
                    $query->where('group', 'like', "%$search%")
                        ->orWhere('name', 'like', "%$search%");
                });
            })
            ->orderBy('group')
            ->get()
            ->map(function ($permission) use ($request) {
                if (! empty($permission->group)) {
                    $key = Str::plural(Str::kebab($permission->group));
                    $resource = Nova::resourceForKey($key);

                    if (! empty($resource)) {
                        $permission->display = $resource::label();
                    }
                }

                return $permission;
            });

        $models = $this->permissionModel->newQuery()
            ->select('authorizable_id', 'authorizable_type', 'guard_name')
            ->distinct()
            ->with('authorizable')
            ->whereNotNull(['authorizable_id', 'authorizable_id'])
            ->when(! empty($search), function ($query) use ($search) {
                return $query->where('name', 'like', "%$search%");
            })
            ->get()
            ->map(function ($permission) {
                /** @var \Laravel\Nova\Resource $resource */
                $resource = Nova::newResourceFromModel($permission->authorizable);

                $permission->display = $resource::singularLabel().': '.$resource->title();

                unset($permission->authorizable);

                return $permission;
            })
            ->filter();

        $groups = $groups->concat($models)
            ->sortBy('group')
            ->values()
            ->all();

        return response()->json([
            'roles' => $roles,
            'groups' => $groups,
        ]);
    }

    /**
     * @param  string  $guard
     * @param  string  $search
     * @return \Illuminate\Database\Eloquent\Builder
     */
    protected function getPermissionQuery(string $guard, string $search): EloquentBuilder
    {
        return $this->permissionModel->newQuery()
            ->select('id', 'name', 'guard_name')
            ->with('roles')
            ->where('guard_name', '=', $guard)
            ->when(! empty($search), function (EloquentBuilder $query) use ($search) {
                return $query->where('name', 'like', "%$search%");
            })
            ->orderBy('name');
    }

    /**
     * Get permissions by group name.
     *
     * @param  \BBSLab\NovaPermission\Http\Requests\PermissionByGroupRequest  $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function permissionsByGroup(PermissionByGroupRequest $request)
    {
        $roles = $this->getRoles();

        $permissions = $this->getPermissionQuery($request->guard, $request->searchValue())
            ->when(empty($request->group), function (EloquentBuilder $query) {
                return $query->whereNull(['group', 'authorizable_id', 'authorizable_type']);
            })
            ->when(! empty($request->group), function (EloquentBuilder $query) use ($request) {
                return $query->where('group', '=', $request->group)
                    ->whereNull(['authorizable_id', 'authorizable_type']);
            })
            ->get()
            ->map
            ->serializeForPermissionBuilder($roles);

        return response()->json($permissions);
    }

    /**
     * Get permissions by authorizable information.
     *
     * @param  \BBSLab\NovaPermission\Http\Requests\PermissionByAuthorizableRequest  $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function permissionsByAuthorizable(PermissionByAuthorizableRequest $request)
    {
        $roles = $this->getRoles();

        $permissions = $this->getPermissionQuery($request->guard, $request->searchValue())
            ->where([
                'authorizable_id' => $request->id,
                'authorizable_type' => $request->type,
            ])
            ->get()
            ->map
            ->serializeForPermissionBuilder($roles);

        return response()->json($permissions);
    }

    /**
     * Attach or detach permissions.
     *
     * @param  \BBSLab\NovaPermission\Http\Requests\AttachRequest  $request
     * @param $role
     * @return \Illuminate\Http\JsonResponse
     */
    public function attachPermission(AttachRequest $request, $role)
    {
        /** @var \BBSLab\NovaPermission\Models\Role $role */
        $role = $this->roleModel->newQuery()->findOrFail($role);

        $method = $request->attach ? 'syncWithoutDetaching' : 'detach';
        $message = $request->attach ? 'nova-permission::permission-builder.attached' : 'nova-permission::permission-builder.detached';

        $role->permissions()->{$method}($request->permissions);

        app(PermissionRegistrar::class)->forgetCachedPermissions();

        return response()->json([
            'message' => trans_choice($message, count($request->permissions)),
        ]);
    }

    /**
     * Generate resources permissions.
     *
     * @param  \BBSLab\NovaPermission\Actions\GenerateResourcePermissionsAction  $generateResourcePermissionsAction
     * @return \Illuminate\Http\JsonResponse
     */
    public function generatePermission(GenerateResourcePermissionsAction $generateResourcePermissionsAction)
    {
        try {
            $generateResourcePermissionsAction->execute();

            return response()->json([
                'message' => trans('nova-permission::permission-builder.permissions-generated'),
            ]);
        } catch (\Exception $exception) {
            abort(500, $exception->getMessage());
        }
    }
}


1			<?php
2
3			namespace BBSLab\NovaPermission\Http\Controllers;
4
5			use BBSLab\NovaPermission\Actions\GenerateResourcePermissionsAction;
6			use BBSLab\NovaPermission\Http\Requests\AttachRequest;
7			use BBSLab\NovaPermission\Http\Requests\PermissionByAuthorizableRequest;
8			use BBSLab\NovaPermission\Http\Requests\PermissionByGroupRequest;
9			use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
10			use Illuminate\Http\Request;
11			use Illuminate\Support\Collection;
12			use Illuminate\Support\Str;
13			use Laravel\Nova\Nova;
14			use Spatie\Permission\PermissionRegistrar;
15
16			class PermissionController
17			{
18			/** @var \BBSLab\NovaPermission\Contracts\Role */
19			protected $roleModel;
20
21			/** @var \BBSLab\NovaPermission\Contracts\Permission */
22			protected $permissionModel;
23
24			/**
25			* Create new PermissionController instance.
26			*
27			* @param \Spatie\Permission\PermissionRegistrar $registrar
28			*/
29			public function __construct(PermissionRegistrar $registrar)
30			{
31			$this->roleModel = $registrar->getRoleClass();
32			$this->permissionModel = $registrar->getPermissionClass();
33			}
34
35			protected function getRoles(): Collection
36			{
37			return $this->roleModel->newQuery()
38			->select('id', 'name', 'guard_name')
39			->where('override_permission', '=', false)
40			->orderBy('name')
41			->get();
42			}
43
44			/**
45			* Get the permission groups.
46			*
47			* @param \Illuminate\Http\Request $request
48			* @return \Illuminate\Http\JsonResponse
49			*/
50			public function groups(Request $request)
51			{
52			$search = trim($request->query('search'));
53
54			$roles = $this->getRoles();
55
56			$groups = $this->permissionModel->newQuery()
57			->select('group', 'authorizable_id', 'authorizable_type', 'guard_name')
58			->distinct()
59			->whereNull(['authorizable_id', 'authorizable_id'])
60			->when(! empty($search), function ($query) use ($search) {
61			return $query->where(function ($query) use ($search) {
62			$query->where('group', 'like', "%$search%")
63			->orWhere('name', 'like', "%$search%");
64			});
65			})
66			->orderBy('group')
67			->get()
68			->map(function ($permission) use ($request) {
69			if (! empty($permission->group)) {
70			$key = Str::plural(Str::kebab($permission->group));
71			$resource = Nova::resourceForKey($key);
72
73			if (! empty($resource)) {
74			$permission->display = $resource::label();
75			}
76			}
77
78			return $permission;
79			});
80
81			$models = $this->permissionModel->newQuery()
82			->select('authorizable_id', 'authorizable_type', 'guard_name')
83			->distinct()
84			->with('authorizable')
85			->whereNotNull(['authorizable_id', 'authorizable_id'])
86			->when(! empty($search), function ($query) use ($search) {
87			return $query->where('name', 'like', "%$search%");
88			})
89			->get()
90			->map(function ($permission) {
91			/** @var \Laravel\Nova\Resource $resource */
92			$resource = Nova::newResourceFromModel($permission->authorizable);
93
94			$permission->display = $resource::singularLabel().': '.$resource->title();
95
96			unset($permission->authorizable);
97
98			return $permission;
99			})
100			->filter();
101
102			$groups = $groups->concat($models)
103			->sortBy('group')
104			->values()
105			->all();
106
107			return response()->json([
108			'roles' => $roles,
109			'groups' => $groups,
110			]);
111			}
112
113			/**
114			* @param string $guard
115			* @param string $search
116			* @return \Illuminate\Database\Eloquent\Builder
117			*/
118			protected function getPermissionQuery(string $guard, string $search): EloquentBuilder
119			{
120			return $this->permissionModel->newQuery()
121			->select('id', 'name', 'guard_name')
122			->with('roles')
123			->where('guard_name', '=', $guard)
124			->when(! empty($search), function (EloquentBuilder $query) use ($search) {
125			return $query->where('name', 'like', "%$search%");
126			})
127			->orderBy('name');
128			}
129
130			/**
131			* Get permissions by group name.
132			*
133			* @param \BBSLab\NovaPermission\Http\Requests\PermissionByGroupRequest $request
134			* @return \Illuminate\Http\JsonResponse
135			*/
136			public function permissionsByGroup(PermissionByGroupRequest $request)
137			{
138			$roles = $this->getRoles();
139
140			$permissions = $this->getPermissionQuery($request->guard, $request->searchValue())
141			->when(empty($request->group), function (EloquentBuilder $query) {
142			return $query->whereNull(['group', 'authorizable_id', 'authorizable_type']);
143			})
144			->when(! empty($request->group), function (EloquentBuilder $query) use ($request) {
145			return $query->where('group', '=', $request->group)
146			->whereNull(['authorizable_id', 'authorizable_type']);
147			})
148			->get()
149			->map
150			->serializeForPermissionBuilder($roles);
151
152			return response()->json($permissions);
153			}
154
155			/**
156			* Get permissions by authorizable information.
157			*
158			* @param \BBSLab\NovaPermission\Http\Requests\PermissionByAuthorizableRequest $request
159			* @return \Illuminate\Http\JsonResponse
160			*/
161			public function permissionsByAuthorizable(PermissionByAuthorizableRequest $request)
162			{
163			$roles = $this->getRoles();
164
165			$permissions = $this->getPermissionQuery($request->guard, $request->searchValue())
166			->where([
167			'authorizable_id' => $request->id,
168			'authorizable_type' => $request->type,
169			])
170			->get()
171			->map
172			->serializeForPermissionBuilder($roles);
173
174			return response()->json($permissions);
175			}
176
177			/**
178			* Attach or detach permissions.
179			*
180			* @param \BBSLab\NovaPermission\Http\Requests\AttachRequest $request
181			* @param $role
182			* @return \Illuminate\Http\JsonResponse
183			*/
184			public function attachPermission(AttachRequest $request, $role)
185			{
186			/** @var \BBSLab\NovaPermission\Models\Role $role */
187			$role = $this->roleModel->newQuery()->findOrFail($role);
188
189			$method = $request->attach ? 'syncWithoutDetaching' : 'detach';
190			$message = $request->attach ? 'nova-permission::permission-builder.attached' : 'nova-permission::permission-builder.detached';
191
192			$role->permissions()->{$method}($request->permissions);
193
194			app(PermissionRegistrar::class)->forgetCachedPermissions();
195
196			return response()->json([
197			'message' => trans_choice($message, count($request->permissions)),
198			]);
199			}
200
201			/**
202			* Generate resources permissions.
203			*
204			* @param \BBSLab\NovaPermission\Actions\GenerateResourcePermissionsAction $generateResourcePermissionsAction
205			* @return \Illuminate\Http\JsonResponse
206			*/
207			public function generatePermission(GenerateResourcePermissionsAction $generateResourcePermissionsAction)
208			{
209			try {
210			$generateResourcePermissionsAction->execute();
211
212			return response()->json([
213			'message' => trans('nova-permission::permission-builder.permissions-generated'),
214			]);
215			} catch (\Exception $exception) {
216			abort(500, $exception->getMessage());
217			}
218			}
219			}
220

BBS-Lab / nova-permission

Push — master ( 04617a...36d859 )

PermissionController::groups() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like