Thinktomorrow\Chief\Management\AbstractManager

Complexity

Total Complexity

41

Size/Duplication

Total Lines	289
Duplicated Lines	0 %

Test Coverage

Coverage

96.15%

Importance

Changes	6
Bugs	2	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	route()	0	21	2
A	__construct()	0	11	1
A	guard()	0	7	2
A	hasExistingModel()	0	3	2
A	fieldsWithAssistantFields()	0	13	3
A	storeRequest()	0	3	1
A	validateConstraints()	0	4	2
A	indexSorting()	0	12	3
A	can()	0	10	3
A	delete()	0	11	3
A	model()	0	3	1
A	updateRequest()	0	3	1
A	indexPagination()	0	9	1
A	filters()	0	3	1
A	findManaged()	0	7	1
A	bootTraitMethods()	0	16	5
A	manage()	0	5	1
A	indexCollection()	0	18	2
A	fieldArrangement()	0	3	1
A	fields()	0	3	1
A	existingModel()	0	7	2
A	indexBuilder()	0	3	1
A	requestContainsTranslations()	0	3	1

<?php

namespace Thinktomorrow\Chief\Management;

use Illuminate\Contracts\Pagination\Paginator;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
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;
use Thinktomorrow\Chief\Relations\ActsAsChild;
use Thinktomorrow\Chief\Relations\ActsAsParent;
use Thinktomorrow\Chief\Relations\Relation;

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\Fields\SavingFields requires the property $key which is not provided by Thinktomorrow\Chief\Management\AbstractManager.

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

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

    protected $translation_columns = [];

    protected $model;

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

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

    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 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 indexCollection()
    {
        $model = $this->registration->model();

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

        $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->isAssistedBy('publish')) {
            $builder->orderBy('published', 'DESC');
        }

        // if model has no timestamps, updated_at doesn't exist
        if ($this->model()->timestamps) {
            $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 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
    {
        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->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()
    {
        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);
                }
            }
        }
    }
}