Larapie\Actions\Action

Complexity

Total Complexity

19

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Test Coverage

Coverage

86.27%

Importance

Changes	3
Bugs	1	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	createFrom()	0	3	1
A	__construct()	0	6	2
A	runAs()	0	9	2
A	actingAs()	0	5	1
A	resolveBeforeHook()	0	6	2
A	runUnauthorized()	0	3	1
A	delegateTo()	0	3	1
A	reset()	0	5	1
A	execute()	0	3	1
A	run()	0	19	3
A	user()	0	3	1
A	make()	0	3	1
A	runningAs()	0	3	2

<?php

namespace Larapie\Actions;

use Illuminate\Routing\Controller;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Str;
use Throwable;

abstract class Action extends Controller
{
    use Concerns\HasAttributes;
    use Concerns\ResolvesMethodDependencies;

The trait Larapie\Actions\Concerns\ResolvesMethodDependencies requires the property $name which is not provided by Larapie\Actions\Action.

    use Concerns\ResolvesAuthorization;
    use Concerns\ResolvesValidation;
    use Concerns\ResolveIncludes;
    use Concerns\ResolveDefaults;
    use Concerns\ResolveCasting;
    use Concerns\RunsAsController;
    use Concerns\SuccessHook;
    use Concerns\FailHook;

    protected $actingAs;
    protected $runningAs = 'object';

    public function __construct(array $attributes = [])
    {
        $this->fill($attributes);

        if (method_exists($this, 'register')) {
            $this->register();

The method register() does not exist on Larapie\Actions\Action. Since you implemented __call, consider adding a @method annotation.

        }
    }

    public static function createFrom(self $action)
    {
        return (new static())->fill($action->all());
    }

    public function runAs(self $action)
    {
        if ($action->runningAs('controller')) {
            return $this->runAsController($action->getRequest());
        }

        $this->actingAs($action->user());

        return $this->run();
    }

    public function runUnauthorized(array $attributes = [])
    {
        $this->run($attributes, false);
    }

    public function run(array $attributes = [], $authorization = true)
    {
        $this->resolveDefaults();
        $this->fill($attributes);
        $this->resolveIncludes();
        $this->resolveBeforeHook();

        if ($authorization)
            $this->resolveAuthorization();

        $this->resolveValidation();
        try {
            $value = $this->resolveAndCall($this, 'handle');
        } catch (Throwable $exception) {
            $this->failHook($exception);
        }

        return tap($value, function ($value) {
            $this->successHook($value);
        });
    }

    public function resolveBeforeHook()
    {
        $method = 'as' . Str::studly($this->runningAs);

        if (method_exists($this, $method)) {
            return $this->resolveAndCall($this, $method);
        }
    }

    public function runningAs($matches)
    {
        return in_array($this->runningAs, is_array($matches) ? $matches : func_get_args());
    }

    public function actingAs($user)
    {
        $this->actingAs = $user;

        return $this;
    }

    public function user()
    {
        return $this->actingAs ?? Auth::user();
    }

    public function reset($user = null)
    {
        $this->actingAs = $user;
        $this->attributes = [];
        $this->validator = null;
    }

    public function delegateTo($actionClass)
    {
        return $actionClass::createFrom($this)->runAs($this);
    }

    public static function make(array $attributes = [])
    {
        return new static($attributes);
    }

    public static function execute(array $attributes = [], $authorized = true)
    {
        return self::make()->run($attributes, $authorized);
    }
}