HasPermissions::getGuardNames() - Code Metrics - Inspection of "Merge pull request #1254 from sergiz/pr/remove-ver..." - spatie/laravel-permission - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 878502...d89219 )

by Chris

created 2019-11-07 14:50 UTC

HasPermissions::getGuardNames() A

↳ Parent: HasPermissions

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	0
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;
use Spatie\Permission\Exceptions\PermissionDoesNotExist;

trait HasPermissions
{
    private $permissionClass;

    public static function bootHasPermissions()

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

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

    public function getPermissionClass()
    {
        if (! isset($this->permissionClass)) {
            $this->permissionClass = app(PermissionRegistrar::class)->getPermissionClass();
        }

        return $this->permissionClass;
    }

    /**
     * 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'),
            config('permission.column_names.model_morph_key'),
            '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 = is_array($permissions) ? $permissions : [$permissions];

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

            return $this->getPermissionClass()->findByName($permission, $this->getDefaultGuardName());
        }, $permissions);
    }

    /**
     * Determine if the model may perform the given permission.
     *
     * @param string|int|\Spatie\Permission\Contracts\Permission $permission
     * @param string|null $guardName
     *
     * @return bool
     * @throws PermissionDoesNotExist
     */
    public function hasPermissionTo($permission, $guardName = null): bool
    {
        $permissionClass = $this->getPermissionClass();

        if (is_string($permission)) {
            $permission = $permissionClass->findByName(
                $permission,
                $guardName ?? $this->getDefaultGuardName()
            );
        }

        if (is_int($permission)) {
            $permission = $permissionClass->findById(
                $permission,
                $guardName ?? $this->getDefaultGuardName()
            );
        }

        if (! $permission instanceof Permission) {
            throw new PermissionDoesNotExist;
        }

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

    /**
     * @deprecated since 2.35.0
     * @alias of hasPermissionTo()
     */
    public function hasUncachedPermissionTo($permission, $guardName = null): bool
    {
        return $this->hasPermissionTo($permission, $guardName);
    }

    /**
     * An alias to hasPermissionTo(), but avoids throwing an exception.
     *
     * @param string|int|\Spatie\Permission\Contracts\Permission $permission
     * @param string|null $guardName
     *
     * @return bool
     */
    public function checkPermissionTo($permission, $guardName = null): bool
    {
        try {
            return $this->hasPermissionTo($permission, $guardName);
        } catch (PermissionDoesNotExist $e) {
            return false;
        }
    }

    /**
     * Determine if the model has any of the given permissions.
     *
     * @param array ...$permissions
     *
     * @return bool
     * @throws \Exception
     */
    public function hasAnyPermission(...$permissions): bool

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

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

        return false;
    }

    /**
     * Determine if the model has all of the given permissions.
     *
     * @param array ...$permissions
     *
     * @return bool
     * @throws \Exception
     */
    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|int|\Spatie\Permission\Contracts\Permission $permission
     *
     * @return bool
     * @throws PermissionDoesNotExist
     */
    public function hasDirectPermission($permission): bool
    {
        $permissionClass = $this->getPermissionClass();

        if (is_string($permission)) {
            $permission = $permissionClass->findByName($permission, $this->getDefaultGuardName());
            if (! $permission) {
                return false;
            }
        }

        if (is_int($permission)) {
            $permission = $permissionClass->findById($permission, $this->getDefaultGuardName());
            if (! $permission) {
                return false;
            }
        }

        if (! $permission instanceof 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->loadMissing('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.
     *
     * @throws \Exception
     */
    public function getAllPermissions(): Collection
    {
        $permissions = $this->permissions;

        if ($this->roles) {
class MyClass { }

$x = new MyClass();
$x->foo = true;
            $permissions = $permissions->merge($this->getPermissionsViaRoles());
        }

        return $permissions->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) {
                if (empty($permission)) {
                    return false;
                }

                return $this->getStoredPermission($permission);
            })
            ->filter(function ($permission) {
                return $permission instanceof Permission;
            })
            ->each(function ($permission) {
                $this->ensureModelSharesGuard($permission);
            })
            ->map->id
            ->all();

        $model = $this->getModel();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        if ($model->exists) {
            $this->permissions()->sync($permissions, false);
            $model->load('permissions');
        } else {
            $class = \get_class($model);

            $class::saved(
                function ($object) use ($permissions, $model) {
                    static $modelLastFiredOn;
                    if ($modelLastFiredOn !== null && $modelLastFiredOn === $model) {
                        return;
                    }
                    $object->permissions()->sync($permissions, false);
                    $object->load('permissions');
                    $modelLastFiredOn = $object;
                }
            );
        }

        $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();

        $this->load('permissions');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        return $this;
    }

    public function getPermissionNames(): Collection
    {
        return $this->permissions->pluck('name');
    }

    /**
     * @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)
    {
        $permissionClass = $this->getPermissionClass();

        if (is_numeric($permissions)) {
            return $permissionClass->findById($permissions, $this->getDefaultGuardName());
        }

        if (is_string($permissions)) {
            return $permissionClass->findByName($permissions, $this->getDefaultGuardName());
        }

        if (is_array($permissions)) {
            return $permissionClass
                ->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();
    }
}


Push — master ( 878502...d89219 )

HasPermissions::getGuardNames() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

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		use Spatie\Permission\Exceptions\PermissionDoesNotExist;
13
14		trait HasPermissions
15		{
16		private $permissionClass;
17
18	View Code Duplication	public static function bootHasPermissions()
		0 ignored issues – show Duplication introduced 2018-04-30 13:13 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...
19		{
20		static::deleting(function ($model) {
21		if (method_exists($model, 'isForceDeleting') && ! $model->isForceDeleting()) {
22		return;
23		}
24
25		$model->permissions()->detach();
26		});
27		}
28
29		public function getPermissionClass()
30		{
31		if (! isset($this->permissionClass)) {
32		$this->permissionClass = app(PermissionRegistrar::class)->getPermissionClass();
33		}
34
35		return $this->permissionClass;
36		}
37
38		/**
39		* A model may have multiple direct permissions.
40		*/
41		public function permissions(): MorphToMany
42		{
43		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...
44		config('permission.models.permission'),
45		'model',
46		config('permission.table_names.model_has_permissions'),
47		config('permission.column_names.model_morph_key'),
48		'permission_id'
49		);
50		}
51
52		/**
53		* Scope the model query to certain permissions only.
54		*
55		* @param \Illuminate\Database\Eloquent\Builder $query
56		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
57		*
58		* @return \Illuminate\Database\Eloquent\Builder
59		*/
60		public function scopePermission(Builder $query, $permissions): Builder
61		{
62		$permissions = $this->convertToPermissionModels($permissions);
63
64		$rolesWithPermissions = array_unique(array_reduce($permissions, function ($result, $permission) {
65		return array_merge($result, $permission->roles->all());
66		}, []));
67
68		return $query->where(function ($query) use ($permissions, $rolesWithPermissions) {
69		$query->whereHas('permissions', function ($query) use ($permissions) {
70		$query->where(function ($query) use ($permissions) {
71		foreach ($permissions as $permission) {
72		$query->orWhere(config('permission.table_names.permissions').'.id', $permission->id);
73		}
74		});
75		});
76		if (count($rolesWithPermissions) > 0) {
77		$query->orWhereHas('roles', function ($query) use ($rolesWithPermissions) {
78		$query->where(function ($query) use ($rolesWithPermissions) {
79		foreach ($rolesWithPermissions as $role) {
80		$query->orWhere(config('permission.table_names.roles').'.id', $role->id);
81		}
82		});
83		});
84		}
85		});
86		}
87
88		/**
89		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
90		*
91		* @return array
92		*/
93		protected function convertToPermissionModels($permissions): array
94		{
95		if ($permissions instanceof Collection) {
96		$permissions = $permissions->all();
97		}
98
99		$permissions = is_array($permissions) ? $permissions : [$permissions];
100
101		return array_map(function ($permission) {
102		if ($permission instanceof Permission) {
103		return $permission;
104		}
105
106		return $this->getPermissionClass()->findByName($permission, $this->getDefaultGuardName());
107		}, $permissions);
108		}
109
110		/**
111		* Determine if the model may perform the given permission.
112		*
113		* @param string\|int\|\Spatie\Permission\Contracts\Permission $permission
114		* @param string\|null $guardName
115		*
116		* @return bool
117		* @throws PermissionDoesNotExist
118		*/
119		public function hasPermissionTo($permission, $guardName = null): bool
120		{
121		$permissionClass = $this->getPermissionClass();
122
123		if (is_string($permission)) {
124		$permission = $permissionClass->findByName(
125		$permission,
126		$guardName ?? $this->getDefaultGuardName()
127		);
128		}
129
130		if (is_int($permission)) {
131		$permission = $permissionClass->findById(
132		$permission,
133		$guardName ?? $this->getDefaultGuardName()
134		);
135		}
136
137		if (! $permission instanceof Permission) {
138		throw new PermissionDoesNotExist;
139		}
140
141		return $this->hasDirectPermission($permission) \|\| $this->hasPermissionViaRole($permission);
142		}
143
144		/**
145		* @deprecated since 2.35.0
146		* @alias of hasPermissionTo()
147		*/
148		public function hasUncachedPermissionTo($permission, $guardName = null): bool
149		{
150		return $this->hasPermissionTo($permission, $guardName);
151		}
152
153		/**
154		* An alias to hasPermissionTo(), but avoids throwing an exception.
155		*
156		* @param string\|int\|\Spatie\Permission\Contracts\Permission $permission
157		* @param string\|null $guardName
158		*
159		* @return bool
160		*/
161		public function checkPermissionTo($permission, $guardName = null): bool
162		{
163		try {
164		return $this->hasPermissionTo($permission, $guardName);
165		} catch (PermissionDoesNotExist $e) {
166		return false;
167		}
168		}
169
170		/**
171		* Determine if the model has any of the given permissions.
172		*
173		* @param array ...$permissions
174		*
175		* @return bool
176		* @throws \Exception
177		*/
178	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...
179		{
180		if (is_array($permissions[0])) {
181		$permissions = $permissions[0];
182		}
183
184		foreach ($permissions as $permission) {
185		if ($this->checkPermissionTo($permission)) {
186		return true;
187		}
188		}
189
190		return false;
191		}
192
193		/**
194		* Determine if the model has all of the given permissions.
195		*
196		* @param array ...$permissions
197		*
198		* @return bool
199		* @throws \Exception
200		*/
201	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...
202		{
203		if (is_array($permissions[0])) {
204		$permissions = $permissions[0];
205		}
206
207		foreach ($permissions as $permission) {
208		if (! $this->hasPermissionTo($permission)) {
209		return false;
210		}
211		}
212
213		return true;
214		}
215
216		/**
217		* Determine if the model has, via roles, the given permission.
218		*
219		* @param \Spatie\Permission\Contracts\Permission $permission
220		*
221		* @return bool
222		*/
223		protected function hasPermissionViaRole(Permission $permission): bool
224		{
225		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...
226		}
227
228		/**
229		* Determine if the model has the given permission.
230		*
231		* @param string\|int\|\Spatie\Permission\Contracts\Permission $permission
232		*
233		* @return bool
234		* @throws PermissionDoesNotExist
235		*/
236		public function hasDirectPermission($permission): bool
237		{
238		$permissionClass = $this->getPermissionClass();
239
240		if (is_string($permission)) {
241		$permission = $permissionClass->findByName($permission, $this->getDefaultGuardName());
242		if (! $permission) {
243		return false;
244		}
245		}
246
247		if (is_int($permission)) {
248		$permission = $permissionClass->findById($permission, $this->getDefaultGuardName());
249		if (! $permission) {
250		return false;
251		}
252		}
253
254		if (! $permission instanceof Permission) {
255		return false;
256		}
257
258		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... Bug introduced 2018-08-08 00:11 UTC by Report Bug Copy Issue Report Accessing `id` 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...
259		}
260
261		/**
262		* Return all the permissions the model has via roles.
263		*/
264		public function getPermissionsViaRoles(): Collection
265		{
266		return $this->loadMissing('roles', 'roles.permissions')
		0 ignored issues – show Bug introduced 2018-10-13 19:14 UTC by Report Bug Copy Issue Report It seems like `loadMissing()` 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...
267		->roles->flatMap(function ($role) {
268		return $role->permissions;
269		})->sort()->values();
270		}
271
272		/**
273		* Return all the permissions the model has, both directly and via roles.
274		*
275		* @throws \Exception
276		*/
277		public function getAllPermissions(): Collection
278		{
279		$permissions = $this->permissions;
280
281		if ($this->roles) {
		0 ignored issues – show Bug introduced 2018-10-14 00:08 UTC by Report Bug Copy Issue Report The property `roles` 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...
282		$permissions = $permissions->merge($this->getPermissionsViaRoles());
283		}
284
285		return $permissions->sort()->values();
286		}
287
288		/**
289		* Grant the given permission(s) to a role.
290		*
291		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
292		*
293		* @return $this
294		*/
295	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...
296		{
297		$permissions = collect($permissions)
298		->flatten()
299		->map(function ($permission) {
300		if (empty($permission)) {
301		return false;
302		}
303
304		return $this->getStoredPermission($permission);
305		})
306		->filter(function ($permission) {
307		return $permission instanceof Permission;
308		})
309		->each(function ($permission) {
310		$this->ensureModelSharesGuard($permission);
311		})
312		->map->id
313		->all();
314
315		$model = $this->getModel();
		0 ignored issues – show Bug introduced 2018-09-20 00:40 UTC by Report Bug Copy Issue Report It seems like `getModel()` 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...
316
317		if ($model->exists) {
318		$this->permissions()->sync($permissions, false);
319		$model->load('permissions');
320		} else {
321		$class = \get_class($model);
322
323		$class::saved(
324		function ($object) use ($permissions, $model) {
325		static $modelLastFiredOn;
326		if ($modelLastFiredOn !== null && $modelLastFiredOn === $model) {
327		return;
328		}
329		$object->permissions()->sync($permissions, false);
330		$object->load('permissions');
331		$modelLastFiredOn = $object;
332		}
333		);
334		}
335
336		$this->forgetCachedPermissions();
337
338		return $this;
339		}
340
341		/**
342		* Remove all current permissions and set the given ones.
343		*
344		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
345		*
346		* @return $this
347		*/
348		public function syncPermissions(...$permissions)
349		{
350		$this->permissions()->detach();
351
352		return $this->givePermissionTo($permissions);
353		}
354
355		/**
356		* Revoke the given permission.
357		*
358		* @param \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Permission[]\|string\|string[] $permission
359		*
360		* @return $this
361		*/
362		public function revokePermissionTo($permission)
363		{
364		$this->permissions()->detach($this->getStoredPermission($permission));
365
366		$this->forgetCachedPermissions();
367
368		$this->load('permissions');
		0 ignored issues – show Bug introduced 2018-11-07 03:56 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...
369
370		return $this;
371		}
372
373		public function getPermissionNames(): Collection
374		{
375		return $this->permissions->pluck('name');
376		}
377
378		/**
379		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
380		*
381		* @return \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Permission[]\|\Illuminate\Support\Collection
382		*/
383		protected function getStoredPermission($permissions)
384		{
385		$permissionClass = $this->getPermissionClass();
386
387		if (is_numeric($permissions)) {
388		return $permissionClass->findById($permissions, $this->getDefaultGuardName());
389		}
390
391		if (is_string($permissions)) {
392		return $permissionClass->findByName($permissions, $this->getDefaultGuardName());
393		}
394
395		if (is_array($permissions)) {
396		return $permissionClass
397		->whereIn('name', $permissions)
398		->whereIn('guard_name', $this->getGuardNames())
399		->get();
400		}
401
402		return $permissions;
403		}
404
405		/**
406		* @param \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Role $roleOrPermission
407		*
408		* @throws \Spatie\Permission\Exceptions\GuardDoesNotMatch
409		*/
410		protected function ensureModelSharesGuard($roleOrPermission)
411		{
412		if (! $this->getGuardNames()->contains($roleOrPermission->guard_name)) {
413		throw GuardDoesNotMatch::create($roleOrPermission->guard_name, $this->getGuardNames());
414		}
415		}
416
417		protected function getGuardNames(): Collection
418		{
419		return Guard::getNames($this);
420		}
421
422		protected function getDefaultGuardName(): string
423		{
424		return Guard::getDefaultName($this);
425		}
426
427		/**
428		* Forget the cached permissions.
429		*/
430		public function forgetCachedPermissions()
431		{
432		app(PermissionRegistrar::class)->forgetCachedPermissions();
433		}
434		}
435

spatie / laravel-permission

Push — master ( 878502...d89219 )

HasPermissions::getGuardNames() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like