ldc-groupe/app/Models/Document.php

<?php

namespace App\Models;

use App\Contracts\TranslatableModel;
use App\Enums\Document\DocumentStatusEnum;
use App\Enums\YearsEnum;
use App\Helpers\TranslationHelper;
use App\Traits\Models\HasTranslations;
use App\Traits\Models\HasUwilImages;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Support\Arr;
use Carbon\Carbon;
use Illuminate\Support\Facades\Cache;
use Uwil\LaravelActivityLogs\Traits\ActivityLog;

class Document extends Model implements TranslatableModel
{
    use ActivityLog;
    use HasFactory;
    use HasTranslations;
    use HasUwilImages {
        HasUwilImages::inertiaFill as traitInertiaFill;
    }

    /**
     * Champs contenant des images dynamiques à gérer.
     *
     * @var array
     */
    protected array $imageFields = [
        'path'
    ];

    /**
     * The attributes that are mass assignable.
     *
     * @var list<string>
     */
    protected $fillable = [
        'name',
        'path',
        'exercice',
        'status',
        'published_at',
        'unpublished_at'
    ];

    /**
     * The attributes that should be cast.
     *
     * @var array<string, string>
     */
    protected $casts = [
        'status'         => DocumentStatusEnum::class,
        'exercice'       => YearsEnum::class,
        'published_at'   => 'datetime',
        'unpublished_at' => 'datetime',
    ];

    /**
     * The translatable columns.
     *
     * @var list<string>
     */
    public $translatable = [
        'name',
        'path',
    ];

    /**
     * Perform any actions required after the model boots.
     *
     * @return void
     */
    protected static function booted(): void
    {
        static::creating(function (self $model) {
            self::manageFields($model);
        });
        static::created(function () {
            self::resetCache();
        });
        static::updating(function (self $model) {
            self::manageFields($model);
        });
        static::updated(function () {
            self::resetCache();
        });
        static::deleted(function () {
            self::resetCache();
        });
    }

    /**
     * Adjusts model status using current status and publish dates.
     * Case 1: publish model when all null -> set published_at date.
     * Case 2: unpublish model when all null -> nothing to do.
     * Case 3: publish model when published_at is already set -> only change status.
     * Case 4: unpublish model when published_at is already set -> can't update model.
     * Case 5: publish model when unpublished_at is already set -> can't update model.
     * Case 6: unpublish model when unpublished_at is already set -> only change status.
     *
     * @param self $model
     * @return void
     */
    private static function makeStatusSense(self $model): void
    {
        /** @var \Carbon\Carbon|null */
        $published_at = $model->published_at;

        /** @var \Carbon\Carbon|null */
        $unpublished_at = $model->unpublished_at;

        $wantedStatus = $model->status;

        // Check if dates are already set.
        if ($published_at or $unpublished_at) {
            $model->status = $model->planificated_status;
        }
        // If there is a diff, no update.
        if ($wantedStatus !== $model->status) {
            session()->flash('error', \trans(
                'La publication est modifiée en concordance avec les dates enregistrées.
                Pour modifier l\'état de publication, veuillez modifier ou enlever les dates correspondantes.'
            ));
        }
        // Set default published_at date when publishing model.
        if (!$published_at && $model->status->equals(DocumentStatusEnum::published)) {
            $model->published_at = Carbon::now();
        }
    }

    /**
     * Getter the current status following planification dates planificated_status.
     *
     * @return \App\Enums\Document\DocumentStatusEnum
     */
    protected function getPlanificatedStatusAttribute(): \App\Enums\Document\DocumentStatusEnum
    {
        /** @var \Carbon\Carbon|null */
        $published_at = $this->published_at;
        /** @var \Carbon\Carbon|null */
        $unpublished_at = $this->unpublished_at;

        if ($published_at and $unpublished_at) {
            return ($unpublished_at->greaterThanOrEqualTo(now()) and $published_at->lessThan(now()))
                ? DocumentStatusEnum::published
                : DocumentStatusEnum::unpublished;
        }
        if ($published_at) {
            return $published_at->lessThan(now())
                ? DocumentStatusEnum::published
                : DocumentStatusEnum::unpublished;
        }
        if ($unpublished_at) {
            return $unpublished_at->greaterThanOrEqualTo(now())
                ? DocumentStatusEnum::published
                : DocumentStatusEnum::unpublished;
        }
        return DocumentStatusEnum::unpublished;
    }
    // * METHODS

    /**
     * Manage model fields.
     *
     * @param self $model
     * @return void
     */
    private static function manageFields(self $model): void
    {
        // Check unique fields.
        TranslationHelper::assertTranslationFieldIsUnique($model, $model->name, 'name');
        // Check translations.
        self::validateFallbackTranslations($model);
        // Set status.
        self::makeStatusSense($model);
    }

    /**
     * Reset all cache elements related to this model.
     *
     * @return void
     */
    public static function resetCache(): void
    {
        Cache::forget('getPublishedDocuments');
        self::getPublishedDocuments();
    }

    /**
     * Get all published news.
     *
     * @return \Illuminate\Database\Eloquent\Collection<int,self>
     */
    public static function getPublishedDocuments(): \Illuminate\Database\Eloquent\Collection
    {
        return Cache::remember('getPublishedDocuments', 86400, function () {
            return self::query()
                ->where('status', DocumentStatusEnum::published)
                ->with(['tags'])
                ->get();
        });
    }


    /**
     * Assert fallback locale translation is present.
     *
     * @param self $model
     * @return void
     * @throws \Illuminate\Validation\ValidationException Translations missing.
     */
    public static function validateFallbackTranslations(self $model): void
    {
        if (! $model->status->equals(DocumentStatusEnum::published)) {
            return;
        }
        TranslationHelper::validateFallbackTranslations($model);
    }

    /**
     * Relation to Tag
     *
     * @return BelongsToMany
     */
    public function tags(): BelongsToMany
    {
        return $this->belongsToMany(DocumentTag::class);
    }

    /**
     * Relation to Category
     *
     * @return BelongsToMany
     */
    public function categories(): BelongsToMany
    {
        return $this->belongsToMany(DocumentCategory::class);
    }

    public function inertiaFill(array $attributes)
    {
        $attributes = Arr::except($attributes, ['tags', 'categories']);
        $this->traitInertiaFill($attributes);
    }
}