Sco\Admin\Component\Concerns\HasAccess

Complexity

Total Complexity

26

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	bootHasAccess()	0	6	1
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	observe()	0	13	4
A	getObservableAbilities()	0	10	1
A	registerAbility()	0	4	1
A	makeAbilityCallback()	0	12	3
A	can()	0	9	3
A	getAccesses()	0	6	1

<?php

namespace Sco\Admin\Component\Concerns;

use Illuminate\Support\Collection;
use Illuminate\Support\Str;

trait HasAccess
{
    /**
     * @var \Illuminate\Support\Collection
     */
    protected $abilities;

    /**
     * Access observer class
     *
     * @var string
     */
    protected $observer = \Sco\Admin\Component\Observer::class;

    /**
     * User exposed observable abilities.
     *
     * @var array
     */
    protected $observables = [];

    public function bootHasAccess()
    {
        $this->abilities = new Collection();

        $this->observe($this->observer);
    }

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

    protected function isRestorableModel()
    {
        return $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?

    }

    /**
     * Register an observer with the Component.
     *
     * @param $class
     */
    public function observe($class)
    {
        $className = is_string($class) ? $class : get_class($class);

        foreach ($this->getObservableAbilities() as $ability) {
            if (method_exists($class, $ability)) {
                $this->registerAbility(
                    $ability,
                    $className . '@' . $ability
                );
            }
        }
    }

    /**
     * Get the observable ability names.
     *
     * @return array
     */
    public function getObservableAbilities()
    {
        return array_merge(
            [
                'view', 'create', 'edit', 'delete',
                'destroy', 'restore',
            ],
            $this->observables
        );
    }

    public function registerAbility($ability, $callback)
    {
        $this->abilities->put($ability, $this->makeAbilityCallback($callback));
    }

    protected function makeAbilityCallback($callback)
    {
        return function ($component) use ($callback) {
            if (is_callable($callback)) {
                return $callback($component);
            }
            if (is_string($callback)) {
                list($class, $method) = Str::parseCallback($callback);
                return call_user_func([$this->app->make($class), $method], $component);

The property app does not exist. Did you maybe forget to declare it?

            }
        };
    }

    /**
     * @param string $ability
     *
     * @return mixed
     */
    final public function can($ability)
    {
        if (!$this->abilities->has($ability)) {
            return false;
        }
        $value = $this->abilities->get($ability);

        return $value($this) ? true : false;
    }

    public function getAccesses()
    {
        return $this->abilities->mapWithKeys(function ($item, $key) {
            return [$key => $this->can($key)];
        });
    }
}