Thinktomorrow\Chief\Management\ManagesPagebuilder

Complexity

Total Complexity

13

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Test Coverage

Coverage

98.11%

Importance

Changes	2
Bugs	1	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	saveSectionsField()	0	15	1
A	findEditUrl()	0	10	3
A	createPagebuilderField()	0	41	3
A	guessPagebuilderSectionType()	0	21	6

<?php


namespace Thinktomorrow\Chief\Management;

use Illuminate\Http\Request;
use Thinktomorrow\Chief\Pages\Page;
use Thinktomorrow\Chief\Sets\SetReference;
use Thinktomorrow\Chief\Modules\TextModule;
use Thinktomorrow\Chief\Modules\PagetitleModule;
use Thinktomorrow\Chief\Sets\StoredSetReference;
use Thinktomorrow\Chief\PageBuilder\UpdateSections;
use Thinktomorrow\Chief\Relations\AvailableChildren;
use Thinktomorrow\Chief\Fields\Types\PagebuilderField;
use Thinktomorrow\Chief\FlatReferences\FlatReferencePresenter;
use Thinktomorrow\Chief\Concerns\Translatable\TranslatableContract;

trait ManagesPagebuilder
{
    /**
     * The naming convention is important here because to hook into the saving
     * flow it needs to have the save<key>Field method naming.
     *
     * @param PagebuilderField $field
     * @param Request $request
     */
    public function saveSectionsField(PagebuilderField $field, Request $request)

The parameter $field is not used and could be removed.

    {
        $sections = $request->get('sections', []);

        $modules = $sections['modules'] ?? [];
        $text    = $sections['text'] ?? [];
        $sets    = $sections['pagesets'] ?? [];
        $order   = $sections['order'] ?? [];

        UpdateSections::forModel($this->model, $modules, $text, $sets, $order)
            ->updateModules()
            ->updateSets()
            ->addTextModules()
            ->updateTextModules()
            ->sort();
    }

    protected function createPagebuilderField(): PagebuilderField
    {
        $model = $this->model;

        $availableChildren = AvailableChildren::forParent($model);

        $modules = $availableChildren->onlyModules()->reject(function ($module) use ($model) {
            return $module->page_id != null && $module->page_id != $model->id;
        });

        $available_modules = FlatReferencePresenter::toGroupedSelectValues($modules)->toArray();
        $available_pages = FlatReferencePresenter::toGroupedSelectValues($availableChildren->onlyPages())->toArray();
        $available_sets = FlatReferencePresenter::toGroupedSelectValues($availableChildren->onlySets())->toArray();

        // Current sections
        $sections = $model->children()->map(function ($section, $index) {
            if ($section instanceof TranslatableContract) {
                $section->injectTranslationForForm();

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

            }

            return [
                // Module reference is by id.
                'id'         => $section->flatReference()->get(),

                // Key is a separate value to assign each individual module.
                // This is separate from id to avoid vue key binding conflicts.
                'key'        => $section->flatReference()->get(),
                'type'       => $this->guessPagebuilderSectionType($section),
                'slug'       => $section->slug,
                'editUrl'    => $this->findEditUrl($section),
                'sort'       => $index,
                'trans'      => $section->trans ?? [],
            ];
        })->toArray();

        return PagebuilderField::make('sections')

The expression return Thinktomorrow\Chief\Fields\Types\PagebuilderField::make('sections')->translatable($this->model->availableLocales())->sections($sections)->availablePages($available_pages)->availableModules($available_modules)->availableSets($available_sets) could return the type null|string which is incompatible with the type-hinted return Thinktomorrow\Chief\Fields\Types\PagebuilderField. Consider adding an additional type-check to rule them out.

                                ->translatable($this->model->availableLocales())
                                ->sections($sections)
                                ->availablePages($available_pages)
                                ->availableModules($available_modules)
                                ->availableSets($available_sets);
    }

    /**
     * @param $model
     * @return string|null
     */
    private function findEditUrl($model): ?string
    {
        if (! $model instanceof ManagedModel) {
            return null;
        }

        try {
            return app(Managers::class)->findByModel($model)->route('edit');
        } catch (NonRegisteredManager $e) {
            return null;
        }
    }

    /**
     * Section type is the grouping inside the pagebuilder (specifically the menu)
     *
     * @param $section
     * @return string
     */
    private function guessPagebuilderSectionType($section)
    {
        if ($section instanceof TextModule) {
            return 'text';
        }

        if ($section instanceof PagetitleModule) {
            return 'pagetitle';
        }

        if ($section instanceof StoredSetReference || $section instanceof SetReference) {
            // TODO: clean this up and replace 'pageset' with 'set';
            return 'pageset';
        }

        if ($section instanceof Page) {
            return 'page';
        }

        // We want all other types to be registered as modules
        return 'module';
    }
}