create-crm-tmp 1.1.3 → 2.1.0

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

@@ -1,14 +1,15 @@
 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 } 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';
@@ -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
@@ -58,13 +70,17 @@ 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 créer une visioconférence.',
+            configLink: '/settings?section=integrations',
+          },
           { status: 400 },
         );
       }
@@ -81,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) {
@@ -99,14 +116,21 @@ export async function POST(request: NextRequest) {
           await prisma.userGoogleAccount.update({
             where: { userId: session.user.id },
             data: {
-              accessToken,
+              accessToken: encrypt(accessToken),
               tokenExpiresAt,
             },
           });
         }
 
+        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: {
@@ -131,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
@@ -149,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,
@@ -249,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 { auth } from '@/lib/auth';
 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 } from '@/lib/encryption';
-import { render } from '@react-email/render';
+import { decrypt, encrypt } from '@/lib/encryption';
 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 '';
@@ -22,62 +27,81 @@ function htmlToText(html: string): string {
 // GET /api/tasks - Récupérer les tâches de l'utilisateur
 export async function GET(request: NextRequest) {
   try {
-    const session = await auth.api.getSession({
-      headers: request.headers,
-    });
+    const authUser = await getAuthUser();
 
-    if (!session) {
+    if (!authUser) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const { session, permissions } = authUser;
+    const canViewAll = permissions.includes('tasks.view_all');
+    const canViewOwn = permissions.includes('tasks.view_own');
+
+    if (!canViewAll && !canViewOwn) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { searchParams } = new URL(request.url);
     const startDate = searchParams.get('startDate');
     const endDate = searchParams.get('endDate');
-    const assignedTo = searchParams.get('assignedTo'); // Pour les admins
-    const contactId = searchParams.get('contactId'); // Filtrer par contact
+    const assignedTo = searchParams.get('assignedTo');
+    const contactId = searchParams.get('contactId');
     const showOtherUsers = searchParams.get('showOtherUsers') === 'true';
 
-    // Construire les filtres
-    const where: any = {
-      scheduledAt: {
-        gte: startDate ? new Date(startDate) : new Date(),
+    // Construire les filtres de base
+    // Pour les événements multi-jours, on récupère les tâches avec une marge
+    // Les tâches qui commencent jusqu'à 30 jours avant le début de la période
+    // peuvent potentiellement être affichées (événements longs)
+    const baseFilters: any = {};
+
+    if (startDate) {
+      const startDateObj = new Date(startDate);
+      // Marge de 30 jours avant pour capturer les événements longs
+      const marginStart = new Date(startDateObj);
+      marginStart.setDate(marginStart.getDate() - 30);
+
+      baseFilters.scheduledAt = {
+        gte: marginStart,
         lte: endDate ? new Date(endDate) : undefined,
-      },
-    };
+      };
+
+      if (!endDate) {
+        delete baseFilters.scheduledAt.lte;
+      }
+    } else {
+      baseFilters.scheduledAt = {
+        gte: new Date(),
+        lte: endDate ? new Date(endDate) : undefined,
+      };
+
+      if (!endDate) {
+        delete baseFilters.scheduledAt.lte;
+      }
+    }
 
     // Filtrer par contact si fourni
     if (contactId) {
-      where.contactId = contactId;
+      baseFilters.contactId = contactId;
     }
 
-    // Vérifier la permission pour voir les événements des autres utilisateurs
-    if (showOtherUsers) {
-      const { checkPermission } = await import('@/lib/check-permission');
-      const hasPermission = await checkPermission('tasks.view_other_users_events');
-      if (hasPermission) {
-        // Ne pas filtrer par utilisateur, voir tous les événements
-        delete where.assignedUserId;
-      } else {
-        // Pas de permission, voir uniquement ses propres tâches
-        where.assignedUserId = session.user.id;
-      }
-    } else if (assignedTo && assignedTo !== session.user.id) {
-      const { checkPermission } = await import('@/lib/check-permission');
-      const canViewOthers = await checkPermission('tasks.view_other_users_events');
-      if (canViewOthers) {
-        where.assignedUserId = assignedTo;
-      } else {
-        // Pas de permission, voir uniquement ses propres tâches
-        where.assignedUserId = session.user.id;
+    // Construire les filtres d'utilisateur basés sur les permissions
+    let userFilters: any = {};
+
+    if (showOtherUsers && permissions.includes('tasks.view_other_users_events')) {
+      userFilters = {};
+    } else if (canViewAll) {
+      if (assignedTo) {
+        userFilters = { assignedUserId: assignedTo };
       }
     } else {
-      // Par défaut, voir ses propres tâches
-      where.assignedUserId = session.user.id;
+      userFilters = { assignedUserId: session.user.id };
     }
 
-    if (!endDate) {
-      delete where.scheduledAt.lte;
-    }
+    // Combiner tous les filtres
+    const where: any = {
+      ...baseFilters,
+      ...userFilters,
+    };
 
     const tasks = await prisma.task.findMany({
       where,
@@ -96,7 +120,6 @@ export async function GET(request: NextRequest) {
             id: true,
             name: true,
             email: true,
-            eventColor: true,
           },
         },
         createdBy: {
@@ -115,22 +138,32 @@ export async function GET(request: NextRequest) {
     return NextResponse.json(tasks);
   } catch (error: any) {
     console.error('Erreur lors de la récupération des tâches:', error);
-    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+    return NextResponse.json(
+      {
+        error:
+          process.env.NODE_ENV === 'development'
+            ? error.message || 'Erreur serveur'
+            : 'Erreur serveur',
+      },
+      { status: 500 },
+    );
   }
 }
 
 // POST /api/tasks - Créer une nouvelle tâche
 export async function POST(request: NextRequest) {
   try {
-    const session = await auth.api.getSession({
-      headers: request.headers,
-    });
+    const [authUser, body] = await Promise.all([getAuthUser(), request.json()]);
 
-    if (!session) {
+    if (!authUser) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
-    const body = await request.json();
+    const { session } = authUser;
+
+    if (!authUser.permissions.includes('tasks.create')) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
     const {
       type,
       title,
@@ -143,6 +176,13 @@ export async function POST(request: NextRequest) {
       internalNote,
       attendees = [],
       addToGoogleCalendar = true,
+      googleCalendarId: bodyGoogleCalendarId,
+      // Champs pour les rendez-vous physiques
+      location,
+      locationAddress,
+      locationCity,
+      locationPostalCode,
+      isAtHome = false,
     } = body;
 
     // Validation
@@ -153,20 +193,30 @@ export async function POST(request: NextRequest) {
       );
     }
 
-    // Déterminer l'utilisateur assigné
+    // Déterminer l'utilisateur assigné (selon permissions d'assignation)
+    const canAssignFull = await checkPermission('tasks.assign');
+    const canAssignToSales = await checkPermission('tasks.assign_to_sales');
+
     let finalAssignedUserId: string;
-    if (assignedUserId && assignedUserId !== session.user.id) {
-      const { checkPermission: checkPerm } = await import('@/lib/check-permission');
-      const canAssignOthers = await checkPerm('tasks.view_other_users_events');
-      if (canAssignOthers) {
-        // Utilisateur avec permission peut assigner à n'importe qui
+    if (assignedUserId && (canAssignFull || canAssignToSales)) {
+      if (canAssignFull) {
         finalAssignedUserId = assignedUserId;
       } else {
-        // Pas de permission, s'assigne automatiquement
-        finalAssignedUserId = session.user.id;
+        // 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 {
-      finalAssignedUserId = assignedUserId || session.user.id;
+      finalAssignedUserId = session.user.id;
     }
 
     // Vérifier que le contact existe si fourni
@@ -193,6 +243,12 @@ export async function POST(request: NextRequest) {
           typeof reminderMinutesBefore === 'number' ? reminderMinutesBefore : null,
         notifyContact: notifyContact === true,
         internalNote: internalNote || null,
+        // Champs d'adresse pour les rendez-vous physiques
+        location: location || null,
+        locationAddress: locationAddress || null,
+        locationCity: locationCity || null,
+        locationPostalCode: locationPostalCode || null,
+        isAtHome: isAtHome === true,
       },
       include: {
         contact: {
@@ -209,7 +265,6 @@ export async function POST(request: NextRequest) {
             id: true,
             name: true,
             email: true,
-            eventColor: true,
           },
         },
         createdBy: {
@@ -241,44 +296,79 @@ export async function POST(request: NextRequest) {
     // Si c'est un rendez-vous (physique) ou une tâche et que l'utilisateur veut l'ajouter à Google Calendar
     if ((type === 'MEETING' || type === 'TASK') && addToGoogleCalendar) {
       try {
-        const googleAccount = await prisma.userGoogleAccount.findUnique({
-          where: { userId: session.user.id },
-        });
-
-        if (googleAccount) {
-          const accessToken = await getValidAccessToken(
-            googleAccount.accessToken,
-            googleAccount.refreshToken,
-            googleAccount.tokenExpiresAt,
-          );
-
-          // Durée par défaut de 60 minutes pour les rendez-vous physiques, 30 minutes pour les tâches
-          const startDate = new Date(scheduledAt);
-          const duration = type === 'MEETING' ? 60 : 30;
-          const endDate = new Date(startDate.getTime() + duration * 60 * 1000);
-
-          const googleEvent = await createGoogleCalendarEvent(accessToken, {
-            summary: title || (type === 'MEETING' ? 'Rendez-vous' : 'Tâche'),
-            description: htmlToText(description),
-            start: {
-              dateTime: startDate.toISOString(),
-              timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-            },
-            end: {
-              dateTime: endDate.toISOString(),
-              timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        const { getUserGoogleAccount } = await import('@/lib/google-calendar');
+        const googleAccount = await getUserGoogleAccount(session.user.id);
+
+        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: encrypt(accessToken),
+              tokenExpiresAt,
             },
-            attendees: allAttendees.length > 0 ? allAttendees : undefined,
           });
+        }
 
-          // Sauvegarder l'ID de l'évènement pour synchroniser les modifications/suppressions
-          await prisma.task.update({
-            where: { id: task.id },
-            data: {
-              googleEventId: googleEvent.id,
-            },
+        // Durée par défaut de 60 minutes pour les rendez-vous physiques, 30 minutes pour les tâches
+        const startDate = new Date(scheduledAt);
+        const duration = type === 'MEETING' ? 60 : 30;
+        const endDate = new Date(startDate.getTime() + duration * 60 * 1000);
+
+        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: googleDescription,
+          start: {
+            dateTime: startDate.toISOString(),
+            timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+          },
+          end: {
+            dateTime: endDate.toISOString(),
+            timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+          },
+          attendees: googleAttendees.length > 0 ? googleAttendees : undefined,
+          location: location || undefined, // Ajouter l'adresse du rendez-vous
+        });
+
+        // Sauvegarder l'ID de l'évènement pour synchroniser les modifications/suppressions
+        await prisma.task.update({
+          where: { id: task.id },
+          data: {
+            googleEventId: googleEvent.id,
+            googleCalendarId: targetCalendarId === 'primary' ? null : targetCalendarId,
+          },
+        });
       } catch (googleError: any) {
         console.error('Erreur lors de la création de lévènement Google Calendar:', googleError);
         // On ne bloque pas la création de la tâche si Google Calendar échoue
@@ -299,7 +389,8 @@ export async function POST(request: NextRequest) {
           );
 
           // Envoyer un email de notification si demandé (contact ou invités)
-          if (notifyContact) {
+          // Vérifier explicitement que notifyContact est true
+          if (notifyContact === true) {
             try {
               // Récupérer la configuration SMTP
               const smtpConfig = await prisma.smtpConfig.findUnique({
@@ -312,6 +403,7 @@ export async function POST(request: NextRequest) {
                 try {
                   password = decrypt(smtpConfig.password);
                 } catch (error) {
+                  console.error(error);
                   password = smtpConfig.password;
                 }
 
@@ -358,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,
@@ -378,7 +471,7 @@ export async function POST(request: NextRequest) {
                         ? `"${smtpConfig.fromName}" <${smtpConfig.fromEmail}>`
                         : smtpConfig.fromEmail,
                       to: recipient.email,
-                      subject: `Confirmation de rendez-vous${title ? ` : ${title}` : ''}`,
+                      subject: `Confirmation de rendez-vous ${title ? `: ${title}` : ''}`,
                       text: emailText,
                       html: emailHtml,
                     });
@@ -396,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,
@@ -405,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) {
@@ -416,6 +513,14 @@ export async function POST(request: NextRequest) {
     return NextResponse.json(task, { status: 201 });
   } catch (error: any) {
     console.error('Erreur lors de la création de la tâche:', error);
-    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+    return NextResponse.json(
+      {
+        error:
+          process.env.NODE_ENV === 'development'
+            ? error.message || 'Erreur serveur'
+            : 'Erreur serveur',
+      },
+      { status: 500 },
+    );
   }
 }