opencrm/backend/dist/services/stressfreiEmail.service.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getEmailsByCustomerId = getEmailsByCustomerId;
exports.getEmailsWithMailboxByCustomerId = getEmailsWithMailboxByCustomerId;
exports.getEmailById = getEmailById;
exports.getEmailWithMailboxById = getEmailWithMailboxById;
exports.createEmail = createEmail;
exports.updateEmail = updateEmail;
exports.deleteEmail = deleteEmail;
exports.enableMailbox = enableMailbox;
exports.syncMailboxStatus = syncMailboxStatus;
exports.getDecryptedPassword = getDecryptedPassword;
exports.resetMailboxPassword = resetMailboxPassword;
const client_1 = require("@prisma/client");
const encryption_js_1 = require("../utils/encryption.js");
const emailProviderService_js_1 = require("./emailProvider/emailProviderService.js");
const passwordGenerator_js_1 = require("../utils/passwordGenerator.js");
const prisma = new client_1.PrismaClient();
async function getEmailsByCustomerId(customerId, includeInactive = false) {
    const where = { customerId };
    if (!includeInactive) {
        where.isActive = true;
    }
    return prisma.stressfreiEmail.findMany({
        where,
        orderBy: { createdAt: 'desc' },
    });
}
// Mit Mailbox-Status für E-Mail-Client
async function getEmailsWithMailboxByCustomerId(customerId) {
    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' },
    });
}
async function getEmailById(id) {
    return prisma.stressfreiEmail.findUnique({
        where: { id },
    });
}
// E-Mail mit Mailbox-Status laden
async function getEmailWithMailboxById(id) {
    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,
        },
    });
}
async function createEmail(data) {
    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 = (0, passwordGenerator_js_1.generateSecurePassword)();
            const result = await (0, emailProviderService_js_1.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 = (0, encryption_js_1.encrypt)(password);
            return prisma.stressfreiEmail.create({
                data: {
                    ...emailData,
                    isActive: true,
                    hasMailbox: true,
                    emailPasswordEncrypted: passwordEncrypted,
                },
            });
        }
        else {
            // Nur Weiterleitung anlegen
            const result = await (0, emailProviderService_js_1.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: {
            ...emailData,
            isActive: true,
            hasMailbox: createMailbox || false,
        },
    });
}
async function updateEmail(id, data) {
    return prisma.stressfreiEmail.update({
        where: { id },
        data,
    });
}
async function deleteEmail(id) {
    return prisma.stressfreiEmail.delete({ where: { id } });
}
// Mailbox nachträglich aktivieren (für existierende E-Mail-Weiterleitung)
async function enableMailbox(id) {
    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 = (0, passwordGenerator_js_1.generateSecurePassword)();
    // Mailbox für existierende E-Mail aktivieren (nicht neu erstellen!)
    const result = await (0, emailProviderService_js_1.enableMailboxForExistingEmail)(localPart, password);
    if (!result.success) {
        return { success: false, error: result.error || 'Fehler beim Aktivieren der Mailbox' };
    }
    // Passwort verschlüsseln und speichern
    const passwordEncrypted = (0, encryption_js_1.encrypt)(password);
    await prisma.stressfreiEmail.update({
        where: { id },
        data: {
            hasMailbox: true,
            emailPasswordEncrypted: passwordEncrypted,
        },
    });
    return { success: true };
}
// Mailbox-Status mit Provider synchronisieren
async function syncMailboxStatus(id) {
    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 (0, emailProviderService_js_1.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)
async function getDecryptedPassword(id) {
    const stressfreiEmail = await prisma.stressfreiEmail.findUnique({
        where: { id },
        select: { emailPasswordEncrypted: true },
    });
    if (!stressfreiEmail?.emailPasswordEncrypted) {
        return null;
    }
    try {
        return (0, encryption_js_1.decrypt)(stressfreiEmail.emailPasswordEncrypted);
    }
    catch {
        console.error('Fehler beim Entschlüsseln des Passworts');
        return null;
    }
}
// Passwort neu generieren und beim Provider setzen
async function resetMailboxPassword(id) {
    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 = (0, passwordGenerator_js_1.generateSecurePassword)();
    const localPart = stressfreiEmail.email.split('@')[0];
    // Passwort beim Provider ändern
    const providerResult = await (0, emailProviderService_js_1.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 = (0, encryption_js_1.encrypt)(newPassword);
    await prisma.stressfreiEmail.update({
        where: { id },
        data: { emailPasswordEncrypted: passwordEncrypted },
    });
    return { success: true, password: newPassword };
}
//# sourceMappingURL=stressfreiEmail.service.js.map