create-crm-tmp 1.0.0

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

@@ -0,0 +1,381 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { handleContactDuplicate } from '@/lib/contact-duplicate';
+import { normalizePhoneNumber } from '@/lib/utils';
+
+// POST /api/contacts/import - Importer des contacts depuis un fichier CSV/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 });
+    }
+
+    const formData = await request.formData();
+    const file = formData.get('file') as File;
+    const fieldMappingsJson = formData.get('fieldMappings') as string;
+    const skipFirstRow = formData.get('skipFirstRow') === 'true';
+    
+    // Récupérer les valeurs par défaut
+    const defaultStatusId = formData.get('defaultStatusId') as string | null;
+    const defaultCommercialId = formData.get('defaultCommercialId') as string | null;
+    const defaultOrigin = formData.get('defaultOrigin') as string | null;
+
+    if (!file) {
+      return NextResponse.json({ error: 'Aucun fichier fourni' }, { status: 400 });
+    }
+
+    if (!fieldMappingsJson) {
+      return NextResponse.json({ error: 'Mapping des colonnes requis' }, { status: 400 });
+    }
+
+    const fieldMappings: Record<
+      string,
+      {
+        action: 'map' | 'note' | 'ignore';
+        crmField?: string;
+      }
+    > = JSON.parse(fieldMappingsJson);
+
+    // Construire le mapping inversé (crmField -> colonne du fichier) pour les champs mappés
+    const mapping: Record<string, string> = {};
+    const noteFields: string[] = [];
+
+    for (const [fileColumn, config] of Object.entries(fieldMappings)) {
+      if (config.action === 'map' && config.crmField) {
+        mapping[config.crmField] = fileColumn;
+      } else if (config.action === 'note') {
+        noteFields.push(fileColumn);
+      }
+      // 'ignore' : on ne fait rien
+    }
+
+    // Parser le fichier selon son type
+    let rows: any[] = [];
+    const fileName = file.name.toLowerCase();
+    const fileExtension = fileName.split('.').pop();
+
+    if (fileExtension === 'csv') {
+      // Parser CSV
+      const text = await file.text();
+      rows = parseCSV(text);
+    } else if (fileExtension === 'xlsx' || fileExtension === 'xls') {
+      // Parser Excel
+      try {
+        const XLSX = require('xlsx');
+        const buffer = await file.arrayBuffer();
+        const workbook = XLSX.read(buffer, { type: 'array' });
+        const sheetName = workbook.SheetNames[0];
+        const worksheet = workbook.Sheets[sheetName];
+        rows = XLSX.utils.sheet_to_json(worksheet, { raw: false });
+      } catch (error) {
+        return NextResponse.json(
+          { error: 'Erreur lors du parsing Excel. Assurez-vous que xlsx est installé.' },
+          { status: 400 },
+        );
+      }
+    } else {
+      return NextResponse.json(
+        { error: 'Format de fichier non supporté. Utilisez CSV ou Excel (.xlsx, .xls)' },
+        { status: 400 },
+      );
+    }
+
+    if (rows.length === 0) {
+      return NextResponse.json({ error: 'Le fichier est vide' }, { status: 400 });
+    }
+
+    // Ignorer la première ligne si c'est un en-tête
+    const dataRows = skipFirstRow ? rows.slice(1) : rows;
+
+    // Valider et mapper les données
+    const contactsToCreate: any[] = [];
+    const errors: string[] = [];
+    const skipped: number[] = [];
+
+    for (let i = 0; i < dataRows.length; i++) {
+      const row = dataRows[i];
+      const rowNumber = skipFirstRow ? i + 2 : i + 1;
+
+      try {
+        // Mapper les colonnes selon le mapping fourni
+        const phone = getValueFromRow(row, mapping.phone);
+        if (!phone) {
+          skipped.push(rowNumber);
+          continue; // Le téléphone est obligatoire
+        }
+
+        // Normaliser le numéro de téléphone au format : 0X XX XX XX XX
+        const normalizedPhone = normalizePhoneNumber(phone.toString());
+
+        // Déterminer le statusId : utiliser le mapping si fourni, sinon le statut par défaut fourni
+        let statusId = null;
+        if (mapping.statusId) {
+          const mappedStatus = getValueFromRow(row, mapping.statusId);
+          if (mappedStatus) {
+            // Si une valeur est mappée, chercher le statut par nom
+            const status = await prisma.status.findUnique({
+              where: { name: mappedStatus },
+            });
+            statusId = status?.id || null;
+          }
+        }
+        // Si aucun statut n'a été trouvé via le mapping, utiliser le statut par défaut fourni
+        if (!statusId && defaultStatusId) {
+          statusId = defaultStatusId;
+        }
+        // Si toujours aucun statut, utiliser "Nouveau" par défaut
+        if (!statusId) {
+          const nouveauStatus = await prisma.status.findUnique({
+            where: { name: 'Nouveau' },
+          });
+          statusId = nouveauStatus?.id || null;
+        }
+
+        // Déterminer l'origine : utiliser le mapping si fourni, sinon la valeur par défaut fournie
+        const origin = getValueFromRow(row, mapping.origin) || defaultOrigin || null;
+
+        // Déterminer le commercial : utiliser le mapping si fourni, sinon le commercial par défaut fourni
+        let assignedCommercialId = null;
+        if (mapping.assignedCommercialId) {
+          assignedCommercialId = getValueFromRow(row, mapping.assignedCommercialId) || null;
+        }
+        if (!assignedCommercialId && defaultCommercialId) {
+          assignedCommercialId = defaultCommercialId;
+        }
+
+        const contactData: any = {
+          phone: normalizedPhone,
+          civility: getValueFromRow(row, mapping.civility) || null,
+          firstName: getValueFromRow(row, mapping.firstName) || null,
+          lastName: getValueFromRow(row, mapping.lastName) || null,
+          secondaryPhone: mapping.secondaryPhone
+            ? normalizePhoneNumber(getValueFromRow(row, mapping.secondaryPhone) || '') || null
+            : null,
+          email: getValueFromRow(row, mapping.email) || null,
+          address: getValueFromRow(row, mapping.address) || null,
+          city: getValueFromRow(row, mapping.city) || null,
+          postalCode: getValueFromRow(row, mapping.postalCode) || null,
+          origin: origin,
+          statusId: statusId,
+          assignedCommercialId: assignedCommercialId,
+          assignedTeleproId: mapping.assignedTeleproId
+            ? getValueFromRow(row, mapping.assignedTeleproId) || null
+            : null,
+          createdById: session.user.id,
+        };
+
+        // Collecter les notes à ajouter
+        const noteContents: string[] = [];
+        for (const noteField of noteFields) {
+          const value = getValueFromRow(row, noteField);
+          if (value) {
+            noteContents.push(`${noteField}: ${value}`);
+          }
+        }
+
+        // Valider les données
+        if (!contactData.phone || contactData.phone.trim() === '') {
+          skipped.push(rowNumber);
+          continue;
+        }
+
+        // Stocker les notes avec le contact
+        contactsToCreate.push({
+          ...contactData,
+          _noteContents: noteContents, // Préfixe _ pour indiquer que c'est une propriété temporaire
+        });
+      } catch (error: any) {
+        errors.push(`Ligne ${rowNumber}: ${error.message}`);
+      }
+    }
+
+    // Créer les contacts en lot
+    const createdContacts = [];
+    const duplicateErrors = [];
+
+    for (const contactDataWithNotes of contactsToCreate) {
+      // Extraire les notes et les données du contact
+      const { _noteContents, ...contactData } = contactDataWithNotes as any;
+      const noteContents = _noteContents || [];
+
+      try {
+        // Vérifier si c'est un doublon (nom, prénom ET email)
+        const duplicateContactId = await handleContactDuplicate(
+          contactData.firstName,
+          contactData.lastName,
+          contactData.email,
+          contactData.origin || 'Import CSV/Excel',
+          session.user.id,
+        );
+
+        if (duplicateContactId) {
+          // C'est un doublon, récupérer le contact existant
+          const existingContact = await prisma.contact.findUnique({
+            where: { id: duplicateContactId },
+            include: {
+              status: true,
+              assignedCommercial: {
+                select: { id: true, name: true, email: true },
+              },
+              assignedTelepro: {
+                select: { id: true, name: true, email: true },
+              },
+              createdBy: {
+                select: { id: true, name: true, email: true },
+              },
+            },
+          });
+          if (existingContact) {
+            createdContacts.push(existingContact);
+            duplicateErrors.push(
+              `Contact ${contactData.firstName} ${contactData.lastName} (${contactData.email}) - doublon détecté`,
+            );
+          }
+          continue;
+        }
+
+        // Vérifier aussi par téléphone pour éviter les doublons par téléphone uniquement
+        const existingByPhone = await prisma.contact.findFirst({
+          where: { phone: contactData.phone },
+        });
+
+        if (existingByPhone) {
+          duplicateErrors.push(`Téléphone ${contactData.phone} déjà existant`);
+          continue;
+        }
+
+        // Préparer les interactions à créer
+        const interactionsToCreate: any[] = [
+          {
+            type: 'NOTE',
+            title: 'Contact importé',
+            content: `Contact importé depuis un fichier le ${new Date().toLocaleDateString(
+              'fr-FR',
+              {
+                day: 'numeric',
+                month: 'long',
+                year: 'numeric',
+                hour: '2-digit',
+                minute: '2-digit',
+              },
+            )}`,
+            userId: session.user.id,
+            date: new Date(),
+          },
+        ];
+
+        // Ajouter les notes pour les colonnes configurées comme "note"
+        if (noteContents.length > 0) {
+          interactionsToCreate.push({
+            type: 'NOTE',
+            title: 'Informations supplémentaires',
+            content: noteContents.join('\n'),
+            userId: session.user.id,
+            date: new Date(),
+          });
+        }
+
+        const contact = await prisma.contact.create({
+          data: {
+            ...contactData,
+            interactions: {
+              create: interactionsToCreate,
+            },
+          },
+          include: {
+            status: true,
+            assignedCommercial: {
+              select: { id: true, name: true, email: true },
+            },
+            assignedTelepro: {
+              select: { id: true, name: true, email: true },
+            },
+            createdBy: {
+              select: { id: true, name: true, email: true },
+            },
+          },
+        });
+
+        createdContacts.push(contact);
+      } catch (error: any) {
+        errors.push(`Erreur lors de la création: ${error.message}`);
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      imported: createdContacts.length,
+      skipped: skipped.length,
+      duplicates: duplicateErrors.length,
+      errors: errors.length,
+      details: {
+        created: createdContacts.length,
+        skippedRows: skipped,
+        duplicatePhones: duplicateErrors,
+        errors: errors.slice(0, 10), // Limiter à 10 erreurs
+      },
+    });
+  } catch (error: any) {
+    console.error("Erreur lors de l'import:", error);
+    return NextResponse.json(
+      { error: error.message || "Erreur serveur lors de l'import" },
+      { status: 500 },
+    );
+  }
+}
+
+// Fonction pour parser CSV
+function parseCSV(text: string): any[] {
+  const lines = text.split('\n').filter((line) => line.trim() !== '');
+  if (lines.length === 0) return [];
+
+  // Détecter le délimiteur (virgule ou point-virgule)
+  const firstLine = lines[0];
+  const delimiter = firstLine.includes(';') ? ';' : ',';
+
+  // Parser les en-têtes
+  const headers = lines[0].split(delimiter).map((h) => h.trim().replace(/^"|"$/g, ''));
+
+  // Parser les lignes de données
+  const rows: any[] = [];
+  for (let i = 1; i < lines.length; i++) {
+    const values = lines[i].split(delimiter).map((v) => v.trim().replace(/^"|"$/g, ''));
+    const row: any = {};
+    headers.forEach((header, index) => {
+      row[header] = values[index] || '';
+    });
+    rows.push(row);
+  }
+
+  return rows;
+}
+
+// Fonction pour extraire une valeur d'une ligne selon le mapping
+function getValueFromRow(row: any, columnName: string | null | undefined): string | null {
+  if (!columnName || columnName === '') return null;
+
+  // Essayer d'abord le nom exact (pour les colonnes du fichier)
+  if (row[columnName] !== undefined && row[columnName] !== null && row[columnName] !== '') {
+    return String(row[columnName]).trim();
+  }
+
+  // Essayer différentes variantes du nom de colonne
+  const variants = [
+    columnName.trim(),
+    columnName.toLowerCase(),
+    columnName.toUpperCase(),
+  ];
+
+  for (const variant of variants) {
+    if (row[variant] !== undefined && row[variant] !== null && row[variant] !== '') {
+      return String(row[variant]).trim();
+    }
+  }
+
+  return null;
+}

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

@@ -0,0 +1,283 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { handleContactDuplicate } from '@/lib/contact-duplicate';
+import { executeWorkflowsOnContactCreated } from '@/lib/workflow-executor';
+import { normalizePhoneNumber } from '@/lib/utils';
+
+// GET /api/contacts - Récupérer tous les contacts avec filtres
+export async function GET(request: NextRequest) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { searchParams } = new URL(request.url);
+    const search = searchParams.get('search') || '';
+    const statusId = searchParams.get('statusId');
+    const assignedCommercialId = searchParams.get('assignedCommercialId');
+    const assignedTeleproId = searchParams.get('assignedTeleproId');
+    const origin = searchParams.get('origin');
+    const createdAtStart = searchParams.get('createdAtStart');
+    const createdAtEnd = searchParams.get('createdAtEnd');
+    const updatedAtStart = searchParams.get('updatedAtStart');
+    const updatedAtEnd = searchParams.get('updatedAtEnd');
+    // const isCompany = searchParams.get('isCompany');
+    const page = parseInt(searchParams.get('page') || '1');
+    const limit = parseInt(searchParams.get('limit') || '50');
+    const skip = (page - 1) * limit;
+
+    // Construire les filtres
+    const where: any = {};
+
+    if (search) {
+      where.OR = [
+        { firstName: { contains: search, mode: 'insensitive' } },
+        { lastName: { contains: search, mode: 'insensitive' } },
+        { email: { contains: search, mode: 'insensitive' } },
+        { phone: { contains: search, mode: 'insensitive' } },
+      ];
+    }
+
+    if (statusId) {
+      where.statusId = statusId;
+    }
+
+    if (assignedCommercialId) {
+      where.assignedCommercialId = assignedCommercialId;
+    }
+
+    if (assignedTeleproId) {
+      where.assignedTeleproId = assignedTeleproId;
+    }
+
+    if (origin) {
+      where.origin = origin;
+    }
+
+    // Filtres de date pour createdAt
+    if (createdAtStart || createdAtEnd) {
+      where.createdAt = {};
+      if (createdAtStart) {
+        const startDate = new Date(createdAtStart);
+        if (!isNaN(startDate.getTime())) {
+          where.createdAt.gte = startDate;
+        }
+      }
+      if (createdAtEnd) {
+        // Ajouter 23h59m59s pour inclure toute la journée
+        const endDate = new Date(createdAtEnd);
+        if (!isNaN(endDate.getTime())) {
+          endDate.setHours(23, 59, 59, 999);
+          where.createdAt.lte = endDate;
+        }
+      }
+    }
+
+    // Filtres de date pour updatedAt
+    if (updatedAtStart || updatedAtEnd) {
+      where.updatedAt = {};
+      if (updatedAtStart) {
+        const startDate = new Date(updatedAtStart);
+        if (!isNaN(startDate.getTime())) {
+          where.updatedAt.gte = startDate;
+        }
+      }
+      if (updatedAtEnd) {
+        // Ajouter 23h59m59s pour inclure toute la journée
+        const endDate = new Date(updatedAtEnd);
+        if (!isNaN(endDate.getTime())) {
+          endDate.setHours(23, 59, 59, 999);
+          where.updatedAt.lte = endDate;
+        }
+      }
+    }
+
+    // if (isCompany === 'true') {
+    //   where = { ...where, isCompany: true };
+    // }
+
+    const [contacts, total] = await Promise.all([
+      prisma.contact.findMany({
+        where: {
+          ...where,
+          isCompany: false,
+        },
+        include: {
+          status: true,
+          companyRelation: {
+            select: { id: true, firstName: true, lastName: true, isCompany: true },
+          },
+          assignedCommercial: {
+            select: { id: true, name: true, email: true },
+          },
+          assignedTelepro: {
+            select: { id: true, name: true, email: true },
+          },
+          createdBy: {
+            select: { id: true, name: true, email: true },
+          },
+        },
+        orderBy: { createdAt: 'desc' },
+        skip,
+        take: limit,
+      }),
+      prisma.contact.count({ where: { ...where, isCompany: false } }),
+    ]);
+
+    return NextResponse.json({
+      contacts,
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages: Math.ceil(total / limit),
+      },
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des contacts:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// POST /api/contacts - Créer un nouveau contact
+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 });
+    }
+
+    const body = await request.json();
+    const {
+      civility,
+      firstName,
+      lastName,
+      phone,
+      secondaryPhone,
+      email,
+      address,
+      city,
+      postalCode,
+      origin,
+      companyName,
+      isCompany,
+      companyId,
+      statusId,
+      closingReason,
+      assignedCommercialId,
+      assignedTeleproId,
+    } = body;
+
+    // Validation
+    if (!phone) {
+      return NextResponse.json({ error: 'Le téléphone est obligatoire' }, { status: 400 });
+    }
+
+    // Vérifier si c'est un doublon (nom, prénom ET email)
+    const duplicateContactId = await handleContactDuplicate(
+      firstName,
+      lastName,
+      email,
+      origin || 'Création manuelle',
+      session.user.id,
+    );
+
+    // Si c'est un doublon, retourner le contact existant
+    if (duplicateContactId) {
+      const existingContact = await prisma.contact.findUnique({
+        where: { id: duplicateContactId },
+        include: {
+          status: true,
+          companyRelation: {
+            select: { id: true, firstName: true, lastName: true, isCompany: true },
+          },
+          assignedCommercial: {
+            select: { id: true, name: true, email: true },
+          },
+          assignedTelepro: {
+            select: { id: true, name: true, email: true },
+          },
+          createdBy: {
+            select: { id: true, name: true, email: true },
+          },
+        },
+      });
+      return NextResponse.json(existingContact, { status: 200 });
+    }
+
+    // Sinon, créer un nouveau contact
+    const contact = await prisma.contact.create({
+      data: {
+        civility: civility || null,
+        firstName: firstName || null,
+        lastName: lastName || null,
+        phone: normalizePhoneNumber(phone),
+        secondaryPhone: secondaryPhone ? normalizePhoneNumber(secondaryPhone) : null,
+        email: email || null,
+        address: address || null,
+        city: city || null,
+        postalCode: postalCode || null,
+        origin: origin || null,
+        companyName: companyName || null,
+        isCompany: isCompany === true,
+        companyId: companyId || null,
+        statusId: statusId || null,
+        closingReason: closingReason || null,
+        assignedCommercialId: assignedCommercialId || null,
+        assignedTeleproId: assignedTeleproId || null,
+        createdById: session.user.id,
+        interactions: {
+          create: {
+            type: 'NOTE',
+            title: 'Contact créé',
+            content: `Contact créé le ${new Date().toLocaleDateString('fr-FR', {
+              day: 'numeric',
+              month: 'long',
+              year: 'numeric',
+              hour: '2-digit',
+              minute: '2-digit',
+            })}`,
+            userId: session.user.id,
+            date: new Date(),
+          },
+        },
+      },
+      include: {
+        status: true,
+        companyRelation: {
+          select: { id: true, firstName: true, lastName: true, isCompany: true },
+        },
+        assignedCommercial: {
+          select: { id: true, name: true, email: true },
+        },
+        assignedTelepro: {
+          select: { id: true, name: true, email: true },
+        },
+        createdBy: {
+          select: { id: true, name: true, email: true },
+        },
+      },
+    });
+
+    // Exécuter les workflows déclenchés par la création d'un contact
+    try {
+      await executeWorkflowsOnContactCreated(contact.id);
+    } catch (workflowError) {
+      // Ne pas faire échouer la création du contact si les workflows échouent
+      console.error('Erreur lors de l\'exécution des workflows:', workflowError);
+    }
+
+    return NextResponse.json(contact, { status: 201 });
+  } catch (error: any) {
+    console.error('Erreur lors de la création du contact:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}