14-04-2026

app/Http/Controllers/Admin/PaymentDashboardController.php

@@ -0,0 +1,568 @@
+<?php
+
+namespace App\Http\Controllers\Admin;
+
+use App\Http\Controllers\Controller;
+use App\Http\Requests\PaymentIncident\AddIncidentActivityRequest;
+use App\Http\Requests\PaymentIncident\StorePaymentIncidentRequest;
+use App\Http\Requests\PaymentIncident\UpdateIncidentStatusRequest;
+use App\Mail\PaymentIncidentAlert;
+use App\Models\CheckoutFunnelEvent;
+use App\Models\IncidentActivity;
+use App\Models\PaymentIncident;
+use App\Models\PaymentTransaction;
+use App\Models\ProviderUptimeLog;
+use App\Models\ShoppingOrder;
+use App\Models\ShoppingPayment;
+use App\Services\MyLog;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Mail;
+use Illuminate\View\View;
+
+class PaymentDashboardController extends Controller
+{
+    public function __construct()
+    {
+        $this->middleware('admin');
+    }
+
+    /**
+     * Entwickler-Ansicht mit allen Incidents, Live-Transaktionen und Logs.
+     */
+    public function index(): View
+    {
+        $stats = $this->getIncidentStats();
+        $transactionStats = $this->getTransactionStats(7);
+        $openIncidents = PaymentIncident::open()->with('activities')->orderBy('detected_at', 'desc')->get();
+        $allIncidents = PaymentIncident::with('activities')->orderBy('detected_at', 'desc')->paginate(20);
+        $providerStats = $this->getProviderStats();
+        $uptimeStats = $this->getUptimeStats();
+
+        return view('admin.payment-dashboard.index', compact(
+            'stats',
+            'transactionStats',
+            'openIncidents',
+            'allIncidents',
+            'providerStats',
+            'uptimeStats',
+        ));
+    }
+
+    /**
+     * GF-Ansicht: vereinfacht, nur lesen. Nur für Super-Admins (admin >= 3).
+     */
+    public function management(): View
+    {
+        abort_unless(auth()->user()->isSuperAdmin(), 403);
+        $stats = $this->getIncidentStats();
+        $transactionStats = $this->getTransactionStats(30);
+        $openIncidents = PaymentIncident::open()->orderBy('detected_at', 'desc')->get();
+        $recentIncidents = PaymentIncident::orderBy('detected_at', 'desc')->take(10)->get();
+        $providerStats = $this->getProviderStats();
+
+        return view('admin.payment-dashboard.management', compact(
+            'stats',
+            'transactionStats',
+            'openIncidents',
+            'recentIncidents',
+            'providerStats',
+        ));
+    }
+
+    /**
+     * Incident-Detail mit Timeline.
+     */
+    public function show(PaymentIncident $incident): View
+    {
+        $incident->load('activities');
+
+        return view('admin.payment-dashboard.show', compact('incident'));
+    }
+
+    /**
+     * Neuen Incident anlegen.
+     */
+    public function store(StorePaymentIncidentRequest $request): RedirectResponse
+    {
+        $incident = PaymentIncident::create($request->validated());
+
+        IncidentActivity::create([
+            'incident_id' => $incident->id,
+            'type' => 'note',
+            'title' => 'Incident eröffnet',
+            'content' => $request->validated('description'),
+            'author' => auth()->user()->name ?? 'System',
+        ]);
+
+        if ($incident->severity === 'critical') {
+            MyLog::writeLog(
+                'payment',
+                'error',
+                'Kritischer Zahlungs-Incident eröffnet: '.$incident->title,
+                $request->validated(),
+            );
+
+            Mail::to(config('app.exception_mail'))
+                ->queue(new PaymentIncidentAlert($incident));
+        }
+
+        $this->invalidateIncidentCache();
+
+        return redirect()->route('admin.payment-dashboard.index')
+            ->with('success', 'Incident erfolgreich angelegt.');
+    }
+
+    /**
+     * Aktivität zu einem Incident hinzufügen.
+     */
+    public function addActivity(AddIncidentActivityRequest $request, PaymentIncident $incident): RedirectResponse
+    {
+        IncidentActivity::create([
+            'incident_id' => $incident->id,
+            'type' => $request->validated('type'),
+            'title' => $request->validated('title'),
+            'content' => $request->validated('content'),
+            'author' => auth()->user()->name ?? 'System',
+        ]);
+
+        if ($incident->status === 'open') {
+            $incident->update(['status' => 'in_progress']);
+            $this->invalidateIncidentCache();
+        }
+
+        return back()->with('success', 'Aktivität hinzugefügt.');
+    }
+
+    /**
+     * Status eines Incidents ändern.
+     */
+    public function updateStatus(UpdateIncidentStatusRequest $request, PaymentIncident $incident): RedirectResponse
+    {
+
+        $oldLabel = $incident->status_label;
+        $incident->update([
+            'status' => $request->status,
+            'resolved_at' => in_array($request->status, ['resolved', 'closed']) ? now() : null,
+        ]);
+
+        IncidentActivity::create([
+            'incident_id' => $incident->id,
+            'type' => 'status_change',
+            'title' => 'Status geändert: '.$oldLabel.' → '.$incident->fresh()->status_label,
+            'author' => auth()->user()->name ?? 'System',
+        ]);
+
+        $this->invalidateIncidentCache();
+
+        return back()->with('success', 'Status aktualisiert.');
+    }
+
+    /**
+     * Live-Transaktionsdaten aus payment_transactions.
+     */
+    public function transactions(): View
+    {
+        $days = request()->integer('days', 7);
+        $txactionFilter = request()->string('txaction', '');
+
+        $query = PaymentTransaction::with('shopping_payment')
+            ->orderBy('created_at', 'desc');
+
+        if ($days > 0) {
+            $query->where('created_at', '>=', now()->subDays($days));
+        }
+
+        if ($txactionFilter && $txactionFilter !== '') {
+            $query->where('txaction', $txactionFilter);
+        }
+
+        $transactions = $query->paginate(30)->withQueryString();
+        $transactionStats = $this->getTransactionStats($days > 0 ? $days : 30);
+
+        return view('admin.payment-dashboard.transactions', compact('transactions', 'transactionStats', 'days', 'txactionFilter'));
+    }
+
+    /**
+     * Checkout-Funnel-Tracking: Übersicht der 5 Funnel-Schritte.
+     */
+    public function funnel(): View
+    {
+        $days = request()->integer('days', 30);
+        $since = $days > 0 ? now()->subDays($days) : null;
+        $filterEvent = request()->string('event', '');
+        $filterStatus = request()->string('return_status', '');
+        $filterSource = request()->string('source', '');
+
+        // ── Funnel-Schritte ──────────────────────────────────────────────────
+        $steps = ['checkout_visited', 'form_submitted', 'payment_initiated', 'payment_returned', 'payment_confirmed'];
+
+        $counts = CheckoutFunnelEvent::query()
+            ->when($since, fn ($q) => $q->where('created_at', '>=', $since))
+            ->selectRaw('event, COUNT(*) as count')
+            ->groupBy('event')
+            ->pluck('count', 'event');
+
+        $funnelSteps = array_map(fn (string $step) => [
+            'event' => $step,
+            'label' => CheckoutFunnelEvent::eventLabels()[$step],
+            'count' => (int) ($counts[$step] ?? 0),
+        ], $steps);
+
+        foreach ($funnelSteps as $i => &$step) {
+            if ($i === 0 || $funnelSteps[$i - 1]['count'] === 0) {
+                $step['conversion'] = null;
+            } else {
+                $step['conversion'] = round($step['count'] / $funnelSteps[$i - 1]['count'] * 100, 1);
+            }
+        }
+        unset($step);
+
+        // ── Rückkehr-Status ───────────────────────────────────────────────────
+        $returnStats = CheckoutFunnelEvent::query()
+            ->where('event', 'payment_returned')
+            ->when($since, fn ($q) => $q->where('created_at', '>=', $since))
+            ->selectRaw('return_status, COUNT(*) as count')
+            ->groupBy('return_status')
+            ->pluck('count', 'return_status');
+
+        // ── Quelle (Source) Breakdown ─────────────────────────────────────────
+        // Klassifizierung über Domain-Präfix direkt in SQL
+        $sourceRaw = CheckoutFunnelEvent::query()
+            ->where('event', 'checkout_visited')
+            ->when($since, fn ($q) => $q->where('created_at', '>=', $since))
+            ->selectRaw("
+                CASE
+                    WHEN domain LIKE 'my.%'           THEN 'salescenter'
+                    WHEN domain LIKE 'in.%'           THEN 'beraterzugang'
+                    WHEN domain LIKE '%.test'         THEN 'testserver'
+                    WHEN domain LIKE '%.care'
+                      OR domain LIKE '%.shop'         THEN 'kundenshop'
+                    ELSE 'unbekannt'
+                END AS source_type,
+                COUNT(*) as count
+            ")
+            ->groupBy('source_type')
+            ->pluck('count', 'source_type');
+
+        $sourceBreakdown = collect(CheckoutFunnelEvent::sourceLabels())
+            ->map(fn ($label, $key) => [
+                'label' => $label,
+                'count' => (int) ($sourceRaw[$key] ?? 0),
+            ])
+            ->filter(fn ($s) => $s['count'] > 0);
+
+        // ── Ereignisse (gefiltert, paginiert) ─────────────────────────────────
+        $eventsQuery = CheckoutFunnelEvent::with(['shopping_order', 'consultant'])
+            ->when($since, fn ($q) => $q->where('created_at', '>=', $since))
+            ->when($filterEvent !== '', fn ($q) => $q->where('event', $filterEvent))
+            ->when($filterStatus !== '', fn ($q) => $q->where('return_status', $filterStatus))
+            ->when($filterSource !== '', function ($q) use ($filterSource) {
+                return match ($filterSource) {
+                    'salescenter' => $q->where('domain', 'like', 'my.%'),
+                    'beraterzugang' => $q->where('domain', 'like', 'in.%'),
+                    'testserver' => $q->where('domain', 'like', '%.test'),
+                    'kundenshop' => $q->where(fn ($s) => $s->where('domain', 'like', '%.care')->orWhere('domain', 'like', '%.shop')),
+                    default => $q,
+                };
+            })
+            ->latest();
+
+        $recentEvents = $eventsQuery->paginate(50)->withQueryString();
+
+        return view('admin.payment-dashboard.funnel', compact(
+            'funnelSteps',
+            'returnStats',
+            'sourceBreakdown',
+            'recentEvents',
+            'days',
+            'filterEvent',
+            'filterStatus',
+            'filterSource',
+        ));
+    }
+
+    /**
+     * Abbruch-Analyse: Orders ohne Payment, abgebrochene und nicht bestätigte Payments.
+     */
+    public function abandoned(): View
+    {
+        $days = request()->integer('days', 30);
+        $since = $days > 0 ? now()->subDays($days) : null;
+
+        // Tab 1: Orders mit txaction='prev' ohne ShoppingPayment – Zahlung nie gestartet
+        // Mindestens 30 Minuten alt, damit laufende Checkouts nicht erscheinen
+        $ordersWithoutPayment = ShoppingOrder::with(['auth_user', 'shopping_user'])
+            ->where('txaction', 'prev')
+            ->doesntHave('shopping_payments')
+            ->where('created_at', '<=', now()->subMinutes(30))
+            ->when($since, fn ($q) => $q->where('created_at', '>=', $since))
+            ->orderBy('created_at', 'desc')
+            ->paginate(20, ['*'], 'page_no_payment')
+            ->withQueryString();
+
+        // Tab 2: ShoppingPayments mit status = 'cancel' oder 'error'
+        $cancelledPayments = ShoppingPayment::with([
+            'shopping_order.auth_user',
+            'shopping_order.shopping_user',
+            'payment_transactions',
+        ])
+            ->whereIn('status', ['cancel', 'error'])
+            ->when($since, fn ($q) => $q->where('created_at', '>=', $since))
+            ->orderBy('created_at', 'desc')
+            ->paginate(20, ['*'], 'page_cancelled')
+            ->withQueryString();
+
+        // Tab 3: ShoppingPayments ohne status (kein Callback) – mindestens 2 Stunden alt
+        $pendingPayments = ShoppingPayment::with([
+            'shopping_order.auth_user',
+            'shopping_order.shopping_user',
+            'payment_transactions',
+        ])
+            ->whereNull('status')
+            ->doesntHave('payment_transactions')
+            ->where('created_at', '<=', now()->subHours(2))
+            ->when($since, fn ($q) => $q->where('created_at', '>=', $since))
+            ->orderBy('created_at', 'desc')
+            ->paginate(20, ['*'], 'page_pending')
+            ->withQueryString();
+
+        $abandonedStats = [
+            'no_payment' => ShoppingOrder::where('txaction', 'prev')
+                ->doesntHave('shopping_payments')
+                ->where('created_at', '<=', now()->subMinutes(30))
+                ->when($since, fn ($q) => $q->where('created_at', '>=', $since))
+                ->count(),
+            'cancelled' => ShoppingPayment::whereIn('status', ['cancel', 'error'])
+                ->when($since, fn ($q) => $q->where('created_at', '>=', $since))
+                ->count(),
+            'no_callback' => ShoppingPayment::whereNull('status')
+                ->doesntHave('payment_transactions')
+                ->where('created_at', '<=', now()->subHours(2))
+                ->when($since, fn ($q) => $q->where('created_at', '>=', $since))
+                ->count(),
+        ];
+
+        return view('admin.payment-dashboard.abandoned', compact(
+            'ordersWithoutPayment',
+            'cancelledPayments',
+            'pendingPayments',
+            'abandonedStats',
+            'days',
+        ));
+    }
+
+    /**
+     * Zahlung-zentrierte Übersicht: ShoppingPayments mit Transaktionen und Bestellung.
+     */
+    public function payments(): View
+    {
+        $days = request()->integer('days', 7);
+        $statusFilter = request()->string('txaction', '')->toString();
+        $modeFilter = request()->string('mode', '')->toString();
+
+        $query = ShoppingPayment::with([
+            'payment_transactions' => fn ($q) => $q->orderBy('created_at'),
+            'shopping_order.auth_user',
+            'shopping_order.shopping_user',
+        ])->orderBy('created_at', 'desc');
+
+        if ($days > 0) {
+            $query->where('created_at', '>=', now()->subDays($days));
+        }
+
+        if ($statusFilter !== '') {
+            $query->where('txaction', $statusFilter);
+        }
+
+        if ($modeFilter !== '') {
+            $query->where('mode', $modeFilter);
+        }
+
+        $payments = $query->paginate(25)->withQueryString();
+
+        $paymentStats = $this->getPaymentStats($days > 0 ? $days : 30);
+
+        return view('admin.payment-dashboard.payments', compact('payments', 'paymentStats', 'days', 'statusFilter', 'modeFilter'));
+    }
+
+    /**
+     * PAYONE Log-Viewer.
+     */
+    public function logs(): View
+    {
+        $availableDates = $this->getAvailableLogDates();
+        $selectedDate = request()->string('date', now()->format('Y-m-d'))->toString();
+
+        if (! preg_match('/^\d{4}-\d{2}-\d{2}$/', $selectedDate) || ! in_array($selectedDate, $availableDates)) {
+            $selectedDate = ! empty($availableDates) ? $availableDates[0] : now()->format('Y-m-d');
+        }
+
+        $logFile = storage_path('logs/payone-'.$selectedDate.'.log');
+        $entries = [];
+
+        if (file_exists($logFile)) {
+            $lines = array_reverse(file($logFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES));
+            foreach (array_slice($lines, 0, 300) as $line) {
+                if (preg_match('/^\[(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[^\]]*)\] \w+\.(\w+): (.+)$/', $line, $m)) {
+                    $entries[] = [
+                        'timestamp' => $m[1],
+                        'level' => $m[2],
+                        'message' => $m[3],
+                    ];
+                }
+            }
+        }
+
+        return view('admin.payment-dashboard.logs', compact('entries', 'availableDates', 'selectedDate'));
+    }
+
+    // ─── Private Helpers ──────────────────────────────────────────────────────
+
+    private function getIncidentStats(): array
+    {
+        return [
+            'open_incidents' => PaymentIncident::whereIn('status', ['open', 'waiting_provider'])->count(),
+            'in_progress' => PaymentIncident::where('status', 'in_progress')->count(),
+            'resolved_this_month' => PaymentIncident::where('status', 'resolved')
+                ->whereMonth('resolved_at', now()->month)->count(),
+            'total_affected_revenue' => PaymentIncident::open()->sum('affected_revenue'),
+            'payone_incidents_30d' => PaymentIncident::payone()->lastDays(30)->count(),
+            'critical_open' => PaymentIncident::open()->where('severity', 'critical')->count(),
+        ];
+    }
+
+    private function getTransactionStats(int $days): array
+    {
+        $since = now()->subDays($days);
+
+        $total = PaymentTransaction::where('created_at', '>=', $since)->count();
+        $paid = PaymentTransaction::where('txaction', 'paid')->where('created_at', '>=', $since)->count();
+        $failed = PaymentTransaction::where('txaction', 'failed')->where('created_at', '>=', $since)->count();
+        $successRate = $total > 0 ? round(($paid / $total) * 100, 1) : 0;
+
+        $errorDistribution = PaymentTransaction::whereNotNull('errorcode')
+            ->where('created_at', '>=', $since)
+            ->select('errorcode', 'errormessage', DB::raw('count(*) as count'))
+            ->groupBy('errorcode', 'errormessage')
+            ->orderByDesc('count')
+            ->get();
+
+        $lastFailed = PaymentTransaction::where('txaction', 'failed')->latest()->first();
+
+        return [
+            'total' => $total,
+            'paid' => $paid,
+            'failed' => $failed,
+            'success_rate' => $successRate,
+            'error_distribution' => $errorDistribution,
+            'last_failed' => $lastFailed,
+            'days' => $days,
+        ];
+    }
+
+    private function getProviderStats(): array
+    {
+        $providers = [
+            'payone',
+            // 'stripe',  // aktuell nicht aktiv
+            'paypal',
+            // 'mollie',  // aktuell nicht aktiv
+            'other',
+        ];
+        $stats = [];
+
+        foreach ($providers as $provider) {
+            $stats[$provider] = [
+                'label' => strtoupper($provider),
+                'open_incidents' => PaymentIncident::where('provider', $provider)->open()->count(),
+                'total_30d' => PaymentIncident::where('provider', $provider)->lastDays(30)->count(),
+                'last_incident' => PaymentIncident::where('provider', $provider)
+                    ->orderBy('detected_at', 'desc')
+                    ->first(),
+            ];
+        }
+
+        return $stats;
+    }
+
+    /**
+     * @return array{total: int, paid: int, failed: int, pending: int, total_amount: float, failed_amount: float}
+     */
+    private function getPaymentStats(int $days): array
+    {
+        $since = now()->subDays($days);
+
+        $base = ShoppingPayment::where('created_at', '>=', $since);
+
+        return [
+            'total' => (clone $base)->count(),
+            'paid' => (clone $base)->where('txaction', 'paid')->count(),
+            'failed' => (clone $base)->whereHas('payment_transactions', fn ($q) => $q->where('txaction', 'failed'))->count(),
+            'pending' => (clone $base)->whereNotIn('txaction', ['paid', 'failed'])->count(),
+            'total_amount' => round((clone $base)->sum('amount') / 100, 2),
+            'failed_amount' => round(
+                (clone $base)->whereHas('payment_transactions', fn ($q) => $q->where('txaction', 'failed'))->sum('amount') / 100,
+                2
+            ),
+            'days' => $days,
+        ];
+    }
+
+    private function getAvailableLogDates(): array
+    {
+        $logPath = storage_path('logs');
+        $files = glob($logPath.'/payone-*.log');
+        $dates = [];
+
+        foreach ($files as $file) {
+            if (preg_match('/payone-(\d{4}-\d{2}-\d{2})\.log$/', $file, $m)) {
+                $dates[] = $m[1];
+            }
+        }
+
+        rsort($dates);
+
+        return $dates;
+    }
+
+    /**
+     * @return array<string, array{last_check: ProviderUptimeLog|null, uptime_24h: float, checks_24h: int, failures_24h: int}>
+     */
+    private function getUptimeStats(): array
+    {
+        $providers = [
+            'payone',
+            // 'stripe',  // aktuell nicht aktiv
+            'paypal',
+            // 'mollie',  // aktuell nicht aktiv
+        ];
+        $stats = [];
+        $since = now()->subHours(24);
+
+        foreach ($providers as $provider) {
+            $recentLogs = ProviderUptimeLog::where('provider', $provider)
+                ->where('checked_at', '>=', $since)
+                ->orderBy('checked_at', 'desc')
+                ->get();
+
+            $total = $recentLogs->count();
+            $upCount = $recentLogs->where('is_up', true)->count();
+
+            $stats[$provider] = [
+                'last_check' => ProviderUptimeLog::where('provider', $provider)->latest('checked_at')->first(),
+                'uptime_24h' => $total > 0 ? round(($upCount / $total) * 100, 1) : null,
+                'checks_24h' => $total,
+                'failures_24h' => $total - $upCount,
+            ];
+        }
+
+        return $stats;
+    }
+
+    private function invalidateIncidentCache(): void
+    {
+        Cache::forget('open_incident_count');
+    }
+}