Arcanedev\LaravelAuth\Traits\AuthRoleTrait

Complexity

Total Complexity

15

Size/Duplication

Total Lines	160
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	attachRole()	0	7	2
A	syncRoles()	0	12	1
A	detachRole()	0	11	2
A	detachAllRoles()	0	7	1
A	hasRole()	0	7	2
A	isAll()	0	6	1
A	isOne()	0	9	3
A	hasRoleSlug()	0	8	1
A	loadRoles()	0	4	2

<?php namespace Arcanedev\LaravelAuth\Traits;

use Arcanesoft\Contracts\Auth\Models\Role as RoleContract;
use Illuminate\Database\Eloquent\Model as Eloquent;

/**
 * Trait     AuthRoleTrait
 *
 * @package  Arcanedev\LaravelAuth\Traits
 * @author   ARCANEDEV <arcanedev.maroc@gmail.com>
 *
 * @property  \Illuminate\Database\Eloquent\Collection  roles
 *
 * @method    \Illuminate\Database\Eloquent\Relations\BelongsToMany  roles()
 * @method    \Arcanedev\LaravelAuth\Traits\AuthRoleTrait            load(mixed $relations)
 */
trait AuthRoleTrait
{
    /* ------------------------------------------------------------------------------------------------
     |  Role CRUD Functions
     | ------------------------------------------------------------------------------------------------
     */
    /**
     * Attach a role to a user.
     *
     * @param  \Arcanesoft\Contracts\Auth\Models\Role|int  $role
     * @param  bool                                    $reload
     */
    public function attachRole($role, $reload = true)
    {
        if ( ! $this->hasRole($role)) {
            $this->roles()->attach($role);
            $this->loadRoles($reload);
        }
    }

    /**
     * Sync the roles by its slugs.
     *
     * @param  array  $slugs
     * @param  bool   $reload
     *
     * @return array
     */
    public function syncRoles(array $slugs, $reload = true)
    {
        /** @var \Illuminate\Database\Eloquent\Collection $roles */
        $roles  = app(RoleContract::class)->whereIn('slug', $slugs)->get();
        $synced = $this->roles()->sync(
            $roles->pluck('id')->toArray()
        );

        $this->loadRoles($reload);

        return $synced;
    }

    /**
     * Detach a role from a user.
     *
     * @param  \Arcanesoft\Contracts\Auth\Models\Role|int  $role
     * @param  bool                                        $reload
     *
     * @return int
     */
    public function detachRole($role, $reload = true)
    {
        if ($role instanceof Eloquent) {

The class Illuminate\Database\Eloquent\Model does not exist. Did you forget a USE statement, or did you not list all dependencies?

            $role = (array) $role->getKey();
        }

        $results = $this->roles()->detach($role);
        $this->loadRoles($reload);

        return $results;
    }

    /**
     * Detach all roles from a user.
     *
     * @param  bool  $reload
     *
     * @return int
     */
    public function detachAllRoles($reload = true)
    {
        $results = $this->roles()->detach();
        $this->loadRoles($reload);

        return $results;
    }

    /* ------------------------------------------------------------------------------------------------
     |  Check Functions
     | ------------------------------------------------------------------------------------------------
     */
    /**
     * Check if user has the given role (Role Model or Id).
     *
     * @param  mixed  $id
     *
     * @return bool
     */
    public function hasRole($id)
    {
        if ($id instanceof Eloquent)

The class Illuminate\Database\Eloquent\Model does not exist. Did you forget a USE statement, or did you not list all dependencies?

            $id = $id->getKey();

        return $this->roles->contains($id);
    }

    /**
     * Check if has all roles.
     *
     * @param  array  $roles
     * @param  array  &$failedRoles
     *
     * @return bool
     */
    public function isAll(array $roles, array &$failedRoles = [])
    {
        $this->isOne($roles, $failedRoles);

        return count($failedRoles) === 0;
    }

    /**
     * Check if has at least one role.
     *
     * @param  array  $roles
     * @param  array  &$failedRoles
     *
     * @return bool
     */
    public function isOne(array $roles, array &$failedRoles = [])
    {
        foreach ($roles as $role) {
            if ( ! $this->hasRoleSlug($role))
                $failedRoles[] = $role;
        }

        return count($roles) !== count($failedRoles);
    }

    /**
     * Check if has a role by its slug.
     *
     * @param  string  $slug
     *
     * @return bool
     */
    public function hasRoleSlug($slug)
    {
        $roles = $this->roles->filter(function(RoleContract $role) use ($slug) {
            return $role->checkSlug($slug);
        });

        return ! $roles->isEmpty();
    }

    /* ------------------------------------------------------------------------------------------------
     |  Other Functions
     | ------------------------------------------------------------------------------------------------
     */
    /**
     * Load all roles.
     *
     * @param  bool  $load
     *
     * @return self
     */
    protected function loadRoles($load = true)
    {
        return $load ? $this->load('roles') : $this;
    }
}