added backup and email client

2026-02-01 00:02:35 +01:00
parent ef18381dd8
commit 8c9e61cf17
210 changed files with 24211 additions and 742 deletions
@@ -1,4 +1,14 @@
 import { PrismaClient } from '@prisma/client';
+import { encrypt, decrypt } from '../utils/encryption.js';
+import {
+  provisionEmail,
+  provisionEmailWithMailbox,
+  enableMailboxForExistingEmail,
+  checkEmailExists,
+  getProviderDomain,
+  updateMailboxPassword,
+} from './emailProvider/emailProviderService.js';
+import { generateSecurePassword } from '../utils/passwordGenerator.js';

 const prisma = new PrismaClient();

@@ -13,22 +23,116 @@ export async function getEmailsByCustomerId(customerId: number, includeInactive
  });
 }

+// Mit Mailbox-Status für E-Mail-Client
+export async function getEmailsWithMailboxByCustomerId(customerId: number) {
+  return prisma.stressfreiEmail.findMany({
+    where: {
+      customerId,
+      isActive: true,
+      hasMailbox: true,
+    },
+    select: {
+      id: true,
+      email: true,
+      notes: true,
+      hasMailbox: true,
+      _count: {
+        select: {
+          cachedEmails: true,
+        },
+      },
+    },
+    orderBy: { email: 'asc' },
+  });
+}
+
 export async function getEmailById(id: number) {
  return prisma.stressfreiEmail.findUnique({
    where: { id },
  });
 }

-export async function createEmail(data: {
+// E-Mail mit Mailbox-Status laden
+export async function getEmailWithMailboxById(id: number) {
+  return prisma.stressfreiEmail.findUnique({
+    where: { id },
+    select: {
+      id: true,
+      customerId: true,
+      email: true,
+      platform: true,
+      notes: true,
+      isActive: true,
+      hasMailbox: true,
+      emailPasswordEncrypted: true,
+      createdAt: true,
+      updatedAt: true,
+    },
+  });
+}
+
+export interface CreateEmailData {
  customerId: number;
  email: string;
  platform?: string;
  notes?: string;
-}) {
+  provisionAtProvider?: boolean;
+  createMailbox?: boolean;
+}
+
+export async function createEmail(data: CreateEmailData) {
+  const { provisionAtProvider, createMailbox, ...emailData } = data;
+
+  // Falls beim Provider anlegen gewünscht
+  if (provisionAtProvider) {
+    // Kunde laden für Weiterleitung
+    const customer = await prisma.customer.findUnique({
+      where: { id: data.customerId },
+      select: { email: true },
+    });
+
+    if (!customer?.email) {
+      throw new Error('Kunde hat keine E-Mail-Adresse für Weiterleitung');
+    }
+
+    // LocalPart extrahieren
+    const localPart = data.email.split('@')[0];
+
+    if (createMailbox) {
+      // Mit echter Mailbox anlegen
+      const password = generateSecurePassword();
+      const result = await provisionEmailWithMailbox(localPart, customer.email, password);
+
+      if (!result.success) {
+        throw new Error(result.error || 'Fehler beim Anlegen der Mailbox');
+      }
+
+      // Passwort verschlüsseln und speichern
+      const passwordEncrypted = encrypt(password);
+
+      return prisma.stressfreiEmail.create({
+        data: {
+          ...emailData,
+          isActive: true,
+          hasMailbox: true,
+          emailPasswordEncrypted: passwordEncrypted,
+        },
+      });
+    } else {
+      // Nur Weiterleitung anlegen
+      const result = await provisionEmail(localPart, customer.email);
+
+      if (!result.success && !result.message?.includes('existiert bereits')) {
+        throw new Error(result.error || 'Fehler beim Anlegen der E-Mail');
+      }
+    }
+  }
+
  return prisma.stressfreiEmail.create({
    data: {
-      ...data,
+      ...emailData,
      isActive: true,
+      hasMailbox: createMailbox || false,
    },
  });
 }
@@ -51,3 +155,136 @@ export async function updateEmail(
 export async function deleteEmail(id: number) {
  return prisma.stressfreiEmail.delete({ where: { 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({
+    where: { id },
+  });
+
+  if (!stressfreiEmail) {
+    return { success: false, error: 'StressfreiEmail nicht gefunden' };
+  }
+
+  if (stressfreiEmail.hasMailbox) {
+    return { success: false, error: 'Mailbox ist bereits aktiviert' };
+  }
+
+  const localPart = stressfreiEmail.email.split('@')[0];
+  const password = generateSecurePassword();
+
+  // Mailbox für existierende E-Mail aktivieren (nicht neu erstellen!)
+  const result = await enableMailboxForExistingEmail(localPart, password);
+
+  if (!result.success) {
+    return { success: false, error: result.error || 'Fehler beim Aktivieren der Mailbox' };
+  }
+
+  // Passwort verschlüsseln und speichern
+  const passwordEncrypted = encrypt(password);
+
+  await prisma.stressfreiEmail.update({
+    where: { id },
+    data: {
+      hasMailbox: true,
+      emailPasswordEncrypted: passwordEncrypted,
+    },
+  });
+
+  return { success: true };
+}
+
+// Mailbox-Status mit Provider synchronisieren
+export async function syncMailboxStatus(id: number): Promise<{
+  success: boolean;
+  hasMailbox?: boolean;
+  wasUpdated?: boolean;
+  error?: string
+}> {
+  const stressfreiEmail = await prisma.stressfreiEmail.findUnique({
+    where: { id },
+    select: { email: true, hasMailbox: true },
+  });
+
+  if (!stressfreiEmail) {
+    return { success: false, error: 'StressfreiEmail nicht gefunden' };
+  }
+
+  const localPart = stressfreiEmail.email.split('@')[0];
+
+  // Provider-Status prüfen
+  const providerStatus = await checkEmailExists(localPart);
+
+  if (!providerStatus.exists) {
+    return { success: true, hasMailbox: false, wasUpdated: false };
+  }
+
+  const providerHasMailbox = providerStatus.hasMailbox === true;
+
+  // DB aktualisieren wenn Status abweicht
+  if (stressfreiEmail.hasMailbox !== providerHasMailbox) {
+    await prisma.stressfreiEmail.update({
+      where: { id },
+      data: { hasMailbox: providerHasMailbox },
+    });
+    console.log(`Mailbox-Status für ${stressfreiEmail.email} aktualisiert: ${stressfreiEmail.hasMailbox} -> ${providerHasMailbox}`);
+    return { success: true, hasMailbox: providerHasMailbox, wasUpdated: true };
+  }
+
+  return { success: true, hasMailbox: providerHasMailbox, wasUpdated: false };
+}
+
+// Passwort für IMAP/SMTP-Zugang entschlüsseln (nur für autorisierte Nutzung)
+export async function getDecryptedPassword(id: number): Promise<string | null> {
+  const stressfreiEmail = await prisma.stressfreiEmail.findUnique({
+    where: { id },
+    select: { emailPasswordEncrypted: true },
+  });
+
+  if (!stressfreiEmail?.emailPasswordEncrypted) {
+    return null;
+  }
+
+  try {
+    return decrypt(stressfreiEmail.emailPasswordEncrypted);
+  } catch {
+    console.error('Fehler beim Entschlüsseln des Passworts');
+    return null;
+  }
+}
+
+// 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({
+    where: { id },
+    select: { email: true, hasMailbox: true },
+  });
+
+  if (!stressfreiEmail) {
+    return { success: false, error: 'StressfreiEmail nicht gefunden' };
+  }
+
+  if (!stressfreiEmail.hasMailbox) {
+    return { success: false, error: 'Keine Mailbox für diese E-Mail-Adresse' };
+  }
+
+  // Neues Passwort generieren
+  const newPassword = generateSecurePassword();
+  const localPart = stressfreiEmail.email.split('@')[0];
+
+  // Passwort beim Provider ändern
+  const providerResult = await updateMailboxPassword(localPart, newPassword);
+  if (!providerResult.success) {
+    return { success: false, error: providerResult.error || 'Fehler beim Aktualisieren des Passworts beim Provider' };
+  }
+
+  // Passwort verschlüsseln und lokal speichern
+  const passwordEncrypted = encrypt(newPassword);
+
+  await prisma.stressfreiEmail.update({
+    where: { id },
+    data: { emailPasswordEncrypted: passwordEncrypted },
+  });
+
+  return { success: true, password: newPassword };
+}