Yajra\Acl\Traits\InteractsWithPermission

Complexity

Total Complexity

12

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	grantPermissionBySlug()	0	11	1
A	getPermissionClass()	0	8	2
A	permissions()	0	4	1
A	grantPermissionByResource()	0	11	1
A	grantPermission()	0	6	1
A	revokePermissionBySlug()	0	11	1
A	revokePermissionByResource()	0	11	1
A	revokePermission()	0	8	1
A	syncPermissions()	0	8	1
A	revokeAllPermissions()	0	8	1
A	getPermissions()	0	4	1

<?php

namespace Yajra\Acl\Traits;

use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Yajra\Acl\Models\Permission;

/**
 * @property \Illuminate\Database\Eloquent\Collection|Permission[] permissions
 * @mixin \Illuminate\Database\Eloquent\Model
 */
trait InteractsWithPermission
{
    private $permissionClass;

    /**
     * Grant permissions by slug(/s).
     *
     * @param  string|array  $slug
     */
    public function grantPermissionBySlug($slug)
    {
        $this->getPermissionClass()
            ->newQuery()
            ->whereIn('slug', (array) $slug)
            ->each(function ($permission) {
                $this->grantPermission($permission);
            });

        $this->load('permissions');

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

    }

    /**
     * Get Permission class.
     *
     * @return \Yajra\Acl\Models\Permission
     */
    public function getPermissionClass(): Permission
    {
        if (!isset($this->permissionClass)) {
            $this->permissionClass = resolve(config('acl.permission'));
        }

        return $this->permissionClass;
    }

    /**
     * Get related permissions.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
     */
    public function permissions(): BelongsToMany
    {
        return $this->belongsToMany(config('acl.permission', Permission::class))->withTimestamps();

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

    }

    /**
     * Grant permissions by resource.
     *
     * @param  string|array  $resource
     */
    public function grantPermissionByResource($resource)
    {
        $this->getPermissionClass()
            ->newQuery()
            ->whereIn('resource', (array) $resource)
            ->each(function ($permission) {
                $this->grantPermission($permission);
            });

        $this->load('permissions');

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

    }

    /**
     * Grant the given permission.
     *
     * @param  \Illuminate\Support\Collection|\Illuminate\Database\Eloquent\Model|array  $id
     * @param  array  $attributes
     * @param  bool  $touch
     * @return void
     */
    public function grantPermission($id, array $attributes = [], $touch = true)
    {
        $this->permissions()->attach($id, $attributes, $touch);

        $this->load('permissions');

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

    }

    /**
     * Revoke permissions by the given slug(/s).
     *
     * @param  string|array  $slug
     */
    public function revokePermissionBySlug($slug)
    {
        $this->getPermissionClass()
            ->newQuery()
            ->whereIn('slug', (array) $slug)
            ->each(function ($permission) {
                $this->revokePermission($permission);
            });

        $this->load('permissions');

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

    }

    /**
     * Revoke permissions by resource.
     *
     * @param string|array $resource
     */
    public function revokePermissionByResource($resource)
    {
        $this->getPermissionClass()
            ->newQuery()
            ->whereIn('resource', (array) $resource)
            ->each(function ($permission) {
                $this->revokePermission($permission);
            });

        $this->load('permissions');

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

    }

    /**
     * Revokes the given permission.
     *
     * @param  mixed  $id
     * @param  bool  $touch
     * @return int
     */
    public function revokePermission($id = null, $touch = true): int
    {
        $detached = $this->permissions()->detach($id, $touch);

        $this->load('permissions');

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 permission.
     *
     * @param  \Illuminate\Support\Collection|\Illuminate\Database\Eloquent\Model|array  $ids
     * @param  bool  $detaching
     * @return array
     */
    public function syncPermissions($ids, $detaching = true): array
    {
        $synced = $this->permissions()->sync($ids, $detaching);

        $this->load('permissions');

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 permissions.
     *
     * @return int
     */
    public function revokeAllPermissions(): int
    {
        $detached = $this->permissions()->detach();

        $this->load('permissions');

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

        return $detached;
    }

    /**
     * Get list of permissions slug.
     *
     * @return array
     */
    public function getPermissions(): array
    {
        return $this->permissions->pluck('slug')->toArray();
    }
}