ActionsManager::__construct() - Code Metrics - adminarchitect/core - Measure and Improve Code Quality continuously with Scrutinizer

ActionsManager::__construct() A
last analyzed 2020-02-03 14:42 UTC

↳ Parent: ActionsManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	2
c	1
b	0
f	0
nc	1
nop	2
dl	0
loc	5
ccs	0
cts	0
cp	0
crap	2
rs	10

<?php

namespace Terranet\Administrator;

use Illuminate\Database\Eloquent\Model;
filter:
    dependency_paths: ["lib/*"]
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Str;
use Terranet\Administrator\Actions\Collection;
use Terranet\Administrator\Contracts\ActionsManager as ActionsManagerContract;
use Terranet\Administrator\Contracts\Module;
use Terranet\Administrator\Contracts\Services\CrudActions;

class ActionsManager implements ActionsManagerContract
{
    /**
     * @var CrudActions
     */
    protected $service;

    /**
     * @var Module
     */
    protected $module;

    /**
     * List of item-related actions.
     *
     * @var array
     */
    protected $actions;

    /**
     * List of global actions.
     *
     * @var array
     */
    protected $globalActions;

    /**
     * Check if resource is readonly - has no actions.
     *
     * @var null|bool
     */
    protected $readonly;

    /**
     * ActionsManager constructor.
     *
     * @param  CrudActions  $service
     * @param  Module  $module
     */
    public function __construct(CrudActions $service, Module $module)
    {
        $this->service = $service;

        $this->module = $module;
    }

    /**
     * Fetch module's single (per item) actions.
     *
     * @return Collection
     */
    public function actions()
    {
        return $this->scaffoldActions();
    }

    /**
     * Fetch module's batch actions.
     *
     * @return Collection
     */
    public function batch()
    {
        return $this->scaffoldBatch();
    }

    /**
     * Determine if the user is authorized to make this request.
     *
     * @param string $ability
     * @param $model
     *
     * @return bool
     */
    public function authorize($ability, ?Model $model = null)
    {
        // for most cases it is enough to set
        // permissions in Resource object.
        if (method_exists($this->module, $abilityMethod = 'can'.Str::title(Str::camel($ability)))) {
            $user = auth('admin')->user();
            $user = /** @scrutinizer ignore-call */ auth('admin')->user();
            $cacheID = $user->getAuthIdentifier().':'.$ability.($model ? '_'.$model->getKey() : '');

            return Cache::remember($cacheID, 1, function () use ($user, $ability, $model) {
                $abilityMethod = 'can'.Str::title(Str::camel($ability));

                return $this->module->$abilityMethod($user, $ability, $model);
            });
        }

        // Ask Actions Service for action permissions.
        return $this->service->authorize($ability, $model, $this->module);
        return $this->service->/** @scrutinizer ignore-call */ authorize($ability, $model, $this->module);
    }

    /**
     * Checks if resource has no Actions at all / Readonly mode.
     */
    public function readonly()
    {
        if (null === $this->readonly) {
            $this->readonly = false;

            // check for <Module>::readonly() method.
            if (method_exists($this->module, 'readonly')) {
                $this->readonly = $this->module->readonly();
            }
        }

        return $this->readonly;
    }

    /**
     * Call handler method.
     *
     * @param string $method
     * @param array $arguments
     *
     * @return mixed
     */
    public function exec(string $method, array $arguments = [])
    {
        // execute custom action
        if (Str::startsWith($method, 'action::')) {
            $handler = $this->scaffoldActions()->find(
                str_replace('action::', '', $method)
            );

            return \call_user_func_array([$handler, 'handle'], $arguments);
        }

        // Execute batch action
        if (Str::startsWith($method, 'batch::')) {
            $handler = $this->scaffoldBatch()->find(
                str_replace('batch::', '', $method)
            );

            return \call_user_func_array([$handler, 'handle'], $arguments);
        }

        // Execute CRUD action
        return \call_user_func_array([$this->service, $method], (array) $arguments);
    }

    /**
     * Parse handler class for per-item and global actions.
     *
     * @return Collection
     */
    protected function scaffoldActions()
    {
        return new Collection($this->service->actions());
    }

    /**
     * Parse handler class for per-item and global actions.
     *
     * @return Collection
     */
    protected function scaffoldBatch()
    {
        return new Collection($this->service->batchActions());
    }
}


adminarchitect / core

ActionsManager::__construct() A last analyzed 2020-02-03 14:42 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ActionsManager::__construct() A
last analyzed 2020-02-03 14:42 UTC