create-crm-tmp 1.0.0

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

@@ -0,0 +1,526 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { getValidAccessToken, GoogleTokenError } from '@/lib/google-calendar';
+import { handleContactDuplicate } from '@/lib/contact-duplicate';
+
+// POST /api/integrations/google-sheet/sync - Synchroniser toutes les configurations actives
+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 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,
+        );
+
+        // 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;
+        let maxProcessedRow = config.lastSyncedRow || headerRowIndex;
+
+        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,
+                },
+              },
+            });
+          }
+
+          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',
+        });
+      }
+    }
+
+    return NextResponse.json({
+      totalImported,
+      totalUpdated,
+      totalSkipped,
+      results,
+    });
+  } catch (error: any) {
+    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

@@ -0,0 +1,88 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { hashPassword } from '@/lib/auth';
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { token, password } = body;
+
+    if (!token || !password) {
+      return NextResponse.json({ error: 'Token et mot de passe requis' }, { status: 400 });
+    }
+
+    if (password.length < 6) {
+      return NextResponse.json(
+        { error: 'Le mot de passe doit contenir au moins 6 caractères' },
+        { status: 400 },
+      );
+    }
+
+    // Valider le token
+    const verification = await prisma.verification.findFirst({
+      where: {
+        value: token,
+        expiresAt: {
+          gt: new Date(),
+        },
+      },
+    });
+
+    if (!verification) {
+      return NextResponse.json({ error: 'Lien invalide ou expiré' }, { status: 400 });
+    }
+
+    // Trouver l'utilisateur
+    const user = await prisma.user.findUnique({
+      where: { email: verification.identifier },
+      include: {
+        accounts: {
+          where: { providerId: 'credential' },
+        },
+      },
+    });
+
+    if (!user) {
+      return NextResponse.json({ error: 'Utilisateur non trouvé' }, { status: 404 });
+    }
+
+    // Vérifier si le compte existe déjà
+    if (user.accounts.length > 0) {
+      return NextResponse.json({ error: 'Ce compte a déjà été activé' }, { status: 400 });
+    }
+
+    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,
+      },
+    });
+
+    return NextResponse.json({
+      success: true,
+      message: 'Mot de passe défini avec succès',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la complétion:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}

package/template/src/app/api/invite/validate/route.ts

@@ -0,0 +1,55 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const token = searchParams.get('token');
+
+    if (!token) {
+      return NextResponse.json({ error: 'Token manquant' }, { status: 400 });
+    }
+
+    // Trouver le token de vérification
+    const verification = await prisma.verification.findFirst({
+      where: {
+        value: token,
+        expiresAt: {
+          gt: new Date(), // Pas expiré
+        },
+      },
+    });
+
+    if (!verification) {
+      return NextResponse.json({ error: 'Lien invalide ou expiré' }, { status: 400 });
+    }
+
+    // Vérifier si l'utilisateur existe et n'a pas encore de compte
+    const user = await prisma.user.findUnique({
+      where: { email: verification.identifier },
+      include: {
+        accounts: {
+          where: { providerId: 'credential' },
+        },
+      },
+    });
+
+    if (!user) {
+      return NextResponse.json({ error: 'Utilisateur non trouvé' }, { status: 404 });
+    }
+
+    // Vérifier si le compte existe déjà (mot de passe déjà défini)
+    if (user.accounts.length > 0) {
+      return NextResponse.json({ error: 'Ce compte a déjà été activé' }, { status: 400 });
+    }
+
+    return NextResponse.json({
+      email: user.email,
+      name: user.name,
+      valid: true,
+    });
+  } catch (error) {
+    console.error('Erreur lors de la validation:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}