presseportale/app/Jobs/ClassifyPressRelease.php

<?php

namespace App\Jobs;

use App\Models\KiAudit;
use App\Models\PressRelease;
use App\Scopes\PortalScope;
use App\Services\PressRelease\BlacklistViolationException;
use App\Services\PressRelease\Classification\ClassificationManager;
use App\Services\PressRelease\Classification\ClassificationResult;
use App\Services\PressRelease\PressReleaseService;
use App\Services\PressRelease\QuotaExceededException;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Queue\Queueable;
use Illuminate\Support\Facades\Log;

/**
 * Klassifiziert eine Pressemitteilung asynchron (Red Flag, Konzept §15.1).
 *
 * Läuft auf der dedizierten Queue „classification". Nutzt den konfigurierten
 * KI-Treiber; bei Ausfall wird auf den deterministischen Treiber
 * zurückgefallen, damit eine Einreichung nie an einer KI-Störung hängen
 * bleibt. Ergebnis landet in `press_releases.classification`/`classified_at`
 * und als unveränderlicher Eintrag in `ki_audits`.
 *
 * Das Ergebnis wird gespeichert/auditiert und anschließend über
 * PressReleaseService::routeByClassification() in den Status überführt
 * (Rot→rejected, Gelb→review, Grün→publish).
 *
 * Inhaltsbindung (Audit F07): Der Job trägt die Prüfsumme des Inhalts zum
 * Zeitpunkt der Einplanung. Hat sich der Text während des KI-Aufrufs
 * geändert, wird das Ergebnis verworfen (Audit mit `discarded_at`) und ein
 * neuer Lauf für den aktuellen Stand eingeplant – ein altes Urteil darf
 * weder eine neue Version bewerten noch freigeben.
 */
class ClassifyPressRelease implements ShouldQueue
{
    use Queueable;

    public int $tries = 3;

    /**
     * Drei HTTP-Versuche à Timeout plus Verbindungsaufbau überschreiten die
     * 60 s des Workers; retry_after (config/queue.php) liegt darüber.
     */
    public int $timeout = 120;

    /**
     * @param  int  $pressReleaseId  Zu prüfende PM
     * @param  bool  $route  Ob das Ergebnis den Status steuert (Rot→reject,
     *                       Grün→publish). Beim regulären Einreichen `true`;
     *                       beim manuellen Admin-Re-Check `false` (nur
     *                       klassifizieren/auditieren, Status unverändert).
     * @param  string|null  $providerOverride  Optionaler abweichender Treiber
     *                                         (z. B. 'openai'|'deterministic') für diesen Lauf.
     * @param  string|null  $contentHash  Prüfsumme des Inhalts bei Einplanung;
     *                                    null → wird beim Start des Jobs gelesen
     *                                    (Admin-Re-Checks, Altbestand in der Queue).
     */
    public function __construct(
        public readonly int $pressReleaseId,
        public readonly bool $route = true,
        public readonly ?string $providerOverride = null,
        public readonly ?string $contentHash = null,
    ) {}

    public function handle(ClassificationManager $manager, PressReleaseService $service): void
    {
        $pressRelease = PressRelease::withoutGlobalScope(PortalScope::class)->find($this->pressReleaseId);

        if ($pressRelease === null) {
            return;
        }

        $analyzedHash = $this->contentHash ?? $pressRelease->content_hash;
        $result = $this->classify($manager, $pressRelease);

        // Inhalt seit der Einplanung geändert? Dann gilt das Urteil für einen
        // Text, den es nicht mehr gibt: verwerfen und den aktuellen prüfen.
        $currentHash = PressRelease::withoutGlobalScope(PortalScope::class)->whereKey($pressRelease->id)->value('content_hash');

        if ($analyzedHash !== null && $currentHash !== null && $currentHash !== $analyzedHash) {
            KiAudit::query()->create([
                'press_release_id' => $pressRelease->id,
                'type' => KiAudit::TYPE_CLASSIFICATION,
                'provider' => $result->provider,
                'model' => $result->model,
                'result' => $result->classification->value,
                'reason' => 'Verworfen: Inhalt wurde während der Prüfung geändert. '.$result->reasonText(),
                'raw_response' => $result->rawResponse,
                'content_hash' => $analyzedHash,
                'discarded_at' => now(),
                'created_at' => now(),
            ]);

            self::dispatch($pressRelease->id, $this->route, $this->providerOverride, $currentHash)->onQueue('classification');

            return;
        }

        $pressRelease->forceFill([
            'classification' => $result->classification->value,
            'classified_at' => now(),
        ])->save();

        KiAudit::query()->create([
            'press_release_id' => $pressRelease->id,
            'type' => KiAudit::TYPE_CLASSIFICATION,
            'provider' => $result->provider,
            'model' => $result->model,
            'result' => $result->classification->value,
            'reason' => $result->reasonText(),
            'raw_response' => $result->rawResponse,
            'content_hash' => $analyzedHash,
            'created_at' => now(),
        ]);

        if (! $this->route) {
            return;
        }

        try {
            $service->routeByClassification($pressRelease, $result->classification, $result->reasonText());
        } catch (BlacklistViolationException) {
            // publish() hat die PM bereits abgelehnt und den Autor benachrichtigt.
        } catch (QuotaExceededException $exception) {
            // Kontingent zwischen Einreichung und KI-Freigabe aufgebraucht: PM
            // bleibt in Review, damit Autor/Admin bewusst entscheiden — kein
            // Job-Retry, der die Klassifikation sinnlos wiederholt.
            Log::info('Auto-Veröffentlichung übersprungen: PM-Kontingent aufgebraucht, PM bleibt in Review.', [
                'press_release_id' => $pressRelease->id,
            ]);
        }
    }

    /**
     * Klassifiziert über den aktiven (oder explizit gewählten) Treiber; bei
     * Fehler greift der deterministische Fallback, damit das Ergebnis
     * nachvollziehbar bleibt.
     */
    private function classify(ClassificationManager $manager, PressRelease $pressRelease): ClassificationResult
    {
        $provider = $this->providerOverride ?: $manager->getDefaultDriver();

        try {
            return $manager->driver($provider)->classify($pressRelease);
        } catch (\Throwable $exception) {
            Log::warning('KI-Klassifikation fiel auf den deterministischen Treiber zurück.', [
                'press_release_id' => $pressRelease->id,
                'provider' => $provider,
                'error' => $exception->getMessage(),
            ]);

            return $manager->driver('deterministic')->classify($pressRelease);
        }
    }
}