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({