create-crm-tmp 2.0.0 → 2.1.0

package/template/src/app/api/tasks/meet/route.ts

@@ -1,12 +1,13 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
 import {
   getValidAccessToken,
   createGoogleCalendarEvent,
   extractMeetLink,
+  assertWritableGoogleCalendar,
 } from '@/lib/google-calendar';
-import { createInteraction } from '@/lib/contact-interactions';
 import nodemailer from 'nodemailer';
 import { decrypt, encrypt } from '@/lib/encryption';
 import { render } from '@react-email/render';
@@ -37,6 +38,16 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const [canCreate, canEditOwn, canEditAll] = await Promise.all([
+      checkPermission('tasks.create'),
+      checkPermission('tasks.edit_own'),
+      checkPermission('tasks.edit_all'),
+    ]);
+
+    if (!canCreate && !canEditOwn && !canEditAll) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const body = await request.json();
     const {
       title,
@@ -48,6 +59,7 @@ export async function POST(request: NextRequest) {
       internalNote,
       contactId,
       addToGoogleCalendar = true,
+      googleCalendarId: bodyGoogleCalendarId,
     } = body;
 
     // Validation
@@ -66,7 +78,8 @@ export async function POST(request: NextRequest) {
           {
             error:
               error.message ||
-              'Veuillez connecter votre compte Google dans les paramètres pour utiliser Google Calendar.',
+              'Veuillez connecter votre compte Google dans les paramètres pour créer une visioconférence.',
+            configLink: '/settings?section=integrations',
           },
           { status: 400 },
         );
@@ -84,6 +97,7 @@ export async function POST(request: NextRequest) {
 
     let googleEventId: string | null = null;
     let meetLink: string | null = null;
+    let storedGoogleCalendarId: string | null = null;
 
     // Créer l'évènement Google Calendar avec Meet seulement si demandé
     if (addToGoogleCalendar && googleAccount) {
@@ -108,8 +122,15 @@ export async function POST(request: NextRequest) {
           });
         }
 
+        const targetCalendarId =
+          typeof bodyGoogleCalendarId === 'string' && bodyGoogleCalendarId.trim() !== ''
+            ? bodyGoogleCalendarId.trim()
+            : googleAccount.defaultGoogleCalendarId?.trim() || 'primary';
+
+        await assertWritableGoogleCalendar(accessToken, targetCalendarId);
+
         // Créer l'évènement Google Calendar avec Meet
-        const googleEvent = await createGoogleCalendarEvent(accessToken, {
+        const googleEvent = await createGoogleCalendarEvent(accessToken, targetCalendarId, {
           summary: title,
           description: description || '',
           start: {
@@ -134,6 +155,7 @@ export async function POST(request: NextRequest) {
 
         googleEventId = googleEvent.id;
         meetLink = extractMeetLink(googleEvent);
+        storedGoogleCalendarId = targetCalendarId === 'primary' ? null : targetCalendarId;
       } catch (googleError: any) {
         console.error("Erreur lors de la création de l'évènement Google Calendar:", googleError);
         // On continue quand même la création de la tâche
@@ -152,6 +174,7 @@ export async function POST(request: NextRequest) {
         createdById: session.user.id,
         contactId: contactId || null,
         googleEventId: googleEventId,
+        googleCalendarId: storedGoogleCalendarId,
         googleMeetLink: meetLink,
         durationMinutes,
         internalNote: internalNote || null,
@@ -252,22 +275,7 @@ export async function POST(request: NextRequest) {
       }
     }
 
-    // Si la tâche est liée à un contact, créer aussi une interaction
-    if (contactId) {
-      try {
-        await createInteraction({
-          contactId,
-          type: 'APPOINTMENT_CREATED' as any,
-          title: title || null,
-          content: description || '',
-          userId: session.user.id,
-          date: startDate,
-        });
-      } catch (error) {
-        // Ne pas faire échouer la création du Meet si l'interaction échoue
-        console.error("Erreur lors de la création de l'interaction:", error);
-      }
-    }
+    // Pas d'interaction pour un Google Meet : affichage via la tâche tant qu'elle existe en base.
 
     return NextResponse.json(task, { status: 201 });
   } catch (error: any) {

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

@@ -1,13 +1,18 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { prisma } from '@/lib/prisma';
 import { getAuthUser } from '@/lib/get-auth-user';
+import { checkPermission } from '@/lib/check-permission';
 import { logAppointmentCreated, createInteraction } from '@/lib/contact-interactions';
 import nodemailer from 'nodemailer';
 import { decrypt, encrypt } from '@/lib/encryption';
-import { render } from '@react-email/render';
 import { MeetConfirmationEmailTemplate } from '@/components/meet-confirmation-email-template';
 import React from 'react';
-import { createGoogleCalendarEvent, getValidAccessToken } from '@/lib/google-calendar';
+import {
+  appendGoogleCalendarContactFooter,
+  assertWritableGoogleCalendar,
+  createGoogleCalendarEvent,
+  getValidAccessToken,
+} from '@/lib/google-calendar';
 
 function htmlToText(html: string): string {
   if (!html) return '';
@@ -171,6 +176,7 @@ export async function POST(request: NextRequest) {
       internalNote,
       attendees = [],
       addToGoogleCalendar = true,
+      googleCalendarId: bodyGoogleCalendarId,
       // Champs pour les rendez-vous physiques
       location,
       locationAddress,
@@ -187,19 +193,29 @@ export async function POST(request: NextRequest) {
       );
     }
 
-    // Vérifier si l'utilisateur est admin
-    const user = await prisma.user.findUnique({
-      where: { id: session.user.id },
-      select: { role: true },
-    });
+    // Déterminer l'utilisateur assigné (selon permissions d'assignation)
+    const canAssignFull = await checkPermission('tasks.assign');
+    const canAssignToSales = await checkPermission('tasks.assign_to_sales');
 
-    // Déterminer l'utilisateur assigné
     let finalAssignedUserId: string;
-    if (assignedUserId && user?.role === 'ADMIN') {
-      // Admin peut assigner à n'importe qui
-      finalAssignedUserId = assignedUserId;
+    if (assignedUserId && (canAssignFull || canAssignToSales)) {
+      if (canAssignFull) {
+        finalAssignedUserId = assignedUserId;
+      } else {
+        // assign_to_sales : uniquement COMMERCIAL ou TELEPRO
+        const target = await prisma.user.findUnique({
+          where: { id: assignedUserId },
+          select: { role: true },
+        });
+        if (!target || (target.role !== 'COMMERCIAL' && target.role !== 'TELEPRO')) {
+          return NextResponse.json(
+            { error: "Vous ne pouvez assigner une tâche qu'à un commercial ou un télépro" },
+            { status: 403 },
+          );
+        }
+        finalAssignedUserId = assignedUserId;
+      }
     } else {
-      // Utilisateur normal s'assigne automatiquement
       finalAssignedUserId = session.user.id;
     }
 
@@ -307,9 +323,32 @@ export async function POST(request: NextRequest) {
         const duration = type === 'MEETING' ? 60 : 30;
         const endDate = new Date(startDate.getTime() + duration * 60 * 1000);
 
-        const googleEvent = await createGoogleCalendarEvent(accessToken, {
+        const targetCalendarId =
+          typeof bodyGoogleCalendarId === 'string' && bodyGoogleCalendarId.trim() !== ''
+            ? bodyGoogleCalendarId.trim()
+            : googleAccount.defaultGoogleCalendarId?.trim() || 'primary';
+
+        await assertWritableGoogleCalendar(accessToken, targetCalendarId);
+
+        const googleAttendees =
+          type === 'TASK' && task.contact?.email
+            ? allAttendees.filter(
+                (a) => a.email.toLowerCase() !== task.contact!.email!.toLowerCase(),
+              )
+            : allAttendees;
+
+        let googleDescription = htmlToText(description);
+        if (type === 'TASK' && task.contact?.email) {
+          googleDescription = appendGoogleCalendarContactFooter(googleDescription, {
+            firstName: task.contact.firstName,
+            lastName: task.contact.lastName,
+            email: task.contact.email,
+          });
+        }
+
+        const googleEvent = await createGoogleCalendarEvent(accessToken, targetCalendarId, {
           summary: title || (type === 'MEETING' ? 'Rendez-vous' : 'Tâche'),
-          description: htmlToText(description),
+          description: googleDescription,
           start: {
             dateTime: startDate.toISOString(),
             timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
@@ -318,7 +357,7 @@ export async function POST(request: NextRequest) {
             dateTime: endDate.toISOString(),
             timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
           },
-          attendees: allAttendees.length > 0 ? allAttendees : undefined,
+          attendees: googleAttendees.length > 0 ? googleAttendees : undefined,
           location: location || undefined, // Ajouter l'adresse du rendez-vous
         });
 
@@ -327,6 +366,7 @@ export async function POST(request: NextRequest) {
           where: { id: task.id },
           data: {
             googleEventId: googleEvent.id,
+            googleCalendarId: targetCalendarId === 'primary' ? null : targetCalendarId,
           },
         });
       } catch (googleError: any) {
@@ -410,6 +450,7 @@ export async function POST(request: NextRequest) {
                 // Envoyer un email individuel à chaque destinataire
                 for (const recipient of recipients) {
                   try {
+                    const { render } = await import('@react-email/render');
                     // Générer le contenu HTML de l'email avec le composant React
                     const emailComponent = React.createElement(MeetConfirmationEmailTemplate, {
                       contactName: recipient.name,
@@ -448,8 +489,8 @@ export async function POST(request: NextRequest) {
               console.error("Erreur lors de l'envoi de l'email de notification:", emailError);
             }
           }
-        } else {
-          // Pour les autres types de tâches, créer une interaction de type TASK
+        } else if (type !== 'VIDEO_CONFERENCE') {
+          // Pas d'interaction pour la visio (annulable) : le fil d'activité lit la tâche en base.
           await createInteraction({
             contactId,
             type: 'TASK' as any,
@@ -457,6 +498,10 @@ export async function POST(request: NextRequest) {
             content: description,
             userId: session.user.id,
             date: new Date(scheduledAt),
+            metadata: {
+              taskId: task.id,
+              scheduledAt: new Date(scheduledAt).toISOString(),
+            },
           });
         }
       } catch (error) {

package/template/src/app/api/users/[id]/route.ts

@@ -101,22 +101,28 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       }
     }
 
-    const updatedUser = await prisma.user.update({
-      where: { id },
-      data: {
-        ...(name && { name }),
-        ...(customRoleId !== undefined && { customRoleId: customRoleId || null }),
-        ...(resolvedRole && { role: resolvedRole as any }),
-        ...(typeof active === 'boolean' && { active }),
-      },
-      include: {
-        customRole: {
-          select: {
-            id: true,
-            name: true,
+    const updatedUser = await prisma.$transaction(async (tx) => {
+      const userRow = await tx.user.update({
+        where: { id },
+        data: {
+          ...(name && { name }),
+          ...(customRoleId !== undefined && { customRoleId: customRoleId || null }),
+          ...(resolvedRole && { role: resolvedRole as any }),
+          ...(typeof active === 'boolean' && { active }),
+        },
+        include: {
+          customRole: {
+            select: {
+              id: true,
+              name: true,
+            },
           },
         },
-      },
+      });
+      if (typeof active === 'boolean' && active === false && existingUser.active) {
+        await tx.session.deleteMany({ where: { userId: id } });
+      }
+      return userRow;
     });
 
     // Récupérer les noms des profils pour les métadonnées

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

@@ -1,9 +1,14 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
-import { prisma } from '@/lib/prisma';
+import { prisma, type Role } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
 
-// GET /api/users/list - Récupérer la liste des utilisateurs avec leurs profils (pour les admins)
+// Tous les rôles assignables (permission contacts.assign)
+const ASSIGNABLE_ROLES: Role[] = ['ADMIN', 'MANAGER', 'COMMERCIAL', 'TELEPRO'];
+// Uniquement commercial et télépro (permission contacts.assign_to_sales)
+const SALES_ROLES: Role[] = ['COMMERCIAL', 'TELEPRO'];
+
+// GET /api/users/list - Liste des utilisateurs (admins: tous ; édition contacts: liste pour attribution)
 export async function GET(request: NextRequest) {
   try {
     const session = await auth.api.getSession({
@@ -14,28 +19,61 @@ export async function GET(request: NextRequest) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
-    // Vérifier que l'utilisateur a la permission de gérer les rôles (admin)
-    const hasPermission = await checkPermission('users.manage_roles');
-    if (!hasPermission) {
+    const [canManageRoles, canAssignContactsFull, canAssignContactsToSales, canAssignTasksFull, canAssignTasksToSales, canEditOwn, canEditAll] = await Promise.all([
+      checkPermission('users.manage_roles'),
+      checkPermission('contacts.assign'),
+      checkPermission('contacts.assign_to_sales'),
+      checkPermission('tasks.assign'),
+      checkPermission('tasks.assign_to_sales'),
+      checkPermission('contacts.edit_own'),
+      checkPermission('contacts.edit_all'),
+    ]);
+    const canEditContacts = canEditOwn || canEditAll;
+
+    const canAssignFull = canAssignContactsFull || canAssignTasksFull;
+    const canAssignToSales = canAssignContactsToSales || canAssignTasksToSales;
+
+    const canAccessList =
+      canManageRoles ||
+      canAssignFull ||
+      canAssignToSales ||
+      canEditContacts;
+    if (!canAccessList) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
     }
 
-    // Récupérer tous les utilisateurs avec leurs profils
-    const users = await prisma.user.findMany({
-      select: {
-        id: true,
-        name: true,
-        email: true,
-        customRole: {
-          select: {
-            id: true,
-            name: true,
-            permissions: true,
-          },
+    const select = {
+      id: true,
+      name: true,
+      email: true,
+      role: true,
+      customRole: {
+        select: {
+          id: true,
+          name: true,
+          permissions: true,
         },
       },
-      orderBy: { name: 'asc' },
-    });
+    };
+
+    // Déterminer les rôles à inclure : admins = tous ; assign (contacts ou tâches) full = ASSIGNABLE_ROLES ; sinon SALES_ROLES
+    const assignableRoles = canManageRoles
+      ? undefined
+      : canAssignFull
+        ? ASSIGNABLE_ROLES
+        : SALES_ROLES;
+
+    const users =
+      assignableRoles === undefined
+        ? await prisma.user.findMany({
+            select,
+            orderBy: { name: 'asc' },
+          })
+        : await prisma.user.findMany({
+            where: { role: { in: assignableRoles }, active: true },
+            select,
+            orderBy: { name: 'asc' },
+          });
 
     return NextResponse.json(users);
   } catch (error: any) {

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

@@ -29,21 +29,26 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ received: true });
     }
 
-    // Sécurité HMAC (si configurée)
+    // Sécurité HMAC (obligatoire)
     const webhookSecret = process.env.GOOGLE_ADS_WEBHOOK_SECRET;
-    if (webhookSecret) {
-      const signatureHeader = request.headers.get('x-goog-signature');
-      if (signatureHeader) {
-        const expectedSignature = crypto
-          .createHmac('sha256', webhookSecret)
-          .update(rawBody)
-          .digest('base64');
-
-        if (signatureHeader !== expectedSignature) {
-          console.error('Webhook Google Ads Lead Forms: Signature HMAC invalide');
-          return NextResponse.json({ error: 'Invalid signature' }, { status: 401 });
-        }
-      }
+    if (!webhookSecret) {
+      console.error('GOOGLE_ADS_WEBHOOK_SECRET not configured');
+      return NextResponse.json({ error: 'Webhook not configured' }, { status: 503 });
+    }
+
+    const signatureHeader = request.headers.get('x-goog-signature');
+    if (!signatureHeader) {
+      console.error('Webhook Google Ads Lead Forms: Signature HMAC manquante');
+      return NextResponse.json({ error: 'Missing signature' }, { status: 401 });
+    }
+    const expectedSignature = crypto
+      .createHmac('sha256', webhookSecret)
+      .update(rawBody)
+      .digest('base64');
+
+    if (signatureHeader !== expectedSignature) {
+      console.error('Webhook Google Ads Lead Forms: Signature HMAC invalide');
+      return NextResponse.json({ error: 'Invalid signature' }, { status: 401 });
     }
 
     const client = prisma as any;
@@ -219,6 +224,21 @@ export async function POST(request: NextRequest) {
       },
     });
 
+    // Log d'import pour les notifications admin
+    await prisma.integrationImportLog.create({
+      data: {
+        integrationType: 'google_ads',
+        configId: config.id,
+        configName: config.name,
+        action: 'synced',
+        actorId: null,
+        totalImported: duplicateContactId ? 0 : 1,
+        totalDuplicates: duplicateContactId ? 1 : 0,
+        totalUpdated: 0,
+        totalErrors: 0,
+      },
+    });
+
     return NextResponse.json({ received: true });
   } catch (error: any) {
     console.error('Erreur lors du traitement du webhook Google Ads Lead Forms:', error);

package/template/src/app/api/webhooks/meta-leads/route.ts

@@ -58,19 +58,24 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ received: true });
     }
 
-    // Sécurité HMAC (si configurée)
+    // Sécurité HMAC (obligatoire)
     const webhookSecret = process.env.META_LEADS_WEBHOOK_SECRET;
-    if (webhookSecret) {
-      const signatureHeader = request.headers.get('x-hub-signature-256');
-      if (signatureHeader) {
-        const expectedSignature =
-          'sha256=' + crypto.createHmac('sha256', webhookSecret).update(rawBody).digest('hex');
-
-        if (signatureHeader !== expectedSignature) {
-          console.error('Webhook Meta Lead Ads: Signature HMAC invalide');
-          return NextResponse.json({ error: 'Invalid signature' }, { status: 401 });
-        }
-      }
+    if (!webhookSecret) {
+      console.error('META_LEADS_WEBHOOK_SECRET not configured');
+      return NextResponse.json({ error: 'Webhook not configured' }, { status: 503 });
+    }
+
+    const signatureHeader = request.headers.get('x-hub-signature-256');
+    if (!signatureHeader) {
+      console.error('Webhook Meta Lead Ads: Signature HMAC manquante');
+      return NextResponse.json({ error: 'Missing signature' }, { status: 401 });
+    }
+    const expectedSignature =
+      'sha256=' + crypto.createHmac('sha256', webhookSecret).update(rawBody).digest('hex');
+
+    if (signatureHeader !== expectedSignature) {
+      console.error('Webhook Meta Lead Ads: Signature HMAC invalide');
+      return NextResponse.json({ error: 'Invalid signature' }, { status: 401 });
     }
 
     // Récupérer toutes les configurations actives
@@ -261,6 +266,21 @@ export async function POST(request: NextRequest) {
               },
             });
           }
+
+          // Log d'import pour les notifications admin
+          await prisma.integrationImportLog.create({
+            data: {
+              integrationType: 'meta_lead',
+              configId: config.id,
+              configName: config.name,
+              action: 'synced',
+              actorId: null,
+              totalImported: duplicateContactId ? 0 : 1,
+              totalDuplicates: duplicateContactId ? 1 : 0,
+              totalUpdated: 0,
+              totalErrors: 0,
+            },
+          });
         } catch (err: any) {
           console.error('Erreur lors du traitement du lead Meta:', err);
         }

package/template/src/app/api/workflows/[id]/route.ts

@@ -80,8 +80,6 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       triggerTimeHours,
       triggerTimeReference,
       triggerTaskType,
-      triggerTransactionFromStatus,
-      triggerTransactionToStatus,
       actions = [],
     } = body;
 
@@ -120,8 +118,6 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
         triggerTimeHours: triggerTimeHours || null,
         triggerTimeReference: triggerTimeReference || null,
         triggerTaskType: triggerTaskType || null,
-        triggerTransactionFromStatus: triggerTransactionFromStatus || null,
-        triggerTransactionToStatus: triggerTransactionToStatus || null,
         actions: {
           create: actions.map((action: any, index: number) => ({
             actionType: action.actionType,