create-crm-tmp 1.0.0

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

@@ -0,0 +1,254 @@
+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;
+
+  // 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;
+}
+
+// GET /api/settings/google-sheet - Récupérer toutes les configurations Google Sheets (admin uniquement)
+export async function GET(request: NextRequest) {
+  try {
+    await requireAdmin(request.headers);
+
+    const client = prisma as any;
+
+    const configs = await client.googleSheetSyncConfig.findMany({
+      include: {
+        defaultStatus: true,
+        defaultAssignedUser: {
+          select: { id: true, name: true, email: true },
+        },
+        ownerUser: {
+          select: { id: true, name: true, email: true },
+        },
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+
+    return NextResponse.json(
+      configs.map((config: any) => ({
+        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,
+        columnMappings: config.columnMappings
+          ? (typeof config.columnMappings === 'string'
+              ? JSON.parse(config.columnMappings)
+              : config.columnMappings)
+          : null,
+        active: config.active,
+        lastSyncedRow: config.lastSyncedRow,
+        defaultStatusId: config.defaultStatusId,
+        defaultAssignedUserId: config.defaultAssignedUserId,
+        ownerUser: config.ownerUser,
+        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 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: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// POST /api/settings/google-sheet - Créer une nouvelle configuration (admin uniquement)
+export async function POST(request: NextRequest) {
+  try {
+    const session = await requireAdmin(request.headers);
+
+    const body = await request.json();
+    const {
+      name,
+      sheetUrl,
+      sheetName,
+      headerRow,
+      phoneColumn, // Ancien format (compatibilité)
+      firstNameColumn,
+      lastNameColumn,
+      emailColumn,
+      cityColumn,
+      postalCodeColumn,
+      originColumn,
+      columnMappings, // Nouveau format
+      active = true,
+      defaultStatusId,
+      defaultAssignedUserId,
+    } = body;
+
+    if (!name || !sheetUrl || !sheetName || !headerRow) {
+      return NextResponse.json(
+        {
+          error:
+            'Les champs nom, lien du Google Sheet, nom de l’onglet et ligne des en-têtes sont obligatoires.',
+        },
+        { status: 400 },
+      );
+    }
+
+    // Vérifier qu'au moins un mapping téléphone est configuré
+    if (columnMappings && Array.isArray(columnMappings)) {
+      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 },
+        );
+      }
+    } else if (!phoneColumn) {
+      return NextResponse.json(
+        {
+          error: 'Le mapping du téléphone est obligatoire.',
+        },
+        { 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 },
+      );
+    }
+
+    const client = prisma as any;
+
+    // Convertir les mappings vers l'ancien format pour la 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;
+
+    if (columnMappings && Array.isArray(columnMappings)) {
+      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;
+          }
+        }
+      });
+    }
+
+    const config = await client.googleSheetSyncConfig.create({
+      data: {
+        name,
+        ownerUserId: session.user.id,
+        spreadsheetId,
+        sheetName,
+        headerRow: headerRowNumber,
+        phoneColumn: phoneColumnValue,
+        firstNameColumn: firstNameColumnValue,
+        lastNameColumn: lastNameColumnValue,
+        emailColumn: emailColumnValue,
+        cityColumn: cityColumnValue,
+        postalCodeColumn: postalCodeColumnValue,
+        originColumn: originColumnValue,
+        columnMappings: columnMappings ? JSON.parse(JSON.stringify(columnMappings)) : null,
+        active: !!active,
+        defaultStatusId: defaultStatusId || null,
+        defaultAssignedUserId: defaultAssignedUserId || null,
+      },
+    });
+
+    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 créée avec succès.',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la création 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/meta-leads/[id]/route.ts

@@ -0,0 +1,123 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { requireAdmin } from '@/lib/roles';
+import { encrypt } from '@/lib/encryption';
+
+// PUT /api/settings/meta-leads/[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,
+      pageId,
+      accessToken,
+      verifyToken,
+      active,
+      defaultStatusId,
+      defaultAssignedUserId,
+    } = body;
+
+    const existingConfig = await prisma.metaLeadConfig.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 (pageId !== undefined) updateData.pageId = pageId;
+    if (accessToken !== undefined) {
+      try {
+        updateData.accessToken = encrypt(accessToken);
+      } catch (encryptError: any) {
+        console.error("Erreur lors du chiffrement du jeton d'accès Meta:", encryptError);
+        return NextResponse.json(
+          { error: `Erreur de chiffrement: ${encryptError.message}` },
+          { status: 500 },
+        );
+      }
+    }
+    if (verifyToken !== undefined) updateData.verifyToken = verifyToken;
+    if (active !== undefined) updateData.active = !!active;
+    if (defaultStatusId !== undefined) updateData.defaultStatusId = defaultStatusId || null;
+    if (defaultAssignedUserId !== undefined)
+      updateData.defaultAssignedUserId = defaultAssignedUserId || null;
+
+    const config = await prisma.metaLeadConfig.update({
+      where: { id },
+      data: updateData,
+    });
+
+    return NextResponse.json({
+      success: true,
+      config: {
+        id: config.id,
+        name: config.name,
+        pageId: config.pageId,
+        verifyToken: config.verifyToken,
+        active: config.active,
+        defaultStatusId: config.defaultStatusId,
+        defaultAssignedUserId: config.defaultAssignedUserId,
+      },
+      message: 'Configuration Meta Lead Ads mise à jour avec succès.',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la mise à jour de la configuration Meta Lead Ads:', 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/meta-leads/[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 existingConfig = await prisma.metaLeadConfig.findUnique({
+      where: { id },
+    });
+
+    if (!existingConfig) {
+      return NextResponse.json({ error: 'Configuration non trouvée' }, { status: 404 });
+    }
+
+    await prisma.metaLeadConfig.delete({
+      where: { id },
+    });
+
+    return NextResponse.json({
+      success: true,
+      message: 'Configuration Meta Lead Ads supprimée avec succès.',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la suppression de la configuration Meta Lead Ads:', 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/meta-leads/route.ts

@@ -0,0 +1,132 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { requireAdmin } from '@/lib/roles';
+import { encrypt } from '@/lib/encryption';
+
+// GET /api/settings/meta-leads - Récupérer toutes les configurations Meta Lead Ads (admin uniquement)
+export async function GET(request: NextRequest) {
+  try {
+    await requireAdmin(request.headers);
+
+    const configs = await prisma.metaLeadConfig.findMany({
+      include: {
+        defaultStatus: true,
+        defaultAssignedUser: {
+          select: { id: true, name: true, email: true },
+        },
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+
+    return NextResponse.json(
+      configs.map((config) => ({
+        id: config.id,
+        name: config.name,
+        pageId: config.pageId,
+        verifyToken: config.verifyToken,
+        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 Meta Lead Ads:', 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/meta-leads - 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,
+      pageId,
+      accessToken,
+      verifyToken,
+      active = true,
+      defaultStatusId,
+      defaultAssignedUserId,
+    } = body;
+
+    if (!name || !pageId || !accessToken || !verifyToken) {
+      return NextResponse.json(
+        {
+          error:
+            'Les champs nom, pageId, accessToken et verifyToken sont obligatoires pour activer Meta Lead Ads.',
+        },
+        { status: 400 },
+      );
+    }
+
+    let encryptedAccessToken: string;
+    try {
+      encryptedAccessToken = encrypt(accessToken);
+    } catch (encryptError: any) {
+      console.error("Erreur lors du chiffrement du jeton d'accès Meta:", encryptError);
+      return NextResponse.json(
+        { error: `Erreur de chiffrement: ${encryptError.message}` },
+        { status: 500 },
+      );
+    }
+
+    const config = await prisma.metaLeadConfig.create({
+      data: {
+        name,
+        pageId,
+        accessToken: encryptedAccessToken,
+        verifyToken,
+        active: !!active,
+        defaultStatusId: defaultStatusId || null,
+        defaultAssignedUserId: defaultAssignedUserId || null,
+      },
+    });
+
+    return NextResponse.json({
+      success: true,
+      config: {
+        id: config.id,
+        name: config.name,
+        pageId: config.pageId,
+        verifyToken: config.verifyToken,
+        active: config.active,
+        defaultStatusId: config.defaultStatusId,
+        defaultAssignedUserId: config.defaultAssignedUserId,
+      },
+      message: 'Configuration Meta Lead Ads créée avec succès.',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la création de la configuration Meta Lead Ads:', 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/profile/route.ts

@@ -0,0 +1,42 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+// PUT /api/settings/profile - Mettre à jour le profil de l'utilisateur (nom uniquement)
+export async function PUT(request: NextRequest) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const body = await request.json();
+    const { name } = body;
+
+    if (!name || name.trim().length === 0) {
+      return NextResponse.json({ error: 'Le nom est requis' }, { status: 400 });
+    }
+
+    // Mettre à jour le nom de l'utilisateur
+    const updatedUser = await prisma.user.update({
+      where: { id: session.user.id },
+      data: { name: name.trim() },
+    });
+
+    return NextResponse.json({
+      success: true,
+      user: {
+        id: updatedUser.id,
+        name: updatedUser.name,
+        email: updatedUser.email,
+      },
+      message: 'Nom mis à jour avec succès',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la mise à jour du profil:', error);
+    return NextResponse.json({ error: 'Erreur lors de la mise à jour du profil' }, { status: 500 });
+  }
+}

package/template/src/app/api/settings/smtp/route.ts

@@ -0,0 +1,130 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { encrypt } from '@/lib/encryption';
+
+// GET /api/settings/smtp - Récupérer la configuration SMTP de l'utilisateur
+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 smtpConfig = await prisma.smtpConfig.findUnique({
+      where: { userId: session.user.id },
+      select: {
+        id: true,
+        host: true,
+        port: true,
+        secure: true,
+        username: true,
+        fromEmail: true,
+        fromName: true,
+        signature: true,
+        // Ne pas retourner le mot de passe
+      },
+    });
+
+    return NextResponse.json(smtpConfig || null);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération de la config SMTP:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// PUT /api/settings/smtp - Sauvegarder ou mettre à jour la configuration SMTP
+export async function PUT(request: NextRequest) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const body = await request.json();
+    const { host, port, secure, username, password, fromEmail, fromName, signature } = body;
+
+    // Validation
+    if (!host || !port || !username || !password || !fromEmail) {
+      return NextResponse.json(
+        { error: 'Tous les champs sont requis (host, port, username, password, fromEmail)' },
+        { status: 400 },
+      );
+    }
+
+    if (port < 1 || port > 65535) {
+      return NextResponse.json({ error: 'Le port doit être entre 1 et 65535' }, { status: 400 });
+    }
+
+    // Chiffrer le mot de passe avant stockage
+    let encryptedPassword: string;
+    try {
+      encryptedPassword = encrypt(password);
+    } catch (encryptError: any) {
+      console.error('Erreur lors du chiffrement du mot de passe:', encryptError);
+      return NextResponse.json(
+        { error: `Erreur de chiffrement: ${encryptError.message}` },
+        { status: 500 },
+      );
+    }
+
+    // Créer ou mettre à jour la configuration SMTP
+    let smtpConfig;
+    try {
+      smtpConfig = await prisma.smtpConfig.upsert({
+        where: { userId: session.user.id },
+        update: {
+          host,
+          port: parseInt(port),
+          secure: secure === true || secure === 'true',
+          username,
+          password: encryptedPassword, // Mot de passe chiffré
+          fromEmail,
+          fromName: fromName || null,
+          signature: signature || null,
+        },
+        create: {
+          userId: session.user.id,
+          host,
+          port: parseInt(port),
+          secure: secure === true || secure === 'true',
+          username,
+          password: encryptedPassword, // Mot de passe chiffré
+          fromEmail,
+          fromName: fromName || null,
+          signature: signature || null,
+        },
+      });
+    } catch (dbError: any) {
+      console.error('Erreur lors de la sauvegarde en base de données:', dbError);
+      return NextResponse.json(
+        { error: `Erreur de base de données: ${dbError.message}` },
+        { status: 500 },
+      );
+    }
+
+    return NextResponse.json({
+      success: true,
+      config: {
+        id: smtpConfig.id,
+        host: smtpConfig.host,
+        port: smtpConfig.port,
+        secure: smtpConfig.secure,
+        username: smtpConfig.username,
+        fromEmail: smtpConfig.fromEmail,
+        fromName: smtpConfig.fromName,
+        signature: smtpConfig.signature,
+      },
+      message: 'Configuration SMTP sauvegardée avec succès',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la sauvegarde de la config SMTP:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}