Thinktomorrow\Chief\Pages\Page

Complexity

Total Complexity

42

Size/Duplication

Total Lines	259
Duplicated Lines	0 %

Importance

Changes	5
Bugs	2	Features	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	mediaUrls()	0	9	2
A	flatReference()	0	3	1
A	findPublished()	0	3	1
A	clearCachedUrls()	0	3	1
A	managedModelKey()	0	7	2
A	resolveUrl()	0	5	1
A	__construct()	0	9	2
A	mediaUrl()	0	3	1
A	scopeSortedByCreated()	0	3	1
A	url()	0	17	4
A	getAttribute()	0	9	2
A	flatReferenceGroup()	0	10	2
A	modules()	0	3	1
A	flatReferenceLabel()	0	9	4
A	baseUrlSegment()	0	24	5
A	changeStateOf()	0	10	2
A	statusAsPlainLabel()	0	15	4
A	statusAsLabel()	0	15	4
A	menuLabel()	0	3	1
A	stateOf()	0	3	1

<?php

declare(strict_types=1);

namespace Thinktomorrow\Chief\Pages;

use Illuminate\Support\Str;
use Illuminate\Support\Collection;
use Illuminate\Database\Eloquent\Model;
use Thinktomorrow\Chief\Fragments\HasFragments;
use Thinktomorrow\Chief\States\PageState;
use Thinktomorrow\Chief\Management\ManagedModel;
use Thinktomorrow\Chief\Urls\MemoizedUrlRecord;
use Thinktomorrow\Chief\Urls\ProvidesUrl\ProvidesUrl;
use Thinktomorrow\Chief\States\State\StatefulContract;
use Thinktomorrow\Chief\Urls\ProvidesUrl\ResolvingRoute;
use Thinktomorrow\Chief\Concerns\Viewable\Viewable;
use Thinktomorrow\Chief\Concerns\Viewable\ViewableContract;
use Thinktomorrow\Chief\Modules\Module;
use Thinktomorrow\Chief\Concerns\Featurable;
use Thinktomorrow\Chief\Menu\ActsAsMenuItem;
use Illuminate\Database\Eloquent\SoftDeletes;
use Thinktomorrow\Chief\Relations\ActsAsChild;
use Thinktomorrow\Chief\Snippets\WithSnippets;
use Thinktomorrow\Chief\Relations\ActsAsParent;
use Thinktomorrow\Chief\Relations\ActingAsChild;
use Thinktomorrow\AssetLibrary\AssetTrait;
use Thinktomorrow\Chief\Relations\ActingAsParent;
use Thinktomorrow\Chief\Concerns\Morphable\Morphable;
use Thinktomorrow\Chief\FlatReferences\FlatReference;
use Thinktomorrow\Chief\States\Archivable\Archivable;
use Astrotomic\Translatable\Translatable as BaseTranslatable;
use Thinktomorrow\Chief\States\Publishable\Publishable;
use Thinktomorrow\Chief\Concerns\Translatable\Translatable;
use Thinktomorrow\AssetLibrary\HasAsset;
use Thinktomorrow\Chief\Concerns\Morphable\MorphableContract;
use Thinktomorrow\Chief\Concerns\Translatable\TranslatableContract;
use Thinktomorrow\Chief\Urls\UrlRecordNotFound;

class Page extends Model implements ManagedModel, TranslatableContract, HasAsset, ActsAsParent, ActsAsChild, ActsAsMenuItem, MorphableContract, ViewableContract, ProvidesUrl, StatefulContract
{
    use BaseTranslatable {

The trait Astrotomic\Translatable\Translatable requires the property $each which is not provided by Thinktomorrow\Chief\Pages\Page.

        getAttribute as getTranslatableAttribute;
    }

    use Morphable;

The trait Thinktomorrow\Chief\Concerns\Morphable\Morphable requires the property $morph_key which is not provided by Thinktomorrow\Chief\Pages\Page.

    use AssetTrait;

The trait Thinktomorrow\AssetLibrary\AssetTrait requires some properties which are not provided by Thinktomorrow\Chief\Pages\Page: $assetRelation, $pivot, $fallbackPath, $assetFallbackLocale, $each, $locale, $mediaConversionRegistrations, $useAssetFallbackLocale, $fallbackUrl, $media, $collection_name

    use Translatable;
    use SoftDeletes;
    use Publishable;
    use Featurable;
    use Archivable;
    use ActingAsParent;
    use ActingAsChild;
    use WithSnippets;
    use ResolvingRoute;
    use Viewable;

The trait Thinktomorrow\Chief\Concerns\Viewable\Viewable requires some properties which are not provided by Thinktomorrow\Chief\Pages\Page: $content, $viewKey

    use HasFragments;

    // Explicitly mention the translation model so on inheritance the child class uses the proper default translation model
    protected $translationModel = PageTranslation::class;
    protected $translationForeignKey = 'page_id';
    protected $translatedAttributes = [
        'title',
        'content',
        'short',
        'seo_title',
        'seo_description',
        'seo_keywords',
        'seo_image',
    ];

    public $table = "pages";
    protected $guarded = [];
    protected $with = ['translations'];

    protected $baseViewPath;
    protected static $baseUrlSegment = '/';

    protected static $cachedUrls = [];

    public static function clearCachedUrls()
    {
        static::$cachedUrls = null;
    }

    final public function __construct(array $attributes = [])
    {
        $this->constructWithSnippets();

        if (!isset($this->baseViewPath)) {
            $this->baseViewPath = config('thinktomorrow.chief.base-view-paths.pages', 'pages');
        }

        parent::__construct($attributes);
    }

    public static function managedModelKey(): string
    {
        if (isset(static::$managedModelKey)) {
            return static::$managedModelKey;

The property managedModelKey does not seem to exist on Thinktomorrow\Chief\Pages\Page. Are you sure there is no database migration missing?

        }

        throw new \Exception('Missing required static property \'managedModelKey\' on ' . static::class . '.');
    }

    /**
     * Parse and render any found snippets in custom
     * or translatable attribute values.
     *
     * @param string $value
     * @return mixed|null|string|string[]
     */
    public function getAttribute($value)
    {
        $value = $this->getTranslatableAttribute($value);

        if ($this->shouldParseWithSnippets($value)) {
            $value = $this->parseWithSnippets($value);
        }

        return $value;
    }

    /**
     * Page specific modules. We exclude text modules since they are modules in pure
     * technical terms and not so much as behavioural elements for the admin.
     *
     * @return \Illuminate\Database\Eloquent\Relations\HasMany
     */
    public function modules()
    {
        return $this->hasMany(Module::class, 'page_id')->where('morph_key', '<>', 'text');
    }

    public function flatReference(): FlatReference
    {
        return new FlatReference(static::class, $this->id);
    }

    public function flatReferenceLabel(): string
    {
        if ($this->exists) {
            $status = !$this->isPublished() ? ' [' . $this->statusAsPlainLabel() . ']' : null;

            return $this->title ? $this->title . $status : '';

The property title does not seem to exist on Thinktomorrow\Chief\Pages\Page. Are you sure there is no database migration missing?

        }

        return '';
    }

    public function flatReferenceGroup(): string
    {
        $classKey = get_class($this);
        if (property_exists($this, 'labelSingular')) {
            $labelSingular = $this->labelSingular;

The property labelSingular does not seem to exist on Thinktomorrow\Chief\Pages\Page. Are you sure there is no database migration missing?

        } else {
            $labelSingular = Str::singular($classKey);
        }

        return $labelSingular;
    }

    public function mediaUrls($type = null, $size = 'full'): Collection
    {
        $assets = $this->assets($type, app()->getLocale())->map->url($size);

The method getLocale() does not exist on Illuminate\Container\Container. Are you sure you never get this type here, but always one of the subclasses?

        if ($assets->first() == null) {
            $assets = $this->assets($type)->map->url($size);
        }

        return $assets;
    }

    public function mediaUrl($type = null, $size = 'full'): ?string
    {
        return $this->mediaUrls($type, $size)->first();
    }

    public static function findPublished($id)
    {
        return static::published()->find($id);
    }

    public function scopeSortedByCreated($query)
    {
        $query->orderBy('created_at', 'DESC');
    }

    /** @inheritdoc */
    public function url(string $locale = null): string
    {
        if (!$locale) {
            $locale = app()->getLocale();
        }
        try {
            $memoizedKey = $this->getMorphClass() . '-' . $this->id . '-' . $locale;

            if (isset(static::$cachedUrls[$memoizedKey])) {
                return static::$cachedUrls[$memoizedKey];
            }

            $slug = MemoizedUrlRecord::findByModel($this, $locale)->slug;

            return static::$cachedUrls[$memoizedKey] = $this->resolveUrl($locale, [$slug]);
        } catch (UrlRecordNotFound $e) {
            return '';
        }
    }

    public function resolveUrl(string $locale = null, $parameters = null): string
    {
        $routeName = config('thinktomorrow.chief.route.name');

        return $this->resolveRoute($routeName, $parameters, $locale);

It seems like $locale can also be of type string; however, parameter $locale of Thinktomorrow\Chief\Pages\Page::resolveRoute() does only seem to accept null, maybe add an additional type check?

    }

    /** @inheritdoc */
    public function baseUrlSegment(string $locale = null): string
    {
        if (!isset(static::$baseUrlSegment)) {
            return '/';
        }

        if (!is_array(static::$baseUrlSegment)) {

The condition is_array(static::baseUrlSegment) is always false.

            return static::$baseUrlSegment;
        }

        // When an array, we try to locate the expected segment by locale
        $key = $locale ?? app()->getlocale();

        if (isset(static::$baseUrlSegment[$key])) {
            return static::$baseUrlSegment[$key];
        }

        $fallback_locale = config('app.fallback_locale');
        if (isset(static::$baseUrlSegment[$fallback_locale])) {
            return static::$baseUrlSegment[$fallback_locale];
        }

        // Fall back to first entry in case no match is found
        return reset(static::$baseUrlSegment);
    }

    public function menuLabel(): string
    {
        return $this->title ?? '';

The property title does not seem to exist on Thinktomorrow\Chief\Pages\Page. Are you sure there is no database migration missing?

    }

    public function statusAsLabel()
    {
        if ($this->isPublished()) {
            return '<a href="' . $this->url() . '" target="_blank"><em>online</em></a>';
        }

        if ($this->isDraft()) {
            return '<a href="' . $this->url() . '" target="_blank" class="text-error"><em>offline</em></a>';
        }

        if ($this->isArchived()) {
            return '<span><em>gearchiveerd</em></span>';
        }

        return '-';
    }

    public function statusAsPlainLabel()
    {
        if ($this->isPublished()) {
            return 'online';
        }

        if ($this->isDraft()) {
            return 'offline';
        }

        if ($this->isArchived()) {
            return 'gearchiveerd';
        }

        return '-';
    }

    public function stateOf($key): string
    {
        return $this->$key ?? PageState::DRAFT;
    }

    public function changeStateOf($key, $state)
    {
        // Ignore change to current state - it should not trigger events either
        if ($state === $this->stateOf($key)) {
            return;
        }

        PageState::assertNewState($this, $key, $state);

        $this->$key = $state;
    }
}