presseportale/app/Jobs/ClassifyPressRelease.php

<?php

namespace App\Jobs;

use App\Models\KiAudit;
use App\Models\PressRelease;
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).
 */
class ClassifyPressRelease implements ShouldQueue
{
    use Queueable;

    public int $tries = 3;

    /**
     * @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.
     */
    public function __construct(
        public readonly int $pressReleaseId,
        public readonly bool $route = true,
        public readonly ?string $providerOverride = null,
    ) {}

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

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

        $result = $this->classify($manager, $pressRelease);

        $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,
            '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);
        }
    }
}