feat(stressfrei): Weiterleitungen manuell synchronisieren

Nach Änderung der Kunden-Stamm-E-Mail (oder der defaultForwardEmail in
den Provider-Settings) müssen die Plesk-Forwards der Stressfrei-Adressen
des Kunden auf den neuen Wert umgestellt werden. Bisher ging das nur
manuell pro Adresse im Plesk-UI – jetzt mit einem Klick pro Adresse im
CRM.

Backend:
- emailProviderService.setEmailForwardTargets(localPart, targets[]):
  dünner Wrapper um die schon vorhandene IEmailProvider-Methode
  updateForwardTargets (`set:email1,email2` ersetzt komplett, idempotent)
- stressfreiEmail.service.syncForwardingForEmail(id): lädt Kunde +
  Provider-Config, baut [customer.email, defaultForwardEmail] und ruft
  den Provider auf
- POST /api/stressfrei-emails/:id/sync-forwarding, customers:update,
  Audit-Log mit den neuen Forward-Targets im Label

Frontend:
- Refresh-Icon-Button in der Action-Reihe jeder Stressfrei-Adresse,
  sichtbar nur wenn isProvisioned (sonst sinnlos). Confirm-Dialog
  zeigt die Ziele, Tooltip erklärt den Vorgang.
- ExternalLink-Icon neben der E-Mail in der Kundenakte (Stammdaten →
  Kontakt) öffnet den Stressfrei-Tab des Kunden in neuem Tab.

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

backend/src/controllers/stressfreiEmail.controller.ts

@@ -103,6 +103,41 @@ export async function deleteEmail(req: Request, res: Response): Promise<void> {
   }
 }
 
+export async function syncForwarding(req: AuthRequest, res: Response): Promise<void> {
+  try {
+    const emailId = parseInt(req.params.id);
+    if (!(await canAccessStressfreiEmail(req, res, emailId))) return;
+
+    const result = await stressfreiEmailService.syncForwardingForEmail(emailId);
+    if (!result.success) {
+      res.status(400).json({ success: false, error: result.error } as ApiResponse);
+      return;
+    }
+
+    await logChange({
+      req,
+      action: 'UPDATE',
+      resourceType: 'StressfreiEmail',
+      resourceId: emailId.toString(),
+      label: `Weiterleitungen synchronisiert: ${(result.forwardTargets || []).join(', ')}`,
+    });
+
+    res.json({
+      success: true,
+      data: {
+        forwardTargets: result.forwardTargets,
+        customerEmail: result.customerEmail,
+      },
+      message: 'Weiterleitungen aktualisiert',
+    } as ApiResponse);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error instanceof Error ? error.message : 'Fehler beim Synchronisieren der Weiterleitungen',
+    } as ApiResponse);
+  }
+}
+
 export async function resetPassword(req: Request, res: Response): Promise<void> {
   try {
     const result = await stressfreiEmailService.resetMailboxPassword(parseInt(req.params.id));

backend/src/routes/stressfreiEmail.routes.ts

@@ -12,4 +12,7 @@ router.delete('/:id', authenticate, requirePermission('customers:delete'), stres
 // Passwort zurücksetzen (generiert neues Passwort und setzt es beim Provider)
 router.post('/:id/reset-password', authenticate, requirePermission('customers:update'), stressfreiEmailController.resetPassword);
 
+// Weiterleitungen neu setzen (z.B. nach Änderung der Kunden-Stamm-E-Mail)
+router.post('/:id/sync-forwarding', authenticate, requirePermission('customers:update'), stressfreiEmailController.syncForwarding);
+
 export default router;

backend/src/services/emailProvider/emailProviderService.ts

@@ -469,6 +469,22 @@ export async function deprovisionEmail(localPart: string): Promise<EmailOperatio
   }
 }
 
+// Weiterleitungsziele ersetzen (set:, nicht add:) – nutzen wir, um nach einer
+// Kunden-Email-Änderung die Forwards einer Stressfrei-Adresse auf den neuen
+// Kunden-Inbox + unsere Service-Adresse zu setzen.
+export async function setEmailForwardTargets(
+  localPart: string,
+  targets: string[],
+): Promise<EmailOperationResult> {
+  try {
+    const provider = await getProviderInstance();
+    return provider.updateForwardTargets(localPart, targets);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unbekannter Fehler';
+    return { success: false, error: errorMessage };
+  }
+}
+
 // E-Mail umbenennen
 export async function renameProvisionedEmail(
   oldLocalPart: string,

backend/src/services/stressfreiEmail.service.ts

@@ -7,6 +7,8 @@ import {
   checkEmailExists,
   getProviderDomain,
   updateMailboxPassword,
+  setEmailForwardTargets,
+  getActiveProviderConfig,
 } from './emailProvider/emailProviderService.js';
 import { generateSecurePassword } from '../utils/passwordGenerator.js';
 
@@ -251,6 +253,59 @@ export async function getDecryptedPassword(id: number): Promise<string | null> {
   }
 }
 
+// Weiterleitungen einer Stressfrei-Adresse neu setzen (z.B. nach Änderung der
+// Stamm-E-Mail des Kunden). Ersetzt alle bestehenden Forwards durch
+// [aktuelle Kunden-E-Mail, defaultForwardEmail aus Provider-Config].
+//
+// Idempotent: das Plesk-CLI `set:` überschreibt die Adressliste komplett, kein
+// Duplikat-Risiko bei Mehrfachaufruf.
+export async function syncForwardingForEmail(
+  id: number,
+): Promise<{
+  success: boolean;
+  forwardTargets?: string[];
+  customerEmail?: string;
+  error?: string;
+}> {
+  const stressfreiEmail = await prisma.stressfreiEmail.findUnique({
+    where: { id },
+    select: { email: true, customerId: true, isProvisioned: true },
+  });
+
+  if (!stressfreiEmail) {
+    return { success: false, error: 'StressfreiEmail nicht gefunden' };
+  }
+  if (!stressfreiEmail.isProvisioned) {
+    return { success: false, error: 'E-Mail ist nicht beim Provider angelegt – Sync nicht möglich' };
+  }
+
+  const customer = await prisma.customer.findUnique({
+    where: { id: stressfreiEmail.customerId },
+    select: { email: true },
+  });
+  if (!customer?.email) {
+    return { success: false, error: 'Kunde hat keine Stamm-E-Mail-Adresse hinterlegt' };
+  }
+
+  const config = await getActiveProviderConfig();
+  const forwardTargets: string[] = [customer.email];
+  if (config?.defaultForwardEmail) {
+    forwardTargets.push(config.defaultForwardEmail);
+  }
+
+  const localPart = stressfreiEmail.email.split('@')[0];
+  const result = await setEmailForwardTargets(localPart, forwardTargets);
+  if (!result.success) {
+    return { success: false, error: result.error || 'Provider-Update fehlgeschlagen' };
+  }
+
+  return {
+    success: true,
+    forwardTargets,
+    customerEmail: customer.email,
+  };
+}
+
 // Passwort neu generieren und beim Provider setzen
 export async function resetMailboxPassword(id: number): Promise<{ success: boolean; password?: string; error?: string }> {
   const stressfreiEmail = await prisma.stressfreiEmail.findUnique({

docs/todo.md

@@ -97,6 +97,20 @@ isolierte Instanz (keine Multi-Tenancy im Code), Provisioning + Abrechnung
 
 ## ✅ Erledigt
 
+- [x] **🔁 Stressfrei-Adressen: Weiterleitungen manuell synchronisieren**
+  - Refresh-Icon-Button in der Action-Reihe jeder provisionierten
+    Stressfrei-Adresse (Tooltip erklärt: „ersetzt die Forwards am Provider
+    durch Kunden-Stamm-E-Mail + Service-Adresse"). Use-Case: nach
+    Änderung der Stamm-E-Mail eines Kunden, oder nach Wechsel der
+    `defaultForwardEmail` in den Provider-Settings.
+  - Backend nutzt das bestehende Plesk `updateForwardTargets`
+    (`set:email1,email2` → ersetzt komplett, idempotent).
+  - Endpoint: `POST /api/stressfrei-emails/:id/sync-forwarding`,
+    `customers:update`-Permission, Audit-Log mit Forward-Targets.
+  - In der Kundenakte (Stammdaten → Kontakt → E-Mail) externes
+    Link-Icon, das in neuem Tab direkt den Stressfrei-Tab des Kunden
+    öffnet – sichtbar nur wenn Stressfrei-Adressen vorhanden sind.
+
 - [x] **🛡️ Pentest-Hardening-Runde 11: Header-Hygiene**
   - **HSTS-Doppel-Header** (18× low im Audit): Helmet's
     `Strict-Transport-Security` komplett deaktiviert. Der Nginx Proxy Manager

frontend/src/pages/customers/CustomerDetail.tsx

@@ -13,7 +13,7 @@ import Modal from '../../components/ui/Modal';
 import Input from '../../components/ui/Input';
 import Select from '../../components/ui/Select';
 import FileUpload from '../../components/ui/FileUpload';
-import { Edit, Plus, Trash2, MapPin, CreditCard, FileText, Gauge, Eye, EyeOff, Download, Globe, UserPlus, X, Search, Mail, Copy, Check, ChevronDown, ChevronRight, Info, Shield, ShieldCheck, ShieldX, ShieldAlert, Lock, ArrowLeft, Cake } from 'lucide-react';
+import { Edit, Plus, Trash2, MapPin, CreditCard, FileText, Gauge, Eye, EyeOff, Download, Globe, UserPlus, X, Search, Mail, Copy, Check, ChevronDown, ChevronRight, Info, Shield, ShieldCheck, ShieldX, ShieldAlert, Lock, ArrowLeft, Cake, RefreshCw, ExternalLink } from 'lucide-react';
 import CopyButton, { CopyableBlock } from '../../components/ui/CopyButton';
 import BirthdayManagementModal from '../../components/BirthdayManagementModal';
 import { formatDate } from '../../utils/dateFormat';
@@ -353,6 +353,17 @@ export default function CustomerDetail({ portalCustomerId }: { portalCustomerId?
                     {c.email}
                   </a>
                   <CopyButton value={c.email} />
+                  {(c.stressfreiEmails?.length ?? 0) > 0 && (
+                    <a
+                      href={`/customers/${c.id}?tab=stressfrei`}
+                      target="_blank"
+                      rel="noopener noreferrer"
+                      className="text-gray-400 hover:text-blue-600 ml-1"
+                      title="Stressfrei-Wechseln-Adressen öffnen (neuer Tab). Nach Änderung der Stamm-E-Mail dort die Weiterleitungen synchronisieren."
+                    >
+                      <ExternalLink className="w-3.5 h-3.5" />
+                    </a>
+                  )}
                 </dd>
               </div>
             )}
@@ -2964,6 +2975,26 @@ function StressfreiEmailsTab({
     onSuccess: () => queryClient.invalidateQueries({ queryKey: ['customer', customerId] }),
   });
 
+  // Weiterleitungen am Provider neu setzen (Stamm-Email-Wechsel-Use-Case).
+  const syncForwardingMutation = useMutation({
+    mutationFn: stressfreiEmailApi.syncForwarding,
+    onSuccess: (res) => {
+      const targets = res?.data?.forwardTargets || [];
+      alert(
+        targets.length > 0
+          ? `Weiterleitungen aktualisiert:\n${targets.map((t) => `• ${t}`).join('\n')}`
+          : 'Weiterleitungen aktualisiert.',
+      );
+      queryClient.invalidateQueries({ queryKey: ['customer', customerId] });
+    },
+    onError: (err: any) => {
+      alert(
+        'Fehler beim Aktualisieren der Weiterleitungen:\n' +
+          (err?.response?.data?.error || err?.message || 'Unbekannter Fehler'),
+      );
+    },
+  });
+
   const filtered = showInactive ? emails : emails.filter((e) => e.isActive);
 
   return (
@@ -3023,6 +3054,30 @@ function StressfreiEmailsTab({
                     >
                       <Edit className="w-4 h-4" />
                     </Button>
+                    {emailItem.isProvisioned && (
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        disabled={syncForwardingMutation.isPending}
+                        onClick={() => {
+                          if (
+                            confirm(
+                              'Weiterleitungen für ' + emailItem.email + ' jetzt neu setzen?\n\n' +
+                                'Alle bestehenden Weiterleitungen werden ersetzt durch:\n' +
+                                '• die aktuelle Stamm-E-Mail des Kunden\n' +
+                                '• unsere Service-Weiterleitungsadresse aus den Provider-Einstellungen',
+                            )
+                          ) {
+                            syncForwardingMutation.mutate(emailItem.id);
+                          }
+                        }}
+                        title="Weiterleitungen synchronisieren – ersetzt die Forwards am Provider durch (Kunden-Stamm-E-Mail + Service-Adresse). Nützlich nach Änderung der Stamm-E-Mail."
+                      >
+                        <RefreshCw
+                          className={`w-4 h-4 ${syncForwardingMutation.isPending ? 'animate-spin' : ''}`}
+                        />
+                      </Button>
+                    )}
                     {emailItem.isActive ? (
                       <Button
                         variant="ghost"

frontend/src/services/api.ts

@@ -268,6 +268,7 @@ export interface StressfreiEmail {
   platform?: string;
   notes?: string;
   isActive: boolean;
+  isProvisioned?: boolean;
   hasMailbox: boolean;
   createdAt: string;
   updatedAt: string;
@@ -426,6 +427,13 @@ export const stressfreiEmailApi = {
     const res = await api.post<ApiResponse<{ password: string }>>(`/stressfrei-emails/${id}/reset-password`);
     return res.data;
   },
+  // Weiterleitungen neu setzen (z.B. nach Änderung der Kunden-Stamm-E-Mail)
+  syncForwarding: async (id: number) => {
+    const res = await api.post<ApiResponse<{ forwardTargets: string[]; customerEmail: string }>>(
+      `/stressfrei-emails/${id}/sync-forwarding`,
+    );
+    return res.data;
+  },
   // E-Mails synchronisieren
   syncEmails: async (id: number, fullSync = false) => {
     const res = await api.post<ApiResponse<SyncResult>>(`/stressfrei-emails/${id}/sync`, {}, { params: { full: fullSync } });