HasRoles::revokePermissions() - Code Metrics - andrey-helldar/laravel-roles - Measure and Improve Code Quality continuously with Scrutinizer

HasRoles::revokePermissions() A
last analyzed 2020-09-24 11:24 UTC

↳ Parent: HasRoles
Complexity

Conditions	2
Paths	2
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	3
CRAP Score	2
Importance

Changes
Metric	Value
cc	2
eloc	2
c	0
b	0
f	0
nc	2
nop	1
dl	0
loc	4
ccs	3
cts	3
cp	1
crap	2
rs	10
<?php

namespace Helldar\Roles\Traits;

use Helldar\Roles\Constants\Tables;
use Helldar\Roles\Facades\Config;
use Helldar\Roles\Facades\Database\Search;
use Helldar\Roles\Models\Permission;
use Helldar\Roles\Models\Role;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;

/**
 * @property \Helldar\Roles\Models\Role[]|\Illuminate\Database\Eloquent\Collection $roles
 * @property \Helldar\Roles\Models\Permission[]|\Illuminate\Database\Eloquent\Collection $permissions
 *
 * @mixin \Illuminate\Database\Eloquent\Model
 */
trait HasRoles
{
    use Searchable;
    use Cacheable;

    /**
     * @return \Helldar\Roles\Models\BaseModel|\Illuminate\Database\Eloquent\Relations\BelongsToMany
     */
    public function roles(): BelongsToMany
    {
        return $this->belongsToMany(Role::class, Tables::USER_ROLE);
        return $this->/** @scrutinizer ignore-call */ belongsToMany(Role::class, Tables::USER_ROLE);
    }

    public function hasRootRole(): bool
    {
        return $this->cache(__FUNCTION__, function () {
            return $this->roles()
                ->where('is_root', true)
                ->exists();
        });
    }

    public function createRole(string $slug, string $title = null, bool $is_root = false): Model
    {
        return $this->roles()->create(compact('slug', 'title', 'is_root'));
    }

    /**
     * @param  \Helldar\Roles\Models\Role|string  $role
     *
     * @throws \Throwable
     */
    public function assignRole($role): void
    {
        $role = $this->findRole($role);

        $this->roles()->attach($role->id);
    }

    /**
     * @param  \Helldar\Roles\Models\Role[]|string[]  $roles
     *
     * @throws \Throwable
     */
    public function assignRoles(...$roles): void
    {
        foreach ($roles as $role) {
            $this->assignRole($role);
            $this->assignRole(/** @scrutinizer ignore-type */ $role);
        }
    }

    /**
     * @throws \Throwable
     */
    public function assignDefaultRole(): void
    {
        if ($role = Config::defaultRole()) {
            $this->assignRole($role);
        }
    }

    /**
     * @param  \Helldar\Roles\Models\Role|string  $role
     *
     * @throws \Throwable
     */
    public function revokeRole($role): void
    {
        $role = $this->findRole($role);

        $this->roles()->detach($role->id);
    }

    /**
     * @param  \Helldar\Roles\Models\Role[]|string[]  $roles
     *
     * @throws \Throwable
     */
    public function revokeRoles(...$roles): void
    {
        foreach ($roles as $role) {
            $this->revokeRole($role);
            $this->revokeRole(/** @scrutinizer ignore-type */ $role);
        }
    }

    /**
     * @param  int[]  $roles_ids
     */
    public function syncRoles(array $roles_ids): void
    {
        $this->roles()->sync($roles_ids);
    }

    /**
     * @param  \Helldar\Roles\Models\Role[]|string[]  $roles
     *
     * @return bool
     */
    public function hasRole(...$roles): bool
    {
        return $this->cache(__FUNCTION__, function () use ($roles) {
            return Search::by($this->roles(), $roles)->exists();
        }, $roles);
    }

    /**
     * @param  \Helldar\Roles\Models\Role[]|string[]  $roles
     *
     * @return bool
     */
    public function hasRoles(...$roles): bool
    {
        return $this->cache(__FUNCTION__, function () use ($roles) {
            $count = Search::by($this->roles(), $roles)->count();

            return $count === count($roles);
        }, $roles);
    }

    /**
     * @return \Helldar\Roles\Models\BaseModel|\Illuminate\Database\Eloquent\Relations\BelongsToMany
     */
    public function permissions(): BelongsToMany
    {
        return $this->belongsToMany(Permission::class, Tables::USER_PERMISSION);
    }

    public function createPermission(string $slug, string $title = null): Model
    {
        return $this->permissions()->create(compact('slug', 'title'));
    }

    /**
     * @param  \Helldar\Roles\Models\Permission|string  $permission
     *
     * @throws \Throwable
     */
    public function assignPermission($permission): void
    {
        $permission = $this->findPermission($permission);

        $this->permissions()->attach($permission->id);
    }

    /**
     * @param  \Helldar\Roles\Models\Permission[]|string[]  $permissions
     *
     * @throws \Throwable
     */
    public function assignPermissions(...$permissions): void
    {
        foreach ($permissions as $permission) {
            $this->assignPermission($permission);
            $this->assignPermission(/** @scrutinizer ignore-type */ $permission);
        }
    }

    /**
     * @param  \Helldar\Roles\Models\Permission|string  $permission
     *
     * @throws \Throwable
     */
    public function revokePermission($permission): void
    {
        $permission = $this->findPermission($permission);

        $this->permissions()->detach($permission->id);
    }

    /**
     * @param  \Helldar\Roles\Models\Permission[]|string[]  $permissions
     *
     * @throws \Throwable
     */
    public function revokePermissions(...$permissions): void
    {
        foreach ($permissions as $permission) {
            $this->revokePermission($permission);
            $this->revokePermission(/** @scrutinizer ignore-type */ $permission);
        }
    }

    /**
     * @param  int[]  $permissions_ids
     */
    public function syncPermissions(array $permissions_ids): void
    {
        $this->permissions()->sync($permissions_ids);
    }

    /**
     * @param  \Helldar\Roles\Models\Permission[]|int[]|string[]  $permission
     *
     * @return bool
     */
    public function hasPermission(...$permission): bool
    {
        return $this->cache(__FUNCTION__, function () use ($permission) {
            $first = Search::by($this->permissions(), $permission)->exists();

            $second = $this->roles()
                ->whereHas('permissions', function (Builder $builder) use ($permission) {
                    return Search::by($builder, $permission);
                })->exists();

            return $first || $second;
        }, $permission);
    }

    /**
     * @param  \Helldar\Roles\Models\Permission[]|string[]  $permissions
     *
     * @return bool
     */
    public function hasPermissions(...$permissions): bool
    {
        return $this->cache(__FUNCTION__, function () use ($permissions) {
            $count = Search::by($this->permissions(), $permissions)->count();

            return $count === count($permissions);
        }, $permissions);
    }
}

andrey-helldar / laravel-roles

HasRoles::revokePermissions() A last analyzed 2020-09-24 11:24 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

HasRoles::revokePermissions() A
last analyzed 2020-09-24 11:24 UTC
