create-crm-tmp 1.0.0

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

@@ -0,0 +1,250 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
+import { logAudit } from '@/lib/audit-log';
+
+// GET /api/users - Liste tous les utilisateurs (admin seulement)
+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 });
+    }
+
+    // Vérifier que l'utilisateur a la permission de voir les utilisateurs
+    const hasPermission = await checkPermission('users.view');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    const users = await prisma.user.findMany({
+      include: {
+        customRole: {
+          select: {
+            id: true,
+            name: true,
+          },
+        },
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+
+    // Mapper les utilisateurs avec le profil
+    const usersWithRole = users.map((user: any) => ({
+      id: user.id,
+      name: user.name,
+      email: user.email,
+      role: user.role || 'USER',
+      customRoleId: user.customRoleId,
+      customRole: user.customRole,
+      emailVerified: user.emailVerified,
+      active: user.active,
+      createdAt: user.createdAt,
+      updatedAt: user.updatedAt,
+      image: user.image,
+    }));
+
+    return NextResponse.json(usersWithRole);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des utilisateurs:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// POST /api/users - Créer un nouvel utilisateur (admin seulement)
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    // Vérifier que l'utilisateur a la permission de créer des utilisateurs
+    const hasPermission = await checkPermission('users.create');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    const body = await request.json();
+    const { name, email, customRoleId } = body;
+
+    // Validation
+    if (!name || !email) {
+      return NextResponse.json({ error: 'Nom et email requis' }, { status: 400 });
+    }
+
+    if (!customRoleId) {
+      return NextResponse.json({ error: 'Le profil est requis' }, { status: 400 });
+    }
+
+    // Vérifier si l'email existe déjà
+    const existingUser = await prisma.user.findUnique({
+      where: { email },
+      include: {
+        accounts: {
+          where: { providerId: 'credential' },
+        },
+      },
+    });
+
+    if (existingUser) {
+      // Si l'utilisateur existe déjà avec un compte, erreur
+      if (existingUser.accounts.length > 0) {
+        return NextResponse.json({ error: 'Cet email est déjà utilisé' }, { status: 400 });
+      }
+      // Si l'utilisateur existe mais sans compte, on peut régénérer un token
+    }
+
+    let user;
+    if (existingUser && existingUser.accounts.length === 0) {
+      // Utilisateur existe déjà sans compte, on met à jour et régénère le token
+      user = await prisma.user.update({
+        where: { id: existingUser.id },
+        data: {
+          name,
+          customRoleId,
+          active: true,
+        },
+      });
+    } else {
+      // Créer l'utilisateur SANS mot de passe (sans Account)
+      user = await prisma.user.create({
+        data: {
+          id: crypto.randomUUID(),
+          name,
+          email,
+          role: 'USER', // Rôle par défaut, mais les permissions viendront du customRole
+          customRoleId,
+          emailVerified: false, // Pas encore vérifié
+          active: true,
+        },
+      });
+    }
+
+    // Récupérer le nom du profil pour les métadonnées
+    let customRoleName: string | null = null;
+    if (customRoleId) {
+      const customRole = await prisma.customRole.findUnique({
+        where: { id: customRoleId },
+        select: { name: true },
+      });
+      customRoleName = customRole?.name || null;
+    }
+
+    // Log d'audit : création ou réactivation d'utilisateur
+    await logAudit({
+      actorId: session.user.id,
+      targetUserId: user.id,
+      action: 'USER_CREATED',
+      entityType: 'USER',
+      entityId: user.id,
+      metadata: {
+        name: user.name,
+        email: user.email,
+        customRoleId,
+        customRoleName,
+        wasExisting: Boolean(existingUser),
+      },
+    });
+
+    // Générer un token d'invitation
+    const token = crypto.randomUUID();
+    const expiresAt = new Date();
+    expiresAt.setDate(expiresAt.getDate() + 1); // Valide 1 jour
+
+    // Supprimer les anciens tokens pour cet email
+    await prisma.verification.deleteMany({
+      where: {
+        identifier: email,
+      },
+    });
+
+    // Créer le nouveau token
+    await prisma.verification.create({
+      data: {
+        id: crypto.randomUUID(),
+        identifier: email,
+        value: token,
+        expiresAt,
+      },
+    });
+
+    // Envoyer l'email d'invitation
+    const baseUrl = process.env.BETTER_AUTH_URL || 'http://localhost:3000';
+    const invitationUrl = `${baseUrl}/invite/${token}`;
+
+    try {
+      // Transmettre les cookies de session pour que /api/send puisse identifier l'utilisateur connecté
+      const cookieHeader = request.headers.get('cookie') || '';
+      const emailResponse = await fetch(`${baseUrl}/api/send`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Cookie: cookieHeader,
+        },
+        body: JSON.stringify({
+          to: email,
+          subject: 'Invitation à rejoindre le CRM',
+          template: 'invitation',
+          invitationUrl,
+          name,
+        }),
+      });
+
+      if (!emailResponse.ok) {
+        const errorData = await emailResponse.json().catch(() => ({}));
+        console.error("❌ Erreur lors de l'envoi de l'email:", {
+          status: emailResponse.status,
+          statusText: emailResponse.statusText,
+          error: errorData,
+        });
+      } else {
+        const successData = await emailResponse.json().catch(() => ({}));
+        console.log("✅ Email d'invitation envoyé avec succès:", successData);
+      }
+    } catch (emailError: any) {
+      console.error("❌ Erreur lors de l'envoi de l'email:", emailError);
+      console.error('Détails:', {
+        message: emailError.message,
+        stack: emailError.stack,
+      });
+      // On continue même si l'email échoue, l'utilisateur est créé
+    }
+
+    return NextResponse.json(
+      {
+        id: user.id,
+        name: user.name,
+        email: user.email,
+        role: user.role || 'USER',
+        emailVerified: user.emailVerified,
+        active: user.active,
+        createdAt: user.createdAt,
+        message: "Utilisateur créé, email d'invitation envoyé",
+      },
+      { status: 201 },
+    );
+  } catch (error: any) {
+    console.error("Erreur lors de la création de l'utilisateur:", error);
+
+    // Gérer les erreurs spécifiques
+    if (
+      error.message?.includes('email') ||
+      error.message?.includes('Email') ||
+      error.message?.includes('already exists')
+    ) {
+      return NextResponse.json({ error: 'Cet email est déjà utilisé' }, { status: 400 });
+    }
+
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,208 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { handleContactDuplicate } from '@/lib/contact-duplicate';
+import { normalizePhoneNumber } from '@/lib/utils';
+
+interface GoogleAdsUserColumnData {
+  columnName: string;
+  stringValue?: string;
+}
+
+interface GoogleAdsLeadNotification {
+  googleKey: string;
+  customerId?: string;
+  leadResourceName?: string;
+  userColumnData?: GoogleAdsUserColumnData[];
+}
+
+// POST /api/webhooks/google-ads - Réception des leads Google Ads (lead form extensions)
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+
+    const notification: GoogleAdsLeadNotification | undefined = body?.leadNotification;
+
+    if (!notification || !notification.googleKey) {
+      console.warn('Webhook Google Ads reçu avec un format inattendu:', body);
+      return NextResponse.json({ received: true });
+    }
+
+    const client = prisma as any;
+
+    // Récupérer toutes les configurations actives
+    const configs = await client.googleAdsLeadConfig.findMany({
+      where: { active: true },
+    });
+
+    if (!configs || configs.length === 0) {
+      console.warn(
+        'Webhook Google Ads reçu mais aucune configuration active GoogleAdsLeadConfig trouvée.',
+      );
+      return NextResponse.json({ received: true });
+    }
+
+    // Trouver la configuration correspondante à la clé
+    const config = configs.find((c: any) => c.webhookKey === notification.googleKey);
+
+    if (!config) {
+      console.warn('Clé Google Ads invalide reçue sur le webhook.');
+      return NextResponse.json({ error: 'Clé invalide' }, { status: 403 });
+    }
+
+    const userColumns = notification.userColumnData || [];
+
+    const getField = (name: string): string | undefined => {
+      const field = userColumns.find((f) => f.columnName === name);
+      return field?.stringValue;
+    };
+
+    const fullName = getField('FULL_NAME') || getField('NAME');
+    let firstName = getField('FIRST_NAME');
+    let lastName = getField('LAST_NAME');
+    const email = getField('EMAIL');
+    const phone = getField('PHONE_NUMBER') || getField('PHONE');
+
+    if ((!firstName || !lastName) && fullName) {
+      const parts = fullName.split(' ');
+      firstName = firstName || parts.slice(0, -1).join(' ') || parts[0];
+      lastName = lastName || parts.slice(-1).join(' ');
+    }
+
+    if (!phone && !email) {
+      console.warn(
+        'Lead Google Ads reçu sans téléphone ni email, impossible de créer un contact. Notification:',
+        notification,
+      );
+      return NextResponse.json({ received: true });
+    }
+
+    // Normaliser le numéro de téléphone si présent
+    const normalizedPhone = phone ? normalizePhoneNumber(phone) : '';
+
+    // Déterminer l'utilisateur pour createdById (nécessaire pour créer le contact)
+    let createdById = config.defaultAssignedUserId || null;
+    if (!createdById) {
+      const adminUser = await client.user.findFirst({
+        where: { role: 'ADMIN' },
+        orderBy: { createdAt: 'asc' },
+      });
+      if (adminUser) {
+        createdById = adminUser.id;
+      }
+    }
+
+    if (!createdById) {
+      console.warn(
+        'Lead Google Ads reçu mais aucun utilisateur pour créer le contact trouvé. Notification:',
+        notification,
+      );
+      return NextResponse.json({ received: true });
+    }
+
+    // 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,
+      `Google Ads - ${config.name}`,
+      createdById,
+    );
+
+    let contact;
+    if (duplicateContactId) {
+      // C'est un doublon, récupérer le contact existant
+      contact = await client.contact.findUnique({
+        where: { id: duplicateContactId },
+      });
+    } else {
+      // Vérifier si un contact existe déjà (par téléphone uniquement)
+      contact =
+        (email &&
+          (await client.contact.findFirst({
+            where: {
+              OR: [
+                { email: email.toLowerCase() },
+                normalizedPhone ? { phone: normalizedPhone } : undefined,
+              ].filter(Boolean) as any,
+            },
+          }))) ||
+        (normalizedPhone &&
+          (await client.contact.findFirst({
+            where: { phone: normalizedPhone },
+          })));
+
+      if (!contact) {
+        contact = await client.contact.create({
+          data: {
+            firstName: firstName || null,
+            lastName: lastName || null,
+            email: email ? email.toLowerCase() : null,
+            phone: normalizedPhone,
+            origin: `Google Ads - ${config.name}`,
+            statusId: config.defaultStatusId || null,
+            assignedCommercialId: assignedCommercialId,
+            assignedTeleproId: assignedTeleproId,
+            createdById: createdById,
+          },
+        });
+      } 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),
+            origin: contact.origin || `Google Ads - ${config.name}`,
+            statusId: contact.statusId || config.defaultStatusId || null,
+            // Ne pas écraser les assignations existantes
+            assignedCommercialId: contact.assignedCommercialId || assignedCommercialId,
+            assignedTeleproId: contact.assignedTeleproId || assignedTeleproId,
+          },
+        });
+      }
+    }
+
+    // Créer une interaction "Lead Google Ads"
+    await client.interaction.create({
+      data: {
+        contactId: contact.id,
+        type: 'NOTE',
+        title: `Lead Google Ads - ${config.name}`,
+        content: `Lead importé automatiquement depuis Google Ads (${config.name}, client: ${
+          notification.customerId || 'inconnu'
+        }).`,
+        userId: createdById,
+        date: new Date(),
+      },
+    });
+
+    return NextResponse.json({ received: true });
+  } catch (error: any) {
+    console.error('Erreur lors du traitement du webhook Google Ads Lead Forms:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}