create-crm-tmp 1.1.2 → 2.0.0

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

@@ -1,6 +1,8 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
+import { executeWorkflowsOnTaskCompleted } from '@/lib/workflow-executor';
 import {
   getValidAccessToken,
   updateGoogleCalendarEvent,
@@ -9,7 +11,7 @@ import {
   getGoogleCalendarEvent,
 } from '@/lib/google-calendar';
 import nodemailer from 'nodemailer';
-import { decrypt } from '@/lib/encryption';
+import { decrypt, encrypt } from '@/lib/encryption';
 import { logAppointmentCancelled, logAppointmentChanged } from '@/lib/contact-interactions';
 import { render } from '@react-email/render';
 import { MeetUpdateEmailTemplate } from '@/components/meet-update-email-template';
@@ -37,6 +39,15 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const [canViewAll, canViewOwn] = await Promise.all([
+      checkPermission('tasks.view_all'),
+      checkPermission('tasks.view_own'),
+    ]);
+
+    if (!canViewAll && !canViewOwn) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { id } = await params;
 
     const task = await prisma.task.findUnique({
@@ -72,13 +83,7 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Tâche non trouvée' }, { status: 404 });
     }
 
-    // Vérifier que l'utilisateur peut voir cette tâche
-    const user = await prisma.user.findUnique({
-      where: { id: session.user.id },
-      select: { role: true },
-    });
-
-    if (task.assignedUserId !== session.user.id && user?.role !== 'ADMIN') {
+    if (task.assignedUserId !== session.user.id && !canViewAll) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
     }
 
@@ -100,6 +105,15 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const [canEditAll, canEditOwn] = await Promise.all([
+      checkPermission('tasks.edit_all'),
+      checkPermission('tasks.edit_own'),
+    ]);
+
+    if (!canEditAll && !canEditOwn) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { id } = await params;
     const body = await request.json();
     const {
@@ -115,6 +129,12 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       attendees,
       notifyContact,
       internalNote,
+      // Champs d'adresse pour les rendez-vous physiques
+      location,
+      locationAddress,
+      locationCity,
+      locationPostalCode,
+      isAtHome,
     } = body;
 
     // Vérifier que la tâche existe
@@ -126,13 +146,7 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Tâche non trouvée' }, { status: 404 });
     }
 
-    // Vérifier les permissions
-    const user = await prisma.user.findUnique({
-      where: { id: session.user.id },
-      select: { role: true },
-    });
-
-    if (existingTask.assignedUserId !== session.user.id && user?.role !== 'ADMIN') {
+    if (!canEditAll && existingTask.assignedUserId !== session.user.id) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
     }
 
@@ -161,95 +175,101 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       updateData.completedAt = completed ? new Date() : null;
     }
 
-    // Seuls les admins peuvent changer l'assignation
-    if (assignedUserId !== undefined && user?.role === 'ADMIN') {
+    // Champs d'adresse pour les rendez-vous physiques
+    if (location !== undefined) updateData.location = location || null;
+    if (locationAddress !== undefined) updateData.locationAddress = locationAddress || null;
+    if (locationCity !== undefined) updateData.locationCity = locationCity || null;
+    if (locationPostalCode !== undefined)
+      updateData.locationPostalCode = locationPostalCode || null;
+    if (isAtHome !== undefined) updateData.isAtHome = isAtHome === true;
+
+    const canAssign = await checkPermission('tasks.assign');
+    if (assignedUserId !== undefined && canAssign) {
       updateData.assignedUserId = assignedUserId;
     }
 
     // Si la tâche a un googleEventId, synchroniser avec Google Calendar
     if (existingTask.googleEventId) {
       try {
-        const googleAccount = await prisma.userGoogleAccount.findUnique({
-          where: { userId: session.user.id },
-        });
+        const { getUserGoogleAccount } = await import('@/lib/google-calendar');
+        const googleAccount = await getUserGoogleAccount(session.user.id);
 
-        if (googleAccount) {
-          const accessToken = await getValidAccessToken(
-            googleAccount.accessToken,
-            googleAccount.refreshToken,
-            googleAccount.tokenExpiresAt,
-          );
-
-          // Mettre à jour le token si nécessaire
-          if (accessToken !== googleAccount.accessToken) {
-            const tokenExpiresAt = new Date();
-            tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
-            await prisma.userGoogleAccount.update({
-              where: { userId: session.user.id },
-              data: {
-                accessToken,
-                tokenExpiresAt,
-              },
-            });
-          }
+        const accessToken = await getValidAccessToken(
+          googleAccount.accessToken,
+          googleAccount.refreshToken,
+          googleAccount.tokenExpiresAt,
+        );
 
-          // 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 (scheduledAt !== undefined) {
-            const startDate = new Date(scheduledAt);
-            const duration = durationMinutes || existingTask.durationMinutes || 30;
-            const endDate = new Date(startDate.getTime() + duration * 60 * 1000);
-
-            googleUpdate.start = {
-              dateTime: startDate.toISOString(),
-              timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-            };
-            googleUpdate.end = {
-              dateTime: endDate.toISOString(),
-              timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-            };
-          }
+        // Mettre à jour le token si nécessaire
+        if (accessToken !== googleAccount.accessToken) {
+          const tokenExpiresAt = new Date();
+          tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
+          await prisma.userGoogleAccount.update({
+            where: { userId: session.user.id },
+            data: {
+              accessToken: encrypt(accessToken),
+              tokenExpiresAt,
+            },
+          });
+        }
 
-          // 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 },
-                  select: { email: true },
-                })
-              : null;
-
-            // Construire la liste des invités (contact + invités additionnels)
-            const allAttendees = [];
-            if (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() });
-              }
-            });
+        // 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 (location !== undefined) googleUpdate.location = location || undefined;
+
+        if (scheduledAt !== undefined) {
+          const startDate = new Date(scheduledAt);
+          const duration = durationMinutes || existingTask.durationMinutes || 30;
+          const endDate = new Date(startDate.getTime() + duration * 60 * 1000);
+
+          googleUpdate.start = {
+            dateTime: startDate.toISOString(),
+            timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+          };
+          googleUpdate.end = {
+            dateTime: endDate.toISOString(),
+            timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+          };
+        }
 
-            googleUpdate.attendees = allAttendees.length > 0 ? allAttendees : undefined;
+        // 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 },
+                select: { email: true },
+              })
+            : null;
+
+          // Construire la liste des invités (contact + invités additionnels)
+          const allAttendees = [];
+          if (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() });
+            }
+          });
 
-          // Mettre à jour l'évènement Google Calendar
-          const updatedGoogleEvent = await updateGoogleCalendarEvent(
-            accessToken,
-            existingTask.googleEventId,
-            googleUpdate,
-          );
-
-          // Mettre à jour le lien Meet si nécessaire
-          const meetLink = extractMeetLink(updatedGoogleEvent);
-          if (meetLink) {
-            updateData.googleMeetLink = meetLink;
-          }
+          googleUpdate.attendees = allAttendees.length > 0 ? allAttendees : undefined;
+        }
+
+        // Mettre à jour l'évènement Google Calendar
+        const updatedGoogleEvent = await updateGoogleCalendarEvent(
+          accessToken,
+          existingTask.googleEventId,
+          googleUpdate,
+        );
+
+        // Mettre à jour le lien Meet si nécessaire
+        const meetLink = extractMeetLink(updatedGoogleEvent);
+        if (meetLink) {
+          updateData.googleMeetLink = meetLink;
         }
       } catch (googleError: any) {
         console.error('Erreur lors de la synchronisation avec Google Calendar:', googleError);
@@ -353,11 +373,10 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
           // Pour Google Meet uniquement, récupérer les invités depuis Google Calendar
           if (existingTask.googleEventId && task.googleMeetLink) {
             try {
-              const googleAccount = await prisma.userGoogleAccount.findUnique({
-                where: { userId: session.user.id },
-              });
+              const { getUserGoogleAccount } = await import('@/lib/google-calendar');
+              const googleAccount = await getUserGoogleAccount(session.user.id);
 
-              if (googleAccount && existingTask.googleEventId) {
+              if (existingTask.googleEventId) {
                 const accessToken = await getValidAccessToken(
                   googleAccount.accessToken,
                   googleAccount.refreshToken,
@@ -465,6 +484,15 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       }
     }
 
+    // Déclencher les workflows TASK_COMPLETED si la tâche passe à complétée et a un contact
+    if (completed === true && !existingTask.completed && task.contact?.id) {
+      try {
+        await executeWorkflowsOnTaskCompleted(task.contact.id, existingTask.type);
+      } catch (workflowError) {
+        console.error("Erreur lors de l'exécution des workflows:", workflowError);
+      }
+    }
+
     return NextResponse.json(task);
   } catch (error: any) {
     console.error('Erreur lors de la mise à jour de la tâche:', error);
@@ -486,11 +514,15 @@ export async function DELETE(
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const canDelete = await checkPermission('tasks.delete');
+    if (!canDelete) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { id } = await params;
     const body = await request.json().catch(() => ({}));
     const { notifyContact } = body;
 
-    // Vérifier que la tâche existe
     const task = await prisma.task.findUnique({
       where: { id },
     });
@@ -499,13 +531,8 @@ export async function DELETE(
       return NextResponse.json({ error: 'Tâche non trouvée' }, { status: 404 });
     }
 
-    // Vérifier les permissions
-    const user = await prisma.user.findUnique({
-      where: { id: session.user.id },
-      select: { role: true },
-    });
-
-    if (task.assignedUserId !== session.user.id && user?.role !== 'ADMIN') {
+    const canEditAll = await checkPermission('tasks.edit_all');
+    if (task.assignedUserId !== session.user.id && !canEditAll) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
     }
 
@@ -544,43 +571,40 @@ export async function DELETE(
       allRecipients.push(taskWithContact.contact.email!);
 
       try {
-        const googleAccount = await prisma.userGoogleAccount.findUnique({
-          where: { userId: session.user.id },
-        });
+        const { getUserGoogleAccount } = await import('@/lib/google-calendar');
+        const googleAccount = await getUserGoogleAccount(session.user.id);
 
-        if (googleAccount) {
-          const accessToken = await getValidAccessToken(
-            googleAccount.accessToken,
-            googleAccount.refreshToken,
-            googleAccount.tokenExpiresAt,
-          );
-
-          // Mettre à jour le token si nécessaire
-          if (accessToken !== googleAccount.accessToken) {
-            const tokenExpiresAt = new Date();
-            tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
-            await prisma.userGoogleAccount.update({
-              where: { userId: session.user.id },
-              data: {
-                accessToken,
-                tokenExpiresAt,
-              },
-            });
-          }
+        const accessToken = await getValidAccessToken(
+          googleAccount.accessToken,
+          googleAccount.refreshToken,
+          googleAccount.tokenExpiresAt,
+        );
 
-          // 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);
-              }
-            });
-          }
+        // Mettre à jour le token si nécessaire
+        if (accessToken !== googleAccount.accessToken) {
+          const tokenExpiresAt = new Date();
+          tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
+          await prisma.userGoogleAccount.update({
+            where: { userId: session.user.id },
+            data: {
+              accessToken: encrypt(accessToken),
+              tokenExpiresAt,
+            },
+          });
+        }
 
-          // Supprimer l'événement Google Calendar
-          await deleteGoogleCalendarEvent(accessToken, task.googleEventId);
+        // 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);
+            }
+          });
         }
+
+        // Supprimer l'événement Google Calendar
+        await deleteGoogleCalendarEvent(accessToken, 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

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

@@ -8,7 +8,7 @@ import {
 } from '@/lib/google-calendar';
 import { createInteraction } from '@/lib/contact-interactions';
 import nodemailer from 'nodemailer';
-import { decrypt } from '@/lib/encryption';
+import { decrypt, encrypt } from '@/lib/encryption';
 import { render } from '@react-email/render';
 import { MeetConfirmationEmailTemplate } from '@/components/meet-confirmation-email-template';
 import React from 'react';
@@ -58,13 +58,16 @@ export async function POST(request: NextRequest) {
     // Vérifier que l'utilisateur a un compte Google connecté seulement si on veut ajouter à Google Calendar
     let googleAccount = null;
     if (addToGoogleCalendar) {
-      googleAccount = await prisma.userGoogleAccount.findUnique({
-        where: { userId: session.user.id },
-      });
-
-      if (!googleAccount) {
+      try {
+        const { getUserGoogleAccount } = await import('@/lib/google-calendar');
+        googleAccount = await getUserGoogleAccount(session.user.id);
+      } catch (error: any) {
         return NextResponse.json(
-          { error: 'Veuillez connecter votre compte Google dans les paramètres' },
+          {
+            error:
+              error.message ||
+              'Veuillez connecter votre compte Google dans les paramètres pour utiliser Google Calendar.',
+          },
           { status: 400 },
         );
       }
@@ -99,7 +102,7 @@ export async function POST(request: NextRequest) {
           await prisma.userGoogleAccount.update({
             where: { userId: session.user.id },
             data: {
-              accessToken,
+              accessToken: encrypt(accessToken),
               tokenExpiresAt,
             },
           });