InteractsWithRole::hasRole() - Code Metrics - yajra/laravel-acl - Measure and Improve Code Quality continuously with Scrutinizer

InteractsWithRole::hasRole() A
last analyzed 2021-04-18 08:52 UTC

↳ Parent: InteractsWithRole

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Yajra\Acl\Traits;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Yajra\Acl\Models\Role;

/**
 * @property \Illuminate\Database\Eloquent\Collection|Role[] roles
 * @method static Builder havingRoles($roleIds)
 * @method static Builder havingRolesBySlugs($slugs)
 */
trait InteractsWithRole
{
    private $roleClass;

    /**
     * Check if user has the given role.
     *
     * @param  string|array  $role
     * @return bool
     */
    public function hasRole($role): bool
    {
        if (is_array($role)) {
            $roles = $this->getRoleSlugs();

            $intersection = array_intersect($roles, (array) $role);
            $intersectionCount = count($intersection);

            return $intersectionCount > 0;
        }

        return $this->roles->contains('slug', $role);
    }

    /**
     * Get all user roles.
     *
     * @return array
     */
    public function getRoleSlugs(): array
    {
        return $this->roles->pluck('slug')->toArray();
    }

    /**
     * Attach a role to user using slug.
     *
     * @param  string  $slug
     */
    public function attachRoleBySlug(string $slug)
    {
        $this->attachRole($this->findRoleBySlug($slug));

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

    /**
     * Attach a role to user.
     *
     * @param  mixed  $role
     * @param  array  $attributes
     * @param  bool  $touch
     */
    public function attachRole($role, array $attributes = [], $touch = true)
    {
        $this->roles()->attach($role, $attributes, $touch);

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

    /**
     * Model can have many roles.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
     */
    public function roles(): BelongsToMany
    {
        return $this->belongsToMany(config('acl.role', Role::class))->withTimestamps();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * Find a role by slug.
     *
     * @param  string  $slug
     * @return \Illuminate\Database\Eloquent\Model|static
     * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
     */
    protected function findRoleBySlug(string $slug): Role
    {
        return $this->getRoleClass()->newQuery()->where('slug', $slug)->firstOrFail();
    }

    /**
     * Get Role class.
     *
     * @return Role
     */
    public function getRoleClass(): Role
    {
        if (!isset($this->roleClass)) {
            $this->roleClass = resolve(config('acl.role'));
        }

        return $this->roleClass;
    }

    /**
     * Query scope for user having the given roles.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  mixed  $roles
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeHavingRoles(Builder $query, $roles): Builder
    {
        return $query->whereExists(function ($query) use ($roles) {
            $query->selectRaw('1')
                ->from('role_user')
                ->whereRaw('role_user.user_id = users.id')
                ->whereIn('role_id', $roles);
        });
    }

    /**
     * Query scope for user having the given roles by slugs.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  mixed  $slugs
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeHavingRolesBySlugs(Builder $query, $slugs): Builder
    {
        return $query->whereHas('roles', function ($query) use ($slugs) {
            $query->whereIn('roles.slug', $slugs);
        });
    }

    /**
     * Revokes the given role from the user using slug.
     *
     * @param  string|array  $slug
     * @param  bool  $touch
     * @return int
     */
    public function revokeRoleBySlug($slug, $touch = true): int
    {
        $roles = $this->getRoleClass()
            ->newQuery()
            ->whereIn('slug', (array) $slug)
            ->get();

        $detached = $this->roles()->detach($roles, $touch);

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

        return $detached;
    }

    /**
     * Revokes the given role from the user.
     *
     * @param  mixed  $role
     * @param  bool  $touch
     * @return int
     */
    public function revokeRole($role, $touch = true): int
    {
        $detached = $this->roles()->detach($role, $touch);

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

        return $detached;
    }

    /**
     * Syncs the given role(s) with the user.
     *
     * @param  \Illuminate\Support\Collection|\Illuminate\Database\Eloquent\Model|array  $roles
     * @param  bool  $detaching
     * @return array
     */
    public function syncRoles($roles, $detaching = true): array
    {
        $synced = $this->roles()->sync($roles, $detaching);

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

        return $synced;
    }

    /**
     * Revokes all roles from the user.
     *
     * @return int
     */
    public function revokeAllRoles(): int
    {
        $detached = $this->roles()->detach();

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

        return $detached;
    }
}


1			<?php
2
3			namespace Yajra\Acl\Traits;
4
5			use Illuminate\Database\Eloquent\Builder;
6			use Illuminate\Database\Eloquent\Relations\BelongsToMany;
7			use Yajra\Acl\Models\Role;
8
9			/**
10			* @property \Illuminate\Database\Eloquent\Collection\|Role[] roles
11			* @method static Builder havingRoles($roleIds)
12			* @method static Builder havingRolesBySlugs($slugs)
13			*/
14			trait InteractsWithRole
15			{
16			private $roleClass;
17
18			/**
19			* Check if user has the given role.
20			*
21			* @param string\|array $role
22			* @return bool
23			*/
24			public function hasRole($role): bool
25			{
26			if (is_array($role)) {
27			$roles = $this->getRoleSlugs();
28
29			$intersection = array_intersect($roles, (array) $role);
30			$intersectionCount = count($intersection);
31
32			return $intersectionCount > 0;
33			}
34
35			return $this->roles->contains('slug', $role);
36			}
37
38			/**
39			* Get all user roles.
40			*
41			* @return array
42			*/
43			public function getRoleSlugs(): array
44			{
45			return $this->roles->pluck('slug')->toArray();
46			}
47
48			/**
49			* Attach a role to user using slug.
50			*
51			* @param string $slug
52			*/
53			public function attachRoleBySlug(string $slug)
54			{
55			$this->attachRole($this->findRoleBySlug($slug));
56
57			$this->load('roles');
			0 ignored issues – show Bug introduced 2021-04-18 08:52 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...
58			}
59
60			/**
61			* Attach a role to user.
62			*
63			* @param mixed $role
64			* @param array $attributes
65			* @param bool $touch
66			*/
67			public function attachRole($role, array $attributes = [], $touch = true)
68			{
69			$this->roles()->attach($role, $attributes, $touch);
70
71			$this->load('roles');
			0 ignored issues – show Bug introduced 2021-04-18 08:52 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...
72			}
73
74			/**
75			* Model can have many roles.
76			*
77			* @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
78			*/
79			public function roles(): BelongsToMany
80			{
81			return $this->belongsToMany(config('acl.role', Role::class))->withTimestamps();
			0 ignored issues – show Bug introduced 2021-04-18 08:52 UTC by Report Bug Copy Issue Report It seems like `belongsToMany()` 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...
82			}
83
84			/**
85			* Find a role by slug.
86			*
87			* @param string $slug
88			* @return \Illuminate\Database\Eloquent\Model\|static
89			* @throws \Illuminate\Database\Eloquent\ModelNotFoundException
90			*/
91			protected function findRoleBySlug(string $slug): Role
92			{
93			return $this->getRoleClass()->newQuery()->where('slug', $slug)->firstOrFail();
94			}
95
96			/**
97			* Get Role class.
98			*
99			* @return Role
100			*/
101			public function getRoleClass(): Role
102			{
103			if (!isset($this->roleClass)) {
104			$this->roleClass = resolve(config('acl.role'));
105			}
106
107			return $this->roleClass;
108			}
109
110			/**
111			* Query scope for user having the given roles.
112			*
113			* @param \Illuminate\Database\Eloquent\Builder $query
114			* @param mixed $roles
115			* @return \Illuminate\Database\Eloquent\Builder
116			*/
117			public function scopeHavingRoles(Builder $query, $roles): Builder
118			{
119			return $query->whereExists(function ($query) use ($roles) {
120			$query->selectRaw('1')
121			->from('role_user')
122			->whereRaw('role_user.user_id = users.id')
123			->whereIn('role_id', $roles);
124			});
125			}
126
127			/**
128			* Query scope for user having the given roles by slugs.
129			*
130			* @param \Illuminate\Database\Eloquent\Builder $query
131			* @param mixed $slugs
132			* @return \Illuminate\Database\Eloquent\Builder
133			*/
134			public function scopeHavingRolesBySlugs(Builder $query, $slugs): Builder
135			{
136			return $query->whereHas('roles', function ($query) use ($slugs) {
137			$query->whereIn('roles.slug', $slugs);
138			});
139			}
140
141			/**
142			* Revokes the given role from the user using slug.
143			*
144			* @param string\|array $slug
145			* @param bool $touch
146			* @return int
147			*/
148			public function revokeRoleBySlug($slug, $touch = true): int
149			{
150			$roles = $this->getRoleClass()
151			->newQuery()
152			->whereIn('slug', (array) $slug)
153			->get();
154
155			$detached = $this->roles()->detach($roles, $touch);
156
157			$this->load('roles');
			0 ignored issues – show Bug introduced 2021-04-18 08:52 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...
158
159			return $detached;
160			}
161
162			/**
163			* Revokes the given role from the user.
164			*
165			* @param mixed $role
166			* @param bool $touch
167			* @return int
168			*/
169			public function revokeRole($role, $touch = true): int
170			{
171			$detached = $this->roles()->detach($role, $touch);
172
173			$this->load('roles');
			0 ignored issues – show Bug introduced 2021-04-18 08:52 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...
174
175			return $detached;
176			}
177
178			/**
179			* Syncs the given role(s) with the user.
180			*
181			* @param \Illuminate\Support\Collection\|\Illuminate\Database\Eloquent\Model\|array $roles
182			* @param bool $detaching
183			* @return array
184			*/
185			public function syncRoles($roles, $detaching = true): array
186			{
187			$synced = $this->roles()->sync($roles, $detaching);
188
189			$this->load('roles');
			0 ignored issues – show Bug introduced 2021-04-18 08:52 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...
190
191			return $synced;
192			}
193
194			/**
195			* Revokes all roles from the user.
196			*
197			* @return int
198			*/
199			public function revokeAllRoles(): int
200			{
201			$detached = $this->roles()->detach();
202
203			$this->load('roles');
			0 ignored issues – show Bug introduced 2021-04-18 08:52 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...
204
205			return $detached;
206			}
207			}
208

yajra / laravel-acl

InteractsWithRole::hasRole() A last analyzed 2021-04-18 08:52 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

InteractsWithRole::hasRole() A
last analyzed 2021-04-18 08:52 UTC