HasPermissions - Code Metrics - Inspection of "Adding method hasAllPermissions" - spatie/laravel-permission - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#768)

by Chris

created 2018-06-14 02:50 UTC

HasPermissions B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	324
Duplicated Lines	17.9 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
dl	58
loc	324
rs	8.3157
c	0
b	0
f	0
wmc	43
lcom	1
cbo	5

19 Methods

Rating	Name	Duplication	Size	Complexity
A	bootHasPermissions()	0	10	3
A	permissions()	0	10	1
B	scopePermission()	0	27	4
A	convertToPermissionModels()	0	16	3
A	hasPermissionTo()	6	15	4
A	hasAnyPermission()	14	14	4
A	hasAllPermissions()	14	14	4
A	hasPermissionViaRole()	0	4	1
B	hasDirectPermission()	6	18	5
A	getPermissionsViaRoles()	0	7	1
A	getAllPermissions()	0	7	1
A	givePermissionTo()	18	18	1
A	syncPermissions()	0	6	1
A	revokePermissionTo()	0	8	1
A	getStoredPermission()	0	19	4
A	ensureModelSharesGuard()	0	6	2
A	getGuardNames()	0	4	1
A	getDefaultGuardName()	0	4	1
A	forgetCachedPermissions()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like HasPermissions often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use HasPermissions, and based on these observations, apply Extract Interface, too.

<?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 all of the given permissions.
     *
     * @param array ...$permissions
     *
     * @return bool
     */
    public function hasAllPermissions(...$permissions): bool

    {
        if (is_array($permissions[0])) {
            $permissions = $permissions[0];
        }

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

        return true;
    }

    /**
     * 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->where(function ($query) use ($permissions, $rolesWithPermissions) {
57		$query->whereHas('permissions', function ($query) use ($permissions) {
58		$query->where(function ($query) use ($permissions) {
59		foreach ($permissions as $permission) {
60		$query->orWhere(config('permission.table_names.permissions').'.id', $permission->id);
61		}
62		});
63		});
64		if (count($rolesWithPermissions) > 0) {
65		$query->orWhereHas('roles', function ($query) use ($rolesWithPermissions) {
66		$query->where(function ($query) use ($rolesWithPermissions) {
67		foreach ($rolesWithPermissions as $role) {
68		$query->orWhere(config('permission.table_names.roles').'.id', $role->id);
69		}
70		});
71		});
72		}
73		});
74		}
75
76		/**
77		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
78		*
79		* @return array
80		*/
81		protected function convertToPermissionModels($permissions): array
82		{
83		if ($permissions instanceof Collection) {
84		$permissions = $permissions->all();
85		}
86
87		$permissions = array_wrap($permissions);
88
89		return array_map(function ($permission) {
90		if ($permission instanceof Permission) {
91		return $permission;
92		}
93
94		return app(Permission::class)->findByName($permission, $this->getDefaultGuardName());
95		}, $permissions);
96		}
97
98		/**
99		* Determine if the model may perform the given permission.
100		*
101		* @param string\|\Spatie\Permission\Contracts\Permission $permission
102		* @param string\|null $guardName
103		*
104		* @return bool
105		*/
106		public function hasPermissionTo($permission, $guardName = null): bool
107		{
108	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...
109		$permission = app(Permission::class)->findByName(
110		$permission,
111		$guardName ?? $this->getDefaultGuardName()
112		);
113		}
114
115		if (is_int($permission)) {
116		$permission = app(Permission::class)->findById($permission, $this->getDefaultGuardName());
117		}
118
119		return $this->hasDirectPermission($permission) \|\| $this->hasPermissionViaRole($permission);
120		}
121
122		/**
123		* Determine if the model has any of the given permissions.
124		*
125		* @param array ...$permissions
126		*
127		* @return bool
128		*/
129	View Code Duplication	public function hasAnyPermission(...$permissions): bool
		0 ignored issues – show Duplication introduced 2018-06-14 02:51 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...
130		{
131		if (is_array($permissions[0])) {
132		$permissions = $permissions[0];
133		}
134
135		foreach ($permissions as $permission) {
136		if ($this->hasPermissionTo($permission)) {
137		return true;
138		}
139		}
140
141		return false;
142		}
143
144		/**
145		* Determine if the model has all of the given permissions.
146		*
147		* @param array ...$permissions
148		*
149		* @return bool
150		*/
151	View Code Duplication	public function hasAllPermissions(...$permissions): bool
		0 ignored issues – show Duplication introduced 2018-06-14 02:51 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...
152		{
153		if (is_array($permissions[0])) {
154		$permissions = $permissions[0];
155		}
156
157		foreach ($permissions as $permission) {
158		if (! $this->hasPermissionTo($permission)) {
159		return false;
160		}
161		}
162
163		return true;
164		}
165
166		/**
167		* Determine if the model has, via roles, the given permission.
168		*
169		* @param \Spatie\Permission\Contracts\Permission $permission
170		*
171		* @return bool
172		*/
173		protected function hasPermissionViaRole(Permission $permission): bool
174		{
175		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...
176		}
177
178		/**
179		* Determine if the model has the given permission.
180		*
181		* @param string\|\Spatie\Permission\Contracts\Permission $permission
182		*
183		* @return bool
184		*/
185		public function hasDirectPermission($permission): bool
186		{
187	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...
188		$permission = app(Permission::class)->findByName($permission, $this->getDefaultGuardName());
189		if (! $permission) {
190		return false;
191		}
192		}
193
194		if (is_int($permission)) {
195		$permission = app(Permission::class)->findById($permission, $this->getDefaultGuardName());
196		if (! $permission) {
197		return false;
198		}
199		}
200
201		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...
202		}
203
204		/**
205		* Return all the permissions the model has via roles.
206		*/
207		public function getPermissionsViaRoles(): Collection
208		{
209		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...
210		->roles->flatMap(function ($role) {
211		return $role->permissions;
212		})->sort()->values();
213		}
214
215		/**
216		* Return all the permissions the model has, both directly and via roles.
217		*/
218		public function getAllPermissions(): Collection
219		{
220		return $this->permissions
221		->merge($this->getPermissionsViaRoles())
222		->sort()
223		->values();
224		}
225
226		/**
227		* Grant the given permission(s) to a role.
228		*
229		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
230		*
231		* @return $this
232		*/
233	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...
234		{
235		$permissions = collect($permissions)
236		->flatten()
237		->map(function ($permission) {
238		return $this->getStoredPermission($permission);
239		})
240		->each(function ($permission) {
241		$this->ensureModelSharesGuard($permission);
242		})
243		->all();
244
245		$this->permissions()->saveMany($permissions);
246
247		$this->forgetCachedPermissions();
248
249		return $this;
250		}
251
252		/**
253		* Remove all current permissions and set the given ones.
254		*
255		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
256		*
257		* @return $this
258		*/
259		public function syncPermissions(...$permissions)
260		{
261		$this->permissions()->detach();
262
263		return $this->givePermissionTo($permissions);
264		}
265
266		/**
267		* Revoke the given permission.
268		*
269		* @param \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Permission[]\|string\|string[] $permission
270		*
271		* @return $this
272		*/
273		public function revokePermissionTo($permission)
274		{
275		$this->permissions()->detach($this->getStoredPermission($permission));
276
277		$this->forgetCachedPermissions();
278
279		return $this;
280		}
281
282		/**
283		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
284		*
285		* @return \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Permission[]\|\Illuminate\Support\Collection
286		*/
287		protected function getStoredPermission($permissions)
288		{
289		if (is_numeric($permissions)) {
290		return app(Permission::class)->findById($permissions, $this->getDefaultGuardName());
291		}
292
293		if (is_string($permissions)) {
294		return app(Permission::class)->findByName($permissions, $this->getDefaultGuardName());
295		}
296
297		if (is_array($permissions)) {
298		return app(Permission::class)
299		->whereIn('name', $permissions)
300		->whereIn('guard_name', $this->getGuardNames())
301		->get();
302		}
303
304		return $permissions;
305		}
306
307		/**
308		* @param \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Role $roleOrPermission
309		*
310		* @throws \Spatie\Permission\Exceptions\GuardDoesNotMatch
311		*/
312		protected function ensureModelSharesGuard($roleOrPermission)
313		{
314		if (! $this->getGuardNames()->contains($roleOrPermission->guard_name)) {
315		throw GuardDoesNotMatch::create($roleOrPermission->guard_name, $this->getGuardNames());
316		}
317		}
318
319		protected function getGuardNames(): Collection
320		{
321		return Guard::getNames($this);
322		}
323
324		protected function getDefaultGuardName(): string
325		{
326		return Guard::getDefaultName($this);
327		}
328
329		/**
330		* Forget the cached permissions.
331		*/
332		public function forgetCachedPermissions()
333		{
334		app(PermissionRegistrar::class)->forgetCachedPermissions();
335		}
336		}
337

spatie / laravel-permission