Thinktomorrow\Chief\Management\AbstractManager

Complexity

Total Complexity

59

Size/Duplication

Total Lines	343
Duplicated Lines	0 %

Importance

Changes	4
Bugs	2	Features	0

33 Methods

Rating	Name	Duplication	Size	Complexity
A	fieldsWithAssistantFields()	0	13	3
A	managerKey()	0	3	1
A	hasExistingModel()	0	3	2
A	guard()	0	7	2
A	route()	0	24	2
A	storeRequest()	0	3	1
A	validateConstraints()	0	4	2
A	createView()	0	3	1
A	saveCreateFields()	0	7	3
A	indexSorting()	0	16	5
A	can()	0	10	3
A	delete()	0	13	3
A	updateRequest()	0	3	1
A	indexPagination()	0	9	1
A	filters()	0	3	1
A	isManualSortable()	0	3	3
A	indexViewData()	0	3	1
A	indexView()	0	3	1
A	__construct()	0	11	1
A	editFields()	0	4	1
A	findManaged()	0	5	1
A	bootTraitMethods()	0	16	5
A	createFields()	0	9	3
A	manage()	0	5	1
A	indexCollection()	0	16	2
A	fields()	0	3	1
A	existingModel()	0	7	2
A	editView()	0	3	1
A	requestContainsTranslations()	0	3	1
A	editViewData()	0	3	1
A	indexBuilder()	0	3	1
A	modelInstance()	0	5	1
A	createViewData()	0	3	1

<?php

declare(strict_types=1);

namespace Thinktomorrow\Chief\Management;

use Illuminate\Support\Facades\Schema;
use Illuminate\Contracts\Pagination\Paginator;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Thinktomorrow\Chief\Fields\Types\NumberField;
use Thinktomorrow\Chief\Concerns\Translatable\TranslatableCommand;
use Thinktomorrow\Chief\Fields\FieldReference;
use Thinktomorrow\Chief\Fields\Fields;
use Thinktomorrow\Chief\Fields\SavingFields;
use Thinktomorrow\Chief\Fields\Types\Field;
use Thinktomorrow\Chief\Filters\Filters;
use Thinktomorrow\Chief\Fragments\ManagesFragments;
use Thinktomorrow\Chief\Management\Assistants\ManagesAssistants;
use Thinktomorrow\Chief\Management\Details\HasDetails;
use Thinktomorrow\Chief\Management\Details\HasDetailSections;
use Thinktomorrow\Chief\Management\Exceptions\NonExistingRecord;
use Thinktomorrow\Chief\Management\Exceptions\NotAllowedManagerRoute;
use Thinktomorrow\Chief\Relations\ActsAsChild;
use Thinktomorrow\Chief\Relations\ActsAsParent;

abstract class AbstractManager
{
    use SavingFields;
    use HasDetails;

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

    use HasDetailSections;
    use ManagesMedia;
    use ManagesPagebuilder;

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

    use TranslatableCommand;
    use ManagesAssistants;
    use ManagesFragments;

    protected $translation_columns = [];

    protected $model;

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

    protected $pageCount = 20;
    protected $paginated = true;
    protected static $bootedTraitMethods = [];

    final 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();

        static::bootTraitMethods();
    }

    public function managerKey(): string
    {
        return $this->registration->key();

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

    }

    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 isManualSortable(): bool
    {
        return (isset($this->useManualSorting) && $this->useManualSorting && method_exists($this->modelInstance(), 'scopeSortedManually'));
    }

    public function saveCreateFields(Request $request): void
    {
        if($this->isManualSortable() && !$request->has('order')) {
            $this->model->order = $this->modelInstance()::orderBy('order', 'desc')->first()->order + 1;

The method orderBy() does not exist on Thinktomorrow\Chief\Management\ManagedModel. Since it exists in all sub-types, consider adding an abstract or default implementation to Thinktomorrow\Chief\Management\ManagedModel.

        }

        $this->saveFields($request, $this->createFields());
    }

    public function findManaged($id): Manager
    {
        $modelInstance = $this->modelInstance()::where('id', $id)->withoutGlobalScopes()->first();

The method where() does not exist on Thinktomorrow\Chief\Management\ManagedModel. Since it exists in all sub-types, consider adding an abstract or default implementation to Thinktomorrow\Chief\Management\ManagedModel.

        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 indexCollection()
    {
        $builder = ($this->modelInstance())->query();

The method query() does not exist on Thinktomorrow\Chief\Management\ManagedModel. Since it exists in all sub-types, consider adding an abstract or default implementation to Thinktomorrow\Chief\Management\ManagedModel.

        $this->filters()->apply($builder);

        $builder = $this->indexBuilder($builder);

        $builder = $this->indexSorting($builder);

        if ($this->paginated) {
            return $this->indexPagination($builder);
        }

        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().

        });
    }

    protected function indexBuilder(Builder $builder): Builder
    {
        return $builder;
    }

    protected function indexSorting(Builder $builder): Builder
    {
        if($this->isManualSortable()) {
            $builder->sortedManually();
        }

        if ($this->isAssistedBy('publish') && Schema::hasColumn($this->modelInstance()->getTable(), 'published_at')) {

The method getTable() does not exist on Thinktomorrow\Chief\Management\ManagedModel. Since it exists in all sub-types, consider adding an abstract or default implementation to Thinktomorrow\Chief\Management\ManagedModel.

            $builder->orderBy('published_at', 'DESC');
        }

        // if model has no timestamps, updated_at doesn't exist
        if ($this->modelInstance()->timestamps) {

Accessing timestamps on the interface Thinktomorrow\Chief\Management\ManagedModel suggest that you code against a concrete implementation. How about adding an instanceof check?

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

        return $builder;
    }

    protected function indexPagination($builder): Paginator
    {
        $paginator = $builder->paginate($this->pageCount);

        $modifiedCollection = $builder->paginate($this->pageCount)->getCollection()->transform(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().

        });

        return $paginator->setCollection($modifiedCollection);
    }

    public function indexView(): string
    {
        return 'chief::back.managers._partials._rowitems';
    }

    public function indexViewData(): array
    {
        return [];
    }

    public function modelInstance(): ManagedModel
    {
        $class = $this->registration->model();

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

        return new $class();
    }

    public function existingModel(): ManagedModel
    {
        if (!$this->hasExistingModel()) {
            throw new NonExistingRecord('Model does not exist yet but is expected.');
        }

        return $this->model;

The expression return $this->model could return the type Illuminate\Contracts\Foundation\Application which is incompatible with the type-hinted return Thinktomorrow\Chief\Management\ManagedModel. Consider adding an additional type-check to rule them out.

    }

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

    /**
     * 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()]),
            '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]),

Accessing id on the interface Thinktomorrow\Chief\Management\ManagedModel suggest that you code against a concrete implementation. How about adding an instanceof check?

            '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
    {
        foreach (static::$bootedTraitMethods['can'] as $method) {
            if (!method_exists($this, $method)) {
                continue;
            }
            $this->$method($verb);
        }

        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->assistantsAsClassNames() as $assistantClass) {
            if (!method_exists($assistantClass, 'fields')) {
                continue;
            }

            $fields = $fields->merge($this->assistant($assistantClass)->fields());

The method fields() does not exist on Thinktomorrow\Chief\Management\Assistants\Assistant. It seems like you code against a sub-type of Thinktomorrow\Chief\Management\Assistants\Assistant such as Thinktomorrow\Chief\Management\Assistants\UrlAssistant or Thinktomorrow\Chief\Tests\Feature\Assistants\FakeAssistantWithFields.

$assistantClass of type object is incompatible with the type string expected by parameter $assistantKey of Thinktomorrow\Chief\Management\AbstractManager::assistant().

        }

        return $fields;
    }

    public function createFields(): Fields
    {
        $fields = $this->fieldsWithAssistantFields();

        if($this->isManualSortable() && !$fields->offsetExists('order')) {
            $fields = $fields->add(NumberField::make('order'));
        }
trap($fields);
        return $fields;
    }

    public function editFields(): Fields
    {
        return $this->fieldsWithAssistantFields()->map(function (Field $field) {
            return $field->model($this->model);

The method model() does not exist on Thinktomorrow\Chief\Fields\Types\Field. Since it exists in all sub-types, consider adding an abstract or default implementation to Thinktomorrow\Chief\Fields\Types\Field.

        });
    }

    public function createView(): string
    {
        return 'chief::back.managers._partials._form';
    }

    public function createViewData(): array
    {
        return [];
    }

    public function editView(): string
    {
        return 'chief::back.managers._partials._form';
    }

    public function editViewData(): array
    {
        return [];
    }

    public function delete()
    {
        $this->guard('delete');

        if ($this->model instanceof ActsAsChild) {
            $this->model->detachAllParentRelations();
        }

        if ($this->model instanceof ActsAsParent) {
            $this->model->detachAllChildRelations();
        }

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

    public static function bootTraitMethods()
    {
        $class = static::class;

        $methods = [
            'can',
        ];

        foreach ($methods as $baseMethod) {
            static::$bootedTraitMethods[$baseMethod] = [];

            foreach (class_uses_recursive($class) as $trait) {
                $method = class_basename($trait) . ucfirst($baseMethod);

                if (method_exists($class, $method) && !in_array($method, static::$bootedTraitMethods[$baseMethod])) {
                    static::$bootedTraitMethods[$baseMethod][] = lcfirst($method);
                }
            }
        }
    }
}