create-crm-tmp 2.0.0 → 2.1.0

package/template/src/app/api/integrations/google-sheet/sync/route.ts

@@ -1,573 +1,41 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { prisma } from '@/lib/prisma';
-import { getValidAccessToken, GoogleTokenError } from '@/lib/google-calendar';
-import { handleContactDuplicate } from '@/lib/contact-duplicate';
-import { googleFetch } from '@/lib/google-fetch';
-import { encrypt, decrypt } from '@/lib/encryption';
 import { auth } from '@/lib/auth';
+import { enqueueGoogleSheetSyncJob, SyncJobRateLimitError } from '@/lib/google-sheet-sync-jobs';
 
-// POST /api/integrations/google-sheet/sync - Synchroniser toutes les configurations actives
+// POST /api/integrations/google-sheet/sync — tout utilisateur connecté peut lancer une synchro.
+// La permission integrations.google_sheets.manage reste requise côté UI / routes settings pour configurer l’intégration.
 export async function POST(request: NextRequest) {
   try {
-    const client = prisma as any;
     const session = await auth.api.getSession({ headers: request.headers });
     if (!session) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
-    // Récupérer toutes les configurations actives
-    const configs = await client.googleSheetSyncConfig.findMany({
-      where: { active: true },
-      include: {
-        ownerUser: true,
-      },
-    });
-
-    if (!configs || configs.length === 0) {
-      return NextResponse.json({
-        totalImported: 0,
-        totalUpdated: 0,
-        totalSkipped: 0,
-        results: [],
-        message: "Aucune configuration Google Sheets active n'a été trouvée.",
-      });
-    }
-
-    const results: Array<{
-      configId: string;
-      configName: string;
-      imported: number;
-      updated: number;
-      skipped: number;
-      error?: string;
-    }> = [];
-
-    let totalImported = 0;
-    let totalUpdated = 0;
-    let totalSkipped = 0;
-
-    // Synchroniser chaque configuration
-    for (const config of configs) {
-      const lockKey = `google_sheet_sync:${config.id}`;
-      let lockAcquired = false;
-      try {
-        const lockResult = await client.$queryRaw<
-          Array<{ locked: boolean }>
-        >`SELECT pg_try_advisory_lock(hashtext(${lockKey}), 4261) AS locked`;
-        lockAcquired = lockResult?.[0]?.locked === true;
-        if (!lockAcquired) {
-          results.push({
-            configId: config.id,
-            configName: config.name,
-            imported: 0,
-            updated: 0,
-            skipped: 0,
-            error:
-              'Une synchronisation est déjà en cours pour cette configuration. Veuillez patienter quelques secondes puis relancer.',
-          });
-          continue;
-        }
-
-        const range = encodeURIComponent(config.sheetName);
-        const candidateUserIds = Array.from(
-          new Set(
-            [config.ownerUserId, config.defaultAssignedUserId, session.user.id].filter(
-              (value): value is string => Boolean(value),
-            ),
-          ),
-        );
-
-        let selectedSheetsResponse: Response | null = null;
-        let lastAuthError =
-          'Aucun compte Google compatible trouvé pour cette configuration. Reconnectez Google puis partagez le Sheet avec ce compte.';
-
-        for (const candidateUserId of candidateUserIds) {
-          const googleAccount = await client.userGoogleAccount.findUnique({
-            where: { userId: candidateUserId },
-          });
-
-          if (!googleAccount) {
-            lastAuthError = 'Aucun compte Google connecté parmi les utilisateurs autorisés.';
-            continue;
-          }
-
-          try {
-            const decryptedAccess = decrypt(googleAccount.accessToken);
-            const decryptedRefresh = decrypt(googleAccount.refreshToken);
-            const accessToken = await getValidAccessToken(
-              decryptedAccess,
-              decryptedRefresh,
-              googleAccount.tokenExpiresAt,
-            );
-
-            if (accessToken !== decryptedAccess) {
-              const tokenExpiresAt = new Date();
-              tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
-              await client.userGoogleAccount.update({
-                where: { userId: candidateUserId },
-                data: {
-                  accessToken: encrypt(accessToken),
-                  tokenExpiresAt,
-                },
-              });
-            }
-
-            const candidateResponse = await googleFetch(
-              `https://sheets.googleapis.com/v4/spreadsheets/${config.spreadsheetId}/values/${range}`,
-              {
-                headers: {
-                  Authorization: `Bearer ${accessToken}`,
-                },
-              },
-            );
-
-            if (candidateResponse.ok) {
-              selectedSheetsResponse = candidateResponse;
-              break;
-            }
-
-            const errorText = await candidateResponse.text();
-            lastAuthError =
-              candidateResponse.status === 401 || candidateResponse.status === 403
-                ? 'Le compte Google connecté n’a pas accès à ce Sheet. Partagez le document avec ce compte ou reconnectez Google.'
-                : 'Impossible de lire les données depuis Google Sheets.';
-            console.error(
-              `Erreur lors de la lecture du Google Sheet ${config.name} (user ${candidateUserId}):`,
-              errorText,
-            );
-          } catch (error: any) {
-            if (error instanceof GoogleTokenError && error.isRevoked) {
-              lastAuthError = error.message;
-            } else {
-              lastAuthError = error?.message || 'Erreur lors de la validation du compte Google.';
-            }
-          }
-        }
-
-        if (!selectedSheetsResponse) {
-          results.push({
-            configId: config.id,
-            configName: config.name,
-            imported: 0,
-            updated: 0,
-            skipped: 0,
-            error: lastAuthError,
-          });
-          continue;
-        }
-
-        const data = await selectedSheetsResponse.json();
-        const values: string[][] = data.values || [];
-
-        if (!values.length) {
-          results.push({
-            configId: config.id,
-            configName: config.name,
-            imported: 0,
-            updated: 0,
-            skipped: 0,
-          });
-          continue;
-        }
-
-        const headerRowIndex = config.headerRow - 1;
-        const startRowIndex = Math.max(
-          headerRowIndex + 1,
-          (config.lastSyncedRow || headerRowIndex) + 1,
-        );
-
-        // Récupérer les headers
-        const headerRow = values[headerRowIndex] || [];
-
-        // Utiliser le nouveau format columnMappings
-        let columnMappings: Record<string, number> = {}; // crmField -> index
-        let noteFields: Array<{ name: string; index: number }> = [];
-
-        if (!config.columnMappings) {
-          results.push({
-            configId: config.id,
-            configName: config.name,
-            imported: 0,
-            updated: 0,
-            skipped: 0,
-            error:
-              "La configuration n'utilise pas le nouveau format de mapping. Veuillez reconfigurer cette intégration.",
-          });
-          continue;
-        }
-
-        // Parser les mappings
-        const mappings =
-          typeof config.columnMappings === 'string'
-            ? JSON.parse(config.columnMappings)
-            : config.columnMappings;
-
-        if (!Array.isArray(mappings)) {
-          results.push({
-            configId: config.id,
-            configName: config.name,
-            imported: 0,
-            updated: 0,
-            skipped: 0,
-            error: 'Format de mapping invalide.',
-          });
-          continue;
-        }
-
-        mappings.forEach((mapping: any) => {
-          if (mapping.action === 'map' && mapping.crmField && mapping.columnName) {
-            // Trouver l'index de la colonne par son nom
-            const columnIndex = headerRow.findIndex(
-              (h: string) =>
-                h && h.trim().toLowerCase() === mapping.columnName.trim().toLowerCase(),
-            );
-            if (columnIndex !== -1) {
-              columnMappings[mapping.crmField] = columnIndex;
-            }
-          } else if (mapping.action === 'note' && mapping.columnName) {
-            const columnIndex = headerRow.findIndex(
-              (h: string) =>
-                h && h.trim().toLowerCase() === mapping.columnName.trim().toLowerCase(),
-            );
-            if (columnIndex !== -1) {
-              noteFields.push({ name: mapping.columnName, index: columnIndex });
-            }
-          }
-        });
-
-        // Vérifier que le téléphone est mappé (obligatoire)
-        if (columnMappings['phone'] === undefined) {
-          results.push({
-            configId: config.id,
-            configName: config.name,
-            imported: 0,
-            updated: 0,
-            skipped: 0,
-            error: "La colonne téléphone n'est pas correctement mappée.",
-          });
-          continue;
-        }
-
-        const phoneIdx = columnMappings['phone'];
-
-        // Déterminer le statut par défaut à utiliser (configuré ou "Nouveau")
-        let effectiveDefaultStatusId = config.defaultStatusId || null;
-        if (!effectiveDefaultStatusId) {
-          const fallbackStatus = await client.status.findFirst({
-            where: { name: 'Nouveau' },
-          });
-          if (fallbackStatus) {
-            effectiveDefaultStatusId = fallbackStatus.id;
-          }
-        }
-
-        // Pré-charger le rôle de l'utilisateur par défaut (constant pour toute la config)
-        let assignedCommercialId: string | null = null;
-        let assignedTeleproId: string | null = null;
-
-        if (config.defaultAssignedUserId) {
-          const defaultUser = await client.user.findUnique({
-            where: { id: config.defaultAssignedUserId },
-            select: { role: true },
-          });
-
-          if (defaultUser) {
-            if (
-              defaultUser.role === 'COMMERCIAL' ||
-              defaultUser.role === 'ADMIN' ||
-              defaultUser.role === 'MANAGER'
-            ) {
-              assignedCommercialId = config.defaultAssignedUserId;
-            } else if (defaultUser.role === 'TELEPRO') {
-              assignedTeleproId = config.defaultAssignedUserId;
-            }
-          }
-        }
-
-        const escapeHtml = (text: string): string => {
-          const map: { [key: string]: string } = {
-            '&': '&amp;',
-            '<': '&lt;',
-            '>': '&gt;',
-            '"': '&quot;',
-            "'": '&#039;',
-          };
-          return text.replace(/[&<>"']/g, (m) => map[m]);
-        };
-
-        const formatNoteContent = (noteItems: Array<{ label: string; value: string }>) => {
-          const escapedConfigName = escapeHtml(config.name);
-
-          if (noteItems.length === 0) {
-            return `<p style="font-size: 14px; line-height: 1.5; color: #374151; margin-bottom: 0;">Ce contact a été importé automatiquement depuis Google Sheets (${escapedConfigName}).</p>`;
-          }
-
-          let html = `<p style="font-size: 14px; line-height: 1.5; color: #374151; margin-bottom: 16px;">Ce contact a été importé automatiquement depuis Google Sheets (${escapedConfigName}).</p>`;
-
-          html +=
-            '<div style="display: flex; flex-direction: column; gap: 12px; margin-top: 16px;">';
-
-          noteItems.forEach((item) => {
-            let formattedValue = item.value;
-            try {
-              const parsed = JSON.parse(item.value);
-              if (Array.isArray(parsed)) {
-                formattedValue = parsed.map((v) => String(v)).join(', ');
-              }
-            } catch {
-              // Ce n'est pas du JSON, on garde la valeur telle quelle
-            }
-
-            const humanLabel = item.label
-              .split(/(?=[A-Z])/)
-              .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-              .join(' ');
-
-            const escapedLabel = escapeHtml(humanLabel);
-            const escapedValue = escapeHtml(String(formattedValue)).replace(/\n/g, '<br>');
-
-            html += `
-                <div style="padding: 12px 14px; background: linear-gradient(to right, #f8fafc 0%, #f1f5f9 100%); border-radius: 10px; border-left: 4px solid #6366f1; box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.05); transition: all 0.2s ease;">
-                  <div style="font-size: 11px; font-weight: 700; color: #64748b; text-transform: uppercase; letter-spacing: 0.8px; margin-bottom: 6px;">
-                    ${escapedLabel}
-                  </div>
-                  <div style="font-size: 14px; line-height: 1.5; color: #0f172a; font-weight: 500;">
-                    ${escapedValue}
-                  </div>
-                </div>
-              `;
-          });
-
-          html += '</div>';
-          return html;
-        };
-
-        let imported = 0;
-        let updated = 0;
-        let skipped = 0;
-        let maxProcessedRow = config.lastSyncedRow || headerRowIndex;
-        const seenRowKeys = new Set<string>();
-
-        for (let rowIndex = startRowIndex; rowIndex < values.length; rowIndex++) {
-          const row = values[rowIndex];
-          if (!row) continue;
-
-          const phone = row[phoneIdx]?.trim();
-          if (!phone) {
-            skipped++;
-            continue;
-          }
-
-          const firstName =
-            columnMappings['firstName'] !== undefined
-              ? row[columnMappings['firstName']]?.trim() || undefined
-              : undefined;
-          const lastName =
-            columnMappings['lastName'] !== undefined
-              ? row[columnMappings['lastName']]?.trim() || undefined
-              : undefined;
-          const email =
-            columnMappings['email'] !== undefined
-              ? row[columnMappings['email']]?.trim() || undefined
-              : undefined;
-          const city =
-            columnMappings['city'] !== undefined
-              ? row[columnMappings['city']]?.trim() || undefined
-              : undefined;
-          const postalCode =
-            columnMappings['postalCode'] !== undefined
-              ? row[columnMappings['postalCode']]?.trim() || undefined
-              : undefined;
-          const origin =
-            columnMappings['origin'] !== undefined
-              ? row[columnMappings['origin']]?.trim() || 'Google Sheets'
-              : 'Google Sheets';
-          const normalizedEmail = email ? email.trim().toLowerCase() : '';
-          const normalizedPhone = phone.replace(/\D/g, '');
-          const normalizedFirstName = firstName ? firstName.trim().toLowerCase() : '';
-          const normalizedLastName = lastName ? lastName.trim().toLowerCase() : '';
-          const rowKey = normalizedEmail
-            ? `email:${normalizedEmail}`
-            : normalizedPhone
-              ? `phone:${normalizedPhone}`
-              : `name:${normalizedFirstName}|${normalizedLastName}`;
-
-          if (seenRowKeys.has(rowKey)) {
-            skipped++;
-            continue;
-          }
-          seenRowKeys.add(rowKey);
-
-          const noteContents: Array<{ label: string; value: string }> = [];
-          if (noteFields.length > 0) {
-            noteFields.forEach(({ name, index }) => {
-              if (row[index]) {
-                noteContents.push({
-                  label: name,
-                  value: row[index].trim(),
-                });
-              }
-            });
-          }
-
-          // Vérifier si c'est un doublon (nom, prénom ET email)
-          const duplicateContactId = await handleContactDuplicate(
-            firstName,
-            lastName,
-            email,
-            origin,
-            config.defaultAssignedUserId || config.ownerUserId,
-          );
-
-          let contact;
-          let isNewContact = false;
-
-          if (duplicateContactId) {
-            // C'est un doublon, récupérer le contact existant
-            contact = await client.contact.findUnique({
-              where: { id: duplicateContactId },
-            });
-            updated++;
-          } else {
-            // Chercher un contact existant (par téléphone uniquement)
-            contact =
-              (email &&
-                (await client.contact.findFirst({
-                  where: {
-                    OR: [{ email: email.toLowerCase() }, { phone }],
-                  },
-                }))) ||
-              (await client.contact.findFirst({
-                where: { phone },
-              }));
-
-            if (!contact) {
-              // Préparer les interactions à créer
-              const formattedContent = formatNoteContent(noteContents);
-              const interactionsToCreate: any[] = [
-                {
-                  type: 'NOTE',
-                  title: `Contact importé depuis Google Sheets: ${config.name}`,
-                  content: formattedContent,
-                  userId: config.defaultAssignedUserId || config.ownerUserId,
-                  date: new Date(),
-                  metadata: {
-                    htmlContent: formattedContent,
-                    isGoogleSheetsImport: true,
-                  },
-                },
-              ];
-
-              contact = await client.contact.create({
-                data: {
-                  firstName: firstName || null,
-                  lastName: lastName || null,
-                  email: email ? email.toLowerCase() : null,
-                  phone,
-                  city: city || null,
-                  postalCode: postalCode || null,
-                  origin,
-                  statusId: effectiveDefaultStatusId,
-                  assignedCommercialId: assignedCommercialId,
-                  assignedTeleproId: assignedTeleproId,
-                  createdById: config.defaultAssignedUserId || config.ownerUserId,
-                  interactions: {
-                    create: interactionsToCreate,
-                  },
-                },
-              });
-              isNewContact = true;
-              imported++;
-            } else {
-              await client.contact.update({
-                where: { id: contact.id },
-                data: {
-                  firstName: contact.firstName || firstName || null,
-                  lastName: contact.lastName || lastName || null,
-                  email: contact.email || (email ? email.toLowerCase() : null),
-                  city: contact.city || city || null,
-                  postalCode: contact.postalCode || postalCode || null,
-                  origin: contact.origin || origin,
-                  statusId: contact.statusId || effectiveDefaultStatusId,
-                  // Ne pas écraser les assignations existantes
-                  assignedCommercialId: contact.assignedCommercialId || assignedCommercialId,
-                  assignedTeleproId: contact.assignedTeleproId || assignedTeleproId,
-                },
-              });
-              updated++;
-            }
-          }
-
-          // Créer une interaction de log uniquement pour les contacts mis à jour (pas les nouveaux qui ont déjà leur interaction)
-          if (contact && !isNewContact) {
-            // Contact mis à jour, créer l'interaction si nécessaire
-            const formattedContent = formatNoteContent(noteContents);
-
-            await client.interaction.create({
-              data: {
-                contactId: contact.id,
-                type: 'NOTE',
-                title: `Contact importé depuis Google Sheets: ${config.name}`,
-                content: formattedContent,
-                userId: config.defaultAssignedUserId || config.ownerUserId,
-                date: new Date(),
-                metadata: {
-                  htmlContent: formattedContent,
-                  isGoogleSheetsImport: true,
-                },
-              },
-            });
-          }
-
-          if (rowIndex > maxProcessedRow) {
-            maxProcessedRow = rowIndex;
-          }
-        }
-
-        if (maxProcessedRow > (config.lastSyncedRow || headerRowIndex)) {
-          await client.googleSheetSyncConfig.update({
-            where: { id: config.id },
-            data: {
-              lastSyncedRow: maxProcessedRow,
-            },
-          });
-        }
-
-        totalImported += imported;
-        totalUpdated += updated;
-        totalSkipped += skipped;
-
-        results.push({
-          configId: config.id,
-          configName: config.name,
-          imported,
-          updated,
-          skipped,
-        });
-      } catch (error: any) {
-        console.error(`Erreur lors de la synchronisation de ${config.name}:`, error);
-        results.push({
-          configId: config.id,
-          configName: config.name,
-          imported: 0,
-          updated: 0,
-          skipped: 0,
-          error: error.message || 'Erreur lors de la synchronisation',
-        });
-      } finally {
-        if (lockAcquired) {
-          await client.$queryRaw`SELECT pg_advisory_unlock(hashtext(${lockKey}), 4261)`;
-        }
-      }
+    let body: { configId?: string } = {};
+    try {
+      body = await request.json().catch(() => ({}));
+    } catch {
+      // body optionnel
     }
+    const { configId: requestedConfigId } = body;
 
-    return NextResponse.json({
-      totalImported,
-      totalUpdated,
-      totalSkipped,
-      results,
+    const job = await enqueueGoogleSheetSyncJob({
+      requestedByUserId: session.user.id,
+      configId: requestedConfigId ?? null,
+      triggerType: 'MANUAL',
     });
+
+    return NextResponse.json(
+      {
+        jobId: job.id,
+        status: job.status,
+      },
+      { status: 202 },
+    );
   } catch (error: any) {
+    if (error instanceof SyncJobRateLimitError) {
+      return NextResponse.json({ error: error.message }, { status: 429 });
+    }
     console.error('Erreur lors de la synchronisation Google Sheets:', error);
     return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
   }

package/template/src/app/api/jobs/google-sheet/process/route.ts

@@ -0,0 +1,84 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { runGoogleSheetSync } from '@/lib/google-sheet-sync-runner';
+import { QstashAuthError, verifyQstashRequest } from '@/lib/qstash';
+
+export async function POST(request: NextRequest) {
+  let bodyText = '';
+  let parsedJobId: string | null = null;
+  try {
+    bodyText = await request.text();
+    const signature = request.headers.get('upstash-signature');
+    await verifyQstashRequest(signature, bodyText);
+
+    const body = JSON.parse(bodyText) as { jobId?: string };
+    const jobId = body.jobId;
+    parsedJobId = jobId ?? null;
+    if (!jobId) {
+      return NextResponse.json({ error: 'jobId manquant' }, { status: 400 });
+    }
+
+    const claimed = await prisma.googleSheetSyncJob.updateMany({
+      where: {
+        id: jobId,
+        status: 'QUEUED',
+      },
+      data: {
+        status: 'RUNNING',
+        startedAt: new Date(),
+      },
+    });
+
+    if (claimed.count === 0) {
+      return NextResponse.json({ ok: true, skipped: true });
+    }
+
+    const job = await prisma.googleSheetSyncJob.findUnique({
+      where: { id: jobId },
+      select: { requestedByUserId: true, configId: true },
+    });
+    if (!job) {
+      return NextResponse.json({ error: 'Job introuvable' }, { status: 404 });
+    }
+
+    const result = await runGoogleSheetSync({
+      sessionUserId: job.requestedByUserId,
+      requestedConfigId: job.configId ?? undefined,
+    });
+
+    await prisma.googleSheetSyncJob.update({
+      where: { id: jobId },
+      data: {
+        status: 'SUCCEEDED',
+        finishedAt: new Date(),
+        result: result as object,
+      },
+    });
+
+    return NextResponse.json({ ok: true });
+  } catch (error: any) {
+    if (error instanceof QstashAuthError) {
+      return NextResponse.json({ error: 'Signature QStash invalide' }, { status: 401 });
+    }
+    console.error('Erreur worker Google Sheet:', error);
+    try {
+      if (!parsedJobId && bodyText) {
+        const parsed = JSON.parse(bodyText) as { jobId?: string };
+        parsedJobId = parsed.jobId ?? null;
+      }
+      if (parsedJobId) {
+        await prisma.googleSheetSyncJob.update({
+          where: { id: parsedJobId },
+          data: {
+            status: 'FAILED',
+            finishedAt: new Date(),
+            error: error?.message || 'Erreur worker',
+          },
+        });
+      }
+    } catch {
+      // ignore
+    }
+    return NextResponse.json({ error: 'Erreur worker' }, { status: 500 });
+  }
+}