Sco\Admin\Component\Concerns\HasPermission

Complexity

Total Complexity

29

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	isView()	0	4	2
A	isCreate()	0	4	2
A	isEdit()	0	4	2
A	isDelete()	0	4	1
A	isDestroy()	0	4	2
A	isRestore()	0	4	2
A	isRestorableModel()	0	4	1
A	bootHasPermission()	0	9	2
A	initPermissions()	0	6	2
B	registerObserver()	0	14	5
A	registerPermission()	0	4	1
A	can()	0	11	4
A	getPermissions()	0	13	3

<?php


namespace Sco\Admin\Component\Concerns;


trait HasPermission
{
    protected $permObserve;

    protected $permissions;

    protected $permMethods = [
        'view', 'create', 'edit',
        'delete', 'destroy', 'restore',
    ];

    public function isView()
    {
        return method_exists($this, 'callView') && $this->can('view');
    }

    public function isCreate()
    {
        return method_exists($this, 'callCreate') && $this->can('create');
    }

    public function isEdit()
    {
        return method_exists($this, 'callEdit') && $this->can('edit');
    }

    public function isDelete()
    {
        return $this->can('delete');
    }

    public function isDestroy()
    {
        return $this->isRestorableModel() && $this->can('destroy');
    }

    public function isRestore()
    {
        return $this->isRestorableModel() && $this->can('restore');
    }

    public function isRestorableModel()
    {
        $this->getRepository()->isRestorable();

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

    }

    public static function bootHasPermission()
    {
        $instance = new static;

        $instance->initPermissions();
        if ($instance->permObserve) {
            $instance->registerObserver($instance->permObserve);
        }
    }

    public function initPermissions()
    {
        foreach ($this->permMethods as $method) {
            $this->registerPermission($method, true);
        }
    }

    public function registerObserver($class = null)
    {
        if (!$class) {
            return;
        }

        $className = is_string($class) ? $class : get_class($class);

        foreach ($this->permMethods as $method) {
            if (method_exists($class, $method)) {
                $this->registerPermission($method, [$className, $method]);
            }
        }
    }

    public function registerPermission($permission, $callback)
    {
        $this->permissions[$permission] = $callback;
    }

    public function can($permission)
    {
        if (!isset($this->permissions[$permission])) {
            return false;
        }
        if (is_callable($this->permissions[$permission])) {
            return call_user_func_array($this->permissions[$permission], $this);
        } else {
            return $this->permissions[$permission] ? true : false;
        }
    }

    public function getPermissions()
    {
        $data = collect();
        foreach ($this->permMethods as $perm) {
            $method = 'is' . ucfirst($perm);
            if (!method_exists($this, $method)) {
                $method = 'can';
            }

            $data->put($perm, $this->{$method}($perm));
        }
        return $data;
    }
}