Thinktomorrow\Chief\Management\Assistants\PublishAssistant

Complexity

Total Complexity

25

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Test Coverage

Coverage

77.96%

Importance

Changes	4
Bugs	2	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	isDraft()	0	3	1
A	guard()	0	7	2
A	can()	0	3	1
A	__construct()	0	3	1
A	publishedAt()	0	3	1
A	publish()	0	7	1
A	draft()	0	7	1
A	manager()	0	4	1
A	route()	0	8	1
A	key()	0	3	1
A	findAll()	0	4	1
A	isPublished()	0	3	1
A	publicationStatusAsPlainLabel()	0	11	5
A	publicationStatusAsLabel()	0	14	4
A	previewUrl()	0	3	1
A	hasPreviewUrl()	0	3	2

<?php


namespace Thinktomorrow\Chief\Management\Assistants;

use Carbon\Carbon;
use Illuminate\Support\Collection;
use Thinktomorrow\Chief\Audit\Audit;
use Thinktomorrow\Chief\Management\Manager;
use Thinktomorrow\Chief\Management\Managers;
use Thinktomorrow\Chief\Management\Exceptions\NotAllowedManagerRoute;
use Thinktomorrow\Chief\Urls\ProvidesUrl\ProvidesUrl;

class PublishAssistant implements Assistant
{
    private $manager;

    private $model;

    /** @var Managers */
    private $managers;

    public function __construct(Managers $managers)
    {
        $this->managers = $managers;
    }

    public function manager(Manager $manager)
    {
        $this->manager = $manager;
        $this->model = $manager->model();
    }

    public static function key(): string
    {
        return 'publish';
    }

    public function isPublished(): bool
    {
        return $this->model->isPublished();
    }

    public function isDraft(): bool
    {
        return $this->model->isDraft();
    }

    public function publishedAt(): Carbon
    {
        return $this->model->Published_at;
    }

    public function publish()
    {
        $this->model->publish();

        Audit::activity()
            ->performedOn($this->model)
            ->log('published');
    }

    public function draft()
    {
        $this->model->draft();

        Audit::activity()
            ->performedOn($this->model)
            ->log('draft');
    }

    public function findAll(): Collection
    {
        return $this->model->published()->get()->map(function ($model) {
            return $this->managers->findByModel($model);
        });
    }

    public function route($verb): ?string
    {
        $modelRoutes = [
            'publish'   => route('chief.back.assistants.publish', [$this->manager->details()->key, $this->manager->model()->id]),
            'draft'     => route('chief.back.assistants.draft', [$this->manager->details()->key, $this->manager->model()->id]),
        ];

        return $modelRoutes[$verb] ?? null;
    }

    public function can($verb): bool
    {
        return !is_null($this->route($verb));
    }

    public function guard($verb): Assistant
    {
        if (! $this->can($verb)) {
            NotAllowedManagerRoute::notAllowedVerb($verb, $this->manager);
        }

        return $this;
    }

    public function hasPreviewUrl(): bool
    {
        return $this->model instanceof ProvidesUrl && $this->previewUrl() != '?preview-mode';
    }

    public function publicationStatusAsLabel($plain = false)
    {
        $label = $this->publicationStatusAsPlainLabel();

        $class = $this->isPublished() ? 'text-success' : 'text-error';

        $statusAsLabel = '<span class="'. $class .'"><em>' . $label . '</em></span>';

        if(!$plain && $this->hasPreviewUrl())
        {
            $statusAsLabel =  '<a href="'.$this->previewUrl().'" target="_blank">'. $statusAsLabel .'</a>';
        }

        return $statusAsLabel;
    }

    private function publicationStatusAsPlainLabel()
    {
        if ($this->isPublished()) {
            return 'online';
        }elseif ($this->isDraft()) {
            return 'offline';
        }elseif ($this->manager->isAssistedBy('archive') && $this->manager->assistant('archive')->isArchived()) {
            return 'gearchiveerd';
        }

        return '-';
    }

    public function previewUrl(): string
    {
        return $this->model->previewUrl();
    }
}