HasPermissions::checkPermissionTo() - Code Metrics - Inspection of "add timestamp in model_has_permissions & model_has..." - spatie/laravel-permission - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1170)

unknown

created 2019-07-31 04:55 UTC

HasPermissions::checkPermissionTo() A

↳ Parent: HasPermissions

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
nc	2
nop	2
dl	0
loc	8
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'
        )->withTimestamps();
    }

    /**
     * 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
    {
        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
    {
        $relationships = ['roles', 'roles.permissions'];

        if (method_exists($this, 'loadMissing')) {
            $this->loadMissing($relationships);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        } else {
            $this->load($relationships);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        return $this->roles->flatMap(function ($role) {
class MyClass { }

$x = new MyClass();
$x->foo = true;
            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) {
            $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();
    }
}


Pull Request — master (#1170)

HasPermissions::checkPermissionTo() 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		)->withTimestamps();
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		public function hasAnyPermission(...$permissions): bool
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		public function hasAllPermissions($permissions = []): bool
202		{
203		foreach ($permissions as $permission) {
204		if (! $this->hasPermissionTo($permission)) {
205		return false;
206		}
207		}
208
209		return true;
210		}
211
212		/**
213		* Determine if the model has, via roles, the given permission.
214		*
215		* @param \Spatie\Permission\Contracts\Permission $permission
216		*
217		* @return bool
218		*/
219		protected function hasPermissionViaRole(Permission $permission): bool
220		{
221		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...
222		}
223
224		/**
225		* Determine if the model has the given permission.
226		*
227		* @param string\|int\|\Spatie\Permission\Contracts\Permission $permission
228		*
229		* @return bool
230		* @throws PermissionDoesNotExist
231		*/
232		public function hasDirectPermission($permission): bool
233		{
234		$permissionClass = $this->getPermissionClass();
235
236		if (is_string($permission)) {
237		$permission = $permissionClass->findByName($permission, $this->getDefaultGuardName());
238		if (! $permission) {
239		return false;
240		}
241		}
242
243		if (is_int($permission)) {
244		$permission = $permissionClass->findById($permission, $this->getDefaultGuardName());
245		if (! $permission) {
246		return false;
247		}
248		}
249
250		if (! $permission instanceof Permission) {
251		return false;
252		}
253
254		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...
255		}
256
257		/**
258		* Return all the permissions the model has via roles.
259		*/
260		public function getPermissionsViaRoles(): Collection
261		{
262		$relationships = ['roles', 'roles.permissions'];
263
264		if (method_exists($this, 'loadMissing')) {
265		$this->loadMissing($relationships);
		0 ignored issues – show Bug introduced 2019-05-21 12:54 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...
266		} else {
267		$this->load($relationships);
		0 ignored issues – show Bug introduced 2019-05-21 12:54 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...
268		}
269
270		return $this->roles->flatMap(function ($role) {
		0 ignored issues – show Bug introduced 2019-05-21 12:54 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...
271		return $role->permissions;
272		})->sort()->values();
273		}
274
275		/**
276		* Return all the permissions the model has, both directly and via roles.
277		*
278		* @throws \Exception
279		*/
280		public function getAllPermissions(): Collection
281		{
282		$permissions = $this->permissions;
283
284		if ($this->roles) {
285		$permissions = $permissions->merge($this->getPermissionsViaRoles());
286		}
287
288		return $permissions->sort()->values();
289		}
290
291		/**
292		* Grant the given permission(s) to a role.
293		*
294		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
295		*
296		* @return $this
297		*/
298	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...
299		{
300		$permissions = collect($permissions)
301		->flatten()
302		->map(function ($permission) {
303		if (empty($permission)) {
304		return false;
305		}
306
307		return $this->getStoredPermission($permission);
308		})
309		->filter(function ($permission) {
310		return $permission instanceof Permission;
311		})
312		->each(function ($permission) {
313		$this->ensureModelSharesGuard($permission);
314		})
315		->map->id
316		->all();
317
318		$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...
319
320		if ($model->exists) {
321		$this->permissions()->sync($permissions, false);
322		$model->load('permissions');
323		} else {
324		$class = \get_class($model);
325
326		$class::saved(
327		function ($object) use ($permissions, $model) {
328		static $modelLastFiredOn;
329		if ($modelLastFiredOn !== null && $modelLastFiredOn === $model) {
330		return;
331		}
332		$object->permissions()->sync($permissions, false);
333		$object->load('permissions');
334		$modelLastFiredOn = $object;
335		}
336		);
337		}
338
339		$this->forgetCachedPermissions();
340
341		return $this;
342		}
343
344		/**
345		* Remove all current permissions and set the given ones.
346		*
347		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
348		*
349		* @return $this
350		*/
351		public function syncPermissions(...$permissions)
352		{
353		$this->permissions()->detach();
354
355		return $this->givePermissionTo($permissions);
356		}
357
358		/**
359		* Revoke the given permission.
360		*
361		* @param \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Permission[]\|string\|string[] $permission
362		*
363		* @return $this
364		*/
365		public function revokePermissionTo($permission)
366		{
367		$this->permissions()->detach($this->getStoredPermission($permission));
368
369		$this->forgetCachedPermissions();
370
371		$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...
372
373		return $this;
374		}
375
376		public function getPermissionNames(): Collection
377		{
378		return $this->permissions->pluck('name');
379		}
380
381		/**
382		* @param string\|array\|\Spatie\Permission\Contracts\Permission\|\Illuminate\Support\Collection $permissions
383		*
384		* @return \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Permission[]\|\Illuminate\Support\Collection
385		*/
386		protected function getStoredPermission($permissions)
387		{
388		$permissionClass = $this->getPermissionClass();
389
390		if (is_numeric($permissions)) {
391		return $permissionClass->findById($permissions, $this->getDefaultGuardName());
392		}
393
394		if (is_string($permissions)) {
395		return $permissionClass->findByName($permissions, $this->getDefaultGuardName());
396		}
397
398		if (is_array($permissions)) {
399		return $permissionClass
400		->whereIn('name', $permissions)
401		->whereIn('guard_name', $this->getGuardNames())
402		->get();
403		}
404
405		return $permissions;
406		}
407
408		/**
409		* @param \Spatie\Permission\Contracts\Permission\|\Spatie\Permission\Contracts\Role $roleOrPermission
410		*
411		* @throws \Spatie\Permission\Exceptions\GuardDoesNotMatch
412		*/
413		protected function ensureModelSharesGuard($roleOrPermission)
414		{
415		if (! $this->getGuardNames()->contains($roleOrPermission->guard_name)) {
416		throw GuardDoesNotMatch::create($roleOrPermission->guard_name, $this->getGuardNames());
417		}
418		}
419
420		protected function getGuardNames(): Collection
421		{
422		return Guard::getNames($this);
423		}
424
425		protected function getDefaultGuardName(): string
426		{
427		return Guard::getDefaultName($this);
428		}
429
430		/**
431		* Forget the cached permissions.
432		*/
433		public function forgetCachedPermissions()
434		{
435		app(PermissionRegistrar::class)->forgetCachedPermissions();
436		}
437		}
438

spatie / laravel-permission

Pull Request — master (#1170)

HasPermissions::checkPermissionTo() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like