create-crm-tmp 1.0.0

package/template/src/app/api/contacts/[id]/send-email/route.ts

@@ -0,0 +1,254 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import nodemailer from 'nodemailer';
+import { decrypt } from '@/lib/encryption';
+
+// POST /api/contacts/[id]/send-email - Envoyer un email au contact
+function htmlToText(html: string): string {
+  if (!html) return '';
+  return html
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n\n')
+    .replace(/<[^>]+>/g, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+export async function POST(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { id } = await params;
+
+    // Récupérer FormData
+    const formData = await request.formData();
+    const to = formData.get('to') as string;
+    const cc = formData.get('cc') as string;
+    const bcc = formData.get('bcc') as string;
+    const subject = formData.get('subject') as string;
+    const content = formData.get('content') as string;
+    const attachmentCount = parseInt(formData.get('attachmentCount') as string) || 0;
+
+    // Validation
+    if (!to || !subject || !content) {
+      return NextResponse.json(
+        { error: 'Le destinataire, le sujet et le contenu sont requis' },
+        { status: 400 },
+      );
+    }
+
+    // Récupérer le contact
+    const contact = await prisma.contact.findUnique({
+      where: { id },
+    });
+
+    if (!contact) {
+      return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
+    }
+
+    // Récupérer la configuration SMTP de l'utilisateur
+    const smtpConfig = await prisma.smtpConfig.findUnique({
+      where: { userId: session.user.id },
+    });
+
+    if (!smtpConfig) {
+      return NextResponse.json(
+        {
+          error:
+            'Configuration SMTP non trouvée. Veuillez configurer votre SMTP dans les paramètres.',
+        },
+        { status: 400 },
+      );
+    }
+
+    // Déchiffrer le mot de passe SMTP
+    let password: string;
+    try {
+      password = decrypt(smtpConfig.password);
+    } catch (error) {
+      // Si le déchiffrement échoue, utiliser le mot de passe tel quel (ancien format non chiffré)
+      password = smtpConfig.password;
+    }
+
+    // Créer le transporteur SMTP
+    const transporter = nodemailer.createTransport({
+      host: smtpConfig.host,
+      port: smtpConfig.port,
+      secure: smtpConfig.secure,
+      auth: {
+        user: smtpConfig.username,
+        pass: password,
+      },
+    });
+
+    // Construire les variantes texte / HTML avec la signature (si définie)
+    let baseHtml = content || '';
+    const baseText = htmlToText(baseHtml);
+
+    // Nettoyer les espaces en fin de contenu HTML
+    baseHtml = baseHtml.trim();
+
+    // Ajouter la signature de manière propre avec un espacement raisonnable
+    let signatureHtml = '';
+    let signatureText = '';
+
+    if (smtpConfig.signature) {
+      const signatureContent = smtpConfig.signature.trim();
+      // Ajouter un seul saut de ligne pour un espacement naturel
+      if (baseHtml.length > 0) {
+        signatureHtml = `<br>${signatureContent}`;
+      } else {
+        signatureHtml = signatureContent;
+      }
+      signatureText = `\n\n${htmlToText(signatureContent)}`;
+    }
+
+    // Préparer les destinataires
+    const toEmails = to
+      .split(',')
+      .map((email) => email.trim())
+      .filter((email) => email);
+    const ccEmails = cc
+      ? cc
+          .split(',')
+          .map((email) => email.trim())
+          .filter((email) => email)
+      : [];
+    const bccEmails = bcc
+      ? bcc
+          .split(',')
+          .map((email) => email.trim())
+          .filter((email) => email)
+      : [];
+
+    // Récupérer les pièces jointes
+    const attachments: Array<{ filename: string; content: Buffer }> = [];
+    for (let i = 0; i < attachmentCount; i++) {
+      const file = formData.get(`attachment_${i}`) as File | null;
+      if (file) {
+        const buffer = Buffer.from(await file.arrayBuffer());
+        attachments.push({
+          filename: file.name,
+          content: buffer,
+        });
+      }
+    }
+
+    // Créer d'abord l'interaction pour avoir son ID
+    const attachmentNames = attachments.map((att) => att.filename);
+    const metadata: any = {};
+    if (attachmentNames.length > 0) {
+      metadata.attachments = attachmentNames;
+    }
+    if (ccEmails.length > 0) {
+      metadata.cc = ccEmails;
+    }
+    if (bccEmails.length > 0) {
+      metadata.bcc = bccEmails;
+    }
+    metadata.to = toEmails;
+    metadata.htmlContent = `${baseHtml}${signatureHtml}`; // Stocker le HTML original (sans tracking) pour l'affichage
+
+    const interaction = await prisma.interaction.create({
+      data: {
+        contactId: id,
+        type: 'EMAIL',
+        title: subject,
+        content: baseText, // Texte brut pour la recherche/affichage simple
+        userId: session.user.id,
+        date: new Date(),
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+      },
+    });
+
+    // Créer le tracking pour cet email
+    const emailTracking = await prisma.emailTracking.create({
+      data: {
+        interactionId: interaction.id,
+        openCount: 0,
+      },
+    });
+
+    // Ajouter le pixel de tracking dans le HTML
+    // Utiliser l'URL absolue depuis les variables d'environnement
+    const baseUrl =
+      process.env.NEXT_PUBLIC_APP_URL || process.env.BETTER_AUTH_URL || 'http://localhost:3000';
+    // Ajouter un timestamp pour éviter le cache du client email
+    const timestamp = Date.now();
+    const trackingPixelUrl = `${baseUrl}/api/email/track/${emailTracking.id}?t=${timestamp}`;
+
+    const trackingPixel = `<img src="${trackingPixelUrl}" width="1" height="1" style="display:none;" alt="" />`;
+
+    // Insérer le pixel de tracking avant la fermeture du body ou à la fin du contenu
+    let htmlWithTracking = `${baseHtml}${signatureHtml}`;
+    // Si le HTML contient déjà une balise </body>, insérer avant, sinon à la fin
+    if (htmlWithTracking.includes('</body>')) {
+      htmlWithTracking = htmlWithTracking.replace('</body>', `${trackingPixel}</body>`);
+    } else {
+      htmlWithTracking = `${htmlWithTracking}${trackingPixel}`;
+    }
+
+    // Envoyer l'email avec le pixel de tracking
+    const mailOptions: any = {
+      from: smtpConfig.fromName
+        ? `"${smtpConfig.fromName}" <${smtpConfig.fromEmail}>`
+        : smtpConfig.fromEmail,
+      to: toEmails.join(', '),
+      subject: subject,
+      text: `${baseText}${signatureText}`,
+      html: htmlWithTracking,
+    };
+
+    if (ccEmails.length > 0) {
+      mailOptions.cc = ccEmails.join(', ');
+    }
+
+    if (bccEmails.length > 0) {
+      mailOptions.bcc = bccEmails.join(', ');
+    }
+
+    if (attachments.length > 0) {
+      mailOptions.attachments = attachments;
+    }
+
+    await transporter.sendMail(mailOptions);
+
+    // Récupérer l'interaction avec les relations pour la réponse
+    const interactionWithUser = await prisma.interaction.findUnique({
+      where: { id: interaction.id },
+      include: {
+        user: {
+          select: { id: true, name: true, email: true },
+        },
+      },
+    });
+
+    return NextResponse.json({
+      success: true,
+      message: 'Email envoyé avec succès',
+      interaction: interactionWithUser,
+    });
+  } catch (error: any) {
+    console.error("Erreur lors de l'envoi de l'email:", error);
+
+    // Gérer les erreurs spécifiques de nodemailer
+    if (error.code === 'EAUTH' || error.code === 'ECONNECTION') {
+      return NextResponse.json(
+        { error: "Erreur d'authentification SMTP. Vérifiez votre configuration." },
+        { status: 400 },
+      );
+    }
+
+    return NextResponse.json(
+      { error: error.message || "Erreur lors de l'envoi de l'email" },
+      { status: 500 },
+    );
+  }
+}

package/template/src/app/api/contacts/export/route.ts

@@ -0,0 +1,270 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { getFileInfo } from '@/lib/google-drive';
+
+// POST /api/contacts/export - Exporter des contacts en CSV ou Excel
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    // Vérifier que l'utilisateur est admin
+    const user = await prisma.user.findUnique({
+      where: { id: session.user.id },
+      select: { role: true },
+    });
+
+    if (user?.role !== 'ADMIN') {
+      return NextResponse.json(
+        { error: 'Accès refusé. Seuls les administrateurs peuvent exporter des contacts.' },
+        { status: 403 },
+      );
+    }
+
+    const body = await request.json();
+    const { contactIds, format } = body; // format: 'csv' ou 'excel'
+
+    if (!format || (format !== 'csv' && format !== 'excel')) {
+      return NextResponse.json({ error: 'Format invalide. Utilisez "csv" ou "excel".' }, { status: 400 });
+    }
+
+    // Construire la requête pour récupérer les contacts
+    const where: any = { isCompany: false };
+
+    // Si des IDs sont fournis, exporter seulement ces contacts
+    if (contactIds && Array.isArray(contactIds) && contactIds.length > 0) {
+      where.id = { in: contactIds };
+    }
+
+    // Récupérer les contacts avec toutes les relations nécessaires (notes et fichiers inclus)
+    const contacts = await prisma.contact.findMany({
+      where,
+      include: {
+        status: {
+          select: { name: true },
+        },
+        assignedCommercial: {
+          select: { name: true, email: true },
+        },
+        assignedTelepro: {
+          select: { name: true, email: true },
+        },
+        createdBy: {
+          select: { name: true, email: true },
+        },
+        interactions: {
+          select: {
+            type: true,
+            title: true,
+            content: true,
+            createdAt: true,
+            user: {
+              select: { name: true },
+            },
+          },
+          orderBy: { createdAt: 'desc' },
+        },
+        files: {
+          select: {
+            fileName: true,
+            googleDriveFileId: true,
+            fileSize: true,
+            mimeType: true,
+            createdAt: true,
+          },
+          orderBy: { createdAt: 'desc' },
+        },
+      },
+      orderBy: { createdAt: 'desc' },
+    });
+
+    if (contacts.length === 0) {
+      return NextResponse.json({ error: 'Aucun contact à exporter' }, { status: 400 });
+    }
+
+    // Préparer les données pour l'export avec notes et fichiers
+    const headers = [
+      'Civilité',
+      'Prénom',
+      'Nom',
+      'Téléphone',
+      'Téléphone secondaire',
+      'Email',
+      'Adresse',
+      'Ville',
+      'Code postal',
+      'Origine',
+      'Statut',
+      'Commercial',
+      'Email Commercial',
+      'Télépro',
+      'Email Télépro',
+      'Créé le',
+      'Modifié le',
+      'Notes',
+      'Fichiers',
+    ];
+
+    // Fonction pour formater les notes
+    const formatNotes = (interactions: any[]) => {
+      if (!interactions || interactions.length === 0) return '';
+      
+      return interactions
+        .map((interaction) => {
+          const date = interaction.createdAt
+            ? new Date(interaction.createdAt).toLocaleString('fr-FR', {
+                day: '2-digit',
+                month: '2-digit',
+                year: 'numeric',
+                hour: '2-digit',
+                minute: '2-digit',
+              })
+            : '';
+          const author = interaction.user?.name || 'Inconnu';
+          const title = interaction.title ? `${interaction.title}: ` : '';
+          const content = interaction.content || '';
+          
+          return `[${date}] ${author} - ${title}${content}`;
+        })
+        .join('\n\n');
+    };
+
+    // Fonction pour formater les fichiers (essayer de récupérer les liens si possible)
+    const formatFiles = async (files: any[], userId: string) => {
+      if (!files || files.length === 0) return '';
+      
+      const fileInfos = await Promise.allSettled(
+        files.map(async (file) => {
+          try {
+            // Essayer de récupérer le lien depuis Google Drive
+            const fileInfo = await getFileInfo(userId, file.googleDriveFileId);
+            const sizeKB = (file.fileSize / 1024).toFixed(2);
+            return `${file.fileName} (${sizeKB} KB) - ${fileInfo.webViewLink}`;
+          } catch (error) {
+            // Si échec, utiliser un lien basique
+            const sizeKB = (file.fileSize / 1024).toFixed(2);
+            return `${file.fileName} (${sizeKB} KB) - https://drive.google.com/file/d/${file.googleDriveFileId}/view`;
+          }
+        }),
+      );
+      
+      return fileInfos
+        .map((result) => (result.status === 'fulfilled' ? result.value : result.reason?.message || 'Erreur'))
+        .join('\n');
+    };
+
+    // Préparer les lignes avec notes et fichiers
+    const rows = await Promise.all(
+      contacts.map(async (contact) => {
+        const notes = formatNotes(contact.interactions || []);
+        const files = await formatFiles(contact.files || [], session.user.id);
+        
+        return [
+          contact.civility || '',
+          contact.firstName || '',
+          contact.lastName || '',
+          contact.phone || '',
+          contact.secondaryPhone || '',
+          contact.email || '',
+          contact.address || '',
+          contact.city || '',
+          contact.postalCode || '',
+          contact.origin || '',
+          contact.status?.name || '',
+          contact.assignedCommercial?.name || '',
+          contact.assignedCommercial?.email || '',
+          contact.assignedTelepro?.name || '',
+          contact.assignedTelepro?.email || '',
+          contact.createdAt ? new Date(contact.createdAt).toLocaleString('fr-FR') : '',
+          contact.updatedAt ? new Date(contact.updatedAt).toLocaleString('fr-FR') : '',
+          notes,
+          files,
+        ];
+      }),
+    );
+
+    if (format === 'csv') {
+      // Générer CSV
+      const csvContent = [
+        headers.join(','),
+        ...rows.map((row) =>
+          row
+            .map((cell) => {
+              // Échapper les guillemets et les virgules
+              const cellStr = String(cell || '').replace(/"/g, '""');
+              return `"${cellStr}"`;
+            })
+            .join(','),
+        ),
+      ].join('\n');
+
+      // Ajouter BOM pour Excel UTF-8
+      const csvWithBOM = '\uFEFF' + csvContent;
+
+      return new NextResponse(csvWithBOM, {
+        headers: {
+          'Content-Type': 'text/csv; charset=utf-8',
+          'Content-Disposition': `attachment; filename="contacts_${new Date().toISOString().split('T')[0]}.csv"`,
+        },
+      });
+    } else if (format === 'excel') {
+      // Pour Excel, nous allons utiliser une bibliothèque
+      // Vérifions d'abord si xlsx est disponible, sinon on génère un CSV
+      try {
+        const XLSX = await import('xlsx');
+        const worksheet = XLSX.utils.aoa_to_sheet([headers, ...rows]);
+        const workbook = XLSX.utils.book_new();
+        XLSX.utils.book_append_sheet(workbook, worksheet, 'Contacts');
+
+        // Générer le buffer Excel
+        const excelBuffer = XLSX.write(workbook, {
+          type: 'buffer',
+          bookType: 'xlsx',
+        });
+
+        return new NextResponse(excelBuffer, {
+          headers: {
+            'Content-Type':
+              'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            'Content-Disposition': `attachment; filename="contacts_${new Date().toISOString().split('T')[0]}.xlsx"`,
+          },
+        });
+      } catch (error) {
+        // Si xlsx n'est pas disponible, générer un CSV à la place
+        console.warn('Bibliothèque xlsx non disponible, génération CSV à la place');
+        const csvContent = [
+          headers.join(','),
+          ...rows.map((row) =>
+            row
+              .map((cell) => {
+                const cellStr = String(cell || '').replace(/"/g, '""');
+                return `"${cellStr}"`;
+              })
+              .join(','),
+          ),
+        ].join('\n');
+
+        const csvWithBOM = '\uFEFF' + csvContent;
+
+        return new NextResponse(csvWithBOM, {
+          headers: {
+            'Content-Type': 'text/csv; charset=utf-8',
+            'Content-Disposition': `attachment; filename="contacts_${new Date().toISOString().split('T')[0]}.csv"`,
+          },
+        });
+      }
+    } else {
+      return NextResponse.json({ error: 'Format non supporté' }, { status: 400 });
+    }
+  } catch (error: any) {
+    console.error('Erreur lors de l\'export des contacts:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+