Yajra\Acl\Traits\InteractsWithRole

Complexity

Total Complexity

15

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	hasRole()	0	13	2
A	getRoleSlugs()	0	4	1
A	attachRoleBySlug()	0	6	1
A	attachRole()	0	6	1
A	roles()	0	4	1
A	findRoleBySlug()	0	4	1
A	getRoleClass()	0	8	2
A	scopeHavingRoles()	0	9	1
A	scopeHavingRolesBySlugs()	0	6	1
A	revokeRoleBySlug()	0	13	1
A	revokeRole()	0	8	1
A	syncRoles()	0	8	1
A	revokeAllRoles()	0	8	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');

It seems like load() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * 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');

It seems like load() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

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

It seems like belongsToMany() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * 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');

It seems like load() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        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');

It seems like load() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        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');

It seems like load() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $synced;
    }

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

        $this->load('roles');

It seems like load() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $detached;
    }
}