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

Completed

Push — master ( e518f2...2efb03 )

by Mikaël

created 2019-11-21 15:46 UTC

PermissionController::groups() A

↳ Parent: PermissionController

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	13
rs	9.8333
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?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();
    }

    /**
     * @param  string $search
     * @return \Illuminate\Support\Collection
     */
    protected function getSimpleGroups($search): Collection
    {
        return $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) {
                if (! empty($permission->group)) {
                    $key = Str::plural(Str::kebab($permission->group));
                    $resource = Nova::resourceForKey($key);

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

                return $permission;
            });
    }

    /**
     * @param  string $search
     * @return \Illuminate\Support\Collection
     */
    protected function getModelGroups($search): Collection
    {
        return $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();
    }

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

        return response()->json([
            'roles' => $this->getRoles(),
            'groups' => $this->getSimpleGroups($search)
                ->concat($this->getModelGroups($search))
                ->sortBy('group')
                ->values()
                ->all(),
        ]);
    }

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

BBS-Lab / nova-permission

Push — master ( e518f2...2efb03 )

PermissionController::groups() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like