presseportale/app/Models/PressRelease.php

<?php

namespace App\Models;

use App\Enums\Portal;
use App\Enums\PressReleaseClassification;
use App\Enums\PressReleaseContentTier;
use App\Enums\PressReleasePlaceholder;
use App\Enums\PressReleaseStatus;
use App\Models\Concerns\HasUniqueSlug;
use App\Scopes\PortalScope;
use App\Services\PressRelease\PressReleaseHtmlSanitizer;
use Database\Factories\PressReleaseFactory;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Support\Carbon;
use Illuminate\Support\HtmlString;

class PressRelease extends Model
{
    /** @use HasFactory<PressReleaseFactory> */
    use HasFactory, HasUniqueSlug, SoftDeletes;

    /**
     * @return list<string>
     */
    protected function slugScopeAttributes(): array
    {
        return ['portal', 'language'];
    }

    protected function slugFallback(): string
    {
        return 'pressemitteilung';
    }

    protected static function booted(): void
    {
        static::addGlobalScope(new PortalScope);

        static::creating(function (self $pressRelease): void {
            if (blank($pressRelease->placeholder_variant)) {
                $seed = $pressRelease->uuid ?? $pressRelease->title ?? (string) now()->timestamp;
                $pressRelease->placeholder_variant = PressReleasePlaceholder::fromSeed($seed)->value;
            }
        });
    }

    protected $fillable = [
        'uuid',
        'portal',
        'user_id',
        'company_id',
        'category_id',
        'language',
        'title',
        'subtitle',
        'slug',
        'text',
        'boilerplate_override',
        'placeholder_variant',
        'backlink_url',
        'keywords',
        'status',
        'classification',
        'classified_at',
        'content_score',
        'content_tier',
        'scored_at',
        'hits',
        'teaser_begin',
        'teaser_end',
        'no_export',
        'published_at',
        'scheduled_at',
        'embargo_at',
        'legacy_portal',
        'legacy_id',
    ];

    protected function casts(): array
    {
        return [
            'portal' => Portal::class,
            'placeholder_variant' => PressReleasePlaceholder::class,
            'status' => PressReleaseStatus::class,
            'classification' => PressReleaseClassification::class,
            'classified_at' => 'datetime',
            'content_score' => 'integer',
            'content_tier' => PressReleaseContentTier::class,
            'scored_at' => 'datetime',
            'hits' => 'integer',
            'teaser_begin' => 'integer',
            'teaser_end' => 'integer',
            'no_export' => 'boolean',
            'published_at' => 'datetime',
            'scheduled_at' => 'datetime',
            'embargo_at' => 'datetime',
            'deleted_at' => 'datetime',
        ];
    }

    /**
     * Geplanter Veröffentlichungstermin. Die Anwendung läuft durchgängig in
     * Europe/Berlin (config app.timezone), daher ist keine Umrechnung nötig.
     */
    public function scheduledAtLocal(): ?Carbon
    {
        return $this->scheduled_at;
    }

    /**
     * Sperrfrist (Embargo) in der Anwendungs-Zeitzone (Europe/Berlin).
     */
    public function embargoAtLocal(): ?Carbon
    {
        return $this->embargo_at;
    }

    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }

    public function company(): BelongsTo
    {
        return $this->belongsTo(Company::class);
    }

    public function category(): BelongsTo
    {
        return $this->belongsTo(Category::class);
    }

    public function images(): HasMany
    {
        return $this->hasMany(PressReleaseImage::class);
    }

    public function attachments(): HasMany
    {
        return $this->hasMany(PressReleaseAttachment::class);
    }

    public function contacts(): BelongsToMany
    {
        return $this->belongsToMany(Contact::class, 'press_release_contact');
    }

    public function statusLogs(): HasMany
    {
        return $this->hasMany(PressReleaseStatusLog::class)->orderByDesc('created_at');
    }

    public function kiAudits(): HasMany
    {
        return $this->hasMany(KiAudit::class)->orderByDesc('created_at');
    }

    public function boosts(): HasMany
    {
        return $this->hasMany(Boost::class);
    }

    /**
     * Aktuell geboostet (mindestens ein laufender Boost-Zeitraum)?
     */
    public function isBoosted(): bool
    {
        return $this->boosts()->active()->exists();
    }

    /**
     * Beschränkt auf PMs mit aktuell laufendem Boost — Basis für die
     * Featured-Platzierung auf Start-/Branchenseite.
     */
    public function scopeBoosted(Builder $query): Builder
    {
        return $query->whereHas('boosts', fn (Builder $q) => $q->active());
    }

    /**
     * Eine veröffentlichte PM: freigegebener Status mit gesetztem Datum. Bewusst
     * OHNE Zeitschranke, damit Statistik-Fenster (z. B. „letzte 7 Tage") frei auf
     * `published_at` einschränken können. Single Source of Truth für die
     * öffentlichen Web-Abfragen.
     */
    public function scopePublished(Builder $query): Builder
    {
        return $query->where('status', PressReleaseStatus::Published)
            ->whereNotNull('published_at');
    }

    /**
     * Öffentlich sichtbare PM im Archiv: veröffentlicht UND der Termin liegt nicht
     * in der Zukunft (`published_at <= jetzt`). Basis für alle Listen-/Detail-/
     * Lead-Abfragen der Web-Seiten.
     */
    public function scopeVisibleInArchive(Builder $query): Builder
    {
        return $query->published()->where('published_at', '<=', now());
    }

    /**
     * @param  list<string>  $portalValues
     */
    public function scopeForPortalValues(Builder $query, array $portalValues): Builder
    {
        return $query->whereIn('portal', $portalValues);
    }

    public function scopeForLanguage(Builder $query, string $language): Builder
    {
        return $query->where('language', $language);
    }

    /**
     * Beschränkt auf PMs, die dem User gehören (als Autor) oder zu einer ihm
     * zugeordneten Firma. Bewusst ohne Portal-GlobalScope: ein Kunde darf
     * seine eigenen PMs portalübergreifend sehen und bearbeiten.
     *
     * Single Source of Truth für den Kunden-Zugriff auf PMs — genutzt von der
     * Übersicht, Detail-, Bearbeiten- und Nachweis-Ansicht.
     */
    public function scopeAccessibleBy(Builder $query, User $user): Builder
    {
        return $query->withoutGlobalScopes()
            ->where(function (Builder $q) use ($user): void {
                $q->where('user_id', $user->id);

                $companyIds = $user->accessibleCompanyIds();

                if ($companyIds !== []) {
                    $q->orWhereIn('company_id', $companyIds);
                }
            });
    }

    /**
     * Bewusst enger als {@see scopeAccessibleBy()}: Der API-Zugriff meint nur
     * die eigene Autorschaft (user_id), nicht den breiteren Firmenzugriff.
     * Single Source of Truth für die API-Controller.
     */
    public function scopeOwnedByApiUser(Builder $query, User $user): Builder
    {
        return $query->where('user_id', $user->id);
    }

    /**
     * Display-ready text. Returns sanitized HTML for Phase-7+ PMs and
     * <p>/<br>-wrapped legacy plain text for older imports.
     */
    public function renderedText(): HtmlString
    {
        return app(PressReleaseHtmlSanitizer::class)->render($this->text);
    }

    public function plainTextLength(): int
    {
        return app(PressReleaseHtmlSanitizer::class)->plainTextLength($this->text);
    }
}