create-crm-tmp 2.0.0 → 2.1.0

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

@@ -50,6 +50,44 @@ export async function PUT(request: NextRequest) {
     const body = await request.json();
     const { host, port, secure, username, password, fromEmail, fromName, signature } = body;
 
+    const smtpFieldKeys = ['host', 'port', 'secure', 'username', 'password', 'fromEmail', 'fromName'];
+    const hasSmtpFields = smtpFieldKeys.some((key) => Object.hasOwn(body, key));
+    const hasSignatureField = Object.hasOwn(body, 'signature');
+
+    // Mise à jour partielle: signature seule (sans revalidation SMTP)
+    if (hasSignatureField && !hasSmtpFields) {
+      const existingConfig = await prisma.smtpConfig.findUnique({
+        where: { userId: session.user.id },
+      });
+
+      if (!existingConfig) {
+        return NextResponse.json(
+          { error: "Aucune configuration SMTP existante pour enregistrer la signature" },
+          { status: 400 },
+        );
+      }
+
+      const updatedConfig = await prisma.smtpConfig.update({
+        where: { userId: session.user.id },
+        data: { signature: signature || null },
+      });
+
+      return NextResponse.json({
+        success: true,
+        config: {
+          id: updatedConfig.id,
+          host: updatedConfig.host,
+          port: updatedConfig.port,
+          secure: updatedConfig.secure,
+          username: updatedConfig.username,
+          fromEmail: updatedConfig.fromEmail,
+          fromName: updatedConfig.fromName,
+          signature: updatedConfig.signature,
+        },
+        message: 'Signature sauvegardée avec succès',
+      });
+    }
+
     // Validation
     if (!host || !port || !username || !password || !fromEmail) {
       return NextResponse.json(
@@ -58,6 +96,15 @@ export async function PUT(request: NextRequest) {
       );
     }
 
+    const hostTrimmed = host.trim().toLowerCase();
+    const validHostnameRegex = /^([a-z0-9]([a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/;
+    if (!validHostnameRegex.test(hostTrimmed)) {
+      return NextResponse.json(
+        { error: 'Le nom d\'hôte SMTP est invalide. Vérifiez qu\'il contient un domaine complet (ex: smtp.ionos.fr)' },
+        { status: 400 },
+      );
+    }
+
     if (port < 1 || port > 65535) {
       return NextResponse.json({ error: 'Le port doit être entre 1 et 65535' }, { status: 400 });
     }
@@ -80,22 +127,22 @@ export async function PUT(request: NextRequest) {
       smtpConfig = await prisma.smtpConfig.upsert({
         where: { userId: session.user.id },
         update: {
-          host,
-          port: parseInt(port),
+          host: hostTrimmed,
+          port: Number.parseInt(port, 10),
           secure: secure === true || secure === 'true',
           username,
-          password: encryptedPassword, // Mot de passe chiffré
+          password: encryptedPassword,
           fromEmail,
           fromName: fromName || null,
           signature: signature || null,
         },
         create: {
           userId: session.user.id,
-          host,
-          port: parseInt(port),
+          host: hostTrimmed,
+          port: Number.parseInt(port, 10),
           secure: secure === true || secure === 'true',
           username,
-          password: encryptedPassword, // Mot de passe chiffré
+          password: encryptedPassword,
           fromEmail,
           fromName: fromName || null,
           signature: signature || null,

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

@@ -1,7 +1,12 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
-import { getValidAccessToken, getGoogleCalendarEvent } from '@/lib/google-calendar';
+import { checkPermission } from '@/lib/check-permission';
+import {
+  getValidAccessToken,
+  getGoogleCalendarEvent,
+  resolveTaskGoogleCalendarId,
+} from '@/lib/google-calendar';
 
 // GET /api/tasks/[id]/attendees - Récupérer les invités d'un Google Meet
 export async function GET(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
@@ -21,6 +26,7 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
       select: {
         id: true,
         googleEventId: true,
+        googleCalendarId: true,
         contactId: true,
         contact: {
           select: {
@@ -36,12 +42,17 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
     }
 
     // Vérifier les permissions
-    const user = await prisma.user.findUnique({
-      where: { id: session.user.id },
-      select: { role: true },
-    });
+    const [canEditOwn, canEditAll] = await Promise.all([
+      checkPermission('tasks.edit_own'),
+      checkPermission('tasks.edit_all'),
+    ]);
 
-    if (task.assignedUserId !== session.user.id && user?.role !== 'ADMIN') {
+    if (!canEditAll && !canEditOwn) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    // Vérifier la propriété si l'utilisateur ne peut modifier que ses tâches
+    if (!canEditAll && canEditOwn && task.assignedUserId !== session.user.id) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
     }
 
@@ -55,7 +66,8 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
         {
           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 gérer les invités du Meet.',
+          configLink: '/settings?section=integrations',
         },
         { status: 400 },
       );
@@ -69,7 +81,11 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
     );
 
     // Récupérer l'événement Google Calendar
-    const googleEvent = await getGoogleCalendarEvent(accessToken, task.googleEventId);
+    const googleEvent = await getGoogleCalendarEvent(
+      accessToken,
+      resolveTaskGoogleCalendarId(task.googleCalendarId),
+      task.googleEventId,
+    );
 
     // Extraire les emails des invités (inclure tous les invités, y compris le contact)
     const attendees =

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

@@ -4,15 +4,23 @@ import { prisma } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
 import { executeWorkflowsOnTaskCompleted } from '@/lib/workflow-executor';
 import {
+  appendGoogleCalendarContactFooter,
+  createGoogleCalendarEvent,
   getValidAccessToken,
   updateGoogleCalendarEvent,
   extractMeetLink,
   deleteGoogleCalendarEvent,
   getGoogleCalendarEvent,
+  resolveTaskGoogleCalendarId,
 } from '@/lib/google-calendar';
 import nodemailer from 'nodemailer';
 import { decrypt, encrypt } from '@/lib/encryption';
-import { logAppointmentCancelled, logAppointmentChanged } from '@/lib/contact-interactions';
+import {
+  createInteraction,
+  logAppointmentCancelled,
+  logAppointmentChanged,
+  deleteInteractionsLinkedToTask,
+} from '@/lib/contact-interactions';
 import { render } from '@react-email/render';
 import { MeetUpdateEmailTemplate } from '@/components/meet-update-email-template';
 import { MeetCancellationEmailTemplate } from '@/components/meet-cancellation-email-template';
@@ -135,6 +143,7 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       locationCity,
       locationPostalCode,
       isAtHome,
+      googleCalendarId: bodyGoogleCalendarId,
     } = body;
 
     // Vérifier que la tâche existe
@@ -182,9 +191,30 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
     if (locationPostalCode !== undefined)
       updateData.locationPostalCode = locationPostalCode || null;
     if (isAtHome !== undefined) updateData.isAtHome = isAtHome === true;
+    if (bodyGoogleCalendarId !== undefined) {
+      const normalizedCalendarId =
+        typeof bodyGoogleCalendarId === 'string' && bodyGoogleCalendarId.trim() !== ''
+          ? bodyGoogleCalendarId.trim()
+          : null;
+      updateData.googleCalendarId =
+        normalizedCalendarId && normalizedCalendarId !== 'primary' ? normalizedCalendarId : null;
+    }
 
-    const canAssign = await checkPermission('tasks.assign');
-    if (assignedUserId !== undefined && canAssign) {
+    const canAssignFull = await checkPermission('tasks.assign');
+    const canAssignToSales = await checkPermission('tasks.assign_to_sales');
+    if (assignedUserId !== undefined && (canAssignFull || canAssignToSales)) {
+      if (canAssignToSales && !canAssignFull && assignedUserId) {
+        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 },
+          );
+        }
+      }
       updateData.assignedUserId = assignedUserId;
     }
 
@@ -216,7 +246,28 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
         // Préparer les données de mise à jour pour Google Calendar
         const googleUpdate: any = {};
         if (title !== undefined) googleUpdate.summary = title;
-        if (description !== undefined) googleUpdate.description = description;
+        if (description !== undefined) {
+          if (existingTask.type === 'TASK') {
+            let descPlain = htmlToText(description);
+            if (existingTask.contactId) {
+              const contactForFooter = await prisma.contact.findUnique({
+                where: { id: existingTask.contactId },
+                select: { firstName: true, lastName: true, email: true },
+              });
+              const footerEmail = contactForFooter?.email;
+              if (footerEmail) {
+                descPlain = appendGoogleCalendarContactFooter(descPlain, {
+                  firstName: contactForFooter.firstName,
+                  lastName: contactForFooter.lastName,
+                  email: footerEmail,
+                });
+              }
+            }
+            googleUpdate.description = descPlain;
+          } else {
+            googleUpdate.description = description;
+          }
+        }
         if (location !== undefined) googleUpdate.location = location || undefined;
 
         if (scheduledAt !== undefined) {
@@ -234,9 +285,17 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
           };
         }
 
+        const requestedGoogleCalendarId =
+          typeof bodyGoogleCalendarId === 'string' && bodyGoogleCalendarId.trim() !== ''
+            ? bodyGoogleCalendarId.trim()
+            : resolveTaskGoogleCalendarId(existingTask.googleCalendarId);
+        const gCalId = resolveTaskGoogleCalendarId(existingTask.googleCalendarId);
+        const targetGCalId = resolveTaskGoogleCalendarId(
+          requestedGoogleCalendarId === 'primary' ? null : requestedGoogleCalendarId,
+        );
+
         // Mettre à jour les invités si fournis
         if (attendees !== undefined && Array.isArray(attendees)) {
-          // Récupérer le contact pour l'inclure dans la liste
           const contact = existingTask.contactId
             ? await prisma.contact.findUnique({
                 where: { id: existingTask.contactId },
@@ -244,12 +303,10 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
               })
             : null;
 
-          // Construire la liste des invités (contact + invités additionnels)
-          const allAttendees = [];
-          if (contact?.email) {
+          const allAttendees: Array<{ email: string }> = [];
+          if (existingTask.type !== 'TASK' && contact?.email) {
             allAttendees.push({ email: contact.email });
           }
-          // Ajouter les autres invités (exclure le contact s'il est déjà dans la liste)
           attendees.forEach((email: string) => {
             if (email && email.trim() !== '' && email !== contact?.email) {
               allAttendees.push({ email: email.trim() });
@@ -257,14 +314,73 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
           });
 
           googleUpdate.attendees = allAttendees.length > 0 ? allAttendees : undefined;
+        } else if (
+          existingTask.type === 'TASK' &&
+          existingTask.contactId &&
+          attendees === undefined
+        ) {
+          const contact = await prisma.contact.findUnique({
+            where: { id: existingTask.contactId },
+            select: { email: true },
+          });
+          if (contact?.email) {
+            try {
+              const ge = await getGoogleCalendarEvent(
+                accessToken,
+                gCalId,
+                existingTask.googleEventId,
+              );
+              const contactLower = contact.email.toLowerCase();
+              const hadContact = ge.attendees?.some(
+                (a) => a.email?.toLowerCase() === contactLower,
+              );
+              if (hadContact) {
+                const filtered = (ge.attendees || [])
+                  .filter(
+                    (a) =>
+                      a.email && a.email.toLowerCase() !== contactLower,
+                  )
+                  .map((a) => ({ email: a.email! }));
+                googleUpdate.attendees = filtered.length > 0 ? filtered : [];
+              }
+            } catch (stripErr) {
+              console.error(
+                'Impossible de retirer le contact des invités Google Calendar:',
+                stripErr,
+              );
+            }
+          }
         }
 
         // Mettre à jour l'évènement Google Calendar
-        const updatedGoogleEvent = await updateGoogleCalendarEvent(
-          accessToken,
-          existingTask.googleEventId,
-          googleUpdate,
-        );
+        const calendarChanged = targetGCalId !== gCalId;
+        let updatedGoogleEvent;
+        if (calendarChanged) {
+          const currentGoogleEvent = await getGoogleCalendarEvent(
+            accessToken,
+            gCalId,
+            existingTask.googleEventId,
+          );
+          const createdGoogleEvent = await createGoogleCalendarEvent(accessToken, targetGCalId, {
+            summary: googleUpdate.summary ?? currentGoogleEvent.summary,
+            description: googleUpdate.description ?? currentGoogleEvent.description,
+            location: googleUpdate.location ?? currentGoogleEvent.location,
+            start: googleUpdate.start ?? currentGoogleEvent.start,
+            end: googleUpdate.end ?? currentGoogleEvent.end,
+            attendees: googleUpdate.attendees ?? currentGoogleEvent.attendees,
+          });
+          await deleteGoogleCalendarEvent(accessToken, gCalId, existingTask.googleEventId);
+          updatedGoogleEvent = createdGoogleEvent;
+          updateData.googleEventId = createdGoogleEvent.id;
+          updateData.googleCalendarId = targetGCalId === 'primary' ? null : targetGCalId;
+        } else {
+          updatedGoogleEvent = await updateGoogleCalendarEvent(
+            accessToken,
+            gCalId,
+            existingTask.googleEventId,
+            googleUpdate,
+          );
+        }
 
         // Mettre à jour le lien Meet si nécessaire
         const meetLink = extractMeetLink(updatedGoogleEvent);
@@ -319,11 +435,8 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       },
     });
 
-    // Créer une interaction pour la modification si c'est un rendez-vous
-    if (
-      task.contactId &&
-      (existingTask.type === 'MEETING' || existingTask.type === 'VIDEO_CONFERENCE')
-    ) {
+    // Interaction de modification uniquement pour les RDV physiques (pas la visio)
+    if (task.contactId && existingTask.type === 'MEETING') {
       try {
         await logAppointmentChanged(
           task.contactId,
@@ -331,14 +444,64 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
           task.scheduledAt,
           task.title,
           session.user.id,
-          existingTask.type === 'VIDEO_CONFERENCE',
+          false,
         );
       } catch (interactionError: any) {
         console.error(
           "Erreur lors de la création de l'interaction de modification:",
           interactionError,
         );
-        // On continue même si l'interaction échoue
+      }
+    }
+
+    // Garder l'interaction « TASK » alignée avec les modifications (titre, contenu, date)
+    if (
+      task.contactId &&
+      task.type !== 'MEETING' &&
+      task.type !== 'VIDEO_CONFERENCE' &&
+      (title !== undefined || description !== undefined || scheduledAt !== undefined)
+    ) {
+      try {
+        const interactionDate = task.scheduledAt instanceof Date ? task.scheduledAt : new Date(task.scheduledAt);
+        const interactionContent = description !== undefined ? description : task.description || '';
+        const updated = await prisma.interaction.updateMany({
+          where: {
+            contactId: task.contactId,
+            type: 'TASK',
+            metadata: {
+              path: ['taskId'],
+              equals: task.id,
+            },
+          },
+          data: {
+            title: task.title || null,
+            content: interactionContent,
+            date: interactionDate,
+            userId: session.user.id,
+            metadata: {
+              taskId: task.id,
+              scheduledAt: interactionDate.toISOString(),
+            },
+          },
+        });
+
+        // Sécurité: si aucune interaction liée n'existe, la recréer pour garder la timeline cohérente.
+        if (updated.count === 0) {
+          await createInteraction({
+            contactId: task.contactId,
+            type: 'TASK' as any,
+            title: task.title || null,
+            content: interactionContent,
+            userId: session.user.id,
+            date: interactionDate,
+            metadata: {
+              taskId: task.id,
+              scheduledAt: interactionDate.toISOString(),
+            },
+          });
+        }
+      } catch (interactionSyncError: any) {
+        console.error("Erreur lors de la synchronisation de l'interaction TASK:", interactionSyncError);
       }
     }
 
@@ -363,15 +526,15 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
           where: { userId: session.user.id },
         });
 
-        if (smtpConfig && task.googleMeetLink) {
-          // Récupérer les invités depuis Google Calendar
-          let allRecipients: string[] = [];
-          if (task.contact?.email) {
+        if (smtpConfig) {
+          // Construire la liste des destinataires selon le type de rendez-vous
+          const allRecipients: string[] = [];
+          if (task.contact?.email && !allRecipients.includes(task.contact.email)) {
             allRecipients.push(task.contact.email);
           }
 
           // Pour Google Meet uniquement, récupérer les invités depuis Google Calendar
-          if (existingTask.googleEventId && task.googleMeetLink) {
+          if (shouldNotifyForGoogleMeet && existingTask.googleEventId) {
             try {
               const { getUserGoogleAccount } = await import('@/lib/google-calendar');
               const googleAccount = await getUserGoogleAccount(session.user.id);
@@ -385,6 +548,7 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
 
                 const googleEvent = await getGoogleCalendarEvent(
                   accessToken,
+                  resolveTaskGoogleCalendarId(existingTask.googleCalendarId),
                   existingTask.googleEventId,
                 );
                 if (googleEvent.attendees) {
@@ -446,7 +610,7 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
             newDuration,
             hasDateChanged,
             hasDurationChanged,
-            meetLink: task.googleMeetLink || undefined,
+            meetLink: shouldNotifyForGoogleMeet ? task.googleMeetLink || undefined : undefined,
             description: task.description,
             organizerName,
             signature: smtpConfig.signature || undefined,
@@ -565,11 +729,13 @@ export async function DELETE(
       },
     });
 
-    // Récupérer les invités depuis Google Calendar AVANT suppression pour l'email
-    let allRecipients: string[] = [];
-    if (task.googleEventId && taskWithContact?.contact?.email) {
-      allRecipients.push(taskWithContact.contact.email!);
-
+    // Récupérer les invités depuis Google Calendar AVANT suppression pour l'email ; supprimer l’événement dès que googleEventId est défini (avec ou sans contact)
+    const allRecipients: string[] = [];
+    const contactEmail = taskWithContact?.contact?.email;
+    if (contactEmail && !allRecipients.includes(contactEmail)) {
+      allRecipients.push(contactEmail);
+    }
+    if (task.googleEventId) {
       try {
         const { getUserGoogleAccount } = await import('@/lib/google-calendar');
         const googleAccount = await getUserGoogleAccount(session.user.id);
@@ -593,54 +759,64 @@ export async function DELETE(
           });
         }
 
-        // Récupérer les invités AVANT de supprimer l'événement
-        const googleEvent = await getGoogleCalendarEvent(accessToken, task.googleEventId);
-        if (googleEvent.attendees) {
-          googleEvent.attendees.forEach((attendee) => {
-            if (attendee.email && !allRecipients.includes(attendee.email)) {
-              allRecipients.push(attendee.email);
-            }
-          });
+        const gCalIdDel = resolveTaskGoogleCalendarId(task.googleCalendarId);
+        try {
+          const googleEvent = await getGoogleCalendarEvent(
+            accessToken,
+            gCalIdDel,
+            task.googleEventId,
+          );
+          if (googleEvent.attendees) {
+            googleEvent.attendees.forEach((attendee) => {
+              if (attendee.email && !allRecipients.includes(attendee.email)) {
+                allRecipients.push(attendee.email);
+              }
+            });
+          }
+        } catch (getErr) {
+          console.warn(
+            "Impossible de lire l'événement Google avant suppression (invités email) :",
+            getErr,
+          );
         }
 
-        // Supprimer l'événement Google Calendar
-        await deleteGoogleCalendarEvent(accessToken, task.googleEventId);
+        await deleteGoogleCalendarEvent(accessToken, gCalIdDel, task.googleEventId);
       } catch (googleError: any) {
         console.error("Erreur lors de la suppression de l'événement Google Calendar:", googleError);
         // On continue quand même la suppression de la tâche
       }
     }
 
-    // Créer une interaction pour l'annulation si c'est un Google Meet ou un RDV
-    if (task.contactId && (task.type === 'VIDEO_CONFERENCE' || task.type === 'MEETING')) {
+    // Supprimer les interactions liées à cette tâche (ex. activité « Tâche », RDV créé/modifié)
+    if (task.contactId) {
+      try {
+        const removed = await deleteInteractionsLinkedToTask(task.contactId, id);
+        if (removed.count > 0) {
+          console.log(`Interactions liées à la tâche ${id} supprimées: ${removed.count}`);
+        }
+      } catch (cleanupError: unknown) {
+        console.error('Erreur lors de la suppression des interactions liées à la tâche:', cleanupError);
+        // On continue : la suppression de la tâche reste prioritaire
+      }
+    }
+
+    // Interaction d'annulation uniquement pour les RDV physiques (pas la visio)
+    if (task.contactId && task.type === 'MEETING') {
       try {
-        console.log('Création interaction annulation pour task:', {
-          contactId: task.contactId,
-          taskId: task.id,
-          type: task.type,
-          title: task.title,
-        });
         await logAppointmentCancelled(
           task.contactId,
           task.id,
           task.scheduledAt,
           task.title,
           session.user.id,
-          task.type === 'VIDEO_CONFERENCE',
+          false,
         );
-        console.log("Interaction d'annulation créée avec succès");
       } catch (interactionError: any) {
         console.error(
           "Erreur lors de la création de l'interaction d'annulation:",
           interactionError,
         );
-        // On continue même si l'interaction échoue
       }
-    } else {
-      console.log("Pas de création d'interaction - conditions non remplies:", {
-        contactId: task.contactId,
-        type: task.type,
-      });
     }
 
     // Supprimer la tâche