create-crm-tmp 1.1.2 → 2.0.0

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

@@ -2,11 +2,18 @@ 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';
 
 // POST /api/integrations/google-sheet/sync - Synchroniser toutes les configurations actives
 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({
@@ -41,13 +48,14 @@ export async function POST(request: NextRequest) {
 
     // Synchroniser chaque configuration
     for (const config of configs) {
+      const lockKey = `google_sheet_sync:${config.id}`;
+      let lockAcquired = false;
       try {
-        // Récupérer le compte Google de l'utilisateur propriétaire
-        const googleAccount = await client.userGoogleAccount.findUnique({
-          where: { userId: config.ownerUserId },
-        });
-
-        if (!googleAccount) {
+        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,
@@ -55,73 +63,100 @@ export async function POST(request: NextRequest) {
             updated: 0,
             skipped: 0,
             error:
-              'Aucun compte Google connecté pour l’utilisateur propriétaire. Veuillez connecter votre compte Google dans les paramètres.',
+              'Une synchronisation est déjà en cours pour cette configuration. Veuillez patienter quelques secondes puis relancer.',
           });
           continue;
         }
 
-        let accessToken: string;
-        try {
-          accessToken = await getValidAccessToken(
-            googleAccount.accessToken,
-            googleAccount.refreshToken,
-            googleAccount.tokenExpiresAt,
-          );
+        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),
+            ),
+          ),
+        );
 
-          // 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,
-            });
+        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;
           }
-          // 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}`,
-            },
-          },
-        );
+          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;
+            }
 
-        if (!response.ok) {
-          const errorText = await response.text();
-          console.error(`Erreur lors de la lecture du Google Sheet ${config.name}:`, errorText);
+            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: 'Impossible de lire les données depuis Google Sheets.',
+            error: lastAuthError,
           });
           continue;
         }
 
-        const data = await response.json();
+        const data = await selectedSheetsResponse.json();
         const values: string[][] = data.values || [];
 
         if (!values.length) {
@@ -141,47 +176,6 @@ export async function POST(request: NextRequest) {
           (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] || [];
 
@@ -267,9 +261,92 @@ export async function POST(request: NextRequest) {
           }
         }
 
+        // 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];
@@ -305,8 +382,22 @@ export async function POST(request: NextRequest) {
             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);
 
-          // 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 }) => {
@@ -319,93 +410,6 @@ export async function POST(request: NextRequest) {
             });
           }
 
-          // 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,
@@ -514,10 +518,20 @@ export async function POST(request: NextRequest) {
               },
             });
           }
+
+          if (rowIndex > maxProcessedRow) {
+            maxProcessedRow = rowIndex;
+          }
         }
 
-        // Pas besoin de mettre à jour lastSyncedRow ici,
-        // car il a été réservé atomiquement au début du traitement (claimedMaxRow).
+        if (maxProcessedRow > (config.lastSyncedRow || headerRowIndex)) {
+          await client.googleSheetSyncConfig.update({
+            where: { id: config.id },
+            data: {
+              lastSyncedRow: maxProcessedRow,
+            },
+          });
+        }
 
         totalImported += imported;
         totalUpdated += updated;
@@ -540,6 +554,10 @@ export async function POST(request: NextRequest) {
           skipped: 0,
           error: error.message || 'Erreur lors de la synchronisation',
         });
+      } finally {
+        if (lockAcquired) {
+          await client.$queryRaw`SELECT pg_advisory_unlock(hashtext(${lockKey}), 4261)`;
+        }
       }
     }
 

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,

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

@@ -51,6 +51,7 @@ export async function GET(request: NextRequest) {
       orderBy: {
         scheduledAt: 'asc',
       },
+      take: 100,
     });
 
     // Formater les rappels - inclure toutes les tâches avec rappels

package/template/src/app/api/reset-password/complete/route.ts

@@ -46,21 +46,19 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: 'Utilisateur non trouvé' }, { status: 404 });
     }
 
-    // Hasher le nouveau mot de passe
     const hashedPassword = await hashPassword(password);
 
-    // Mettre à jour le mot de passe dans l'Account
-    await prisma.account.update({
-      where: { id: user.accounts[0].id },
-      data: {
-        password: hashedPassword,
-      },
-    });
-
-    // Supprimer le token de vérification
-    await prisma.verification.delete({
-      where: { id: verification.id },
-    });
+    await prisma.$transaction([
+      prisma.account.update({
+        where: { id: user.accounts[0].id },
+        data: {
+          password: hashedPassword,
+        },
+      }),
+      prisma.verification.delete({
+        where: { id: verification.id },
+      }),
+    ]);
 
     return NextResponse.json({
       success: true,