create-crm-tmp 1.0.0

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

@@ -0,0 +1,240 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import {
+  getValidAccessToken,
+  createGoogleCalendarEvent,
+  extractMeetLink,
+} from '@/lib/google-calendar';
+import nodemailer from 'nodemailer';
+import { decrypt } from '@/lib/encryption';
+import { render } from '@react-email/render';
+import { MeetConfirmationEmailTemplate } from '@/components/meet-confirmation-email-template';
+import React from 'react';
+
+function htmlToText(html: string): string {
+  if (!html) return '';
+  return html
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n\n')
+    .replace(/<[^>]+>/g, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+/**
+ * POST /api/tasks/meet
+ * Crée un Google Meet sans contact
+ */
+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 });
+    }
+
+    const body = await request.json();
+    const {
+      title,
+      description,
+      scheduledAt,
+      durationMinutes = 30,
+      attendees = [],
+      reminderMinutesBefore,
+      internalNote,
+    } = body;
+
+    // Validation
+    if (!title || !scheduledAt) {
+      return NextResponse.json({ error: 'Le titre et la date/heure sont requis' }, { status: 400 });
+    }
+
+    // Vérifier que l'utilisateur a un compte Google connecté
+    const googleAccount = await prisma.userGoogleAccount.findUnique({
+      where: { userId: session.user.id },
+    });
+
+    if (!googleAccount) {
+      return NextResponse.json(
+        { error: 'Veuillez connecter votre compte Google dans les paramètres' },
+        { status: 400 },
+      );
+    }
+
+    // Obtenir un token valide
+    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,
+        },
+      });
+    }
+
+    // Préparer les dates pour Google Calendar
+    const startDate = new Date(scheduledAt);
+    const endDate = new Date(startDate.getTime() + durationMinutes * 60 * 1000);
+
+    // Construire la liste des invités
+    const allAttendees = attendees
+      .filter((email: string) => email && email.trim() !== '')
+      .map((email: string) => ({ email: email.trim() }));
+
+    // Créer l'évènement Google Calendar avec Meet
+    const googleEvent = await createGoogleCalendarEvent(accessToken, {
+      summary: title,
+      description: description || '',
+      start: {
+        dateTime: startDate.toISOString(),
+        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      },
+      end: {
+        dateTime: endDate.toISOString(),
+        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      },
+      attendees: allAttendees.length > 0 ? allAttendees : undefined,
+      conferenceData: {
+        createRequest: {
+          requestId: `meet-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+          conferenceSolutionKey: {
+            type: 'hangoutsMeet',
+          },
+        },
+      },
+      conferenceDataVersion: 1,
+    });
+
+    const meetLink = extractMeetLink(googleEvent);
+
+    // Créer la tâche dans le CRM (sans contact)
+    const task = await prisma.task.create({
+      data: {
+        type: 'VIDEO_CONFERENCE',
+        title,
+        description: description || '',
+        priority: 'MEDIUM',
+        scheduledAt: startDate,
+        reminderMinutesBefore: reminderMinutesBefore || null,
+        assignedUserId: session.user.id,
+        createdById: session.user.id,
+        googleEventId: googleEvent.id,
+        googleMeetLink: meetLink,
+        durationMinutes,
+        internalNote: internalNote || null,
+      },
+      include: {
+        assignedUser: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
+        createdBy: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
+      },
+    });
+
+    // Envoyer l'email de confirmation aux invités si un email est disponible
+    if (allAttendees.length > 0 && meetLink) {
+      try {
+        // Récupérer la configuration SMTP
+        const smtpConfig = await prisma.smtpConfig.findUnique({
+          where: { userId: session.user.id },
+        });
+
+        if (smtpConfig) {
+          // Déchiffrer le mot de passe SMTP
+          let password: string;
+          try {
+            password = decrypt(smtpConfig.password);
+          } catch (error) {
+            password = smtpConfig.password;
+          }
+
+          // Créer le transporteur SMTP
+          const transporter = nodemailer.createTransport({
+            host: smtpConfig.host,
+            port: smtpConfig.port,
+            secure: smtpConfig.secure,
+            auth: {
+              user: smtpConfig.username,
+              pass: password,
+            },
+          });
+
+          // Récupérer le nom de l'organisateur
+          const organizer = await prisma.user.findUnique({
+            where: { id: session.user.id },
+            select: { name: true },
+          });
+
+          const organizerName = organizer?.name || session.user.name || 'Organisateur';
+
+          // Envoyer un email individuel à chaque destinataire
+          for (const attendee of allAttendees) {
+            try {
+              // Générer le contenu HTML de l'email avec le composant React
+              const emailComponent = React.createElement(MeetConfirmationEmailTemplate, {
+                contactName: attendee.email.split('@')[0], // Utiliser le nom d'utilisateur de l'email
+                title,
+                scheduledAt: startDate.toISOString(),
+                durationMinutes,
+                meetLink: meetLink,
+                description,
+                organizerName,
+                signature: smtpConfig.signature || undefined,
+              });
+
+              const emailHtml = await render(emailComponent);
+              const emailText = htmlToText(emailHtml);
+
+              await transporter.sendMail({
+                from: smtpConfig.fromName
+                  ? `"${smtpConfig.fromName}" <${smtpConfig.fromEmail}>`
+                  : smtpConfig.fromEmail,
+                to: attendee.email,
+                subject: `Confirmation de rendez-vous : ${title}`,
+                text: emailText,
+                html: emailHtml,
+              });
+            } catch (individualEmailError: any) {
+              // Logger l'erreur mais continuer avec les autres destinataires
+              console.error(
+                `Erreur lors de l'envoi de l'email à ${attendee.email}:`,
+                individualEmailError,
+              );
+            }
+          }
+        }
+      } catch (emailError: any) {
+        // Ne pas faire échouer la création du Meet si l'email échoue
+        console.error("Erreur lors de l'envoi de l'email de confirmation:", emailError);
+      }
+    }
+
+    return NextResponse.json(task, { status: 201 });
+  } catch (error: any) {
+    console.error('Erreur lors de la création du Google Meet:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+

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

@@ -0,0 +1,417 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { logAppointmentCreated, createInteraction } from '@/lib/contact-interactions';
+import nodemailer from 'nodemailer';
+import { decrypt } 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';
+
+function htmlToText(html: string): string {
+  if (!html) return '';
+  return html
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n\n')
+    .replace(/<[^>]+>/g, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+// 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,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    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
+
+    // Construire les filtres
+    const where: any = {
+      scheduledAt: {
+        gte: startDate ? new Date(startDate) : new Date(),
+        lte: endDate ? new Date(endDate) : undefined,
+      },
+    };
+
+    // Filtrer par contact si fourni
+    if (contactId) {
+      where.contactId = contactId;
+    }
+
+    // Si admin demande les tâches d'un autre utilisateur
+    if (assignedTo && assignedTo !== session.user.id) {
+      const user = await prisma.user.findUnique({
+        where: { id: session.user.id },
+        select: { role: true },
+      });
+      if (user?.role === 'ADMIN') {
+        where.assignedUserId = assignedTo;
+      } else {
+        // Non-admin ne peut voir que ses propres tâches
+        where.assignedUserId = session.user.id;
+      }
+    } else {
+      // Par défaut, voir ses propres tâches
+      where.assignedUserId = session.user.id;
+    }
+
+    if (!endDate) {
+      delete where.scheduledAt.lte;
+    }
+
+    const tasks = await prisma.task.findMany({
+      where,
+      include: {
+        contact: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            email: true,
+            phone: true,
+          },
+        },
+        assignedUser: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
+        createdBy: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
+      },
+      orderBy: {
+        scheduledAt: 'asc',
+      },
+    });
+
+    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 });
+  }
+}
+
+// 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,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const body = await request.json();
+    const {
+      type,
+      title,
+      description,
+      priority,
+      scheduledAt,
+      contactId,
+      assignedUserId,
+      reminderMinutesBefore,
+      notifyContact,
+      internalNote,
+      attendees = [],
+    } = body;
+
+    // Validation
+    if (!type || !description || !scheduledAt) {
+      return NextResponse.json(
+        { error: 'Le type, la description et la date sont requis' },
+        { status: 400 },
+      );
+    }
+
+    // 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é
+    let finalAssignedUserId: string;
+    if (assignedUserId && user?.role === 'ADMIN') {
+      // Admin peut assigner à n'importe qui
+      finalAssignedUserId = assignedUserId;
+    } else {
+      // Utilisateur normal s'assigne automatiquement
+      finalAssignedUserId = session.user.id;
+    }
+
+    // Vérifier que le contact existe si fourni
+    if (contactId) {
+      const contact = await prisma.contact.findUnique({
+        where: { id: contactId },
+      });
+      if (!contact) {
+        return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
+      }
+    }
+
+    // Créer la tâche
+    const task = await prisma.task.create({
+      data: {
+        type,
+        title: title || null,
+        description,
+        priority: priority || 'MEDIUM',
+        scheduledAt: new Date(scheduledAt),
+        contactId: contactId || null,
+        assignedUserId: finalAssignedUserId,
+        createdById: session.user.id,
+        reminderMinutesBefore:
+          typeof reminderMinutesBefore === 'number' ? reminderMinutesBefore : null,
+        notifyContact: notifyContact === true,
+        internalNote: internalNote || null,
+      },
+      include: {
+        contact: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            email: true,
+            phone: true,
+          },
+        },
+        assignedUser: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
+        createdBy: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
+      },
+    });
+
+    // Construire la liste des invités (contact + invités additionnels, ou seulement invités si pas de contact)
+    // Cette liste sera utilisée pour Google Calendar ET pour les emails
+    const allAttendees: Array<{ email: string }> = [];
+    if (task.contact?.email) {
+      allAttendees.push({ email: task.contact.email });
+    }
+    attendees.forEach((email: string) => {
+      if (email && email.trim() !== '') {
+        const trimmedEmail = email.trim();
+        // Éviter les doublons
+        if (!allAttendees.some((a) => a.email === trimmedEmail)) {
+          allAttendees.push({ email: trimmedEmail });
+        }
+      }
+    });
+
+    // Si c'est un rendez-vous (physique) et que l'utilisateur a connecté son Google Agenda,
+    // on crée aussi un évènement dans son calendrier, avec possibilité d'inviter d'autres personnes.
+    if (type === 'MEETING') {
+      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
+          const startDate = new Date(scheduledAt);
+          const endDate = new Date(startDate.getTime() + 60 * 60 * 1000);
+
+          const googleEvent = await createGoogleCalendarEvent(accessToken, {
+            summary: title || 'Rendez-vous',
+            description: htmlToText(description),
+            start: {
+              dateTime: startDate.toISOString(),
+              timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            },
+            end: {
+              dateTime: endDate.toISOString(),
+              timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            },
+            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,
+            },
+          });
+        }
+      } catch (googleError: any) {
+        console.error('Erreur lors de la création de lévènement Google Calendar pour le RDV:', googleError);
+        // On ne bloque pas la création de la tâche si Google Calendar échoue
+      }
+    }
+
+    // Si la tâche est liée à un contact, créer aussi une interaction
+    if (contactId) {
+      try {
+        if (type === 'MEETING') {
+          // Pour les rendez-vous, utiliser la fonction spécialisée
+          await logAppointmentCreated(
+            contactId,
+            task.id,
+            new Date(scheduledAt),
+            title,
+            session.user.id,
+          );
+
+          // Envoyer un email de notification si demandé (contact ou invités)
+          if (notifyContact) {
+            try {
+              // Récupérer la configuration SMTP
+              const smtpConfig = await prisma.smtpConfig.findUnique({
+                where: { userId: session.user.id },
+              });
+
+              if (smtpConfig) {
+                // Déchiffrer le mot de passe SMTP
+                let password: string;
+                try {
+                  password = decrypt(smtpConfig.password);
+                } catch (error) {
+                  password = smtpConfig.password;
+                }
+
+                // Créer le transporteur SMTP
+                const transporter = nodemailer.createTransport({
+                  host: smtpConfig.host,
+                  port: smtpConfig.port,
+                  secure: smtpConfig.secure,
+                  auth: {
+                    user: smtpConfig.username,
+                    pass: password,
+                  },
+                });
+
+                // Récupérer le nom de l'organisateur
+                const organizer = await prisma.user.findUnique({
+                  where: { id: session.user.id },
+                  select: { name: true },
+                });
+
+                const organizerName = organizer?.name || session.user.name || 'Organisateur';
+                const scheduledDate = new Date(scheduledAt);
+
+                // Liste des destinataires : contact (si existe) + invités
+                const recipients: Array<{ email: string; name: string }> = [];
+                
+                if (task.contact?.email) {
+                  const contactName =
+                    `${task.contact.firstName || ''} ${task.contact.lastName || ''}`.trim() ||
+                    'Cher client';
+                  recipients.push({ email: task.contact.email, name: contactName });
+                }
+
+                // Ajouter les invités additionnels
+                allAttendees.forEach((attendee) => {
+                  if (!recipients.some((r) => r.email === attendee.email)) {
+                    recipients.push({
+                      email: attendee.email,
+                      name: attendee.email.split('@')[0], // Utiliser le nom d'utilisateur de l'email
+                    });
+                  }
+                });
+
+                // Envoyer un email individuel à chaque destinataire
+                for (const recipient of recipients) {
+                  try {
+                    // Générer le contenu HTML de l'email avec le composant React
+                    const emailComponent = React.createElement(MeetConfirmationEmailTemplate, {
+                      contactName: recipient.name,
+                      title: title || 'Rendez-vous',
+                      scheduledAt: scheduledDate.toISOString(),
+                      durationMinutes: 0, // Pas de durée pour les rendez-vous physiques
+                      description,
+                      organizerName,
+                      signature: smtpConfig.signature || undefined,
+                    });
+
+                    const emailHtml = await render(emailComponent);
+                    const emailText = htmlToText(emailHtml);
+
+                    // Envoyer l'email
+                    await transporter.sendMail({
+                      from: smtpConfig.fromName
+                        ? `"${smtpConfig.fromName}" <${smtpConfig.fromEmail}>`
+                        : smtpConfig.fromEmail,
+                      to: recipient.email,
+                      subject: `Confirmation de rendez-vous${title ? ` : ${title}` : ''}`,
+                      text: emailText,
+                      html: emailHtml,
+                    });
+                  } catch (individualEmailError: any) {
+                    // Logger l'erreur mais continuer avec les autres destinataires
+                    console.error(
+                      `Erreur lors de l'envoi de l'email à ${recipient.email}:`,
+                      individualEmailError,
+                    );
+                  }
+                }
+              }
+            } catch (emailError: any) {
+              // Ne pas faire échouer la création de la tâche si l'email échoue
+              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 standard
+          const interactionTypeMap: Record<string, string> = {
+            CALL: 'CALL',
+            EMAIL: 'EMAIL',
+            OTHER: 'NOTE',
+          };
+
+          await createInteraction({
+            contactId,
+            type: (interactionTypeMap[type] || 'NOTE') as any,
+            title: title || `Tâche ${type}`,
+            content: description,
+            userId: session.user.id,
+            date: new Date(scheduledAt),
+          });
+        }
+      } catch (error) {
+        // Ne pas faire échouer la création de la tâche si l'interaction échoue
+        console.error("Erreur lors de la création de l'interaction:", error);
+      }
+    }
+
+    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 });
+  }
+}