Thinktomorrow\Chief\Management\Managers

Complexity

Total Complexity

16

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Test Coverage

Coverage

63.27%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	instanceModel()	0	7	1
A	findDetailsByTag()	0	6	1
A	findByTag()	0	6	1
A	all()	0	6	1
A	findByTagForSelect()	0	15	1
A	anyRegisteredByTag()	0	3	1
A	__construct()	0	3	1
A	instance()	0	9	2
A	findByUrl()	0	7	1
A	findByKey()	0	5	1
A	allAssistantClassNames()	0	9	2
A	findByModel()	0	17	3

<?php

declare(strict_types=1);

namespace Thinktomorrow\Chief\Management;

use Illuminate\Support\Collection;
use Thinktomorrow\Chief\Concerns\Morphable\Morphables;
use Thinktomorrow\Chief\Urls\UrlRecord;

class Managers
{
    /** @var Register */
    private $register;

    public function __construct(Register $register)
    {
        $this->register = $register;
    }

    public function findByKey($key, $id = null): Manager
    {
        $registration = $this->register->filterByKey($key)->first();

        return $this->instance($registration, $id);
    }

    public function findByModel($model, $id = null): Manager
    {
        /**
         * If an instance is passed as model, we try to extract the class and id
         * ourselves and assume we can read the id value via the id property
         */
        if (null === $id && !is_string($model)) {
            $modelClass = get_class($model);

            $registration = $this->register->filterByModel($modelClass)->first();

            return $this->instanceModel($registration, $model);
        }

        $registration = $this->register->filterByModel($model)->first();

        return $this->instance($registration, $id);
    }

    public function findByUrl(string $slug, string $locale): Manager
    {
        $urlRecord = UrlRecord::findBySlug($slug, $locale);

        $model = Morphables::instance($urlRecord->model_type)->find($urlRecord->model_id);

        return $this->findByModel($model);
    }

    /**
     * Enlist all details for a certain tag group of managed models
     *
     * @param $tag
     * @return Collection of Managers
     */
    public function findByTag($tag): Collection
    {
        $registrations = collect($this->register->filterByTag($tag)->all());

        return $registrations->map(function ($registration) {

The expression return $registrations->map(function(...) { /* ... */ }) returns the type Tightenco\Collect\Support\Collection which is incompatible with the type-hinted return Illuminate\Support\Collection.

            return $this->instance($registration);
        });
    }

    /**
     * Enlist all details for a certain tag group of managed models
     *
     * @param $tag
     * @return Collection of ManagedModelDetails
     */
    public function findDetailsByTag($tag): Collection
    {
        $registrations = collect($this->register->filterByTag($tag)->all());

        return $registrations->map(function ($registration) {

The expression return $registrations->map(function(...) { /* ... */ }) returns the type Tightenco\Collect\Support\Collection which is incompatible with the type-hinted return Illuminate\Support\Collection.

            return $this->instance($registration)->details();
        });
    }

    public function findByTagForSelect($tag)
    {
        $managers = $this->findByTag($tag);
        //return array with group name and values
        $grouped = [];

The assignment to $grouped is dead and can be removed.

        $managers = $managers->map(function (Manager $item) {
            return [
                'id'    => $item->details()->id,

The property id does not exist on Thinktomorrow\Chief\Management\Details\Details. Since you implemented __get, consider adding a @property annotation.

                'group' => $item->details()->plural,

The property plural does not exist on Thinktomorrow\Chief\Management\Details\Details. Since you implemented __get, consider adding a @property annotation.

            ];
        })->toArray();

        // We remove the group key as we need to have non-assoc array for the multiselect options.
        return collect(array_values($managers));
    }

    public function all(): Collection
    {
        $registrations = collect($this->register->all());

        return $registrations->map(function ($registration) {

The expression return $registrations->map(function(...) { /* ... */ }) returns the type Tightenco\Collect\Support\Collection which is incompatible with the type-hinted return Illuminate\Support\Collection.

            return $this->instance($registration);
        });
    }

    public function allAssistantClassNames(): Collection
    {
        $assistants = collect();

        foreach ($this->all() as $manager) {
            $assistants = $assistants->merge($manager->assistants(false));
        }

        return $assistants->unique();

The expression return $assistants->unique() returns the type Tightenco\Collect\Support\Collection which is incompatible with the type-hinted return Illuminate\Support\Collection.

    }

    public function anyRegisteredByTag($tag)
    {
        return !empty($this->register->filterByTag($tag)->all());
    }

    /**
     * @param $registration
     * @param $id
     * @return mixed
     */
    private function instance(Registration $registration, $id = null)
    {
        $managerClass = $registration->class();

        $manager = new $managerClass($registration);

        return $id
            ? $manager->findManaged($id)
            : $manager;
    }

    /**
     * @param $registration
     * @param $model
     * @return mixed
     */
    private function instanceModel(Registration $registration, $model)
    {
        $managerClass = $registration->class();

        $manager = new $managerClass($registration);

        return $manager->manage($model);
    }
}