Thinktomorrow\Chief\Management\AbstractManager

Complexity

Total Complexity

28

Size/Duplication

Total Lines	219
Duplicated Lines	0 %

Test Coverage

Coverage

95.83%

Importance

Changes	2
Bugs	1	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	findManaged()	0	7	1
A	manage()	0	5	1
A	route()	0	21	2
A	fieldsWithAssistantFields()	0	13	3
A	can()	0	3	1
A	hasExistingModel()	0	3	2
A	guard()	0	7	2
A	storeRequest()	0	3	1
A	validateConstraints()	0	4	2
A	delete()	0	3	1
A	model()	0	3	1
A	updateRequest()	0	3	1
A	filters()	0	3	1
A	findAllManaged()	0	18	3
A	fieldArrangement()	0	3	1
A	fields()	0	3	1
A	existingModel()	0	7	2
A	requestContainsTranslations()	0	3	1

<?php

namespace Thinktomorrow\Chief\Management;

use Illuminate\Http\Request;
use Illuminate\Support\Collection;
use Thinktomorrow\Chief\Concerns\Translatable\TranslatableCommand;
use Thinktomorrow\Chief\Fields\FieldArrangement;
use Thinktomorrow\Chief\Fields\Fields;
use Thinktomorrow\Chief\Fields\RenderingFields;
use Thinktomorrow\Chief\Fields\SavingFields;
use Thinktomorrow\Chief\Filters\Filters;
use Thinktomorrow\Chief\Management\Assistants\AssistedManager;
use Thinktomorrow\Chief\Management\Details\HasDetails;
use Thinktomorrow\Chief\Management\Details\HasSections;
use Thinktomorrow\Chief\Management\Exceptions\NonExistingRecord;
use Thinktomorrow\Chief\Management\Exceptions\NotAllowedManagerRoute;

abstract class AbstractManager
{
    use RenderingFields,

The trait Thinktomorrow\Chief\Management\Details\HasDetails requires some properties which are not provided by Thinktomorrow\Chief\Management\AbstractManager: $labelPlural, $id, $labelSingular, $title

The trait Thinktomorrow\Chief\Management\ManagesPagebuilder requires some properties which are not provided by Thinktomorrow\Chief\Management\AbstractManager: $trans, $slug, $page_id, $id

The trait Thinktomorrow\Chief\Fields\SavingFields requires the property $key which is not provided by Thinktomorrow\Chief\Management\AbstractManager.

        SavingFields,
        HasDetails,
        HasSections,
        ManagesMedia,
        ManagesPagebuilder,
        TranslatableCommand,
        AssistedManager;

    protected $translation_columns = [];

    protected $model;

    /** @var Register */
    protected $registration;

    public function __construct(Registration $registration)
    {
        $this->registration = $registration;

It seems like $registration of type Thinktomorrow\Chief\Management\Registration is incompatible with the declared type Thinktomorrow\Chief\Management\Register of property $registration.

        // Upon instantiation, a general model is set that doesn't point to a persisted record.
        $this->manage(app($this->registration->model()));

        // Check if key and model are present since the model should be set by the manager itself
        $this->validateConstraints();
    }

    public function manage($model): Manager
    {
        $this->model = $model;

        return $this;

The expression return $this returns the type Thinktomorrow\Chief\Management\AbstractManager which is incompatible with the type-hinted return Thinktomorrow\Chief\Management\Manager.

    }

    public function findManaged($id): Manager
    {
        $model = $this->registration->model();

The method model() does not exist on Thinktomorrow\Chief\Management\Register.

        $modelInstance = $model::where('id', $id)->withoutGlobalScopes()->first();

        return (new static($this->registration))->manage($modelInstance);

$this->registration of type Thinktomorrow\Chief\Management\Register is incompatible with the type Thinktomorrow\Chief\Management\Registration expected by parameter $registration of Thinktomorrow\Chief\Management\AbstractManager::__construct().

    }

    public function findAllManaged($apply_filters = false): Collection
    {
        $model = $this->registration->model();

        $builder = (new $model)->query();

        if ($apply_filters) {
            $this->filters()->apply($builder);
        }

        if ($this->isAssistedBy('publish')) {
            $builder->orderBy('published', 'DESC');
        }

        $builder->orderBy('updated_at', 'DESC');

        return $builder->get()->map(function ($model) {
            return (new static($this->registration))->manage($model);

$this->registration of type Thinktomorrow\Chief\Management\Register is incompatible with the type Thinktomorrow\Chief\Management\Registration expected by parameter $registration of Thinktomorrow\Chief\Management\AbstractManager::__construct().

        });
    }

    public function model()
    {
        return $this->model;
    }

    public function hasExistingModel(): bool
    {
        return ($this->model && $this->model->exists);
    }

    /**
     * If the model exists return it otherwise
     * throws a nonExistingRecord exception;
     *
     * @throws NonExistingRecord
     */
    protected function existingModel()
    {
        if (!$this->hasExistingModel()) {
            throw new NonExistingRecord('Model does not exist yet but is expected.');
        }

        return $this->model;
    }

    /**
     * Determine which actions should be available for this
     * manager and their respective routed urls.
     *
     * @param $verb
     * @return null|string
     * @throws NonExistingRecord
     */
    public function route($verb): ?string
    {
        $routes = [
            'index'   => route('chief.back.managers.index', [$this->registration->key()]),

The method key() does not exist on Thinktomorrow\Chief\Management\Register.

            'create'  => route('chief.back.managers.create', [$this->registration->key()]),
            'store'   => route('chief.back.managers.store', [$this->registration->key()]),
        ];

        if (array_key_exists($verb, $routes)) {
            return $routes[$verb] ?? null;
        }

        //These routes expect the model to be persisted in the database
        $modelRoutes = [
            'edit'    => route('chief.back.managers.edit', [$this->registration->key(), $this->existingModel()->id]),
            'update'  => route('chief.back.managers.update', [$this->registration->key(), $this->existingModel()->id]),
            'delete'  => route('chief.back.managers.delete', [$this->registration->key(), $this->existingModel()->id]),
            'upload'  => route('chief.back.managers.media.upload', [$this->registration->key(), $this->existingModel()->id]),
        ];

        return $modelRoutes[$verb] ?? null;
    }

    public function can($verb): bool
    {
        return !is_null($this->route($verb));
    }

    public function guard($verb): Manager
    {
        if (! $this->can($verb)) {
            NotAllowedManagerRoute::notAllowedVerb($verb, $this);
        }

        return $this;

The expression return $this returns the type Thinktomorrow\Chief\Management\AbstractManager which is incompatible with the type-hinted return Thinktomorrow\Chief\Management\Manager.

    }

    public function fields(): Fields
    {
        return new Fields();
    }

    /**
     * Enrich the manager fields with any of the assistant specified fields
     *
     * @return Fields
     * @throws \Exception
     */
    public function fieldsWithAssistantFields(): Fields
    {
        $fields = $this->fields();

        foreach ($this->assistants() as $assistant) {
            if (! method_exists($assistant, 'fields')) {
                continue;
            }

            $fields = $fields->merge($assistant->fields());
        }

        return $fields;
    }

    /**
     * This determines the arrangement of the manageable fields
     * on the create and edit forms. By default, all fields
     * are presented in their order of appearance
     *
     * @param null $key pinpoint to a specific field arrangement e.g. for create page.

Are you sure the doc-type for parameter $key is correct as it would always require null to be passed?

     * @return FieldArrangement
     * @throws \Exception
     */
    public function fieldArrangement($key = null): FieldArrangement
    {
        return new FieldArrangement($this->fieldsWithAssistantFields());
    }

    public function delete()
    {
        $this->model->delete();

The method delete() does not exist on Illuminate\Contracts\Foundation\Application.

    }

    public static function filters(): Filters
    {
        return new Filters();
    }

    /**
     * This method can be used to manipulate the store request payload
     * before being passed to the storing / updating the models.
     *
     * @param Request $request
     * @return Request
     */
    public function storeRequest(Request $request): Request
    {
        return $request;
    }

    /**
     * This method can be used to manipulate the update request payload
     * before being passed to the storing / updating the models.
     *
     * @param Request $request
     * @return Request
     */
    public function updateRequest(Request $request): Request
    {
        return $request;
    }

    protected function requestContainsTranslations(Request $request): bool
    {
        return $request->has('trans');
    }

    protected function validateConstraints()
    {
        if (!$this->model) {
            throw new \DomainException('Model class should be set for this manager. Please set the model property default via the constructor or by extending the setupDefaults method.');
        }
    }
}