create-crm-tmp 1.1.3 → 2.1.0

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

@@ -0,0 +1,50 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
+
+const DAILY_SOFT_LIMIT = 800;
+const DAILY_HARD_TARGET = 950;
+
+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 canManageIntegrations = await checkPermission('integrations.google_sheets.manage');
+    if (!canManageIntegrations) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    const since = new Date(Date.now() - 24 * 60 * 60 * 1000);
+    const grouped = await prisma.googleSheetSyncJob.groupBy({
+      by: ['triggerType'],
+      where: { createdAt: { gte: since } },
+      _count: { _all: true },
+    });
+
+    const scheduled = grouped.find((g) => g.triggerType === 'SCHEDULED')?._count._all ?? 0;
+    const manual = grouped.find((g) => g.triggerType === 'MANUAL')?._count._all ?? 0;
+    const total = scheduled + manual;
+
+    if (total > DAILY_SOFT_LIMIT) {
+      console.warn(
+        `[GoogleSheetSync] usage 24h élevé: total=${total}, scheduled=${scheduled}, manual=${manual}, target=${DAILY_HARD_TARGET}`,
+      );
+    }
+
+    return NextResponse.json({
+      windowHours: 24,
+      total,
+      scheduled,
+      manual,
+      softLimit: DAILY_SOFT_LIMIT,
+      hardTarget: DAILY_HARD_TARGET,
+      remainingBeforeHardTarget: Math.max(0, DAILY_HARD_TARGET - total),
+    });
+  } catch (error) {
+    console.error('Erreur usage jobs Google Sheet:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -1,555 +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 { 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;
-
-    // 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 session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
-    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) {
-      try {
-        // Récupérer le compte Google de l'utilisateur propriétaire
-        const googleAccount = await client.userGoogleAccount.findUnique({
-          where: { userId: config.ownerUserId },
-        });
-
-        if (!googleAccount) {
-          results.push({
-            configId: config.id,
-            configName: config.name,
-            imported: 0,
-            updated: 0,
-            skipped: 0,
-            error:
-              'Aucun compte Google connecté pour l’utilisateur propriétaire. Veuillez connecter votre compte Google dans les paramètres.',
-          });
-          continue;
-        }
-
-        let accessToken: string;
-        try {
-          accessToken = await getValidAccessToken(
-            googleAccount.accessToken,
-            googleAccount.refreshToken,
-            googleAccount.tokenExpiresAt,
-          );
-
-          // Mettre à jour le token si nécessaire
-          if (accessToken !== googleAccount.accessToken) {
-            const tokenExpiresAt = new Date();
-            tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
-            await client.userGoogleAccount.update({
-              where: { userId: config.ownerUserId },
-              data: {
-                accessToken,
-                tokenExpiresAt,
-              },
-            });
-          }
-        } catch (error: any) {
-          // Gérer spécifiquement les erreurs de token expiré/révoqué
-          if (error instanceof GoogleTokenError && error.isRevoked) {
-            results.push({
-              configId: config.id,
-              configName: config.name,
-              imported: 0,
-              updated: 0,
-              skipped: 0,
-              error: error.message,
-            });
-            continue;
-          }
-          // Relancer l'erreur si ce n'est pas une erreur de token
-          throw error;
-        }
-
-        const range = encodeURIComponent(config.sheetName);
-        const response = await fetch(
-          `https://sheets.googleapis.com/v4/spreadsheets/${config.spreadsheetId}/values/${range}`,
-          {
-            headers: {
-              Authorization: `Bearer ${accessToken}`,
-            },
-          },
-        );
-
-        if (!response.ok) {
-          const errorText = await response.text();
-          console.error(`Erreur lors de la lecture du Google Sheet ${config.name}:`, errorText);
-          results.push({
-            configId: config.id,
-            configName: config.name,
-            imported: 0,
-            updated: 0,
-            skipped: 0,
-            error: 'Impossible de lire les données depuis Google Sheets.',
-          });
-          continue;
-        }
-
-        const data = await response.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,
-        );
-
-        // Si aucune nouvelle ligne à traiter, skip
-        if (startRowIndex >= values.length) {
-          results.push({
-            configId: config.id,
-            configName: config.name,
-            imported: 0,
-            updated: 0,
-            skipped: 0,
-          });
-          continue;
-        }
-
-        // Réserver atomiquement les lignes pour éviter les imports en double
-        // (protection contre les synchronisations concurrentes, ex: React Strict Mode, multi-pages)
-        const claimedMaxRow = values.length - 1;
-        const claimCondition: Record<string, unknown> = { id: config.id };
-        if (config.lastSyncedRow !== null && config.lastSyncedRow !== undefined) {
-          claimCondition.lastSyncedRow = config.lastSyncedRow;
-        } else {
-          claimCondition.lastSyncedRow = null;
-        }
-
-        const claimResult = await client.googleSheetSyncConfig.updateMany({
-          where: claimCondition,
-          data: {
-            lastSyncedRow: claimedMaxRow,
-          },
-        });
-
-        if (claimResult.count === 0) {
-          // Une autre synchronisation concurrente a déjà réservé ces lignes
-          results.push({
-            configId: config.id,
-            configName: config.name,
-            imported: 0,
-            updated: 0,
-            skipped: 0,
-          });
-          continue;
-        }
-
-        // 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;
-          }
-        }
-
-        let imported = 0;
-        let updated = 0;
-        let skipped = 0;
-
-        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';
-
-          // Collecter les notes si des colonnes sont configurées comme "note"
-          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(),
-                });
-              }
-            });
-          }
-
-          // Fonction pour échapper le HTML
-          const escapeHtml = (text: string): string => {
-            const map: { [key: string]: string } = {
-              '&': '&amp;',
-              '<': '&lt;',
-              '>': '&gt;',
-              '"': '&quot;',
-              "'": '&#039;',
-            };
-            return text.replace(/[&<>"']/g, (m) => map[m]);
-          };
-
-          // Fonction pour formater le contenu de la note en HTML
-          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) => {
-              // Formater les valeurs qui sont des tableaux JSON
-              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
-              }
-
-              // Capitaliser le label pour le rendre plus humain
-              const humanLabel = item.label
-                .split(/(?=[A-Z])/)
-                .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-                .join(' ');
-
-              // Échapper le HTML pour éviter les injections XSS
-              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;
-          };
-
-          // Déterminer l'assignation selon le rôle de l'utilisateur par défaut
-          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;
-              }
-              // Sinon, on ne assigne pas (null pour les deux)
-            }
-          }
-
-          // 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,
-                },
-              },
-            });
-          }
-        }
-
-        // Pas besoin de mettre à jour lastSyncedRow ici,
-        // car il a été réservé atomiquement au début du traitement (claimedMaxRow).
-
-        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',
-        });
-      }
+    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/invite/complete/route.ts

@@ -53,29 +53,26 @@ export async function POST(request: NextRequest) {
 
     const newPassword = await hashPassword(password);
 
-    // Créer l'Account avec le mot de passe haché
-    await prisma.account.create({
-      data: {
-        id: crypto.randomUUID(),
-        accountId: user.id,
-        providerId: 'credential',
-        userId: user.id,
-        password: newPassword,
-      },
-    });
-
-    // Supprimer le token de vérification
-    await prisma.verification.delete({
-      where: { id: verification.id },
-    });
-
-    // Mettre à jour l'utilisateur comme vérifié
-    await prisma.user.update({
-      where: { id: user.id },
-      data: {
-        emailVerified: true,
-      },
-    });
+    await prisma.$transaction([
+      prisma.account.create({
+        data: {
+          id: crypto.randomUUID(),
+          accountId: user.id,
+          providerId: 'credential',
+          userId: user.id,
+          password: newPassword,
+        },
+      }),
+      prisma.verification.delete({
+        where: { id: verification.id },
+      }),
+      prisma.user.update({
+        where: { id: user.id },
+        data: {
+          emailVerified: true,
+        },
+      }),
+    ]);
 
     return NextResponse.json({
       success: true,