conversion: Konversionsleiter mit Herkunft auf dem Magic-Link-Token (Block 0)

Die zu messende Strecke führt von einer Mail über presseecho.de per Magic Link
auf pressekonto.com und endet in einer Buchung — drei Wechsel, zwei Domains. Ein
cookiefreies Analytics-Tool verliert die Sitzung genau dort, wo die interessante
Konversion passiert. Claim, Registrierung und Buchung sind außerdem keine
Seitenaufrufe, sondern Zustandsänderungen in dieser Datenbank, bei denen die
Identität ohnehin bekannt ist. Deshalb eigene Ereignisdaten statt Umami; Umami
behält Seitenaufrufe und Suchbegriffe.

`conversion_events` hält Ereignistyp, Herkunft sowie Firmen- und Meldungsbezug
— keine Personen, keine Klartextadressen, keine IP. Der rote Faden durch den
Trichter ist die Firma; für die Frage "an welcher Stufe bricht es ab" reicht das
vollständig.

Der Kern ist die Herkunft auf dem Token (neue Spalte magic_links.source). Ohne
sie weiß die Auswertung am Ende, dass jemand gebucht hat, aber nicht, ob er aus
einer Ablehnungsmail kam. Eine Session überlebt den Domainwechsel nicht, das
Token schon. Die Mail-Links tragen zusätzlich `?src=` und `&pr=`; die
Meldungs-ID ist fälschbar, schaltet aber nichts frei und verfälscht im
schlimmsten Fall nur unsere eigene Statistik. Mit dem Magic-Link-Zugang aus 1b.2
entfällt sie.

Fünf Stufen statt gleichrangiger Punkte, jede mit ihrer Diagnose am Enum: Vier
beliebige Konversionspunkte sagen nicht, WO es hakt. Geschrieben wird an Stufe 1
(globale Middleware — die Mail-Links zeigen auf Hub, Spokes und öffentliche
Seiten, eine vergessene Route wäre eine unsichtbare Lücke), Stufe 2
(Magic-Link-Einlösung), Stufe 4 (Registrierung) und Stufe 5 (beide
Zahlungspfade, je Firma dedupliziert — eine zweite Buchung ist keine erste).
Stufe 3 ist definiert und wird ausgewertet; ihre Schreibstelle kommt mit der
Profilpflege aus 1b.3.

Für alle Schreibstellen gilt: Fehler werden geschluckt. Die Messung begleitet
einen Vorgang, sie ist nicht der Vorgang — eine kaputte Statistik darf keine
Anmeldung und erst recht keine Buchung scheitern lassen.

`conversion:funnel` zählt je Stufe die eindeutigen Firmen, nicht die Ereignisse:
Ein doppelter Klick ist kein doppelter Interessent, und nur mit derselben
Einheit auf allen Stufen ist ein Übergang überhaupt eine Quote. Ereignisse ohne
Firmenbezug stehen daneben statt im Nenner.

Aufbewahrung 395 Tage, zusammen mit der Tabelle festgelegt statt nachgetragen,
täglich im Scheduler bereinigt.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

app/Console/Commands/PurgeConversionEvents.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\ConversionEvent;
+use Illuminate\Console\Command;
+
+/**
+ * Begrenzt die Ereignisse der Konversionsleiter auf den Aufbewahrungszeitraum
+ * (Roadmap 0.7).
+ *
+ * Die Frist wurde zusammen mit der Tabelle festgelegt, nicht nachgetragen: 395
+ * Tage, derselbe Horizont wie beim Aufruf-Ereignis-Log. Anders als dort gibt es
+ * hier keine Wasserstandsmarke zu beachten — die Ereignisse werden nirgends
+ * aufsummiert, sie SIND die Auswertung. Wer ältere Zeiträume vergleichen will,
+ * muss den Report vorher laufen lassen und das Ergebnis festhalten.
+ */
+class PurgeConversionEvents extends Command
+{
+    protected $signature = 'conversion:purge-events
+        {--days= : Ereignisse älter als X Tage löschen (Standard: config conversion.events.retention_days)}
+        {--chunk=5000 : Zeilen je Durchgang}
+        {--dry-run : Nur zählen, nichts löschen}';
+
+    protected $description = 'Begrenzt die Ereignisse der Konversionsleiter auf den Aufbewahrungszeitraum.';
+
+    public function handle(): int
+    {
+        $days = (int) ($this->option('days') ?? config('conversion.events.retention_days'));
+
+        if ($days < 1) {
+            $this->error('Aufbewahrungszeitraum muss mindestens einen Tag betragen.');
+
+            return self::FAILURE;
+        }
+
+        $cutoff = now()->subDays($days);
+        $chunk = max(100, (int) $this->option('chunk'));
+
+        $expired = ConversionEvent::query()->where('created_at', '<', $cutoff);
+
+        if ($this->option('dry-run')) {
+            $this->info(sprintf(
+                '[Dry-Run] %d Ereignisse älter als %s.',
+                (clone $expired)->count(),
+                $cutoff->format('d.m.Y'),
+            ));
+
+            return self::SUCCESS;
+        }
+
+        $deleted = 0;
+
+        while (true) {
+            $removed = (clone $expired)->limit($chunk)->delete();
+
+            if ($removed === 0) {
+                break;
+            }
+
+            $deleted += $removed;
+        }
+
+        $this->info(sprintf(
+            'Konversions-Ereignisse bereinigt: %d Einträge vor dem %s gelöscht (Aufbewahrung %d Tage).',
+            $deleted,
+            $cutoff->format('d.m.Y'),
+            $days,
+        ));
+
+        return self::SUCCESS;
+    }
+}

app/Console/Commands/ReportConversionFunnel.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Services\Conversion\ConversionFunnelReport;
+use Illuminate\Console\Command;
+use Illuminate\Support\Carbon;
+
+/**
+ * Trichter je Herkunft und Zeitraum (Roadmap 0.6).
+ *
+ * Die Leiter beantwortet nicht „wie viele konvertieren", sondern „an welcher
+ * Stufe bricht es ab" — deshalb steht neben jeder Stufe, was ein Abbruch dort
+ * bedeutet.
+ */
+class ReportConversionFunnel extends Command
+{
+    protected $signature = 'conversion:funnel
+                            {--months=3 : Zeitraum in Monaten rückwärts}
+                            {--from= : Startdatum, überschreibt --months}
+                            {--to= : Enddatum (Standard: jetzt)}
+                            {--json : Ausgabe als JSON statt als Tabelle}';
+
+    protected $description = 'Konversionstrichter je Herkunft: Firmen je Stufe und Übergangsquoten.';
+
+    public function handle(ConversionFunnelReport $report): int
+    {
+        $to = $this->option('to') !== null ? Carbon::parse((string) $this->option('to')) : Carbon::now();
+        $from = $this->option('from') !== null
+            ? Carbon::parse((string) $this->option('from'))
+            : $to->copy()->subMonths(max(1, (int) $this->option('months')));
+
+        $data = $report->build($from, $to);
+
+        if ($this->option('json')) {
+            $this->line((string) json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES));
+
+            return self::SUCCESS;
+        }
+
+        $this->info("Konversionstrichter — {$data['from']} bis {$data['to']}");
+
+        if ($data['sources'] === []) {
+            $this->newLine();
+            $this->warn('Keine Ereignisse im Zeitraum. Herkunftsdaten lassen sich nicht rückwirkend erzeugen — '
+                .'wenn hier dauerhaft nichts steht, greift eine Schreibstelle nicht.');
+
+            return self::SUCCESS;
+        }
+
+        foreach ($data['sources'] as $source) {
+            $this->newLine();
+            $this->line("<comment>{$source['label']}</comment>");
+
+            $rows = [];
+
+            foreach ($source['steps'] as $step) {
+                $rows[] = [
+                    $step['step'],
+                    $step['label'],
+                    $step['firmen'],
+                    $step['uebergang'] === null ? '–' : $step['uebergang'].' %',
+                    $step['ohne_firma'] > 0 ? $step['ohne_firma'] : '',
+                    $step['diagnosis'],
+                ];
+            }
+
+            $this->table(
+                ['#', 'Stufe', 'Firmen', 'Übergang', 'ohne Firma', 'Ein Abbruch hier bedeutet'],
+                $rows,
+            );
+        }
+
+        $this->newLine();
+        $this->line('  Gezählt werden eindeutige Firmen je Stufe — ein doppelter Klick ist kein doppelter Interessent.');
+        $this->line('  „ohne Firma" steht daneben statt darin: Diese Ereignisse gehören nicht in eine Quote, deren Nenner Firmen sind.');
+
+        return self::SUCCESS;
+    }
+}

app/Enums/ConversionEventType.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace App\Enums;
+
+/**
+ * Stufen der Konversionsleiter (Roadmap Block 0).
+ *
+ * Bewusst eine Leiter und keine Liste gleichrangiger Punkte: Vier beliebige
+ * Konversionspunkte sagen nicht, WO es hakt. Erst die Stufenfolge macht den
+ * Abbruch lesbar — jede Stufe hat eine eigene Diagnose.
+ *
+ * Die Wiedereinreichung nach Ablehnung gehört ausdrücklich NICHT hierher. Sie
+ * misst etwas anderes, nämlich ob die Infoseite (1d) wirkt, und wird gegen den
+ * Basiswert aus 0.2 separat geführt (`press-releases:rejection-rate`).
+ */
+enum ConversionEventType: string
+{
+    case MailLinkClicked = 'mail_link_clicked';
+
+    case MagicLinkConsumed = 'magic_link_consumed';
+
+    case NewsroomEdited = 'newsroom_edited';
+
+    case AccountCreated = 'account_created';
+
+    case FirstBooking = 'first_booking';
+
+    /**
+     * Position in der Leiter. Bestimmt die Reihenfolge im Trichter.
+     */
+    public function step(): int
+    {
+        return match ($this) {
+            self::MailLinkClicked => 1,
+            self::MagicLinkConsumed => 2,
+            self::NewsroomEdited => 3,
+            self::AccountCreated => 4,
+            self::FirstBooking => 5,
+        };
+    }
+
+    public function label(): string
+    {
+        return match ($this) {
+            self::MailLinkClicked => 'Mail-Link geklickt',
+            self::MagicLinkConsumed => 'Magic Link eingelöst',
+            self::NewsroomEdited => 'Newsroom bearbeitet',
+            self::AccountCreated => 'Konto angelegt',
+            self::FirstBooking => 'Erste Buchung',
+        };
+    }
+
+    /**
+     * Was ein Abbruch auf dieser Stufe bedeutet — die Diagnose, wegen der die
+     * Leiter überhaupt als Leiter geführt wird.
+     */
+    public function diagnosis(): string
+    {
+        return match ($this) {
+            self::MailLinkClicked => 'Betreff oder Anlass trägt nicht',
+            self::MagicLinkConsumed => 'Der Verwaltungszugang wird nicht verstanden',
+            self::NewsroomEdited => 'Kein Anreiz, das Profil zu pflegen',
+            self::AccountCreated => 'Der Nutzen des Kontos ist nicht erkennbar',
+            self::FirstBooking => 'Preis oder Angebot passt nicht',
+        };
+    }
+
+    /**
+     * Die Leiter in ihrer Reihenfolge.
+     *
+     * @return list<self>
+     */
+    public static function ladder(): array
+    {
+        $cases = self::cases();
+
+        usort($cases, static fn (self $a, self $b): int => $a->step() <=> $b->step());
+
+        return $cases;
+    }
+}

app/Enums/ConversionSource.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Enums;
+
+/**
+ * Herkunft eines Konversionsereignisses (Roadmap Block 0).
+ *
+ * Der entscheidende Punkt: Der Wert wird auf dem MAGIC-LINK-TOKEN gespeichert,
+ * nicht in einer Session. Die zu messende Strecke führt über zwei Domains
+ * (presseecho.de → pressekonto.com), einen Mailclient und mögliche
+ * Weiterleitungen. Eine Session überlebt das nicht, ein Token schon. Ohne
+ * diesen Schritt wüsste man am Ende, dass jemand gebucht hat, aber nicht, ob er
+ * aus einer Ablehnungsmail kam — und genau das ist die Frage.
+ */
+enum ConversionSource: string
+{
+    case MailPublish = 'mail_publish';
+
+    case MailReject = 'mail_reject';
+
+    case ProfileClaim = 'profile_claim';
+
+    case Organic = 'organic';
+
+    public function label(): string
+    {
+        return match ($this) {
+            self::MailPublish => 'Veröffentlichungsmail',
+            self::MailReject => 'Ablehnungsmail',
+            self::ProfileClaim => 'Hinweis auf der Newsroom-Seite',
+            self::Organic => 'ohne zugeordnete Herkunft',
+        };
+    }
+
+    /**
+     * Auflösung eines Werts aus einer URL oder einem Token.
+     *
+     * Unbekannte Werte werden zu `organic` statt zu einem Fehler: Der Parameter
+     * steht in fremder Hand (Mailclient, Weiterleitung, manuell getippt) und
+     * darf niemals einen Request scheitern lassen.
+     */
+    public static function parse(?string $value): self
+    {
+        return self::tryFrom((string) $value) ?? self::Organic;
+    }
+}

app/Http/Controllers/Auth/MagicLinkConsumeController.php

@@ -2,15 +2,19 @@
 
 namespace App\Http\Controllers\Auth;
 
+use App\Enums\ConversionEventType;
 use App\Http\Controllers\Controller;
 use App\Listeners\RecordAuthActivity;
 use App\Models\MagicLink;
+use App\Services\Conversion\ConversionRecorder;
 use Illuminate\Http\RedirectResponse;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 
 class MagicLinkConsumeController extends Controller
 {
+    public function __construct(private readonly ConversionRecorder $recorder) {}
+
     public function __invoke(Request $request, string $token): RedirectResponse
     {
         $magicLink = MagicLink::query()
@@ -46,6 +50,14 @@ class MagicLinkConsumeController extends Controller
             return redirect()->route('login')->with('status', __('The magic login link has expired or was already used.'));
         }
 
+        // Stufe 2 der Konversionsleiter. Die Herkunft kommt vom Token, nicht
+        // aus der Session — die ist beim Weg über Mail und Domainwechsel
+        // längst gerissen (Roadmap 0.4).
+        $this->recorder->record(
+            ConversionEventType::MagicLinkConsumed,
+            $this->recorder->sourceOf($magicLink),
+        );
+
         $user = $magicLink->user;
 
         // 2FA aktiv: nicht direkt einloggen, sondern – wie der Passwort-Login –

app/Http/Middleware/RecordMailLinkClick.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use App\Enums\ConversionEventType;
+use App\Enums\ConversionSource;
+use App\Models\PressRelease;
+use App\Scopes\PortalScope;
+use App\Services\Conversion\ConversionRecorder;
+use Closure;
+use Illuminate\Http\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * Stufe 1 der Konversionsleiter: Mail-Link geklickt (Roadmap 0.5).
+ *
+ * Jeder Link in unseren Mails trägt `?src=<Herkunft>` und, wo es um eine
+ * konkrete Meldung geht, `&pr=<ID>`. Beides wird hier einmal beim Eintritt
+ * mitgeschrieben.
+ *
+ * Zur ID im Klartext: Sie ist fälschbar. Das ist hier vertretbar, weil sie
+ * nichts freischaltet — sie ordnet ein Ereignis in der internen Statistik
+ * einer Firma zu. Wer sie fälscht, verfälscht ausschließlich unsere eigene
+ * Auswertung. Sobald der Verwaltungszugang über Magic Link steht (1b.2),
+ * tragen die Mail-Links ohnehin ein Token, das Herkunft UND Meldung
+ * fälschungssicher mitführt; der `pr`-Parameter entfällt dann.
+ *
+ * Nur Herkünfte aus Mails lösen aus. `organic` würde sonst bei jedem
+ * getippten Parameter ein Ereignis erzeugen.
+ */
+class RecordMailLinkClick
+{
+    public function __construct(private readonly ConversionRecorder $recorder) {}
+
+    public function handle(Request $request, Closure $next): Response
+    {
+        $source = ConversionSource::parse($request->query('src') !== null ? (string) $request->query('src') : null);
+
+        if (! in_array($source, [ConversionSource::MailPublish, ConversionSource::MailReject], true)) {
+            return $next($request);
+        }
+
+        // Nur echte Aufrufe. Mailclients und Sicherheitsscanner holen Links
+        // vorab per HEAD; das wäre kein Klick, sondern eine Zustellung.
+        if (! $request->isMethod('GET')) {
+            return $next($request);
+        }
+
+        $pressRelease = $this->pressRelease($request);
+
+        $this->recorder->record(
+            ConversionEventType::MailLinkClicked,
+            $source,
+            $this->recorder->companyOf($pressRelease),
+            $pressRelease,
+        );
+
+        return $next($request);
+    }
+
+    /**
+     * Scope-frei aufgelöst: Der Klick landet je nach Link auf dem Hub oder auf
+     * einem der beiden Spokes, der Portal-Scope würde die Meldung dort
+     * wegfiltern.
+     */
+    private function pressRelease(Request $request): ?PressRelease
+    {
+        $id = (int) $request->query('pr');
+
+        if ($id <= 0) {
+            return null;
+        }
+
+        return PressRelease::query()
+            ->withoutGlobalScope(PortalScope::class)
+            ->find($id);
+    }
+}

app/Listeners/ProcessStripeWebhook.php

@@ -23,6 +23,7 @@ use App\Scopes\PortalScope;
 use App\Services\ActivityLog;
 use App\Services\Billing\CreditTopupService;
 use App\Services\Billing\InvoiceNumberGenerator;
+use App\Services\Conversion\ConversionRecorder;
 use App\Services\PressRelease\CorrectionService;
 use App\Services\PressRelease\CorrectionTooLargeException;
 use App\Services\PressRelease\PressReleaseService;
@@ -55,6 +56,7 @@ class ProcessStripeWebhook
     public function __construct(
         private readonly InvoiceNumberGenerator $numbers,
         private readonly ActivityLog $activityLog,
+        private readonly ConversionRecorder $conversions,
     ) {}
 
     public function handle(WebhookReceived $event): void
@@ -245,6 +247,12 @@ class ProcessStripeWebhook
             return;
         }
 
+        // Stufe 5 der Konversionsleiter: die erste bezahlte Rechnung eines
+        // Kontos. Deckt Abos und alle über Rechnung abgewickelten Zahlungen ab;
+        // Einmalkäufe melden zusätzlich in fulfillSinglePurchase(). Die Sperre
+        // je Firma sorgt dafür, dass trotzdem nur die erste Buchung zählt.
+        $this->conversions->recordFirstBooking($user);
+
         try {
             $invoice = DB::transaction(function () use ($user, $stripeInvoice, $stripeInvoiceId, $subtotal, $tax, $total): ?Invoice {
                 if (Invoice::query()->where('stripe_invoice_id', $stripeInvoiceId)->exists()) {
@@ -452,6 +460,11 @@ class ProcessStripeWebhook
 
         if ($result['marked_paid']) {
             Log::info('Einmalkauf als bezahlt markiert.', ['single_purchase_id' => $purchase->id]);
+
+            // Stufe 5 der Konversionsleiter. recordFirstBooking() zählt je
+            // Firma nur den ersten Treffer, deshalb dürfen beide Zahlungspfade
+            // melden, ohne sich gegenseitig zu verfälschen.
+            $this->conversions->recordFirstBooking($purchase->user);
         }
 
         if (($changedRelease = $result['changed_release']) !== null) {

app/Listeners/RecordAuthActivity.php

@@ -3,8 +3,11 @@
 namespace App\Listeners;
 
 use App\Enums\ActivityType;
+use App\Enums\ConversionEventType;
+use App\Enums\ConversionSource;
 use App\Models\User;
 use App\Services\ActivityLog;
+use App\Services\Conversion\ConversionRecorder;
 use Illuminate\Auth\Events\Login;
 use Illuminate\Auth\Events\Registered;
 
@@ -30,7 +33,10 @@ class RecordAuthActivity
         'impersonation' => 'Admin-Impersonation',
     ];
 
-    public function __construct(private readonly ActivityLog $activityLog) {}
+    public function __construct(
+        private readonly ActivityLog $activityLog,
+        private readonly ConversionRecorder $recorder,
+    ) {}
 
     public function recordRegistered(Registered $event): void
     {
@@ -46,6 +52,11 @@ class RecordAuthActivity
             user: $user,
             meta: ['way' => 'form'],
         );
+
+        // Stufe 4 der Konversionsleiter. Ohne Firmenbezug — beim Anlegen des
+        // Kontos steht noch keine fest; die Zuordnung entsteht erst, wenn ein
+        // Newsroom beansprucht wird.
+        $this->recorder->record(ConversionEventType::AccountCreated, ConversionSource::Organic);
     }
 
     public function recordLogin(Login $event): void

app/Mail/PressReleasePublished.php

@@ -2,6 +2,7 @@
 
 namespace App\Mail;
 
+use App\Enums\ConversionSource;
 use App\Enums\EmailNotificationType;
 use App\Mail\Concerns\Unsubscribable;
 use App\Models\PressRelease;
@@ -38,11 +39,20 @@ class PressReleasePublished extends Mailable
         ?string $recipientName = null,
     ) {
         $this->recipientName = $recipientName ?? $user->name;
-        $this->showUrl = $user->canAccessAdmin()
-            ? route('admin.press-releases.show', $pressRelease->id)
-            : route('me.press-releases.show', $pressRelease->id);
+        $this->showUrl = self::tagged(
+            $user->canAccessAdmin()
+                ? route('admin.press-releases.show', $pressRelease->id)
+                : route('me.press-releases.show', $pressRelease->id),
+            $pressRelease->id,
+        );
 
-        $this->portalLinks = $pressRelease->publicPortalLinks();
+        $this->portalLinks = array_map(
+            fn (array $link): array => [
+                ...$link,
+                'url' => self::tagged($link['url'], $pressRelease->id),
+            ],
+            $pressRelease->publicPortalLinks(),
+        );
 
         $this->configureUnsubscribe($user, EmailNotificationType::PressReleasePublished);
     }
@@ -58,4 +68,18 @@ class PressReleasePublished extends Mailable
     {
         return new Content(view: 'emails.press-release.published');
     }
+
+    /**
+     * Hängt Herkunft und Meldung an einen Mail-Link (Roadmap 0.4).
+     *
+     * Ohne diesen Schritt weiß die Auswertung am Ende, dass jemand gebucht hat,
+     * aber nicht, ob er aus dieser Mail kam — und genau das ist die Frage.
+     */
+    public static function tagged(string $url, int $pressReleaseId): string
+    {
+        return $url.(str_contains($url, '?') ? '&' : '?').http_build_query([
+            'src' => ConversionSource::MailPublish->value,
+            'pr' => $pressReleaseId,
+        ]);
+    }
 }

app/Mail/PressReleaseRejected.php

@@ -2,6 +2,7 @@
 
 namespace App\Mail;
 
+use App\Enums\ConversionSource;
 use App\Enums\EmailNotificationType;
 use App\Mail\Concerns\Unsubscribable;
 use App\Models\PressRelease;
@@ -31,10 +32,17 @@ class PressReleaseRejected extends Mailable
         ?string $recipientName = null,
     ) {
         $this->recipientName = $recipientName ?? $user->name;
-        $this->editUrl = $user->canAccessAdmin()
+        $editUrl = $user->canAccessAdmin()
             ? route('admin.press-releases.edit', $pressRelease->id)
             : route('me.press-releases.edit', $pressRelease->id);
 
+        // Herkunft und Meldung an den Link (Roadmap 0.4) — sonst ist später
+        // nicht unterscheidbar, ob eine Wiedereinreichung aus dieser Mail kam.
+        $this->editUrl = $editUrl.(str_contains($editUrl, '?') ? '&' : '?').http_build_query([
+            'src' => ConversionSource::MailReject->value,
+            'pr' => $pressRelease->id,
+        ]);
+
         $this->configureUnsubscribe($user, EmailNotificationType::PressReleaseRejected);
     }
 

app/Models/ConversionEvent.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace App\Models;
+
+use App\Enums\ConversionEventType;
+use App\Enums\ConversionSource;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+/**
+ * Einzelnes Ereignis der Konversionsleiter — reines Append-Log ohne
+ * Personenbezug.
+ *
+ * Geschrieben wird über `ConversionFunnel::record()`, nie direkt: Dort sitzt
+ * das Verschlucken von Fehlern. Eine Messung darf niemals einen Request
+ * scheitern lassen, den sie nur begleitet.
+ */
+class ConversionEvent extends Model
+{
+    public const ?string UPDATED_AT = null;
+
+    protected $fillable = [
+        'type',
+        'source',
+        'company_id',
+        'press_release_id',
+    ];
+
+    /**
+     * @return array<string, string>
+     */
+    protected function casts(): array
+    {
+        return [
+            'type' => ConversionEventType::class,
+            'source' => ConversionSource::class,
+        ];
+    }
+
+    /**
+     * @return BelongsTo<Company, $this>
+     */
+    public function company(): BelongsTo
+    {
+        return $this->belongsTo(Company::class);
+    }
+
+    /**
+     * @return BelongsTo<PressRelease, $this>
+     */
+    public function pressRelease(): BelongsTo
+    {
+        return $this->belongsTo(PressRelease::class);
+    }
+}

app/Models/MagicLink.php

@@ -11,6 +11,7 @@ class MagicLink extends Model
         'user_id',
         'token_hash',
         'purpose',
+        'source',
         'payload',
         'expires_at',
         'consumed_at',

app/Services/Auth/MagicLinkGenerator.php

@@ -2,6 +2,7 @@
 
 namespace App\Services\Auth;
 
+use App\Enums\ConversionSource;
 use App\Models\MagicLink;
 use App\Models\PressRelease;
 use App\Models\User;
@@ -13,8 +14,12 @@ class MagicLinkGenerator
     /**
      * @return array{magic_link: MagicLink, plain_token: string, expires_at: Carbon}
      */
-    public function createLoginLink(User $user, ?string $requestedIp = null, int $ttlMinutes = 15): array
-    {
+    public function createLoginLink(
+        User $user,
+        ?string $requestedIp = null,
+        int $ttlMinutes = 15,
+        ?ConversionSource $source = null,
+    ): array {
         $plainToken = Str::random(64);
         $tokenHash = hash('sha256', $plainToken);
         $expiresAt = now()->addMinutes($ttlMinutes);
@@ -31,6 +36,10 @@ class MagicLinkGenerator
         $magicLink = $user->magicLinks()->create([
             'token_hash' => $tokenHash,
             'purpose' => 'login',
+            // Herkunft gehört auf das Token, nicht in die Session: Die Strecke
+            // führt über zwei Domains und einen Mailclient, die Sitzung reißt
+            // dabei genau an der interessanten Stelle (Roadmap 0.4).
+            'source' => $source?->value,
             'expires_at' => $expiresAt,
             'ip_requested' => $requestedIp,
         ]);

app/Services/Conversion/ConversionFunnelReport.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace App\Services\Conversion;
+
+use App\Enums\ConversionEventType;
+use App\Enums\ConversionSource;
+use App\Models\ConversionEvent;
+use Illuminate\Support\Carbon;
+
+/**
+ * Der Trichter je Herkunft und Zeitraum (Roadmap 0.6).
+ *
+ * Gezählt wird je Stufe die Zahl der EINDEUTIGEN FIRMEN, nicht die Zahl der
+ * Ereignisse. Zwei Gründe: Ein doppelter Klick ist kein doppelter Interessent,
+ * und nur mit derselben Einheit auf allen Stufen ist der Übergang von einer
+ * Stufe zur nächsten überhaupt eine Quote.
+ *
+ * Ereignisse ohne Firmenbezug werden gesondert ausgewiesen statt mitgezählt.
+ * Sie sind nicht wertlos — „Konto angelegt" hat naturgemäß keine Firma —, aber
+ * sie gehören nicht in eine Quote, deren Nenner Firmen sind.
+ */
+class ConversionFunnelReport
+{
+    /**
+     * @return array{
+     *     from: string,
+     *     to: string,
+     *     sources: list<array{
+     *         source: string,
+     *         label: string,
+     *         steps: list<array{step: int, type: string, label: string, diagnosis: string, firmen: int, uebergang: float|null, ohne_firma: int}>,
+     *     }>,
+     * }
+     */
+    public function build(Carbon $from, ?Carbon $to = null): array
+    {
+        $to ??= Carbon::now();
+
+        $rows = ConversionEvent::query()
+            ->whereBetween('created_at', [$from, $to])
+            ->get(['type', 'source', 'company_id']);
+
+        $sources = [];
+
+        foreach (ConversionSource::cases() as $source) {
+            $forSource = $rows->where('source', $source);
+
+            if ($forSource->isEmpty()) {
+                continue;
+            }
+
+            $steps = [];
+            $previous = null;
+
+            foreach (ConversionEventType::ladder() as $type) {
+                $forType = $forSource->where('type', $type);
+
+                $companies = $forType
+                    ->pluck('company_id')
+                    ->filter(static fn ($id): bool => $id !== null)
+                    ->unique()
+                    ->count();
+
+                $steps[] = [
+                    'step' => $type->step(),
+                    'type' => $type->value,
+                    'label' => $type->label(),
+                    'diagnosis' => $type->diagnosis(),
+                    'firmen' => $companies,
+                    // Übergang von der VORIGEN Stufe. Die erste Stufe hat
+                    // keinen Vorgänger und damit keine Quote.
+                    'uebergang' => $previous === null || $previous === 0
+                        ? null
+                        : round($companies / $previous * 100, 1),
+                    'ohne_firma' => $forType->whereNull('company_id')->count(),
+                ];
+
+                $previous = $companies;
+            }
+
+            $sources[] = [
+                'source' => $source->value,
+                'label' => $source->label(),
+                'steps' => $steps,
+            ];
+        }
+
+        return [
+            'from' => $from->toDateString(),
+            'to' => $to->toDateString(),
+            'sources' => $sources,
+        ];
+    }
+}

app/Services/Conversion/ConversionRecorder.php

@@ -0,0 +1,138 @@
+<?php
+
+namespace App\Services\Conversion;
+
+use App\Enums\ConversionEventType;
+use App\Enums\ConversionSource;
+use App\Models\Company;
+use App\Models\ConversionEvent;
+use App\Models\MagicLink;
+use App\Models\PressRelease;
+use App\Models\User;
+use App\Scopes\PortalScope;
+
+/**
+ * Schreibt die Ereignisse der Konversionsleiter (Roadmap 0.5).
+ *
+ * Zwei Regeln, die für alle Schreibstellen gelten:
+ *
+ * 1. **Fehler werden geschluckt.** Die Messung begleitet einen Vorgang, sie ist
+ *    nicht der Vorgang. Eine kaputte Statistik darf keine Anmeldung, keinen
+ *    Magic Link und erst recht keine Buchung scheitern lassen.
+ * 2. **Kein Personenbezug.** Festgehalten werden Firma und Meldung, nie ein
+ *    Mensch. Der rote Faden durch den Trichter ist die Firma; für die Frage
+ *    „an welcher Stufe bricht es ab" reicht das vollständig.
+ */
+class ConversionRecorder
+{
+    public function record(
+        ConversionEventType $type,
+        ConversionSource $source,
+        ?Company $company = null,
+        ?PressRelease $pressRelease = null,
+    ): void {
+        try {
+            ConversionEvent::query()->create([
+                'type' => $type,
+                'source' => $source,
+                'company_id' => $company?->getKey(),
+                'press_release_id' => $pressRelease?->getKey(),
+            ]);
+        } catch (\Throwable $e) {
+            report($e);
+        }
+    }
+
+    /**
+     * Wie record(), aber höchstens einmal je Firma und Stufe.
+     *
+     * Für Stufen, deren Name eine Einmaligkeit behauptet — „Konto angelegt",
+     * „Erste Buchung". Eine zweite Buchung ist keine erste, und ein Ereignis,
+     * das bei jeder Zahlung mitschreibt, würde die Stufe unbrauchbar machen.
+     *
+     * Ohne Firmenbezug greift die Sperre nicht: Dann fehlt der Schlüssel, gegen
+     * den geprüft würde. Solche Ereignisse landen ohne Prüfung im Log und
+     * werden im Trichter ohnehin nur als Randnotiz geführt.
+     */
+    public function recordOnce(
+        ConversionEventType $type,
+        ConversionSource $source,
+        ?Company $company = null,
+        ?PressRelease $pressRelease = null,
+    ): void {
+        try {
+            if ($company !== null && $this->alreadyRecorded($type, $company)) {
+                return;
+            }
+        } catch (\Throwable $e) {
+            report($e);
+
+            return;
+        }
+
+        $this->record($type, $source, $company, $pressRelease);
+    }
+
+    /**
+     * Herkunft eines Magic-Link-Tokens.
+     *
+     * Genau hier zahlt sich die Entscheidung aus, den Wert auf dem Token statt
+     * in der Session zu führen: Der Domainwechsel zwischen Mail, Spoke und Hub
+     * hat die Sitzung längst zerrissen, das Token trägt die Herkunft trotzdem
+     * noch.
+     */
+    public function sourceOf(MagicLink $magicLink): ConversionSource
+    {
+        return ConversionSource::parse($magicLink->source);
+    }
+
+    /**
+     * Firma zu einer Meldung — scope-frei, weil die Schreibstellen auch aus
+     * Jobs und Webhooks ohne passenden Portal-Host laufen.
+     */
+    public function companyOf(?PressRelease $pressRelease): ?Company
+    {
+        if ($pressRelease?->company_id === null) {
+            return null;
+        }
+
+        return Company::query()
+            ->withoutGlobalScope(PortalScope::class)
+            ->find($pressRelease->company_id);
+    }
+
+    /**
+     * Stufe 5 der Konversionsleiter.
+     *
+     * Der Trichter läuft über die FIRMA, gezahlt wird aber vom Konto. Die
+     * Brücke ist die Firma des Kontos — bevorzugt die eigene, sonst die erste
+     * zugeordnete. Ohne Firma bleibt der Bezug leer; das Ereignis ist dann
+     * für die Trichter-Auswertung wertlos, aber immer noch eine ehrliche Zeile
+     * im Log.
+     */
+    public function recordFirstBooking(?User $user): void
+    {
+        if ($user === null) {
+            return;
+        }
+
+        try {
+            $company = $user->ownedCompanies()->withoutGlobalScope(PortalScope::class)->first()
+                ?? $user->companies()->withoutGlobalScope(PortalScope::class)->first();
+        } catch (\Throwable $e) {
+            report($e);
+
+            return;
+        }
+
+        $this->recordOnce(ConversionEventType::FirstBooking, ConversionSource::Organic, $company);
+    }
+
+    private function alreadyRecorded(ConversionEventType $type, Company $company): bool
+    {
+        return ConversionEvent::query()
+            ->where('type', $type->value)
+            ->where('company_id', $company->getKey())
+            ->exists();
+    }
+}