create-crm-tmp 1.1.3 → 2.1.0

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

@@ -1,7 +1,8 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
-import { getFileInfo } from '@/lib/google-drive';
+import { checkPermission } from '@/lib/check-permission';
+import { BUCKETS, createSignedDownloadUrl } from '@/lib/supabase-storage';
 
 // POST /api/contacts/export - Exporter des contacts en CSV ou Excel
 export async function POST(request: NextRequest) {
@@ -14,17 +15,9 @@ export async function POST(request: NextRequest) {
       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 canExport = await checkPermission('contacts.export');
+    if (!canExport) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
     }
 
     const body = await request.json();
@@ -38,14 +31,13 @@ export async function POST(request: NextRequest) {
     }
 
     // Construire la requête pour récupérer les contacts
-    const where: any = { isCompany: false };
+    const where: any =
+      contactIds && Array.isArray(contactIds) && contactIds.length > 0
+        ? { id: { in: contactIds } }
+        : {};
 
-    // Si des IDs sont fournis, exporter seulement ces contacts
-    if (contactIds && Array.isArray(contactIds) && contactIds.length > 0) {
-      where.id = { in: contactIds };
-    }
+    const MAX_EXPORT = 10_000;
 
-    // Récupérer les contacts avec toutes les relations nécessaires (notes et fichiers inclus)
     const contacts = await prisma.contact.findMany({
       where,
       include: {
@@ -72,19 +64,22 @@ export async function POST(request: NextRequest) {
             },
           },
           orderBy: { createdAt: 'desc' },
+          take: 50,
         },
         files: {
           select: {
             fileName: true,
-            googleDriveFileId: true,
+            storagePath: true,
             fileSize: true,
             mimeType: true,
             createdAt: true,
           },
           orderBy: { createdAt: 'desc' },
+          take: 20,
         },
       },
       orderBy: { createdAt: 'desc' },
+      take: MAX_EXPORT,
     });
 
     if (contacts.length === 0) {
@@ -129,7 +124,7 @@ export async function POST(request: NextRequest) {
                 minute: '2-digit',
               })
             : '';
-          const author = interaction.user?.name || 'Ancien utilisateur';
+          const author = interaction.user?.name || 'Inconnu';
           const title = interaction.title ? `${interaction.title}: ` : '';
           const content = interaction.content || '';
 
@@ -138,21 +133,17 @@ export async function POST(request: NextRequest) {
         .join('\n\n');
     };
 
-    // Fonction pour formater les fichiers (essayer de récupérer les liens si possible)
-    const formatFiles = async (files: any[], userId: string) => {
+    const formatFiles = async (files: any[]) => {
       if (!files || files.length === 0) return '';
 
       const fileInfos = await Promise.allSettled(
         files.map(async (file) => {
+          const sizeKB = (file.fileSize / 1024).toFixed(2);
           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`;
+            const url = await createSignedDownloadUrl(BUCKETS.CONTACTS, file.storagePath);
+            return `${file.fileName} (${sizeKB} KB) - ${url}`;
+          } catch {
+            return `${file.fileName} (${sizeKB} KB)`;
           }
         }),
       );
@@ -168,7 +159,7 @@ export async function POST(request: NextRequest) {
     const rows = await Promise.all(
       contacts.map(async (contact) => {
         const notes = formatNotes(contact.interactions || []);
-        const files = await formatFiles(contact.files || [], session.user.id);
+        const files = await formatFiles(contact.files || []);
 
         return [
           contact.civility || '',

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

@@ -1,8 +1,10 @@
 import { NextRequest, NextResponse } from 'next/server';
+import * as XLSX from 'xlsx';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
-import { handleContactDuplicate } from '@/lib/contact-duplicate';
-import { normalizePhoneNumber } from '@/lib/utils';
+import { checkPermission } from '@/lib/check-permission';
+import { handleContactDuplicate, markContactAsDuplicate } from '@/lib/contact-duplicate';
+import { normalizePhoneNumber, parseImportDate } from '@/lib/utils';
 
 // POST /api/contacts/import - Importer des contacts depuis un fichier CSV/Excel
 export async function POST(request: NextRequest) {
@@ -15,10 +17,18 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const canImport = await checkPermission('contacts.import');
+    if (!canImport) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     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';
+    const selectedSheetName = (formData.get('sheetName') as string) || undefined;
+    const headerRowStr = formData.get('headerRow') as string | null;
+    const headerRow = headerRowStr ? Number.parseInt(headerRowStr, 10) : 0;
 
     // Récupérer les valeurs par défaut
     const defaultStatusId = formData.get('defaultStatusId') as string | null;
@@ -64,14 +74,15 @@ export async function POST(request: NextRequest) {
       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 sheetName =
+          selectedSheetName && workbook.SheetNames.includes(selectedSheetName)
+            ? selectedSheetName
+            : workbook.SheetNames[0];
         const worksheet = workbook.Sheets[sheetName];
-        rows = XLSX.utils.sheet_to_json(worksheet, { raw: false });
+        rows = XLSX.utils.sheet_to_json(worksheet, { raw: false, range: headerRow });
       } catch (error) {
         return NextResponse.json(
           { error: 'Erreur lors du parsing Excel. Assurez-vous que xlsx est installé.' },
@@ -92,7 +103,11 @@ export async function POST(request: NextRequest) {
     // 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
+    // Pré-charger tous les statuts pour éviter des requêtes N+1 dans la boucle
+    const allStatuses = await prisma.status.findMany();
+    const statusByName = new Map(allStatuses.map((s) => [s.name, s.id]));
+    const defaultNewStatusId = statusByName.get('Nouveau') || null;
+
     const contactsToCreate: any[] = [];
     const errors: string[] = [];
     const skipped: number[] = [];
@@ -102,38 +117,26 @@ export async function POST(request: NextRequest) {
       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
+          continue;
         }
 
-        // 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;
+            statusId = statusByName.get(mappedStatus) || 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;
+          statusId = defaultNewStatusId;
         }
 
         // Déterminer l'origine : utiliser le mapping si fourni, sinon la valeur par défaut fournie
@@ -148,6 +151,32 @@ export async function POST(request: NextRequest) {
           assignedCommercialId = defaultCommercialId;
         }
 
+        // Construire socialNetworks depuis les colonnes mappées (linkedin, facebook, twitter, instagram)
+        const socialPlatforms: { platform: string; url: string }[] = [];
+        const socialKeys: { key: string; label: string }[] = [
+          { key: 'linkedin', label: 'LinkedIn' },
+          { key: 'facebook', label: 'Facebook' },
+          { key: 'twitter', label: 'Twitter' },
+          { key: 'instagram', label: 'Instagram' },
+        ];
+        for (const { key, label } of socialKeys) {
+          const col = mapping[key];
+          if (col) {
+            const url = getValueFromRow(row, col);
+            if (url && String(url).trim()) {
+              let href = String(url).trim();
+              if (!href.startsWith('http://') && !href.startsWith('https://')) {
+                href = `https://${href}`;
+              }
+              socialPlatforms.push({ platform: label, url: href });
+            }
+          }
+        }
+
+        const createdAtImport = mapping.createdAt
+          ? parseImportDate(getValueFromRow(row, mapping.createdAt))
+          : null;
+
         const contactData: any = {
           phone: normalizedPhone,
           civility: getValueFromRow(row, mapping.civility) || null,
@@ -160,6 +189,10 @@ export async function POST(request: NextRequest) {
           address: getValueFromRow(row, mapping.address) || null,
           city: getValueFromRow(row, mapping.city) || null,
           postalCode: getValueFromRow(row, mapping.postalCode) || null,
+          companyName: getValueFromRow(row, mapping.companyName) || null,
+          website: mapping.website ? (getValueFromRow(row, mapping.website) || null) : null,
+          jobTitle: getValueFromRow(row, mapping.jobTitle) || null,
+          socialNetworks: socialPlatforms.length > 0 ? socialPlatforms : null,
           origin: origin,
           statusId: statusId,
           assignedCommercialId: assignedCommercialId,
@@ -167,6 +200,7 @@ export async function POST(request: NextRequest) {
             ? getValueFromRow(row, mapping.assignedTeleproId) || null
             : null,
           createdById: session.user.id,
+          ...(createdAtImport && { createdAt: createdAtImport }),
         };
 
         // Collecter les notes à ajouter
@@ -197,6 +231,7 @@ export async function POST(request: NextRequest) {
     // Créer les contacts en lot
     const createdContacts = [];
     const duplicateErrors = [];
+    const duplicateContactIds: string[] = [];
 
     for (const contactDataWithNotes of contactsToCreate) {
       // Extraire les notes et les données du contact
@@ -214,28 +249,10 @@ export async function POST(request: NextRequest) {
         );
 
         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é`,
-            );
-          }
+          duplicateContactIds.push(duplicateContactId);
+          duplicateErrors.push(
+            `Contact ${contactData.firstName} ${contactData.lastName} (${contactData.email}) - doublon détecté`,
+          );
           continue;
         }
 
@@ -245,6 +262,13 @@ export async function POST(request: NextRequest) {
         });
 
         if (existingByPhone) {
+          duplicateContactIds.push(existingByPhone.id);
+          await markContactAsDuplicate(
+            existingByPhone.id,
+            contactData.origin || 'Import CSV/Excel',
+            session.user.id,
+            prisma,
+          );
           duplicateErrors.push(`Téléphone ${contactData.phone} déjà existant`);
           continue;
         }
@@ -307,6 +331,15 @@ export async function POST(request: NextRequest) {
       }
     }
 
+    // Bumper le createdAt des doublons APRÈS la création des nouveaux contacts
+    // pour qu'ils remontent en haut de la liste (tri createdAt desc)
+    if (duplicateContactIds.length > 0) {
+      await prisma.contact.updateMany({
+        where: { id: { in: duplicateContactIds } },
+        data: { createdAt: new Date() },
+      });
+    }
+
     return NextResponse.json({
       success: true,
       imported: createdContacts.length,

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

@@ -0,0 +1,139 @@
+import { NextRequest, NextResponse } from 'next/server';
+import * as XLSX from 'xlsx';
+import { auth } from '@/lib/auth';
+import { checkPermission } from '@/lib/check-permission';
+
+function parseCsv(
+  text: string,
+  headerRow = 0,
+): {
+  headers: string[];
+  preview: Record<string, string>[];
+  rawRows: string[][];
+} | null {
+  const lines = text.split('\n').filter((line) => line.trim() !== '');
+  if (lines.length === 0) return null;
+
+  const delimiter = lines[0].includes(';') ? ';' : ',';
+  const strip = (s: string) => s.trim().replaceAll(/(^")|("$)/g, '');
+
+  const rawRows: string[][] = lines.slice(0, 20).map((line) => line.split(delimiter).map(strip));
+
+  if (headerRow >= lines.length) return null;
+
+  const headers = lines[headerRow].split(delimiter).map(strip);
+
+  const preview: Record<string, string>[] = [];
+  for (let i = headerRow + 1; i < Math.min(headerRow + 6, lines.length); i++) {
+    const values = lines[i].split(delimiter).map(strip);
+    const row: Record<string, string> = {};
+    headers.forEach((header, index) => {
+      row[header] = values[index] || '';
+    });
+    preview.push(row);
+  }
+
+  return { headers, preview, rawRows };
+}
+
+function parseExcel(
+  buffer: ArrayBuffer,
+  sheetName?: string,
+  headerRow = 0,
+): {
+  sheetNames: string[];
+  headers: string[];
+  preview: Record<string, string>[];
+  rawRows: string[][];
+} | null {
+  const workbook = XLSX.read(buffer, { type: 'array' });
+  const sheetNames: string[] = workbook.SheetNames;
+
+  const targetSheet = sheetName && sheetNames.includes(sheetName) ? sheetName : sheetNames[0];
+  const worksheet = workbook.Sheets[targetSheet];
+
+  const allRows: string[][] = XLSX.utils.sheet_to_json(worksheet, {
+    header: 1,
+    raw: false,
+    defval: '',
+  });
+
+  if (allRows.length === 0) return null;
+
+  const rawRows = allRows
+    .slice(0, 20)
+    .map((row: unknown[]) => row.map((cell) => String(cell ?? '')));
+
+  if (headerRow >= allRows.length) return null;
+
+  const headers = allRows[headerRow]
+    .map((cell: unknown) => String(cell ?? '').trim())
+    .filter(Boolean);
+
+  const preview: Record<string, string>[] = [];
+  for (let i = headerRow + 1; i < Math.min(headerRow + 6, allRows.length); i++) {
+    const values = allRows[i];
+    const row: Record<string, string> = {};
+    headers.forEach((header, index) => {
+      row[header] = String(values[index] ?? '');
+    });
+    preview.push(row);
+  }
+
+  return { sheetNames, headers, preview, rawRows };
+}
+
+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 hasPermission = await checkPermission('contacts.create');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Permission refusée' }, { status: 403 });
+    }
+
+    const formData = await request.formData();
+    const file = formData.get('file') as File | null;
+    const sheetName = (formData.get('sheetName') as string) || undefined;
+    const headerRowStr = formData.get('headerRow') as string | null;
+    const headerRow = headerRowStr ? Number.parseInt(headerRowStr, 10) : 0;
+
+    if (!file) {
+      return NextResponse.json({ error: 'Aucun fichier fourni' }, { status: 400 });
+    }
+
+    const fileExtension = file.name.toLowerCase().split('.').pop();
+
+    if (fileExtension === 'csv') {
+      const result = parseCsv(await file.text(), headerRow);
+      if (!result) {
+        return NextResponse.json({ error: 'Le fichier est vide' }, { status: 400 });
+      }
+      return NextResponse.json(result);
+    }
+
+    if (fileExtension === 'xlsx' || fileExtension === 'xls') {
+      try {
+        const result = parseExcel(await file.arrayBuffer(), sheetName, headerRow);
+        if (!result) {
+          return NextResponse.json({ error: 'Le fichier est vide' }, { status: 400 });
+        }
+        return NextResponse.json(result);
+      } catch {
+        return NextResponse.json({ error: 'Erreur lors du parsing Excel.' }, { status: 400 });
+      }
+    }
+
+    return NextResponse.json(
+      { error: 'Format de fichier non supporté. Utilisez CSV ou Excel (.xlsx, .xls)' },
+      { status: 400 },
+    );
+  } catch (error: unknown) {
+    console.error('Erreur import-preview:', error);
+    const message = error instanceof Error ? error.message : 'Erreur serveur';
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,63 @@
+import { NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
+
+/** Liste distincte des origines (tous les contacts visibles par l’utilisateur). */
+export async function GET(request: Request) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const [canViewAll, canViewOwn, canViewUnassigned] = await Promise.all([
+      checkPermission('contacts.view_all'),
+      checkPermission('contacts.view_own'),
+      checkPermission('contacts.view_unassigned'),
+    ]);
+
+    if (!canViewAll && !canViewOwn) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    const where: {
+      origin: { not: null };
+      AND?: object[];
+    } = {
+      origin: { not: null },
+    };
+
+    if (!canViewAll && canViewOwn) {
+      const ownershipConditions: object[] = [
+        { assignedCommercialId: session.user.id },
+        { assignedTeleproId: session.user.id },
+        { createdById: session.user.id },
+      ];
+      if (canViewUnassigned) {
+        ownershipConditions.push({
+          AND: [{ assignedCommercialId: null }, { assignedTeleproId: null }],
+        });
+      }
+      where.AND = [{ OR: ownershipConditions }];
+    }
+
+    const grouped = await prisma.contact.groupBy({
+      by: ['origin'],
+      where,
+    });
+
+    const origins = grouped
+      .map((g) => g.origin)
+      .filter((o): o is string => Boolean(o && String(o).trim()))
+      .sort((a, b) => a.localeCompare(b, 'fr'));
+
+    return NextResponse.json({ origins });
+  } catch (e) {
+    console.error('GET /api/contacts/origins:', e);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}