HasPermissions::hasPermissionViaRole() - Code Metrics - Inspection of "Move permissions methods out of HasRoles trait" - spatie/laravel-permission - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#644)

by Chris

created 2018-03-03 23:40 UTC

HasPermissions::hasPermissionViaRole() A

↳ Parent: HasPermissions

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	1
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php

namespace Spatie\Permission\Traits;

use Spatie\Permission\Guard;
use Illuminate\Support\Collection;
use Illuminate\Database\Eloquent\Builder;
use Spatie\Permission\PermissionRegistrar;
use Spatie\Permission\Contracts\Permission;
use Spatie\Permission\Exceptions\GuardDoesNotMatch;
use Illuminate\Database\Eloquent\Relations\MorphToMany;

trait HasPermissions
{
    public static function bootHasPermissions()
    {
        static::deleting(function ($model) {
            if (method_exists($model, 'isForceDeleting') && ! $model->isForceDeleting()) {
                return;
            }

            $model->permissions()->detach();
        });
    }

    /**
     * A model may have multiple direct permissions.
     */
    public function permissions(): MorphToMany
    {
        return $this->morphToMany(
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            config('permission.models.permission'),
            'model',
            config('permission.table_names.model_has_permissions'),
            'model_id',
            'permission_id'
        );
    }

    /**
     * Scope the model query to certain permissions only.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string|array|\Spatie\Permission\Contracts\Permission|\Illuminate\Support\Collection $permissions
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopePermission(Builder $query, $permissions): Builder
    {
        $permissions = $this->convertToPermissionModels($permissions);

        $rolesWithPermissions = array_unique(array_reduce($permissions, function ($result, $permission) {
            return array_merge($result, $permission->roles->all());
        }, []));

        return $query->
        where(function ($query) use ($permissions, $rolesWithPermissions) {
            $query->whereHas('permissions', function ($query) use ($permissions) {
                $query->where(function ($query) use ($permissions) {
                    foreach ($permissions as $permission) {
                        $query->orWhere(config('permission.table_names.permissions').'.id', $permission->id);
                    }
                });
            });
            if (count($rolesWithPermissions) > 0) {
                $query->orWhereHas('roles', function ($query) use ($rolesWithPermissions) {
                    $query->where(function ($query) use ($rolesWithPermissions) {
                        foreach ($rolesWithPermissions as $role) {
                            $query->orWhere(config('permission.table_names.roles').'.id', $role->id);
                        }
                    });
                });
            }
        });
    }

    /**
     * @param string|array|\Spatie\Permission\Contracts\Permission|\Illuminate\Support\Collection $permissions
     *
     * @return array
     */
    protected function convertToPermissionModels($permissions): array
    {
        if ($permissions instanceof Collection) {
            $permissions = $permissions->all();
        }

        $permissions = array_wrap($permissions);

        return array_map(function ($permission) {
            if ($permission instanceof Permission) {
                return $permission;
            }

            return app(Permission::class)->findByName($permission, $this->getDefaultGuardName());
        }, $permissions);
    }

    /**
     * Determine if the model may perform the given permission.
     *
     * @param string|\Spatie\Permission\Contracts\Permission $permission
     * @param string|null $guardName
     *
     * @return bool
     */
    public function hasPermissionTo($permission, $guardName = null): bool
    {
        if (is_string($permission)) {

            $permission = app(Permission::class)->findByName(
                $permission,
                $guardName ?? $this->getDefaultGuardName()
            );
        }

        if (is_int($permission)) {
            $permission = app(Permission::class)->findById($permission, $this->getDefaultGuardName());
        }

        return $this->hasDirectPermission($permission) || $this->hasPermissionViaRole($permission);
    }

    /**
     * Determine if the model has any of the given permissions.
     *
     * @param array ...$permissions
     *
     * @return bool
     */
    public function hasAnyPermission(...$permissions): bool
    {
        if (is_array($permissions[0])) {
            $permissions = $permissions[0];
        }

        foreach ($permissions as $permission) {
            if ($this->hasPermissionTo($permission)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Determine if the model has, via roles, the given permission.
     *
     * @param \Spatie\Permission\Contracts\Permission $permission
     *
     * @return bool
     */
    protected function hasPermissionViaRole(Permission $permission): bool
    {
        return $this->hasRole($permission->roles);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
    }

    /**
     * Determine if the model has the given permission.
     *
     * @param string|\Spatie\Permission\Contracts\Permission $permission
     *
     * @return bool
     */
    public function hasDirectPermission($permission): bool
    {
        if (is_string($permission)) {

            $permission = app(Permission::class)->findByName($permission, $this->getDefaultGuardName());
            if (! $permission) {
                return false;
            }
        }

        if (is_int($permission)) {
            $permission = app(Permission::class)->findById($permission, $this->getDefaultGuardName());
            if (! $permission) {
                return false;
            }
        }

        return $this->permissions->contains('id', $permission->id);
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Return all the permissions the model has via roles.
     */
    public function getPermissionsViaRoles(): Collection
    {
        return $this->load('roles', 'roles.permissions')
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->roles->flatMap(function ($role) {
                return $role->permissions;
            })->sort()->values();
    }

    /**
     * Return all the permissions the model has, both directly and via roles.
     */
    public function getAllPermissions(): Collection
    {
        return $this->permissions
            ->merge($this->getPermissionsViaRoles())
            ->sort()
            ->values();
    }

    /**
     * Grant the given permission(s) to a role.
     *
     * @param string|array|\Spatie\Permission\Contracts\Permission|\Illuminate\Support\Collection $permissions
     *
     * @return $this
     */
    public function givePermissionTo(...$permissions)

    {
        $permissions = collect($permissions)
            ->flatten()
            ->map(function ($permission) {
                return $this->getStoredPermission($permission);
            })
            ->each(function ($permission) {
                $this->ensureModelSharesGuard($permission);
            })
            ->all();

        $this->permissions()->saveMany($permissions);

        $this->forgetCachedPermissions();

        return $this;
    }

    /**
     * Remove all current permissions and set the given ones.
     *
     * @param string|array|\Spatie\Permission\Contracts\Permission|\Illuminate\Support\Collection $permissions
     *
     * @return $this
     */
    public function syncPermissions(...$permissions)
    {
        $this->permissions()->detach();

        return $this->givePermissionTo($permissions);
    }

    /**
     * Revoke the given permission.
     *
     * @param \Spatie\Permission\Contracts\Permission|\Spatie\Permission\Contracts\Permission[]|string|string[] $permission
     *
     * @return $this
     */
    public function revokePermissionTo($permission)
    {
        $this->permissions()->detach($this->getStoredPermission($permission));

        $this->forgetCachedPermissions();

        return $this;
    }

    /**
     * @param string|array|\Spatie\Permission\Contracts\Permission|\Illuminate\Support\Collection $permissions
     *
     * @return \Spatie\Permission\Contracts\Permission|\Spatie\Permission\Contracts\Permission[]|\Illuminate\Support\Collection
     */
    protected function getStoredPermission($permissions)
    {
        if (is_numeric($permissions)) {
            return app(Permission::class)->findById($permissions, $this->getDefaultGuardName());
        }

        if (is_string($permissions)) {
            return app(Permission::class)->findByName($permissions, $this->getDefaultGuardName());
        }

        if (is_array($permissions)) {
            return app(Permission::class)
                ->whereIn('name', $permissions)
                ->whereIn('guard_name', $this->getGuardNames())
                ->get();
        }

        return $permissions;
    }

    /**
     * @param \Spatie\Permission\Contracts\Permission|\Spatie\Permission\Contracts\Role $roleOrPermission
     *
     * @throws \Spatie\Permission\Exceptions\GuardDoesNotMatch
     */
    protected function ensureModelSharesGuard($roleOrPermission)
    {
        if (! $this->getGuardNames()->contains($roleOrPermission->guard_name)) {
            throw GuardDoesNotMatch::create($roleOrPermission->guard_name, $this->getGuardNames());
        }
    }

    protected function getGuardNames(): Collection
    {
        return Guard::getNames($this);
    }

    protected function getDefaultGuardName(): string
    {
        return Guard::getDefaultName($this);
    }

    /**
     * Forget the cached permissions.
     */
    public function forgetCachedPermissions()
    {
        app(PermissionRegistrar::class)->forgetCachedPermissions();
    }
}


1		<?php
2
3		namespace Spatie\Permission\Traits;
4
5		use Spatie\Permission\Guard;
6		use Illuminate\Support\Collection;
7		use Illuminate\Database\Eloquent\Builder;
8		use Spatie\Permission\PermissionRegistrar;
9		use Spatie\Permission\Contracts\Permission;
10		use Spatie\Permission\Exceptions\GuardDoesNotMatch;
11		use Illuminate\Database\Eloquent\Relations\MorphToMany;
12
13		trait HasPermissions
14		{
15		public static function bootHasPermissions()
16		{
17		static::deleting(function ($model) {
18		if (method_exists($model, 'isForceDeleting') && ! $model->isForceDeleting()) {
19		return;
20		}
21
22		$model->permissions()->detach();
23		});
24		}
25
26		/**
27		* A model may have multiple direct permissions.
28		*/
29		public function permissions(): MorphToMany
30		{
31		return $this->morphToMany(
		0 ignored issues – show Bug introduced 2017-04-20 14:18 UTC by Report Bug Copy Issue Report It seems like `morphToMany()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
32		config('permission.models.permission'),
33		'model',
34		config('permission.table_names.model_has_permissions'),
35		'model_id',
36		'permission_id'
37		);
38		}
39
40		/**
41		* Scope the model query to certain permissions only.
42		*
43		* @param \Illuminate\Database\Eloquent\Builder $query
44		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
45		*
46		* @return \Illuminate\Database\Eloquent\Builder
47		*/
48		public function scopePermission(Builder $query, $permissions): Builder
49		{
50		$permissions = $this->convertToPermissionModels($permissions);
51
52		$rolesWithPermissions = array_unique(array_reduce($permissions, function ($result, $permission) {
53		return array_merge($result, $permission->roles->all());
54		}, []));
55
56		return $query->
57		where(function ($query) use ($permissions, $rolesWithPermissions) {
58		$query->whereHas('permissions', function ($query) use ($permissions) {
59		$query->where(function ($query) use ($permissions) {
60		foreach ($permissions as $permission) {
61		$query->orWhere(config('permission.table_names.permissions').'.id', $permission->id);
62		}
63		});
64		});
65		if (count($rolesWithPermissions) > 0) {
66		$query->orWhereHas('roles', function ($query) use ($rolesWithPermissions) {
67		$query->where(function ($query) use ($rolesWithPermissions) {
68		foreach ($rolesWithPermissions as $role) {
69		$query->orWhere(config('permission.table_names.roles').'.id', $role->id);
70		}
71		});
72		});
73		}
74		});
75		}
76
77		/**
78		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
79		*
80		* @return array
81		*/
82		protected function convertToPermissionModels($permissions): array
83		{
84		if ($permissions instanceof Collection) {
85		$permissions = $permissions->all();
86		}
87
88		$permissions = array_wrap($permissions);
89
90		return array_map(function ($permission) {
91		if ($permission instanceof Permission) {
92		return $permission;
93		}
94
95		return app(Permission::class)->findByName($permission, $this->getDefaultGuardName());
96		}, $permissions);
97		}
98
99		/**
100		* Determine if the model may perform the given permission.
101		*
102		* @param string\|\Spatie\Permission\Contracts\Permission $permission
103		* @param string\|null $guardName
104		*
105		* @return bool
106		*/
107		public function hasPermissionTo($permission, $guardName = null): bool
108		{
109	View Code Duplication	if (is_string($permission)) {
		0 ignored issues – show Duplication introduced 2017-06-06 16:24 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
110		$permission = app(Permission::class)->findByName(
111		$permission,
112		$guardName ?? $this->getDefaultGuardName()
113		);
114		}
115
116		if (is_int($permission)) {
117		$permission = app(Permission::class)->findById($permission, $this->getDefaultGuardName());
118		}
119
120		return $this->hasDirectPermission($permission) \|\| $this->hasPermissionViaRole($permission);
121		}
122
123		/**
124		* Determine if the model has any of the given permissions.
125		*
126		* @param array ...$permissions
127		*
128		* @return bool
129		*/
130		public function hasAnyPermission(...$permissions): bool
131		{
132		if (is_array($permissions[0])) {
133		$permissions = $permissions[0];
134		}
135
136		foreach ($permissions as $permission) {
137		if ($this->hasPermissionTo($permission)) {
138		return true;
139		}
140		}
141
142		return false;
143		}
144
145		/**
146		* Determine if the model has, via roles, the given permission.
147		*
148		* @param \Spatie\Permission\Contracts\Permission $permission
149		*
150		* @return bool
151		*/
152		protected function hasPermissionViaRole(Permission $permission): bool
153		{
154		return $this->hasRole($permission->roles);
		0 ignored issues – show Bug introduced 2015-12-21 23:32 UTC by Report Bug Copy Issue Report Accessing `roles` on the interface `Spatie\Permission\Contracts\Permission` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history... Bug introduced 2018-02-05 03:35 UTC by Report Bug Copy Issue Report It seems like `hasRole()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
155		}
156
157		/**
158		* Determine if the model has the given permission.
159		*
160		* @param string\|\Spatie\Permission\Contracts\Permission $permission
161		*
162		* @return bool
163		*/
164		public function hasDirectPermission($permission): bool
165		{
166	View Code Duplication	if (is_string($permission)) {
		0 ignored issues – show Duplication introduced 2017-06-06 16:24 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
167		$permission = app(Permission::class)->findByName($permission, $this->getDefaultGuardName());
168		if (! $permission) {
169		return false;
170		}
171		}
172
173		if (is_int($permission)) {
174		$permission = app(Permission::class)->findById($permission, $this->getDefaultGuardName());
175		if (! $permission) {
176		return false;
177		}
178		}
179
180		return $this->permissions->contains('id', $permission->id);
		0 ignored issues – show Bug introduced 2015-12-21 23:32 UTC by Report Bug Copy Issue Report The property `permissions` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
181		}
182
183		/**
184		* Return all the permissions the model has via roles.
185		*/
186		public function getPermissionsViaRoles(): Collection
187		{
188		return $this->load('roles', 'roles.permissions')
		0 ignored issues – show Bug introduced 2017-02-22 12:47 UTC by Report Bug Copy Issue Report It seems like `load()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
189		->roles->flatMap(function ($role) {
190		return $role->permissions;
191		})->sort()->values();
192		}
193
194		/**
195		* Return all the permissions the model has, both directly and via roles.
196		*/
197		public function getAllPermissions(): Collection
198		{
199		return $this->permissions
200		->merge($this->getPermissionsViaRoles())
201		->sort()
202		->values();
203		}
204
205		/**
206		* Grant the given permission(s) to a role.
207		*
208		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
209		*
210		* @return $this
211		*/
212	View Code Duplication	public function givePermissionTo(...$permissions)
		0 ignored issues – show Duplication introduced 2017-08-07 17:04 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
213		{
214		$permissions = collect($permissions)
215		->flatten()
216		->map(function ($permission) {
217		return $this->getStoredPermission($permission);
218		})
219		->each(function ($permission) {
220		$this->ensureModelSharesGuard($permission);
221		})
222		->all();
223
224		$this->permissions()->saveMany($permissions);
225
226		$this->forgetCachedPermissions();
227
228		return $this;
229		}
230
231		/**
232		* Remove all current permissions and set the given ones.
233		*
234		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
235		*
236		* @return $this
237		*/
238		public function syncPermissions(...$permissions)
239		{
240		$this->permissions()->detach();
241
242		return $this->givePermissionTo($permissions);
243		}
244
245		/**
246		* Revoke the given permission.
247		*
248		* @param \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Permission[]\|string\|string[] $permission
249		*
250		* @return $this
251		*/
252		public function revokePermissionTo($permission)
253		{
254		$this->permissions()->detach($this->getStoredPermission($permission));
255
256		$this->forgetCachedPermissions();
257
258		return $this;
259		}
260
261		/**
262		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
263		*
264		* @return \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Permission[]\|\Illuminate\Support\Collection
265		*/
266		protected function getStoredPermission($permissions)
267		{
268		if (is_numeric($permissions)) {
269		return app(Permission::class)->findById($permissions, $this->getDefaultGuardName());
270		}
271
272		if (is_string($permissions)) {
273		return app(Permission::class)->findByName($permissions, $this->getDefaultGuardName());
274		}
275
276		if (is_array($permissions)) {
277		return app(Permission::class)
278		->whereIn('name', $permissions)
279		->whereIn('guard_name', $this->getGuardNames())
280		->get();
281		}
282
283		return $permissions;
284		}
285
286		/**
287		* @param \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Role $roleOrPermission
288		*
289		* @throws \Spatie\Permission\Exceptions\GuardDoesNotMatch
290		*/
291		protected function ensureModelSharesGuard($roleOrPermission)
292		{
293		if (! $this->getGuardNames()->contains($roleOrPermission->guard_name)) {
294		throw GuardDoesNotMatch::create($roleOrPermission->guard_name, $this->getGuardNames());
295		}
296		}
297
298		protected function getGuardNames(): Collection
299		{
300		return Guard::getNames($this);
301		}
302
303		protected function getDefaultGuardName(): string
304		{
305		return Guard::getDefaultName($this);
306		}
307
308		/**
309		* Forget the cached permissions.
310		*/
311		public function forgetCachedPermissions()
312		{
313		app(PermissionRegistrar::class)->forgetCachedPermissions();
314		}
315		}
316

spatie / laravel-permission

Pull Request — master (#644)

HasPermissions::hasPermissionViaRole() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like