Kevin Adametz
2a2215b3c3
Bilder (N01, N05, N07, N08): gemeinsamer Freigabezustand PressReleaseImage::isPubliclyDeliverable() für Seiten, OG und Medienroute (Bestand bleibt sichtbar, v2 nur mit Bestätigung, Admin-Upload bis zum Kundenklick nicht öffentlich); eigene Ability confirmImageRights nur für den Kontoinhaber, ohne Super-Admin-Kurzschluss, Identität und ausstehende Bestätigung auch im Service; Status-Regel unter der PM-Sperre; Cache-Flush nach dem Commit außerhalb der Dateibereinigung; Snapshot nach Bestätigung an veröffentlichter PM; Bestätigungstexte an die gezeigte Kennung gebunden. Beweisarchiv (N02, N10, N11, N12, N13, 5.1): Tombstone unter Zeilensperre mit erneuter Hold-/Fristprüfung; Dateioperationen ausgewertet, Commands mit FAILURE; record() über .tmp + move; Marker archive_pending_at mit archive:retry-pending und archive:sweep-orphans; Anonymisierung entfernt Bilder über den Remover mit Antragsbezug; Draft-Purge räumt Medien nie veröffentlichter abgelehnter Einreichungen; App-Kopien fallen mit dem Archiv-Tombstone; label_corrected nur für veröffentlichte Bilder; archive_entries.legal_request_id; FileDeletion-Helfer; Systemstatus-Checks. KI und Hintergrund (N03, N04, N14, N20, N21): Ergebnis-UPDATE und Audit in einer Transaktion; erwarteter Hash bis in reject()/holdForManualReview(); Ablaufmail per beanspruchtem Marker in einer Transaktion; strikte Schemaprüfung der Vision-Antwort; Fortschrittsmarke ungecacht. Berichte und Canonical (N15–N19, 5.2): lückenlose Alterskohorten; Feed-Identität mit Portal und Sprache; Sitemap-Rolle in der Kundenansicht; Indexverteilung auf einer Grundgesamtheit; Kopien nach Wegfall der Erstquelle neu bewertet; Kategorie-Admin leert Seiten-Caches; Dry-Run zählt alle Tabellen. Gesamtsuite: 2.122 Tests grün, einer übersprungen; Larastan und Pint sauber. Zwei Migrationen (nullable Spalten, INSTANT). N09 offen. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
1119 lines
46 KiB
PHP
1119 lines
46 KiB
PHP
<?php
|
||
|
||
namespace App\Services\PressRelease;
|
||
|
||
use App\Enums\ActivityType;
|
||
use App\Enums\ArchiveReasonCategory;
|
||
use App\Enums\EmailNotificationType;
|
||
use App\Enums\PressReleaseClassification;
|
||
use App\Enums\PressReleaseStatus;
|
||
use App\Enums\SinglePurchaseStatus;
|
||
use App\Jobs\ClassifyPressRelease;
|
||
use App\Jobs\ScorePressRelease;
|
||
use App\Mail\PressReleaseHeldForReview;
|
||
use App\Mail\PressReleasePublished;
|
||
use App\Mail\PressReleaseRejected;
|
||
use App\Models\AdminPreset;
|
||
use App\Models\Company;
|
||
use App\Models\KiAudit;
|
||
use App\Models\PressRelease;
|
||
use App\Models\PressReleaseAiDeclaration;
|
||
use App\Models\PressReleaseImage;
|
||
use App\Models\PressReleaseStatusLog;
|
||
use App\Models\User;
|
||
use App\Scopes\PortalScope;
|
||
use App\Services\ActivityLog;
|
||
use App\Services\Admin\AdminPerformanceCache;
|
||
use App\Services\Archive\PressReleaseArchiver;
|
||
use App\Services\Mail\EmailSuppressionService;
|
||
use App\Services\PressRelease\Images\PressReleaseImageRemover;
|
||
use App\Services\PressRelease\Images\PublishedImageSnapshot;
|
||
use App\Support\WebCaches;
|
||
use Illuminate\Support\Carbon;
|
||
use Illuminate\Support\Facades\Auth;
|
||
use Illuminate\Support\Facades\DB;
|
||
use Illuminate\Support\Facades\Log;
|
||
use Illuminate\Support\Facades\Mail;
|
||
|
||
/**
|
||
* Kapselt Statusübergänge für Pressemitteilungen inkl. Benachrichtigungs-Mails.
|
||
*
|
||
* Jede Methode verändert exklusiv den Status und versendet optional eine Mail
|
||
* an den Autor (User). Die Caller-Schicht (Volt, Command, API) muss nur noch
|
||
* diese Methoden aufrufen – keine Mail-Logik außerhalb dieser Klasse.
|
||
*/
|
||
class PressReleaseService
|
||
{
|
||
public function __construct(
|
||
private readonly BlacklistService $blacklist,
|
||
private readonly AdminPerformanceCache $adminCache,
|
||
private readonly ActivityLog $activityLog,
|
||
private readonly EmailSuppressionService $suppressions,
|
||
) {}
|
||
|
||
/**
|
||
* @param string $source Einlieferungsweg fuers Status-Log ('customer'
|
||
* = Panel, 'api' = Legacy-/v1-API) — steuert u. a.
|
||
* das Mail-Routing (API → Pressekontakt/Firma).
|
||
*/
|
||
public function submitForReview(PressRelease $pressRelease, string $source = 'customer'): void
|
||
{
|
||
$this->assertStatus($pressRelease, [PressReleaseStatus::Draft, PressReleaseStatus::Rejected]);
|
||
|
||
$user = $pressRelease->user;
|
||
|
||
// Submit-Gate (Decision-Update §5.1): Einreichen erfordert eine aktive
|
||
// Buchung. Bis zum Tarif-Modul steuert billing.enforce_booking den Stub.
|
||
if ($user && ! $user->hasActiveBooking()) {
|
||
throw new BookingRequiredException;
|
||
}
|
||
|
||
// Slot-Guard: Der Slot wird erst bei Veröffentlichung verbraucht
|
||
// (Decision-Update §3.2) — eingereicht werden darf aber nur, wenn
|
||
// noch ein Slot frei ist, sonst würde eine grüne/gelbe PM ohne
|
||
// verfügbares Kontingent automatisch veröffentlicht. Null bedeutet
|
||
// unbegrenzt (Bestandsschutz bzw. Gate noch nicht scharf).
|
||
$quotaRemaining = $user?->pressReleaseQuotaRemaining();
|
||
|
||
if ($user && $quotaRemaining !== null && $quotaRemaining <= 0) {
|
||
throw new QuotaExceededException;
|
||
}
|
||
|
||
// KI-Kennzeichnung (Art. 50 KI-VO): ohne vollständige Deklaration
|
||
// kein Submit — die Editoren validieren das bereits im Modal, dieser
|
||
// Guard sichert alle Aufrufpfade (API, ältere Entwürfe) ab.
|
||
$this->assertAiDeclarationComplete($pressRelease);
|
||
|
||
$previous = $pressRelease->status;
|
||
|
||
if ($word = $this->blacklist->findInPressRelease($pressRelease)) {
|
||
$reason = sprintf('Automatische Ablehnung: unzulässiges Wort "%s" gefunden.', $word);
|
||
|
||
$pressRelease->update(['status' => PressReleaseStatus::Rejected->value]);
|
||
$this->logStatusChange($pressRelease, $previous, PressReleaseStatus::Rejected, $reason, 'blacklist');
|
||
$this->notifyAuthor($pressRelease, 'rejected', $reason);
|
||
|
||
throw new BlacklistViolationException($reason, $word);
|
||
}
|
||
|
||
// Archiv-Hinweis (AGB § 13 Abs. 1, T2neu): Das Einreichungs-Modal
|
||
// verlangt die Bestätigung der dauerhaften Archivierung — der
|
||
// Zeitpunkt wird hier zur Nachweisbarkeit protokolliert. (Spalte
|
||
// heißt historisch withdrawal_waiver_consented_at; die frühere
|
||
// Erlöschens-Checkbox entfiel mit der B2B-Umstellung, E2.)
|
||
// Begrenzter Prüfkreislauf (E3, 16.09.2026): Ist die Automatik für
|
||
// diese Meldung erschöpft, geht die Freigabe ohne KI-Lauf direkt an
|
||
// einen Menschen. Sonst zählt dieser Lauf.
|
||
$manual = $pressRelease->requiresManualReview();
|
||
|
||
$pressRelease->update([
|
||
'status' => PressReleaseStatus::Review->value,
|
||
'withdrawal_waiver_consented_at' => now(),
|
||
'auto_check_attempts' => $manual ? $pressRelease->auto_check_attempts : $pressRelease->auto_check_attempts + 1,
|
||
]);
|
||
$this->logStatusChange(
|
||
$pressRelease,
|
||
$previous,
|
||
PressReleaseStatus::Review,
|
||
$manual ? 'Erneute Freigabe nach erschöpfter automatischer Prüfung — wartet auf manuelle Entscheidung.' : null,
|
||
$source,
|
||
);
|
||
|
||
// Versionierter Audit-Trail der KI-Deklaration: jeder Submit erzeugt
|
||
// einen neuen, unveränderlichen Eintrag (Abs.-50-Verteidigung —
|
||
// "Kunde hat am Datum X Option Y deklariert und bestätigt").
|
||
$this->logAiDeclaration($pressRelease);
|
||
|
||
if (! $manual) {
|
||
// KI-Klassifikation asynchron anstoßen (Red Flag). Das Routing
|
||
// anhand des Ergebnisses übernimmt der Job über
|
||
// routeByClassification().
|
||
ClassifyPressRelease::dispatch($pressRelease->id, contentHash: $pressRelease->content_hash)->onQueue('classification');
|
||
}
|
||
|
||
// Content-Score parallel berechnen (Qualität, ohne Statuswirkung).
|
||
ScorePressRelease::dispatch($pressRelease->id, contentHash: $pressRelease->content_hash)->onQueue('classification');
|
||
}
|
||
|
||
/**
|
||
* Stößt eine erneute KI-Klassifikation an, wenn die PM bereits einmal
|
||
* klassifiziert wurde (Konzept §15.1: „Bei Änderung wird neu klassifiziert").
|
||
*
|
||
* Läuft als Re-Check **ohne Routing**: Bewertung + Audit werden
|
||
* aktualisiert, der Status bleibt unverändert. So führt das bloße
|
||
* Bearbeiten nie zu einer überraschenden automatischen Veröffentlichung
|
||
* – die Entscheidung bleibt beim regulären Workflow/Admin.
|
||
*
|
||
* Eine Ausnahme (Audit U03): Wird der Re-Check Rot und die PM wartet
|
||
* noch in `review` (etwa eine terminierte Grün-PM, die vor dem Termin
|
||
* bearbeitet wurde), lehnt der Job sie wie bei der Erstprüfung ab –
|
||
* inkl. Autorenmail –, statt sie still als rote terminierte Meldung
|
||
* liegen zu lassen. Siehe ClassifyPressRelease.
|
||
*/
|
||
public function reclassifyIfClassified(PressRelease $pressRelease): void
|
||
{
|
||
if ($pressRelease->classification === null) {
|
||
return;
|
||
}
|
||
|
||
ClassifyPressRelease::dispatch($pressRelease->id, route: false, contentHash: $pressRelease->content_hash)->onQueue('classification');
|
||
}
|
||
|
||
/**
|
||
* Stößt eine erneute Content-Score-Berechnung an, wenn die PM bereits
|
||
* einmal bewertet wurde (Konzept §15.2: „bei jeder Änderung neu berechnet").
|
||
*/
|
||
public function rescoreIfScored(PressRelease $pressRelease): void
|
||
{
|
||
if ($pressRelease->content_score === null) {
|
||
return;
|
||
}
|
||
|
||
ScorePressRelease::dispatch($pressRelease->id, contentHash: $pressRelease->content_hash)->onQueue('classification');
|
||
}
|
||
|
||
/**
|
||
* Nach einer inhaltlichen Änderung (Titel/Text) einer bereits geprüften
|
||
* bzw. bewerteten PM erneut prüfen (Re-Check ohne Routing) und neu
|
||
* bewerten. Operiert auf dem frischen Modellstand. Single Source of Truth
|
||
* für die vier PM-Editoren.
|
||
*/
|
||
public function reprocessAfterContentChange(PressRelease $pressRelease): void
|
||
{
|
||
$fresh = $pressRelease->fresh();
|
||
|
||
if ($fresh === null) {
|
||
return;
|
||
}
|
||
|
||
$this->reclassifyIfClassified($fresh);
|
||
$this->rescoreIfScored($fresh);
|
||
}
|
||
|
||
/**
|
||
* Routet eine frisch klassifizierte PM anhand des KI-Ergebnisses
|
||
* (Decision-Update §5.0, Entscheidung 12.06.2026). Wird vom
|
||
* ClassifyPressRelease-Job aufgerufen.
|
||
*
|
||
* - Rot → Ablehnung mit Begründung an den Autor
|
||
* - Gelb/Grün → automatische Veröffentlichung (sofort bzw. zum Termin);
|
||
* Gelb bleibt als interne Markierung erhalten (nicht
|
||
* boostbar, Admin-Signal), löst aber keine manuelle
|
||
* Prüfung aus
|
||
*
|
||
* Greift nur, solange die PM noch im Status `review` steht; manuelle
|
||
* Admin-Eingriffe in der Zwischenzeit haben damit Vorrang.
|
||
*
|
||
* `$expectedHash` ist die Prüfsumme des klassifizierten Inhalts (Audit
|
||
* N04): Rot/Hold werden nur für genau diese Fassung wirksam; hat ein
|
||
* Editor inzwischen korrigiert, greift unter der Sperre die gleiche
|
||
* Regel wie beim Publish (StaleClassificationException, Re-Check).
|
||
*
|
||
* @throws StaleClassificationException
|
||
*/
|
||
public function routeByClassification(PressRelease $pressRelease, PressReleaseClassification $classification, ?string $reason = null, ?string $expectedHash = null): void
|
||
{
|
||
if ($pressRelease->status !== PressReleaseStatus::Review) {
|
||
return;
|
||
}
|
||
|
||
if ($classification === PressReleaseClassification::Red) {
|
||
$max = max(1, (int) config('scoring.classification.max_automatic_attempts', 3));
|
||
|
||
// E3: Nach dem letzten erlaubten Rot nicht noch einmal ablehnen,
|
||
// sondern geblockt in die Admin-Queue — ab hier entscheidet ein
|
||
// Mensch, und die Automatik ist für diese Meldung aus.
|
||
if ($pressRelease->auto_check_attempts >= $max) {
|
||
$this->holdForManualReview($pressRelease, sprintf(
|
||
'Automatische Prüfung erschöpft (%d von %d): %s',
|
||
$pressRelease->auto_check_attempts,
|
||
$max,
|
||
$reason ?: 'Rot ohne Begründung.',
|
||
), automationExhausted: true, expectedHash: $expectedHash);
|
||
|
||
return;
|
||
}
|
||
|
||
$this->reject($pressRelease, $reason ?: 'Automatische Ablehnung durch die KI-Prüfung.', 'ki', $expectedHash);
|
||
|
||
return;
|
||
}
|
||
|
||
// Gelb geht durch (Entscheidung 16.09.2026) — außer der Schalter für
|
||
// die manuelle Queue ist bewusst eingeschaltet.
|
||
if ($classification === PressReleaseClassification::Yellow && config('scoring.classification.yellow_to_manual_queue')) {
|
||
$this->holdForManualReview($pressRelease, 'Gelb — manuelle Prüfung laut Konfiguration.', automationExhausted: false, expectedHash: $expectedHash);
|
||
|
||
return;
|
||
}
|
||
|
||
$this->autoPublishApproved($pressRelease);
|
||
}
|
||
|
||
/**
|
||
* Meldung bleibt in `review`, wird als „Prüfung nötig" markiert und
|
||
* wartet auf die Entscheidung im Admin. Kein Slot-Verbrauch. Der Autor
|
||
* bekommt eine kurze Mail „ein Mensch prüft jetzt" — ohne sie sähe er
|
||
* nach dem letzten Rot nur Stillstand statt einer Ablehnung.
|
||
*
|
||
* Unter Zeilensperre (Audit N04): Nur wenn die PM noch in `review` steht
|
||
* und – bei übergebener Prüfsumme – noch den geprüften Inhalt trägt.
|
||
*
|
||
* @throws StaleClassificationException
|
||
*/
|
||
private function holdForManualReview(PressRelease $pressRelease, string $reason, bool $automationExhausted, ?string $expectedHash = null): void
|
||
{
|
||
/** @var array{stale?: string, skipped?: true}|null $outcome */
|
||
$outcome = DB::transaction(function () use ($pressRelease, $reason, $expectedHash): ?array {
|
||
$locked = PressRelease::query()
|
||
->withoutGlobalScope(PortalScope::class)
|
||
->whereKey($pressRelease->getKey())
|
||
->lockForUpdate()
|
||
->firstOrFail();
|
||
|
||
if ($locked->status !== PressReleaseStatus::Review) {
|
||
return ['skipped' => true];
|
||
}
|
||
|
||
if ($this->classificationIsStale($locked, $expectedHash)) {
|
||
return ['stale' => (string) $locked->content_hash];
|
||
}
|
||
|
||
$locked->update(['manual_review_required_at' => now()]);
|
||
$this->logStatusChange($locked, PressReleaseStatus::Review, PressReleaseStatus::Review, $reason, 'ki');
|
||
|
||
return null;
|
||
});
|
||
|
||
$pressRelease->refresh();
|
||
|
||
if (isset($outcome['stale'])) {
|
||
$this->rescheduleForCurrentContent($pressRelease, $expectedHash, $outcome['stale']);
|
||
}
|
||
|
||
if ($outcome !== null) {
|
||
return;
|
||
}
|
||
|
||
$this->activityLog->record(
|
||
ActivityType::PressReleaseStatus,
|
||
sprintf('PM #%d wartet auf manuelle Prüfung: %s', $pressRelease->id, mb_substr($reason, 0, 160)),
|
||
subject: $pressRelease,
|
||
actorLabel: 'ki',
|
||
);
|
||
|
||
$this->notifyAuthor($pressRelease, 'held', automationExhausted: $automationExhausted);
|
||
}
|
||
|
||
/**
|
||
* Veröffentlicht eine als Gelb oder Grün klassifizierte PM automatisch.
|
||
*
|
||
* Liegt ein Veröffentlichungstermin in der Zukunft, übernimmt der
|
||
* Scheduler die Publikation zum Termin. Andernfalls wird sofort
|
||
* publiziert – optional mit einem Sicherheitsfenster
|
||
* (scoring.classification.green_delay_minutes).
|
||
*/
|
||
private function autoPublishApproved(PressRelease $pressRelease): void
|
||
{
|
||
if ($pressRelease->scheduled_at && $pressRelease->scheduled_at->isFuture()) {
|
||
return;
|
||
}
|
||
|
||
$delayMinutes = (int) config('scoring.classification.green_delay_minutes', 0);
|
||
$publishedAtOverride = $delayMinutes > 0 ? now()->addMinutes($delayMinutes) : null;
|
||
|
||
$this->publish($pressRelease, 'ki', $publishedAtOverride);
|
||
}
|
||
|
||
/**
|
||
* Quellen, die ohne menschliche Entscheidung veröffentlichen. Nur sie
|
||
* prüfen unter der Sperre, ob die freigebende Klassifikation noch zum
|
||
* Inhalt gehört (Audit U02); `admin` ist die bewusste Übersteuerung.
|
||
*/
|
||
private const AUTOMATIC_PUBLISH_SOURCES = ['ki', 'scheduler'];
|
||
|
||
/**
|
||
* @throws BlacklistViolationException Unzulässiges Wort — die PM wurde
|
||
* abgelehnt, der Autor benachrichtigt.
|
||
* @throws StaleClassificationException Nur bei automatischen Quellen
|
||
* (`ki`, `scheduler`): Die jüngste
|
||
* gültige Klassifikation gehört zu
|
||
* einer anderen Inhaltsversion als
|
||
* der gesperrten. Nichts geändert;
|
||
* eine Prüfung mit Routing für den
|
||
* aktuellen Stand ist eingeplant.
|
||
*/
|
||
public function publish(PressRelease $pressRelease, string $source = 'admin', ?Carbon $publishedAtOverride = null): void
|
||
{
|
||
/** @var array{blacklist?: array{reason: string, word: string}, stale?: array{analyzed: string|null, current: string}}|null $outcome */
|
||
$outcome = DB::transaction(function () use ($pressRelease, $source, $publishedAtOverride): ?array {
|
||
$locked = PressRelease::query()
|
||
->withoutGlobalScope(PortalScope::class)
|
||
->whereKey($pressRelease->getKey())
|
||
->lockForUpdate()
|
||
->firstOrFail();
|
||
|
||
$this->assertStatus($locked, [PressReleaseStatus::Review]);
|
||
$previous = $locked->status;
|
||
|
||
// Inhaltsbindung unter der Sperre (Audit U02): Der Vergleich im
|
||
// Job bzw. Scheduler liegt VOR der Sperre – hier zählt, was jetzt
|
||
// gesperrt ist. Innerhalb der Transaktion nichts ändern.
|
||
if (in_array($source, self::AUTOMATIC_PUBLISH_SOURCES, true)) {
|
||
$analyzedHash = $this->latestClassificationHash($locked);
|
||
|
||
if ($this->classificationIsStale($locked, $analyzedHash)) {
|
||
return ['stale' => ['analyzed' => $analyzedHash, 'current' => (string) $locked->content_hash]];
|
||
}
|
||
}
|
||
|
||
if ($word = $this->blacklist->findInPressRelease($locked)) {
|
||
$reason = sprintf('Automatische Ablehnung: unzulässiges Wort "%s" gefunden.', $word);
|
||
|
||
$locked->update(['status' => PressReleaseStatus::Rejected->value]);
|
||
$this->logStatusChange($locked, $previous, PressReleaseStatus::Rejected, $reason, 'blacklist');
|
||
|
||
return ['blacklist' => ['reason' => $reason, 'word' => $word]];
|
||
}
|
||
|
||
// Veröffentlichungsgate (Bildkennzeichnung E.1): kein Bild aus
|
||
// Formular v2 ohne gültige Bestätigung zur aktuellen Datei.
|
||
$this->assertImageRightsConfirmed($locked);
|
||
|
||
$this->consumePublishSlot($locked);
|
||
|
||
$locked->update([
|
||
'status' => PressReleaseStatus::Published->value,
|
||
'published_at' => $this->resolvePublishedAt($locked, $publishedAtOverride),
|
||
'published_ever_at' => $locked->published_ever_at ?? now(),
|
||
]);
|
||
|
||
$this->markImagesPublished($locked);
|
||
|
||
$this->logStatusChange($locked, $previous, PressReleaseStatus::Published, null, $source);
|
||
|
||
return null;
|
||
});
|
||
|
||
$pressRelease->refresh();
|
||
|
||
if ($outcome === null) {
|
||
$this->capturePublishedImages($pressRelease);
|
||
}
|
||
|
||
if (isset($outcome['stale'])) {
|
||
$this->rescheduleForCurrentContent($pressRelease, $outcome['stale']['analyzed'], $outcome['stale']['current']);
|
||
}
|
||
|
||
if (isset($outcome['blacklist'])) {
|
||
$this->notifyAuthor($pressRelease, 'rejected', $outcome['blacklist']['reason']);
|
||
|
||
throw new BlacklistViolationException(
|
||
$outcome['blacklist']['reason'],
|
||
$outcome['blacklist']['word'],
|
||
);
|
||
}
|
||
|
||
$this->assignCanonical($pressRelease);
|
||
|
||
$this->notifyAuthor($pressRelease, 'published');
|
||
}
|
||
|
||
/**
|
||
* Doppelveröffentlichung (Anhang 2, 1c.8): liegt derselbe Text der Firma
|
||
* schon auf dem anderen Portal, bestimmt jetzt das Portal die Erstquelle.
|
||
* Nebensache — darf die Veröffentlichung nie brechen.
|
||
*/
|
||
private function assignCanonical(PressRelease $pressRelease): void
|
||
{
|
||
try {
|
||
app(CanonicalAssigner::class)->assignFor($pressRelease);
|
||
} catch (\Throwable $e) {
|
||
report($e);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Gegenstück zu assignCanonical(): Verschwindet eine Erstquelle aus der
|
||
* öffentlichen Ansicht, bekommen ihre Kopien den Verweis nicht als Leiche
|
||
* mit — sie werden neu zugeordnet oder selbst Erstquelle (Sitemap).
|
||
*/
|
||
private function releaseCanonicalCopies(PressRelease $pressRelease): void
|
||
{
|
||
try {
|
||
app(CanonicalAssigner::class)->reassignCopiesOf($pressRelease);
|
||
} catch (\Throwable $e) {
|
||
report($e);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Prüfsumme der jüngsten gültigen (nicht verworfenen) Klassifikation.
|
||
* Null, wenn es keine gibt oder sie aus der Zeit vor der Bindung stammt.
|
||
*/
|
||
private function latestClassificationHash(PressRelease $pressRelease): ?string
|
||
{
|
||
return KiAudit::query()
|
||
->where('press_release_id', $pressRelease->id)
|
||
->where('type', KiAudit::TYPE_CLASSIFICATION)
|
||
->whereNull('discarded_at')
|
||
->orderByDesc('id')
|
||
->value('content_hash');
|
||
}
|
||
|
||
/**
|
||
* Gleiche Übergangsregel wie im Scheduler: Altbestand ohne Prüfsumme —
|
||
* auf der PM oder im Audit (auch: noch gar kein Audit) — gilt weiter.
|
||
* Nur eine vorhandene, abweichende Summe blockiert.
|
||
*/
|
||
private function classificationIsStale(PressRelease $pressRelease, ?string $analyzedHash): bool
|
||
{
|
||
return $analyzedHash !== null
|
||
&& $pressRelease->content_hash !== null
|
||
&& $analyzedHash !== $pressRelease->content_hash;
|
||
}
|
||
|
||
/**
|
||
* Gemeinsamer Ausgang von publish(), reject() und Hold, wenn die
|
||
* Klassifikation unter der Sperre nicht mehr zum Inhalt passt (U02, N04):
|
||
* Prüfung mit Routing für den aktuellen Stand einplanen und dem Aufrufer
|
||
* die Abweichung melden. Nichts an der PM geändert.
|
||
*
|
||
* @throws StaleClassificationException
|
||
*/
|
||
private function rescheduleForCurrentContent(PressRelease $pressRelease, ?string $analyzedHash, string $currentHash): never
|
||
{
|
||
ClassifyPressRelease::dispatch($pressRelease->id, route: true, contentHash: $currentHash)->onQueue('classification');
|
||
|
||
throw new StaleClassificationException($pressRelease->id, $analyzedHash, $currentHash);
|
||
}
|
||
|
||
/**
|
||
* Zählt beim ersten Übergang zu „published" einen PM-Slot des Eigentümers
|
||
* (Decision-Update §3.2: Slot-Verbrauch bei Veröffentlichung; abgelehnte
|
||
* PMs kosten nichts). Erneutes Publizieren — etwa nach Archivierung —
|
||
* zählt nicht doppelt; geprüft wird über die Status-Logs. Muss vor dem
|
||
* Schreiben des neuen Status-Logs aufgerufen werden.
|
||
*
|
||
* Verbrauchsreihenfolge: zuerst das Plan-Monatskontingent (Zähler
|
||
* `press_release_quota_used_this_month`), danach der älteste bezahlte
|
||
* Einzel-/Extra-PM-Kauf (wird mit der PM verknüpft und eingelöst).
|
||
* Unbegrenzte User (Bestandsschutz) verbrauchen nichts.
|
||
*/
|
||
private function consumePublishSlot(PressRelease $pressRelease): void
|
||
{
|
||
$alreadyPublishedOnce = PressReleaseStatusLog::query()
|
||
->where('press_release_id', $pressRelease->id)
|
||
->where('to_status', PressReleaseStatus::Published->value)
|
||
->exists();
|
||
|
||
if ($alreadyPublishedOnce) {
|
||
return;
|
||
}
|
||
|
||
$user = User::query()
|
||
->whereKey($pressRelease->user_id)
|
||
->lockForUpdate()
|
||
->first();
|
||
|
||
if (! $user || $user->hasUnlimitedPressReleaseQuota()) {
|
||
return;
|
||
}
|
||
|
||
$plan = $user->currentPlan();
|
||
|
||
if ($plan && $user->pressReleaseQuotaUsedThisMonth() < $plan->press_release_quota) {
|
||
// Periodenwechsel atomar unter der Zeilensperre: ein explizit
|
||
// ABWEICHENDER Monat → Zähler beginnt bei 1, sonst erhöhen
|
||
// (Audit F18). NULL (Altbestand vor der Periodenbindung) zählt
|
||
// wie der laufende Monat — dieselbe Lesart wie
|
||
// User::pressReleaseQuotaUsedThisMonth() (Audit U04).
|
||
$period = User::currentQuotaPeriod();
|
||
$continuesPeriod = $user->press_release_quota_period === null
|
||
|| $user->press_release_quota_period === $period;
|
||
|
||
$user->forceFill([
|
||
'press_release_quota_used_this_month' => $continuesPeriod
|
||
? (int) $user->press_release_quota_used_this_month + 1
|
||
: 1,
|
||
'press_release_quota_period' => $period,
|
||
])->save();
|
||
|
||
return;
|
||
}
|
||
|
||
$purchase = $user->singlePurchases()
|
||
->grantingSubmission()
|
||
->oldest('paid_at')
|
||
->lockForUpdate()
|
||
->first();
|
||
|
||
if ($purchase === null) {
|
||
throw new QuotaExceededException;
|
||
}
|
||
|
||
$purchase->update([
|
||
'status' => SinglePurchaseStatus::Consumed->value,
|
||
'consumed_at' => now(),
|
||
'press_release_id' => $pressRelease->id,
|
||
]);
|
||
}
|
||
|
||
/**
|
||
* Bestimmt das wirksame `published_at` einer PM.
|
||
*
|
||
* Reihenfolge:
|
||
* 1. Bereits gesetztes `published_at` bleibt erhalten (z.B. Re-Publish)
|
||
* 2. `scheduled_at` (geplanter Veröffentlichungstermin) hat Vorrang vor "jetzt"
|
||
* 3. `embargo_at` (Sperrfrist) verschiebt zusätzlich nach hinten — egal ob
|
||
* Scheduled vorhanden ist oder nicht
|
||
* 4. Fallback: now()
|
||
*
|
||
* Damit wirken sowohl Scheduling als auch Embargo automatisch über den
|
||
* vorhandenen Sichtbarkeits-Filter `where(published_at <= now())` im
|
||
* öffentlichen Listing.
|
||
*
|
||
* `$override` setzt einen abweichenden Sofort-Zeitpunkt (z.B. das
|
||
* Grün-Sicherheitsfenster) und wirkt nur, wenn kein `scheduled_at` gesetzt
|
||
* ist – ein geplanter Termin hat stets Vorrang.
|
||
*/
|
||
private function resolvePublishedAt(PressRelease $pressRelease, ?Carbon $override = null): Carbon
|
||
{
|
||
if ($pressRelease->published_at) {
|
||
return $pressRelease->published_at;
|
||
}
|
||
|
||
$base = $pressRelease->scheduled_at ?: ($override ?? now());
|
||
|
||
if ($pressRelease->embargo_at && $pressRelease->embargo_at->greaterThan($base)) {
|
||
return $pressRelease->embargo_at;
|
||
}
|
||
|
||
return $base;
|
||
}
|
||
|
||
/**
|
||
* @param string|null $expectedHash Prüfsumme des Inhalts, für den die
|
||
* Ablehnung gilt (KI-Rot, Audit N04).
|
||
* Trägt die gesperrte Zeile eine
|
||
* andere, wird nicht abgelehnt,
|
||
* sondern neu geprüft. Admin-Ablehnung
|
||
* übergibt nichts.
|
||
*
|
||
* @throws StaleClassificationException
|
||
*/
|
||
public function reject(PressRelease $pressRelease, ?string $reason = null, string $source = 'admin', ?string $expectedHash = null): void
|
||
{
|
||
/** @var string|null $staleCurrentHash */
|
||
$staleCurrentHash = DB::transaction(function () use ($pressRelease, $reason, $source, $expectedHash): ?string {
|
||
$locked = PressRelease::query()
|
||
->withoutGlobalScope(PortalScope::class)
|
||
->whereKey($pressRelease->getKey())
|
||
->lockForUpdate()
|
||
->firstOrFail();
|
||
|
||
$this->assertStatus($locked, [PressReleaseStatus::Review]);
|
||
$previous = $locked->status;
|
||
|
||
if ($this->classificationIsStale($locked, $expectedHash)) {
|
||
return (string) $locked->content_hash;
|
||
}
|
||
|
||
$locked->update(['status' => PressReleaseStatus::Rejected->value]);
|
||
$this->logStatusChange($locked, $previous, PressReleaseStatus::Rejected, $reason, $source);
|
||
|
||
return null;
|
||
});
|
||
|
||
$pressRelease->refresh();
|
||
|
||
if ($staleCurrentHash !== null) {
|
||
$this->rescheduleForCurrentContent($pressRelease, $expectedHash, $staleCurrentHash);
|
||
}
|
||
|
||
$this->notifyAuthor($pressRelease, 'rejected', $reason);
|
||
}
|
||
|
||
public function backToDraft(PressRelease $pressRelease): void
|
||
{
|
||
$this->assertStatus($pressRelease, [PressReleaseStatus::Review, PressReleaseStatus::Rejected]);
|
||
|
||
$previous = $pressRelease->status;
|
||
|
||
$pressRelease->update(['status' => PressReleaseStatus::Draft->value]);
|
||
$this->logStatusChange($pressRelease, $previous, PressReleaseStatus::Draft, null, 'admin');
|
||
}
|
||
|
||
public function archive(PressRelease $pressRelease): void
|
||
{
|
||
$this->assertStatus($pressRelease, [PressReleaseStatus::Published]);
|
||
|
||
$previous = $pressRelease->status;
|
||
|
||
$pressRelease->update(['status' => PressReleaseStatus::Archived->value, 'archive_pending_at' => now()]);
|
||
// Sichtbarkeitsregel (Roadmap 1b.1/1b.5): Ein Newsroom ist öffentlich
|
||
// nur mit mindestens einer veröffentlichten Meldung. Fällt die letzte
|
||
// weg, muss auch seine Seite sofort weg — nicht erst nach Ablauf des
|
||
// Seiten-Caches.
|
||
WebCaches::forgetPublicPages();
|
||
$this->logStatusChange($pressRelease, $previous, PressReleaseStatus::Archived, null, 'admin');
|
||
$this->archiveDepublished($pressRelease, ArchiveReasonCategory::OwnDecision);
|
||
}
|
||
|
||
/**
|
||
* Depublikation (T12): kostenpflichtige Entfernung aus der öffentlichen
|
||
* Ansicht auf Wunsch des Absenders. Die PM wechselt auf "archived" und
|
||
* erhält den Depublikations-Marker — die öffentliche Detail-URL zeigt
|
||
* fortan einen Tombstone (410).
|
||
*/
|
||
/**
|
||
* Depubliziert eine veröffentlichte PM (Tombstone bleibt öffentlich).
|
||
*
|
||
* Setzt IMMER die Re-Sync-Sperre — sonst würde der nächste Importer-Lauf
|
||
* die Entfernung überschreiben (Meldeverfahren §7). Aufrufer können über
|
||
* $syncLockReason einen spezifischeren Grund (z. B. die Vorgangsnummer)
|
||
* ins Sperr-Protokoll geben.
|
||
*/
|
||
public function depublish(PressRelease $pressRelease, ?string $syncLockReason = null): void
|
||
{
|
||
$this->assertStatus($pressRelease, [PressReleaseStatus::Published]);
|
||
|
||
$previous = $pressRelease->status;
|
||
|
||
$pressRelease->update([
|
||
'status' => PressReleaseStatus::Archived->value,
|
||
'depublished_at' => now(),
|
||
'archive_pending_at' => now(),
|
||
]);
|
||
$pressRelease->lockSync($syncLockReason ?? 'Depublikation auf Wunsch des Absenders');
|
||
$this->releaseCanonicalCopies($pressRelease);
|
||
WebCaches::forgetPublicPages();
|
||
$this->logStatusChange($pressRelease, $previous, PressReleaseStatus::Archived, 'Depublikation auf Wunsch des Absenders (kostenpflichtige Serviceleistung)', 'depublication');
|
||
$this->archiveDepublished(
|
||
$pressRelease,
|
||
$syncLockReason !== null ? ArchiveReasonCategory::ReportProcedure : ArchiveReasonCategory::CustomerRequest,
|
||
$syncLockReason,
|
||
);
|
||
}
|
||
|
||
public function changeStatusFromAdmin(PressRelease $pressRelease, PressReleaseStatus $status, ?string $reason = null): void
|
||
{
|
||
$previous = $pressRelease->status;
|
||
|
||
DB::transaction(function () use ($pressRelease, $status, $reason): void {
|
||
$locked = PressRelease::query()
|
||
->withoutGlobalScope(PortalScope::class)
|
||
->whereKey($pressRelease->getKey())
|
||
->lockForUpdate()
|
||
->firstOrFail();
|
||
$previous = $locked->status;
|
||
|
||
if ($status === PressReleaseStatus::Published && $previous !== PressReleaseStatus::Published) {
|
||
$this->assertImageRightsConfirmed($locked);
|
||
$this->consumePublishSlot($locked);
|
||
}
|
||
|
||
$locked->update([
|
||
'status' => $status->value,
|
||
'published_at' => $status === PressReleaseStatus::Published
|
||
? ($locked->published_at ?? now())
|
||
: $locked->published_at,
|
||
'published_ever_at' => $status === PressReleaseStatus::Published
|
||
? ($locked->published_ever_at ?? now())
|
||
: $locked->published_ever_at,
|
||
// Archivierung steht aus, bis der Eintrag geschrieben ist (N11).
|
||
'archive_pending_at' => $previous === PressReleaseStatus::Published && $status !== PressReleaseStatus::Published
|
||
? now()
|
||
: $locked->archive_pending_at,
|
||
]);
|
||
|
||
if ($status === PressReleaseStatus::Published) {
|
||
$this->markImagesPublished($locked);
|
||
}
|
||
|
||
if ($previous !== $status) {
|
||
$this->logStatusChange($locked, $previous, $status, $reason, 'admin');
|
||
}
|
||
|
||
if ($previous === PressReleaseStatus::Published && $status !== PressReleaseStatus::Published) {
|
||
WebCaches::forgetPublicPages();
|
||
}
|
||
});
|
||
|
||
$pressRelease->refresh();
|
||
|
||
if ($status === PressReleaseStatus::Published) {
|
||
$this->capturePublishedImages($pressRelease);
|
||
|
||
if ($previous !== PressReleaseStatus::Published) {
|
||
$this->assignCanonical($pressRelease);
|
||
}
|
||
} elseif ($previous === PressReleaseStatus::Published) {
|
||
$this->releaseCanonicalCopies($pressRelease);
|
||
$this->archiveDepublished($pressRelease, ArchiveReasonCategory::OwnDecision, $reason);
|
||
}
|
||
}
|
||
|
||
public function deleteFromAdmin(PressRelease $pressRelease): void
|
||
{
|
||
if ($pressRelease->status === PressReleaseStatus::Published) {
|
||
// Letzter veröffentlichter Stand VOR dem Überschreiben ins Archiv.
|
||
// Bewusst blockierend: ohne Archiveintrag kein Überschreiben.
|
||
app(PressReleaseArchiver::class)->pressReleaseDepublished($pressRelease, ArchiveReasonCategory::OwnDecision, Auth::user(), 'Entfernung durch den Admin');
|
||
|
||
$pressRelease->update([
|
||
'status' => PressReleaseStatus::Archived->value,
|
||
'text' => AdminPreset::activeValue(
|
||
AdminPreset::PRESS_RELEASE_DELETED_PUBLISHED_TEXT,
|
||
"Diese Pressemitteilung wurde entfernt.\n\nDer Inhalt ist nicht mehr verfuegbar."
|
||
),
|
||
'keywords' => null,
|
||
'backlink_url' => null,
|
||
'no_export' => true,
|
||
]);
|
||
$this->releaseCanonicalCopies($pressRelease);
|
||
WebCaches::forgetPublicPages();
|
||
|
||
return;
|
||
}
|
||
|
||
// Nie veröffentlicht: Bilder samt Original und Bestätigung sofort
|
||
// weg (Bildkennzeichnung E.3, Decision-Update E4).
|
||
$remover = app(PressReleaseImageRemover::class);
|
||
|
||
foreach ($pressRelease->images()->get() as $image) {
|
||
$remover->remove($image);
|
||
}
|
||
|
||
$pressRelease->delete();
|
||
}
|
||
|
||
/**
|
||
* Beweisarchiv (Block F.4): letzter veröffentlichter Stand, sobald eine
|
||
* Meldung das öffentliche Angebot verlässt. Der Marker
|
||
* `archive_pending_at` wurde in der fachlichen Transaktion gesetzt und
|
||
* fällt erst mit dem Eintrag; scheitert die Ablage, bleibt er stehen
|
||
* und `archive:retry-pending` holt den Eintrag nach (N11). Nur
|
||
* deleteFromAdmin() archiviert vor dem Überschreiben und bleibt
|
||
* blockierend.
|
||
*/
|
||
private function archiveDepublished(PressRelease $pressRelease, ArchiveReasonCategory $reason, ?string $note = null): void
|
||
{
|
||
try {
|
||
$entry = app(PressReleaseArchiver::class)->pressReleaseDepublished($pressRelease, $reason, Auth::user(), $note);
|
||
} catch (\Throwable $exception) {
|
||
Log::error('Beweisarchiv: Depublikation konnte nicht archiviert werden, wird nachgeholt.', [
|
||
'press_release_id' => $pressRelease->getKey(),
|
||
'error' => $exception->getMessage(),
|
||
]);
|
||
|
||
return;
|
||
}
|
||
|
||
if ($entry !== null && $pressRelease->archive_pending_at !== null) {
|
||
$pressRelease->forceFill(['archive_pending_at' => null])->save();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Veröffentlichungsgate (E.1): Bilder aus Formular v2 brauchen eine
|
||
* Bestätigung zur aktuellen Datei — sonst wartet ein Admin-Upload noch
|
||
* auf den Kunden (E10). Bestandsbilder sind nicht betroffen.
|
||
*/
|
||
private function assertImageRightsConfirmed(PressRelease $pressRelease): void
|
||
{
|
||
$unconfirmed = $pressRelease->images()
|
||
->whereNotNull('rules_version')
|
||
->with('latestRightsConfirmation')
|
||
->get()
|
||
->first(fn (PressReleaseImage $image): bool => ! $image->hasValidRightsConfirmation());
|
||
|
||
if ($unconfirmed !== null) {
|
||
throw new ImageRightsConfirmationRequiredException;
|
||
}
|
||
}
|
||
|
||
private function markImagesPublished(PressRelease $pressRelease): void
|
||
{
|
||
$pressRelease->images()->whereNull('published_ever_at')->update(['published_ever_at' => now()]);
|
||
}
|
||
|
||
/**
|
||
* Snapshot der veröffentlichten Bildfassung nach dem Commit (E.2).
|
||
*/
|
||
private function capturePublishedImages(PressRelease $pressRelease): void
|
||
{
|
||
app(PublishedImageSnapshot::class)->captureForPressRelease($pressRelease);
|
||
}
|
||
|
||
/**
|
||
* Entfernung mit 410 Gone: die Mitteilung verschwindet aus allen
|
||
* öffentlichen Listen, ihre Detail-URL liefert aber weiterhin einen
|
||
* Tombstone statt eines 404.
|
||
*
|
||
* Bewusste Abgrenzung zu deleteFromAdmin(): dort wird der Inhalt durch den
|
||
* Ersatztext überschrieben bzw. die PM soft-gelöscht. Hier bleibt der
|
||
* Datensatz unverändert erhalten, damit die Entfernung über
|
||
* restoreFromGone() umkehrbar und im Audit nachvollziehbar bleibt.
|
||
*
|
||
* Die Re-Sync-Sperre ist Pflicht — ohne sie würde der nächste
|
||
* Importer-Lauf die Entfernung wieder überschreiben.
|
||
*
|
||
* $flushPublicPages steuert den Auslieferungs-Cache. Der Flush verwirft
|
||
* ALLE Seiten-Caches auf einmal (siehe WebPageCache::flush) und ist damit
|
||
* genau einmal je Vorgang richtig — wer die Methode in einer Schleife
|
||
* aufruft, schaltet ihn ab und flusht selbst am Ende. Sonst zwingt jede
|
||
* einzelne Mitteilung die gesamte öffentliche Seite in den Neuaufbau.
|
||
*/
|
||
public function markGone(PressRelease $pressRelease, ?string $reason = null, bool $flushPublicPages = true): void
|
||
{
|
||
if ($pressRelease->gone_at !== null) {
|
||
return;
|
||
}
|
||
|
||
$previous = $pressRelease->status;
|
||
|
||
$pressRelease->update([
|
||
'status' => PressReleaseStatus::Archived->value,
|
||
'gone_at' => now(),
|
||
// Vorzustand sichern: `no_export` kann auch redaktionell oder vom
|
||
// Kunden gesetzt sein und ist in beiden Detailansichten sichtbar.
|
||
// Ohne diesen Merker stünde die Mitteilung nach dem Aufheben
|
||
// dauerhaft als „kein Export“ da, ohne dass das je jemand gewählt
|
||
// hätte.
|
||
'no_export_before_gone' => (bool) $pressRelease->no_export,
|
||
'no_export' => true,
|
||
]);
|
||
|
||
$pressRelease->lockSync($reason ?? 'Entfernung mit 410 (Tombstone)');
|
||
$this->releaseCanonicalCopies($pressRelease);
|
||
|
||
if ($flushPublicPages) {
|
||
WebCaches::forgetPublicPages();
|
||
}
|
||
|
||
$this->logStatusChange(
|
||
$pressRelease,
|
||
$previous,
|
||
PressReleaseStatus::Archived,
|
||
$reason ?? 'Aus der öffentlichen Ansicht entfernt (410 Gone)',
|
||
'gone',
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Hebt eine 410-Entfernung auf. Der Status bleibt bewusst „archived“ —
|
||
* ob die Mitteilung wieder veröffentlicht wird, entscheidet die Redaktion
|
||
* anschließend über den regulären Statuswechsel.
|
||
*
|
||
* `no_export` geht dagegen auf den Stand VOR der Entfernung zurück: Die
|
||
* Sperre gehört zur Entfernung, nicht zur Mitteilung. Fehlt der Merker
|
||
* (Entfernung aus der Zeit vor dieser Spalte), bleibt der aktuelle Wert
|
||
* stehen — raten wäre schlechter als nichts zu tun.
|
||
*
|
||
* Zu $flushPublicPages siehe markGone().
|
||
*/
|
||
public function restoreFromGone(PressRelease $pressRelease, bool $flushPublicPages = true): void
|
||
{
|
||
if ($pressRelease->gone_at === null) {
|
||
return;
|
||
}
|
||
|
||
$pressRelease->update([
|
||
'gone_at' => null,
|
||
'no_export' => $pressRelease->no_export_before_gone ?? $pressRelease->no_export,
|
||
'no_export_before_gone' => null,
|
||
]);
|
||
|
||
if ($flushPublicPages) {
|
||
WebCaches::forgetPublicPages();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param PressReleaseStatus[] $allowed
|
||
*/
|
||
private function assertStatus(PressRelease $pressRelease, array $allowed): void
|
||
{
|
||
if (! in_array($pressRelease->status, $allowed, true)) {
|
||
$allowedValues = implode(', ', array_map(fn ($s) => $s->value, $allowed));
|
||
$currentStatus = $pressRelease->status instanceof PressReleaseStatus
|
||
? $pressRelease->status->value
|
||
: (string) $pressRelease->status;
|
||
|
||
throw new \LogicException(
|
||
"Statusübergang nicht erlaubt. Aktueller Status: {$currentStatus}, erwartet: {$allowedValues}"
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* KI-Kennzeichnung vollständig? Pflicht sind der deklarierte KI-Grad des
|
||
* Textes, die verbindliche Bestätigung sowie eine Kennzeichnung für
|
||
* jedes Bild (Art. 50 KI-VO, Decision-Update 08.07.2026).
|
||
*/
|
||
private function assertAiDeclarationComplete(PressRelease $pressRelease): void
|
||
{
|
||
if ($pressRelease->ai_text_declaration === null || $pressRelease->ai_declaration_confirmed_at === null) {
|
||
throw new AiDeclarationRequiredException;
|
||
}
|
||
|
||
if ($pressRelease->images()->whereNull('ai_declaration')->exists()) {
|
||
throw new AiDeclarationRequiredException(
|
||
__('Bitte für jedes Bild die KI-Kennzeichnung angeben (Originalfoto, KI-generiert oder KI-bearbeitet) — im Bild-Manager der Bearbeiten-Seite.'),
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Schreibt den unveränderlichen Audit-Eintrag der aktuellen Deklaration —
|
||
* inkl. Bild-Snapshot zum Submit-Zeitpunkt.
|
||
*/
|
||
private function logAiDeclaration(PressRelease $pressRelease): void
|
||
{
|
||
$imageDeclarations = $pressRelease->images()
|
||
->orderBy('sort_order')
|
||
->get(['id', 'path', 'ai_declaration'])
|
||
->map(fn (PressReleaseImage $image): array => [
|
||
'image_id' => $image->id,
|
||
'path' => $image->path,
|
||
'declaration' => $image->ai_declaration?->value,
|
||
])
|
||
->values()
|
||
->all();
|
||
|
||
PressReleaseAiDeclaration::query()->create([
|
||
'press_release_id' => $pressRelease->id,
|
||
'user_id' => $pressRelease->user_id,
|
||
'company_id' => $pressRelease->company_id,
|
||
'text_declaration' => $pressRelease->ai_text_declaration?->value,
|
||
'image_declarations' => $imageDeclarations ?: null,
|
||
'confirmed_at' => $pressRelease->ai_declaration_confirmed_at,
|
||
'created_at' => now(),
|
||
]);
|
||
}
|
||
|
||
private function logStatusChange(
|
||
PressRelease $pressRelease,
|
||
?PressReleaseStatus $from,
|
||
PressReleaseStatus $to,
|
||
?string $reason,
|
||
string $source,
|
||
): void {
|
||
PressReleaseStatusLog::query()->create([
|
||
'press_release_id' => $pressRelease->id,
|
||
'changed_by_user_id' => Auth::id(),
|
||
'from_status' => $from?->value,
|
||
'to_status' => $to->value,
|
||
'reason' => $reason,
|
||
'source' => $source,
|
||
'created_at' => now(),
|
||
]);
|
||
|
||
// Aktivitäts-Verlauf: ohne eingeloggten Akteur (KI-Jobs, Scheduler)
|
||
// erscheint der Wechsel als „System".
|
||
$actor = Auth::user();
|
||
$actor = $actor instanceof User ? $actor : null;
|
||
|
||
$this->activityLog->record(
|
||
ActivityType::PressReleaseStatus,
|
||
sprintf(
|
||
'PM „%s“: %s → %s%s',
|
||
$pressRelease->title,
|
||
$from?->label() ?? 'Neu',
|
||
$to->label(),
|
||
$reason ? " — {$reason}" : '',
|
||
),
|
||
user: $actor,
|
||
subject: $pressRelease,
|
||
actorLabel: $actor?->name ?? 'System',
|
||
meta: [
|
||
'from' => $from?->value,
|
||
'to' => $to->value,
|
||
'source' => $source,
|
||
],
|
||
);
|
||
|
||
$this->adminCache->forgetPressReleaseStats();
|
||
}
|
||
|
||
private function notifyAuthor(PressRelease $pressRelease, string $event, ?string $reason = null, bool $automationExhausted = false): void
|
||
{
|
||
/** @var User|null $user */
|
||
$user = $pressRelease->user;
|
||
|
||
if (! $user || ! $user->email) {
|
||
return;
|
||
}
|
||
|
||
// API-Einlieferer (z. B. connektar) nicht zuspammen (Entscheidung
|
||
// 10.07.2026): Statt-Mail an den Pressekontakt der PM, sonst an die
|
||
// Firmen-E-Mail; nur ohne beides an den Einlieferer selbst. Marker
|
||
// ist die Quelle des letzten Review-Uebergangs im Status-Log — der
|
||
// Kontotyp ist nicht verlaesslich (connektar ist z. B. 'agency').
|
||
$recipient = $user->email;
|
||
$recipientName = $user->name;
|
||
$isApiSubmitter = $pressRelease->statusLogs()
|
||
->where('to_status', PressReleaseStatus::Review->value)
|
||
->orderByDesc('id')
|
||
->value('source') === 'api';
|
||
|
||
if ($isApiSubmitter) {
|
||
// Scope-frei auflösen: der Mail-Versand läuft auch aus Jobs/
|
||
// Kontexten ohne passenden Portal-Host (PortalScope). Anrede und
|
||
// Adresse gehören zusammen — sobald die Mail an Pressekontakt
|
||
// oder Firma geht, darf nie der Name des API-Kontos gegrüßt
|
||
// werden. Ohne hinterlegten Namen bleibt $recipientName leer,
|
||
// das Template grüßt dann neutral.
|
||
$contact = $pressRelease->contacts()
|
||
->withoutGlobalScope(PortalScope::class)
|
||
->whereNotNull('contacts.email')
|
||
->where('contacts.email', '!=', '')
|
||
->orderBy('contacts.id')
|
||
->first();
|
||
|
||
$company = Company::withoutGlobalScope(PortalScope::class)->find($pressRelease->company_id);
|
||
$companyName = trim((string) $company?->name);
|
||
|
||
// Gesperrte Adressen (Bounce-Suppression, 1b.6) überspringen:
|
||
// Kontakt → Firmen-E-Mail → sonst gar nicht. Nie zurück an den
|
||
// API-Einlieferer — der soll nicht zugespammt werden.
|
||
if ($contact && ! $this->suppressions->isSuppressed($contact->email)) {
|
||
$recipient = $contact->email;
|
||
$recipientName = trim($contact->first_name.' '.$contact->last_name) ?: $companyName;
|
||
} elseif ($company && filled($company->email) && ! $this->suppressions->isSuppressed($company->email)) {
|
||
$recipient = $company->email;
|
||
$recipientName = $companyName;
|
||
} else {
|
||
return;
|
||
}
|
||
}
|
||
|
||
// Opt-out-Gate: Benachrichtigungs-Mails sind je Typ abbestellbar
|
||
// (One-Click-Unsubscribe aus der Mail bzw. Präferenzen im Profil).
|
||
// Greift nur, wenn der Einlieferer selbst der Empfänger ist —
|
||
// Pressekontakt/Firma haben kein Konto mit Präferenzen. Der
|
||
// Zwischenstand „ein Mensch prüft" hängt am Typ „abgelehnt".
|
||
$notificationType = match ($event) {
|
||
'published' => EmailNotificationType::PressReleasePublished,
|
||
'rejected', 'held' => EmailNotificationType::PressReleaseRejected,
|
||
default => null,
|
||
};
|
||
|
||
if (! $notificationType) {
|
||
return;
|
||
}
|
||
|
||
if ($recipient === $user->email && ! $user->wantsEmailNotification($notificationType)) {
|
||
return;
|
||
}
|
||
|
||
$mailable = match ($event) {
|
||
'published' => new PressReleasePublished($user, $pressRelease, $recipientName, $recipient, $isApiSubmitter),
|
||
'held' => new PressReleaseHeldForReview($user, $pressRelease, $automationExhausted, $recipientName, $recipient),
|
||
default => new PressReleaseRejected($user, $pressRelease, $reason, $recipientName, $recipient),
|
||
};
|
||
|
||
Mail::to($recipient)->queue($mailable);
|
||
}
|
||
}
|