Stripe: Kundendaten, Rechnungsnummer, manueller Zahlungseingang

Rueckmeldung der Buchhaltung und des Stripe-Calls (dev/2026-08-26-stripe/):
Stripe kannte bisher nur die E-Mail des Kunden, Zahlungen waren im Dashboard
weder ueber die Bestell- noch ueber die Rechnungsnummer auffindbar, und ein
Zahlungseingang mit falschem Verwendungszweck zwang die Buchhaltung dazu, die
Rechnung von Hand zu schreiben.

- SE1: Der Checkout haengt einen Stripe-Customer mit Name, E-Mail und
  Rechnungsanschrift an die Session (customer statt customer_email); die ID
  liegt an shopping_users und wird wiederverwendet. Namensformat "Vorname
  Nachname (Firma)", reine Firmenkunden unter der Firma. Faellt die
  Customer-Anlage aus, laeuft der Checkout auf dem bisherigen Weg weiter.
  DSGVO-Loeschungen entfernen jetzt auch das Customer-Objekt; die Charges
  bleiben als Buchungsbeleg bestehen.
- SE2: StripeMetadataBuilder als einzige Quelle fuer Metadaten und die
  description (Bestellnummer, Referenz, Kundenname) - damit greift die
  Dashboard-Suche, die bisher nichts Lesbares zu fassen bekam.
- SE3: Die Rechnungsnummer entsteht erst nach der Zahlung und wird daher per
  Job am PaymentIntent nachgetragen (Vorab-Reservierung wuerde Luecken im
  Nummernkreis erzeugen). stripe:backfill-invoice-metadata traegt sie
  rueckwirkend ab dem Go-Live 2026-07-10 nach.
- SE4: Neuer Admin-Button "Zahlungseingang erfassen" an jeder unbezahlten
  Bestellung - bisher gab es ihn nur bei Rechnungskauf, und er setzte nur
  paid, ohne Rechnung, Punkte, Abo-Aktivierung oder Mail. Der neue Weg laeuft
  durch paymentStatusPaidAction, verlangt den Verwendungszweck als Beleg und
  laesst einen abweichenden Betrag nur mit ausdruecklicher Bestaetigung zu.
- S6.4 (aus dem Juli-Plan vorgezogen): stripe:sync-payment-status gleicht
  offene Zahlungen aktiv gegen die API ab. Aufgefallen beim Testlauf - ein nie
  zugestellter Webhook war bisher nicht reparierbar, das Geld lag bei Stripe
  waehrend die Bestellung auf offen stand. Laeuft stuendlich im Scheduler.
- 110 Tests (Pest) fuer alle Pfade, Stripe-Client durchgehend gemockt.

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

app/Console/Commands/StripeBackfillInvoiceMetadata.php

@@ -0,0 +1,107 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\ShoppingPayment;
+use App\Services\Payment\Stripe\StripeClientWrapper;
+use App\Services\Payment\Stripe\StripeInvoiceReferenceService;
+use Illuminate\Console\Command;
+
+/**
+ * Trägt die MIVITA-Rechnungsnummer an bestehenden Stripe-Zahlungen nach
+ * (Plan dev/2026-08-26-stripe/, Phase SE3.4).
+ *
+ * Stakeholder-Entscheid 2026-08-26 (F3): Die Zahlungen **seit dem Go-Live am
+ * 2026-07-10** sollen rückwirkend ihre Rechnungsnummer bekommen, damit die
+ * Buchhaltung auch die zurückliegenden Monate über die Berichte abstimmen kann.
+ */
+class StripeBackfillInvoiceMetadata extends Command
+{
+    /** Stripe ist seit diesem Datum live (siehe dev/2026-07-08-stripe/). */
+    private const GO_LIVE_DATE = '2026-07-10';
+
+    protected $signature = 'stripe:backfill-invoice-metadata
+        {--from= : Startdatum (Y-m-d), Standard: Go-Live 2026-07-10}
+        {--to= : Enddatum (Y-m-d), Standard: heute}
+        {--dry-run : Nichts an Stripe senden, nur anzeigen was passieren würde}
+        {--limit=0 : Maximale Anzahl bearbeiteter Zahlungen (0 = alle)}';
+
+    protected $description = 'Trägt Rechnungsnummern an bestehenden Stripe-Zahlungen nach (Phase SE3)';
+
+    public function handle(StripeClientWrapper $stripe, StripeInvoiceReferenceService $service): int
+    {
+        if (! $stripe->isConfigured()) {
+            $this->error('STRIPE_SECRET ist nicht gesetzt.');
+
+            return self::FAILURE;
+        }
+
+        $from = $this->option('from') ?: self::GO_LIVE_DATE;
+        $to = $this->option('to');
+        $dryRun = (bool) $this->option('dry-run');
+        $limit = (int) $this->option('limit');
+
+        $query = ShoppingPayment::where('payment_provider', 'stripe')
+            ->where('external_reference', 'LIKE', 'pi\_%')
+            ->where('created_at', '>=', $from.' 00:00:00')
+            ->whereHas('shopping_order.user_invoice')
+            ->with('shopping_order.user_invoice')
+            ->orderBy('id');
+
+        if ($to) {
+            $query->where('created_at', '<=', $to.' 23:59:59');
+        }
+
+        $total = $query->count();
+        $this->info(sprintf('%d Stripe-Zahlungen mit Rechnung ab %s gefunden.', $total, $from));
+
+        $synced = 0;
+        $skipped = 0;
+        $failed = 0;
+
+        $query->chunkById(50, function ($payments) use (&$synced, &$skipped, &$failed, $service, $dryRun, $limit): bool {
+            foreach ($payments as $payment) {
+                $invoice = $payment->shopping_order?->user_invoice;
+                if (! $invoice) {
+                    $skipped++;
+
+                    continue;
+                }
+
+                $this->line(sprintf(
+                    'Zahlung #%-7d %s → Rechnung %s',
+                    $payment->id,
+                    $payment->external_reference,
+                    $invoice->full_number,
+                ));
+
+                if ($dryRun) {
+                    $synced++;
+                } else {
+                    try {
+                        $service->sync($payment, $invoice) ? $synced++ : $skipped++;
+                    } catch (\Throwable $e) {
+                        $failed++;
+                        $this->error('  → '.$e->getMessage());
+                    }
+                }
+
+                if ($limit > 0 && ($synced + $skipped + $failed) >= $limit) {
+                    return false;
+                }
+            }
+
+            return true;
+        });
+
+        $this->info(sprintf(
+            '%s: %d übertragen, %d übersprungen (schon gesetzt / keine Rechnung), %d fehlgeschlagen.',
+            $dryRun ? 'Probelauf' : 'Fertig',
+            $synced,
+            $skipped,
+            $failed,
+        ));
+
+        return $failed > 0 ? self::FAILURE : self::SUCCESS;
+    }
+}