Stressfrei-Adressen: zusätzliche Weiterleitungsziele

Pro StressfreiEmail können jetzt weitere Weiterleitungs-Adressen
gepflegt werden, die zusätzlich zur Stamm-E-Mail des Kunden und
zur globalen Default-Forward-Adresse an den Provider gepusht werden.

- Schema: StressfreiEmail.additionalForwardingEmails (TEXT/JSON-
  Array), Migration mit IF NOT EXISTS.
- syncForwardingForEmail liest die Zusatzliste mit und filtert
  Duplikate gegen customer.email + config.defaultForwardEmail
  (case-insensitive) raus.
- Neuer Endpoint PUT /api/stressfrei-emails/:id/additional-forwards
  mit Body { emails: string[] } – ersetzt die Liste komplett und
  syncht den Provider direkt nach. Hard-Cap 20 Adressen, Format-
  Validation per Regex, Audit-Log.
- Frontend: Button "Weitere Weiterleitungen" im Edit-Modus des
  StressfreiEmailModals (erscheint sobald die Adresse beim Provider
  vorhanden ist). Sub-Modal mit Liste + Add/Remove, Änderungen
  gehen sofort live.

backend/src/controllers/stressfreiEmail.controller.ts

@@ -3,6 +3,7 @@ import * as stressfreiEmailService from '../services/stressfreiEmail.service.js'
 import { logChange } from '../services/audit.service.js';
 import { ApiResponse, AuthRequest } from '../types/index.js';
 import { canAccessCustomer, canAccessStressfreiEmail } from '../utils/accessControl.js';
+import { ApiError } from '../utils/apiError.js';
 
 export async function getEmailsByCustomer(req: AuthRequest, res: Response): Promise<void> {
   try {
@@ -151,6 +152,54 @@ export async function syncForwarding(req: AuthRequest, res: Response): Promise<v
   }
 }
 
+/**
+ * Zusätzliche Weiterleitungs-E-Mails der StressfreiEmail neu setzen.
+ * Body: `{ emails: string[] }`. Liste ersetzt komplett, Provider wird
+ * unmittelbar nachgezogen.
+ */
+export async function updateAdditionalForwards(req: AuthRequest, res: Response): Promise<void> {
+  try {
+    const emailId = parseInt(req.params.id);
+    if (!(await canAccessStressfreiEmail(req, res, emailId))) return;
+
+    const body = req.body ?? {};
+    if (!Array.isArray(body.emails)) {
+      res.status(400).json({ success: false, error: '`emails` muss ein Array sein.' } as ApiResponse);
+      return;
+    }
+    if (body.emails.length > 20) {
+      res.status(400).json({ success: false, error: 'Maximal 20 zusätzliche Weiterleitungen erlaubt.' } as ApiResponse);
+      return;
+    }
+
+    const result = await stressfreiEmailService.setAdditionalForwards(emailId, body.emails);
+    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: `Zusatz-Weiterleitungen aktualisiert (${(result.forwardTargets || []).length} Ziele aktiv)`,
+    });
+
+    res.json({
+      success: true,
+      data: { forwardTargets: result.forwardTargets },
+      message: 'Weiterleitungen aktualisiert',
+    } as ApiResponse);
+  } catch (error) {
+    const status = error instanceof ApiError ? error.statusCode : 500;
+    res.status(status).json({
+      success: false,
+      error: error instanceof Error ? error.message : 'Fehler beim Aktualisieren der Weiterleitungen',
+    } as ApiResponse);
+  }
+}
+
 export async function resetPassword(req: AuthRequest, res: Response): Promise<void> {
   try {
     const emailId = parseInt(req.params.id);

backend/src/routes/stressfreiEmail.routes.ts

@@ -15,4 +15,8 @@ router.post('/:id/reset-password', authenticate, requirePermission('customers:up
 // Weiterleitungen neu setzen (z.B. nach Änderung der Kunden-Stamm-E-Mail)
 router.post('/:id/sync-forwarding', authenticate, requirePermission('customers:update'), stressfreiEmailController.syncForwarding);
 
+// Zusätzliche Weiterleitungs-Ziele setzen (User-pflegbare Liste, zusätzlich
+// zur Stamm-E-Mail des Kunden und der globalen Default-Forward-Adresse).
+router.put('/:id/additional-forwards', authenticate, requirePermission('customers:update'), stressfreiEmailController.updateAdditionalForwards);
+
 export default router;

backend/src/services/stressfreiEmail.service.ts

@@ -11,6 +11,41 @@ import {
   getActiveProviderConfig,
 } from './emailProvider/emailProviderService.js';
 import { generateSecurePassword } from '../utils/passwordGenerator.js';
+import { ApiError } from '../utils/apiError.js';
+
+// Locker, aber strikt genug gegen offensichtlichen Müll (CRLF, Spaces,
+// Komma). Wirklich validiert wird vom Provider beim Sync.
+const FORWARD_EMAIL_REGEX = /^[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}$/;
+
+export function parseAdditionalForwards(raw: string | null | undefined): string[] {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((x): x is string => typeof x === 'string' && x.trim() !== '');
+  } catch {
+    return [];
+  }
+}
+
+export function serializeAdditionalForwards(list: string[]): string | null {
+  const cleaned = list.map((s) => s.trim()).filter((s) => s !== '');
+  return cleaned.length === 0 ? null : JSON.stringify(cleaned);
+}
+
+export function assertValidForwardingEmail(value: unknown): string {
+  if (typeof value !== 'string') {
+    throw new ApiError(400, 'Ungültige Weiterleitungs-E-Mail-Adresse');
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.length > 254) {
+    throw new ApiError(400, 'Weiterleitungs-E-Mail-Adresse ist leer oder zu lang');
+  }
+  if (!FORWARD_EMAIL_REGEX.test(trimmed)) {
+    throw new ApiError(400, `Ungültiges E-Mail-Format: ${trimmed}`);
+  }
+  return trimmed.toLowerCase();
+}
 
 export async function getEmailsByCustomerId(customerId: number, includeInactive = false) {
   const where: Record<string, unknown> = { customerId };
@@ -163,6 +198,36 @@ export async function deleteEmail(id: number) {
   return prisma.stressfreiEmail.delete({ where: { id } });
 }
 
+/**
+ * Komplette Liste zusätzlicher Weiterleitungs-E-Mails ersetzen und
+ * direkt mit dem Provider synchronisieren. Aufrufer hat eine canonical
+ * Liste – das Sub-Modal arbeitet auf Snapshot-Basis.
+ */
+export async function setAdditionalForwards(
+  id: number,
+  emails: string[],
+): Promise<{ success: boolean; forwardTargets?: string[]; error?: string }> {
+  // Input normalisieren + Duplikate raus (case-insensitive).
+  const seen = new Set<string>();
+  const cleaned: string[] = [];
+  for (const raw of emails) {
+    const ok = assertValidForwardingEmail(raw);
+    if (!seen.has(ok)) {
+      seen.add(ok);
+      cleaned.push(ok);
+    }
+  }
+
+  await prisma.stressfreiEmail.update({
+    where: { id },
+    data: { additionalForwardingEmails: serializeAdditionalForwards(cleaned) },
+  });
+
+  // Provider unmittelbar nachziehen, sonst läuft das Plesk-Mail-Konto
+  // mit der alten Liste weiter.
+  return syncForwardingForEmail(id);
+}
+
 // Mailbox nachträglich aktivieren (für existierende E-Mail-Weiterleitung)
 export async function enableMailbox(id: number): Promise<{ success: boolean; error?: string }> {
   const stressfreiEmail = await prisma.stressfreiEmail.findUnique({
@@ -313,6 +378,7 @@ export async function syncForwardingForEmail(
       isProvisioned: true,
       hasMailbox: true,
       emailPasswordEncrypted: true,
+      additionalForwardingEmails: true,
     },
   });
 
@@ -333,6 +399,14 @@ export async function syncForwardingForEmail(
   if (config?.defaultForwardEmail) {
     forwardTargets.push(config.defaultForwardEmail);
   }
+  // Zusätzliche Weiterleitungsziele (vom User im Modal gepflegt). Duplikate
+  // gegen die Stamm-Mail oder den Default werden hier weggefiltert, damit
+  // Plesk nicht mit Wiederholungen die Liste aufbläht.
+  for (const extra of parseAdditionalForwards(stressfreiEmail.additionalForwardingEmails)) {
+    if (!forwardTargets.some((t) => t.toLowerCase() === extra.toLowerCase())) {
+      forwardTargets.push(extra);
+    }
+  }
 
   const localPart = stressfreiEmail.email.split('@')[0];