create-crm-tmp 1.0.0

package/template/src/app/api/settings/google-ads/[id]/route.ts

@@ -0,0 +1,117 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { requireAdmin } from '@/lib/roles';
+
+// PUT /api/settings/google-ads/[id] - Mettre à jour une configuration (admin uniquement)
+export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    await requireAdmin(request.headers);
+
+    const { id } = await params;
+    const body = await request.json();
+    const { name, webhookKey, active, defaultStatusId, defaultAssignedUserId } = body;
+
+    const client = prisma as any;
+
+    const existingConfig = await client.googleAdsLeadConfig.findUnique({
+      where: { id },
+    });
+
+    if (!existingConfig) {
+      return NextResponse.json({ error: 'Configuration non trouvée' }, { status: 404 });
+    }
+
+    const updateData: any = {};
+    if (name !== undefined) updateData.name = name;
+    if (webhookKey !== undefined) updateData.webhookKey = webhookKey;
+    if (active !== undefined) updateData.active = !!active;
+    if (defaultStatusId !== undefined) updateData.defaultStatusId = defaultStatusId || null;
+    if (defaultAssignedUserId !== undefined) {
+      if (!defaultAssignedUserId) {
+        return NextResponse.json(
+          { error: "L'utilisateur assigné par défaut est obligatoire." },
+          { status: 400 },
+        );
+      }
+      updateData.defaultAssignedUserId = defaultAssignedUserId;
+    }
+
+    const config = await client.googleAdsLeadConfig.update({
+      where: { id },
+      data: updateData,
+    });
+
+    return NextResponse.json({
+      success: true,
+      config: {
+        id: config.id,
+        name: config.name,
+        webhookKey: config.webhookKey,
+        active: config.active,
+        defaultStatusId: config.defaultStatusId,
+        defaultAssignedUserId: config.defaultAssignedUserId,
+      },
+      message: 'Configuration Google Ads Lead Forms mise à jour avec succès.',
+    });
+  } catch (error: any) {
+    console.error(
+      'Erreur lors de la mise à jour de la configuration Google Ads Lead Forms:',
+      error,
+    );
+
+    if (error.message === 'Non authentifié') {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    if (error.message === 'Permissions insuffisantes') {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// DELETE /api/settings/google-ads/[id] - Supprimer une configuration (admin uniquement)
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  try {
+    await requireAdmin(request.headers);
+
+    const { id } = await params;
+    const client = prisma as any;
+
+    const existingConfig = await client.googleAdsLeadConfig.findUnique({
+      where: { id },
+    });
+
+    if (!existingConfig) {
+      return NextResponse.json({ error: 'Configuration non trouvée' }, { status: 404 });
+    }
+
+    await client.googleAdsLeadConfig.delete({
+      where: { id },
+    });
+
+    return NextResponse.json({
+      success: true,
+      message: 'Configuration Google Ads Lead Forms supprimée avec succès.',
+    });
+  } catch (error: any) {
+    console.error(
+      'Erreur lors de la suppression de la configuration Google Ads Lead Forms:',
+      error,
+    );
+
+    if (error.message === 'Non authentifié') {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    if (error.message === 'Permissions insuffisantes') {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}

package/template/src/app/api/settings/google-ads/route.ts

@@ -0,0 +1,122 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { requireAdmin } from '@/lib/roles';
+
+// GET /api/settings/google-ads - Récupérer toutes les configurations Google Ads Leads (admin uniquement)
+export async function GET(request: NextRequest) {
+  try {
+    await requireAdmin(request.headers);
+
+    const client = prisma as any;
+
+    const configs = await client.googleAdsLeadConfig.findMany({
+      include: {
+        defaultStatus: true,
+        defaultAssignedUser: {
+          select: { id: true, name: true, email: true },
+        },
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+
+    return NextResponse.json(
+      configs.map((config: any) => ({
+        id: config.id,
+        name: config.name,
+        webhookKey: config.webhookKey,
+        active: config.active,
+        defaultStatusId: config.defaultStatusId,
+        defaultAssignedUserId: config.defaultAssignedUserId,
+        defaultStatus: config.defaultStatus
+          ? {
+              id: config.defaultStatus.id,
+              name: config.defaultStatus.name,
+              color: config.defaultStatus.color,
+            }
+          : null,
+        defaultAssignedUser: config.defaultAssignedUser || null,
+      })),
+    );
+  } catch (error: any) {
+    console.error(
+      'Erreur lors de la récupération des configurations Google Ads Lead Forms:',
+      error,
+    );
+
+    if (error.message === 'Non authentifié') {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    if (error.message === 'Permissions insuffisantes') {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// POST /api/settings/google-ads - Créer une nouvelle configuration (admin uniquement)
+export async function POST(request: NextRequest) {
+  try {
+    await requireAdmin(request.headers);
+
+    const body = await request.json();
+    const { name, webhookKey, active = true, defaultStatusId, defaultAssignedUserId } = body;
+
+    if (!name || !webhookKey) {
+      return NextResponse.json(
+        {
+          error:
+            'Les champs nom et webhookKey sont obligatoires pour activer l’intégration Google Ads (clé secrète partagée).',
+        },
+        { status: 400 },
+      );
+    }
+
+    if (!defaultAssignedUserId) {
+      return NextResponse.json(
+        { error: "L'utilisateur assigné par défaut est obligatoire." },
+        { status: 400 },
+      );
+    }
+
+    const client = prisma as any;
+
+    const config = await client.googleAdsLeadConfig.create({
+      data: {
+        name,
+        webhookKey,
+        active: !!active,
+        defaultStatusId: defaultStatusId || null,
+        defaultAssignedUserId,
+      },
+    });
+
+    return NextResponse.json({
+      success: true,
+      config: {
+        id: config.id,
+        name: config.name,
+        webhookKey: config.webhookKey,
+        active: config.active,
+        defaultStatusId: config.defaultStatusId,
+        defaultAssignedUserId: config.defaultAssignedUserId,
+      },
+      message: 'Configuration Google Ads Lead Forms créée avec succès.',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la création de la configuration Google Ads Lead Forms:', error);
+
+    if (error.message === 'Non authentifié') {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    if (error.message === 'Permissions insuffisantes') {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}

package/template/src/app/api/settings/google-sheet/[id]/route.ts

@@ -0,0 +1,230 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { requireAdmin } from '@/lib/roles';
+
+function extractSpreadsheetId(sheetUrlOrId: string): string {
+  if (!sheetUrlOrId) return sheetUrlOrId;
+
+  if (!sheetUrlOrId.includes('https://')) {
+    return sheetUrlOrId;
+  }
+
+  const match = sheetUrlOrId.match(/spreadsheets\/d\/([a-zA-Z0-9-_]+)/);
+  if (match && match[1]) {
+    return match[1];
+  }
+
+  return sheetUrlOrId;
+}
+
+// PUT /api/settings/google-sheet/[id] - Mettre à jour une configuration (admin uniquement)
+export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    await requireAdmin(request.headers);
+
+    const { id } = await params;
+    const body = await request.json();
+    const {
+      name,
+      sheetUrl,
+      sheetName,
+      headerRow,
+      phoneColumn,
+      firstNameColumn,
+      lastNameColumn,
+      emailColumn,
+      cityColumn,
+      postalCodeColumn,
+      originColumn,
+      columnMappings,
+      active,
+      defaultStatusId,
+      defaultAssignedUserId,
+    } = body;
+
+    const client = prisma as any;
+
+    const existingConfig = await client.googleSheetSyncConfig.findUnique({
+      where: { id },
+    });
+
+    if (!existingConfig) {
+      return NextResponse.json({ error: 'Configuration non trouvée' }, { status: 404 });
+    }
+
+    const updateData: any = {};
+    if (name !== undefined) updateData.name = name;
+    if (sheetUrl !== undefined) updateData.spreadsheetId = extractSpreadsheetId(sheetUrl);
+    if (sheetName !== undefined) updateData.sheetName = sheetName;
+    if (headerRow !== undefined) {
+      const headerRowNumber = Number(headerRow);
+      if (!headerRowNumber || headerRowNumber < 1) {
+        return NextResponse.json(
+          { error: 'La ligne des en-têtes doit être un nombre positif (ex: 1, 2...).' },
+          { status: 400 },
+        );
+      }
+      updateData.headerRow = headerRowNumber;
+    }
+
+    // Gérer les mappings (nouveau format)
+    if (columnMappings !== undefined && Array.isArray(columnMappings)) {
+      // Vérifier qu'au moins un mapping téléphone est configuré
+      const phoneMapping = columnMappings.find(
+        (m: any) => m.action === 'map' && m.crmField === 'phone' && m.columnName?.trim() !== '',
+      );
+      if (!phoneMapping) {
+        return NextResponse.json(
+          {
+            error: 'Le mapping du téléphone est obligatoire.',
+          },
+          { status: 400 },
+        );
+      }
+
+      updateData.columnMappings = JSON.parse(JSON.stringify(columnMappings));
+
+      // Convertir aussi vers l'ancien format pour compatibilité
+      let phoneColumnValue = phoneColumn || '';
+      let firstNameColumnValue = firstNameColumn || null;
+      let lastNameColumnValue = lastNameColumn || null;
+      let emailColumnValue = emailColumn || null;
+      let cityColumnValue = cityColumn || null;
+      let postalCodeColumnValue = postalCodeColumn || null;
+      let originColumnValue = originColumn || null;
+
+      columnMappings.forEach((mapping: any) => {
+        if (mapping.action === 'map' && mapping.crmField && mapping.columnName) {
+          switch (mapping.crmField) {
+            case 'phone':
+              phoneColumnValue = mapping.columnName;
+              break;
+            case 'firstName':
+              firstNameColumnValue = mapping.columnName;
+              break;
+            case 'lastName':
+              lastNameColumnValue = mapping.columnName;
+              break;
+            case 'email':
+              emailColumnValue = mapping.columnName;
+              break;
+            case 'city':
+              cityColumnValue = mapping.columnName;
+              break;
+            case 'postalCode':
+              postalCodeColumnValue = mapping.columnName;
+              break;
+            case 'origin':
+              originColumnValue = mapping.columnName;
+              break;
+          }
+        }
+      });
+
+      updateData.phoneColumn = phoneColumnValue;
+      updateData.firstNameColumn = firstNameColumnValue;
+      updateData.lastNameColumn = lastNameColumnValue;
+      updateData.emailColumn = emailColumnValue;
+      updateData.cityColumn = cityColumnValue;
+      updateData.postalCodeColumn = postalCodeColumnValue;
+      updateData.originColumn = originColumnValue;
+    } else {
+      // Ancien format (compatibilité)
+      if (phoneColumn !== undefined) updateData.phoneColumn = phoneColumn;
+      if (firstNameColumn !== undefined) updateData.firstNameColumn = firstNameColumn || null;
+      if (lastNameColumn !== undefined) updateData.lastNameColumn = lastNameColumn || null;
+      if (emailColumn !== undefined) updateData.emailColumn = emailColumn || null;
+      if (cityColumn !== undefined) updateData.cityColumn = cityColumn || null;
+      if (postalCodeColumn !== undefined) updateData.postalCodeColumn = postalCodeColumn || null;
+      if (originColumn !== undefined) updateData.originColumn = originColumn || null;
+    }
+
+    if (active !== undefined) updateData.active = !!active;
+    if (defaultStatusId !== undefined) updateData.defaultStatusId = defaultStatusId || null;
+    if (defaultAssignedUserId !== undefined) {
+      // Permettre de supprimer l'utilisateur par défaut (null)
+      updateData.defaultAssignedUserId = defaultAssignedUserId || null;
+    }
+
+    const config = await client.googleSheetSyncConfig.update({
+      where: { id },
+      data: updateData,
+    });
+
+    return NextResponse.json({
+      success: true,
+      config: {
+        id: config.id,
+        name: config.name,
+        spreadsheetId: config.spreadsheetId,
+        sheetName: config.sheetName,
+        headerRow: config.headerRow,
+        phoneColumn: config.phoneColumn,
+        firstNameColumn: config.firstNameColumn,
+        lastNameColumn: config.lastNameColumn,
+        emailColumn: config.emailColumn,
+        cityColumn: config.cityColumn,
+        postalCodeColumn: config.postalCodeColumn,
+        originColumn: config.originColumn,
+        active: config.active,
+        defaultStatusId: config.defaultStatusId,
+        defaultAssignedUserId: config.defaultAssignedUserId,
+      },
+      message: 'Configuration Google Sheets mise à jour avec succès.',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la mise à jour de la configuration Google Sheets:', error);
+
+    if (error.message === 'Non authentifié') {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    if (error.message === 'Permissions insuffisantes') {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// DELETE /api/settings/google-sheet/[id] - Supprimer une configuration (admin uniquement)
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  try {
+    await requireAdmin(request.headers);
+
+    const { id } = await params;
+    const client = prisma as any;
+
+    const existingConfig = await client.googleSheetSyncConfig.findUnique({
+      where: { id },
+    });
+
+    if (!existingConfig) {
+      return NextResponse.json({ error: 'Configuration non trouvée' }, { status: 404 });
+    }
+
+    await client.googleSheetSyncConfig.delete({
+      where: { id },
+    });
+
+    return NextResponse.json({
+      success: true,
+      message: 'Configuration Google Sheets supprimée avec succès.',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la suppression de la configuration Google Sheets:', error);
+
+    if (error.message === 'Non authentifié') {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    if (error.message === 'Permissions insuffisantes') {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}

package/template/src/app/api/settings/google-sheet/auto-map/route.ts

@@ -0,0 +1,196 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { requireAdmin } from '@/lib/roles';
+import { getValidAccessToken } from '@/lib/google-calendar';
+
+function extractSpreadsheetId(sheetUrlOrId: string): string {
+  if (!sheetUrlOrId) return sheetUrlOrId;
+
+  // Si c'est déjà un ID simple, on le renvoie
+  if (!sheetUrlOrId.includes('https://')) {
+    return sheetUrlOrId;
+  }
+
+  const match = sheetUrlOrId.match(/spreadsheets\/d\/([a-zA-Z0-9-_]+)/);
+  if (match && match[1]) {
+    return match[1];
+  }
+
+  return sheetUrlOrId;
+}
+
+function indexToColumn(index: number): string {
+  let col = '';
+  let n = index + 1;
+  while (n > 0) {
+    const rem = (n - 1) % 26;
+    col = String.fromCharCode(65 + rem) + col;
+    n = Math.floor((n - 1) / 26);
+  }
+  return col;
+}
+
+// POST /api/settings/google-sheet/auto-map - Proposer un mapping automatique des colonnes
+export async function POST(request: NextRequest) {
+  try {
+    const session = await requireAdmin(request.headers);
+
+    const body = await request.json();
+    const { sheetUrl, sheetName, headerRow } = body || {};
+
+    if (!sheetUrl || !sheetName || !headerRow) {
+      return NextResponse.json(
+        {
+          error:
+            'Les champs lien du Google Sheet, nom de l’onglet et ligne des en-têtes sont obligatoires pour le mapping automatique.',
+        },
+        { status: 400 },
+      );
+    }
+
+    const spreadsheetId = extractSpreadsheetId(sheetUrl);
+    const headerRowNumber = Number(headerRow);
+
+    if (!headerRowNumber || headerRowNumber < 1) {
+      return NextResponse.json(
+        { error: 'La ligne des en-têtes doit être un nombre positif (ex: 1, 2...).' },
+        { status: 400 },
+      );
+    }
+
+    // Récupérer le compte Google de l'utilisateur admin courant
+    const googleAccount = await prisma.userGoogleAccount.findUnique({
+      where: { userId: session.user.id },
+    });
+
+    if (!googleAccount) {
+      return NextResponse.json(
+        {
+          error:
+            'Aucun compte Google connecté. Veuillez connecter votre compte Google dans les paramètres avant de configurer Google Sheets.',
+        },
+        { status: 400 },
+      );
+    }
+
+    const accessToken = await getValidAccessToken(
+      googleAccount.accessToken,
+      googleAccount.refreshToken,
+      googleAccount.tokenExpiresAt,
+    );
+
+    const range = encodeURIComponent(sheetName);
+    const response = await fetch(
+      `https://sheets.googleapis.com/v4/spreadsheets/${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 pour auto-map:', errorText);
+      return NextResponse.json(
+        { error: 'Impossible de lire les données depuis Google Sheets.' },
+        { status: 400 },
+      );
+    }
+
+    const data = await response.json();
+    const values: string[][] = data.values || [];
+
+    if (!values.length) {
+      return NextResponse.json(
+        { error: 'Le Google Sheet ne contient aucune donnée.' },
+        { status: 400 },
+      );
+    }
+
+    const headerRowIndex = headerRowNumber - 1;
+    if (headerRowIndex < 0 || headerRowIndex >= values.length) {
+      return NextResponse.json(
+        { error: 'La ligne des en-têtes spécifiée est en dehors de la plage du fichier.' },
+        { status: 400 },
+      );
+    }
+
+    const headerValues = values[headerRowIndex] || [];
+
+    const fieldMappings: Record<string, string[]> = {
+      phoneColumn: ['téléphone', 'telephone', 'phone', 'tel', 'tél', 'mobile', 'portable'],
+      firstNameColumn: ['prénom', 'prenom', 'firstname', 'first name', 'first_name', 'prenom'],
+      lastNameColumn: ['nom', 'lastname', 'last name', 'last_name', 'nom de famille', 'surname'],
+      emailColumn: ['email', 'e-mail', 'mail', 'courriel', "mél", "mel"],
+      cityColumn: ['ville', 'city', 'localité', 'locality'],
+      postalCodeColumn: ['code postal', 'postal code', 'cp', 'zip', 'zipcode', 'code_postal'],
+      originColumn: ['origine', 'origin', 'source', 'campagne', 'campaign', 'origine de la campagne'],
+    };
+
+    const mapping: Record<string, string> = {};
+
+    headerValues.forEach((header, index) => {
+      if (!header) return;
+      const normalized = header.toString().toLowerCase().trim();
+
+      for (const [fieldKey, aliases] of Object.entries(fieldMappings)) {
+        if (mapping[fieldKey]) continue; // déjà mappé
+        if (
+          aliases.some(
+            (alias) =>
+              normalized.includes(alias) ||
+              alias.includes(normalized) ||
+              normalized === alias.replace(/_/g, ' '),
+          )
+        ) {
+          mapping[fieldKey] = indexToColumn(index);
+          break;
+        }
+      }
+    });
+
+    // Récupérer les 5 premières lignes de données (après la ligne d'en-tête)
+    const previewRows: string[][] = [];
+    const startDataRow = headerRowIndex + 1;
+    const endDataRow = Math.min(startDataRow + 5, values.length);
+    
+    for (let i = startDataRow; i < endDataRow; i++) {
+      if (values[i]) {
+        previewRows.push(values[i]);
+      }
+    }
+
+    // Convertir les lignes en objets avec les headers comme clés
+    const previewData = previewRows.map((row) => {
+      const rowObj: Record<string, string> = {};
+      headerValues.forEach((header, index) => {
+        rowObj[header || `Colonne ${index + 1}`] = row[index] || '';
+      });
+      return rowObj;
+    });
+
+    return NextResponse.json({
+      headers: headerValues,
+      mapping,
+      preview: previewData,
+    });
+  } catch (error: any) {
+    console.error('Erreur lors du mapping automatique Google Sheets:', error);
+
+    if (error.message === 'Non authentifié') {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    if (error.message === 'Permissions insuffisantes') {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    return NextResponse.json(
+      { error: error.message || 'Erreur serveur lors du mapping automatique' },
+      { status: 500 },
+    );
+  }
+}
+
+