create-crm-tmp 1.0.0

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

@@ -0,0 +1,296 @@
+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/contacts/[id]/meet
+ * Crée un Google Meet depuis un contact
+ */
+export async function POST(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { id: contactId } = await params;
+    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 le contact existe
+    const contact = await prisma.contact.findUnique({
+      where: { id: contactId },
+      select: { id: true, email: true, firstName: true, lastName: true },
+    });
+
+    if (!contact) {
+      return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
+    }
+
+    // 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 (contact + invités additionnels)
+    const allAttendees = [];
+    if (contact.email) {
+      allAttendees.push({ email: contact.email });
+    }
+    // Ajouter les autres invités
+    attendees.forEach((email: string) => {
+      if (email && email !== contact.email) {
+        allAttendees.push({ email });
+      }
+    });
+
+    // 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
+    const task = await prisma.task.create({
+      data: {
+        type: 'VIDEO_CONFERENCE',
+        title,
+        description: description || '',
+        priority: 'MEDIUM',
+        scheduledAt: startDate,
+        reminderMinutesBefore: reminderMinutesBefore || null,
+        contactId: contactId,
+        assignedUserId: session.user.id,
+        createdById: session.user.id,
+        googleEventId: googleEvent.id,
+        googleMeetLink: meetLink,
+        durationMinutes,
+        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,
+          },
+        },
+      },
+    });
+
+    // Créer aussi une interaction pour le contact
+    await prisma.interaction.create({
+      data: {
+        contactId,
+        type: 'MEETING',
+        title: `Google Meet: ${title}`,
+        content:
+          description || `Réunion Google Meet programmée${meetLink ? `\n\nLien: ${meetLink}` : ''}`,
+        userId: session.user.id,
+        date: startDate,
+      },
+    });
+
+    // Envoyer l'email de confirmation au contact si un email est disponible
+    if (contact.email && 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 contactName =
+            `${contact.firstName || ''} ${contact.lastName || ''}`.trim() || 'Cher client';
+          const organizerName = organizer?.name || session.user.name || 'Organisateur';
+
+          // Générer le contenu HTML de l'email avec le composant React
+          const emailComponent = React.createElement(MeetConfirmationEmailTemplate, {
+            contactName,
+            title,
+            scheduledAt: startDate.toISOString(),
+            durationMinutes,
+            meetLink: meetLink,
+            description,
+            organizerName,
+            signature: smtpConfig.signature || undefined,
+          });
+
+          const emailHtml = await render(emailComponent);
+          const emailText = htmlToText(emailHtml);
+
+          // Construire la liste de tous les destinataires (contact + invités additionnels)
+          const allRecipients: string[] = [];
+          if (contact.email) {
+            allRecipients.push(contact.email);
+          }
+          // Ajouter les autres invités
+          attendees.forEach((email: string) => {
+            if (email && email.trim() !== '' && email !== contact.email) {
+              allRecipients.push(email.trim());
+            }
+          });
+
+          // Envoyer un email individuel à chaque destinataire pour préserver la confidentialité
+          if (allRecipients.length > 0) {
+            for (const recipientEmail of allRecipients) {
+              try {
+                await transporter.sendMail({
+                  from: smtpConfig.fromName
+                    ? `"${smtpConfig.fromName}" <${smtpConfig.fromEmail}>`
+                    : smtpConfig.fromEmail,
+                  to: recipientEmail,
+                  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 à ${recipientEmail}:`,
+                  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/contacts/[id]/route.ts

@@ -0,0 +1,322 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { logStatusChange, logContactUpdate, logAssignmentChange } from '@/lib/contact-interactions';
+import { executeWorkflowsOnStatusChanged } from '@/lib/workflow-executor';
+import { normalizePhoneNumber } from '@/lib/utils';
+
+// GET /api/contacts/[id] - Récupérer un contact spécifique avec ses interactions
+export async function GET(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { id } = await params;
+
+    const contact = await prisma.contact.findUnique({
+      where: { id },
+      include: {
+        status: true,
+        companyRelation: {
+          select: { id: true, firstName: true, lastName: true, isCompany: true },
+        },
+        contacts: {
+          select: { id: true, firstName: true, lastName: true, isCompany: true },
+        },
+        assignedCommercial: {
+          select: { id: true, name: true, email: true },
+        },
+        assignedTelepro: {
+          select: { id: true, name: true, email: true },
+        },
+        createdBy: {
+          select: { id: true, name: true, email: true },
+        },
+        interactions: {
+          include: {
+            user: {
+              select: { id: true, name: true, email: true },
+            },
+            emailTracking: {
+              select: {
+                id: true,
+                openCount: true,
+                firstOpenedAt: true,
+                lastOpenedAt: true,
+              },
+            },
+          },
+          orderBy: { createdAt: 'desc' },
+        },
+      },
+    });
+
+    if (!contact) {
+      return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
+    }
+
+    return NextResponse.json(contact);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération du contact:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// PUT /api/contacts/[id] - Mettre à jour un contact
+export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { id } = await params;
+    const body = await request.json();
+    const {
+      civility,
+      firstName,
+      lastName,
+      phone,
+      secondaryPhone,
+      email,
+      address,
+      city,
+      postalCode,
+      origin,
+      companyName,
+      isCompany,
+      companyId,
+      statusId,
+      closingReason,
+      assignedCommercialId,
+      assignedTeleproId,
+    } = body;
+
+    // Vérifier que le contact existe avec toutes les relations nécessaires
+    const existing = await prisma.contact.findUnique({
+      where: { id },
+      include: {
+        status: true,
+        companyRelation: {
+          select: { id: true, firstName: true, lastName: true, isCompany: true },
+        },
+        assignedCommercial: {
+          select: { id: true, name: true, email: true },
+        },
+        assignedTelepro: {
+          select: { id: true, name: true, email: true },
+        },
+      },
+    });
+
+    if (!existing) {
+      return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
+    }
+
+    // Validation : si phone est fourni, il ne peut pas être vide
+    if (phone !== undefined && !phone) {
+      return NextResponse.json({ error: 'Le téléphone ne peut pas être vide' }, { status: 400 });
+    }
+
+    // Préparer les données de mise à jour
+    const updateData: any = {
+      civility: civility !== undefined ? civility || null : existing.civility,
+      firstName: firstName !== undefined ? firstName || null : existing.firstName,
+      lastName: lastName !== undefined ? lastName || null : existing.lastName,
+      phone: phone !== undefined ? normalizePhoneNumber(phone) : existing.phone,
+      secondaryPhone:
+        secondaryPhone !== undefined
+          ? normalizePhoneNumber(secondaryPhone) || null
+          : existing.secondaryPhone,
+      email: email !== undefined ? email || null : existing.email,
+      address: address !== undefined ? address || null : existing.address,
+      city: city !== undefined ? city || null : existing.city,
+      postalCode: postalCode !== undefined ? postalCode || null : existing.postalCode,
+      origin: origin !== undefined ? origin || null : existing.origin,
+      companyName: companyName !== undefined ? companyName || null : existing.companyName,
+      isCompany: isCompany !== undefined ? isCompany === true : existing.isCompany,
+      companyId: companyId !== undefined ? companyId || null : existing.companyId,
+      statusId: statusId !== undefined ? statusId || null : existing.statusId,
+      closingReason:
+        closingReason !== undefined ? closingReason || null : existing.closingReason,
+      assignedCommercialId:
+        assignedCommercialId !== undefined
+          ? assignedCommercialId || null
+          : existing.assignedCommercialId,
+      assignedTeleproId:
+        assignedTeleproId !== undefined ? assignedTeleproId || null : existing.assignedTeleproId,
+    };
+
+    // Détecter les changements pour créer les interactions
+    const changes: Record<string, { old: any; new: any }> = {};
+
+    // Changements de champs de contact
+    if (civility !== undefined && civility !== existing.civility) {
+      changes.civility = { old: existing.civility, new: civility };
+    }
+    if (firstName !== undefined && firstName !== existing.firstName) {
+      changes.firstName = { old: existing.firstName, new: firstName };
+    }
+    if (lastName !== undefined && lastName !== existing.lastName) {
+      changes.lastName = { old: existing.lastName, new: lastName };
+    }
+    if (phone !== undefined && phone !== existing.phone) {
+      changes.phone = { old: existing.phone, new: phone };
+    }
+    if (secondaryPhone !== undefined && secondaryPhone !== existing.secondaryPhone) {
+      changes.secondaryPhone = { old: existing.secondaryPhone, new: secondaryPhone };
+    }
+    if (email !== undefined && email !== existing.email) {
+      changes.email = { old: existing.email, new: email };
+    }
+    if (address !== undefined && address !== existing.address) {
+      changes.address = { old: existing.address, new: address };
+    }
+    if (city !== undefined && city !== existing.city) {
+      changes.city = { old: existing.city, new: city };
+    }
+    if (postalCode !== undefined && postalCode !== existing.postalCode) {
+      changes.postalCode = { old: existing.postalCode, new: postalCode };
+    }
+    if (origin !== undefined && origin !== existing.origin) {
+      changes.origin = { old: existing.origin, new: origin };
+    }
+    if (companyName !== undefined && companyName !== existing.companyName) {
+      changes.companyName = { old: existing.companyName, new: companyName };
+    }
+    if (closingReason !== undefined && closingReason !== existing.closingReason) {
+      changes.closingReason = { old: existing.closingReason, new: closingReason };
+    }
+
+    // Mettre à jour le contact
+    const contact = await prisma.contact.update({
+      where: { id },
+      data: updateData,
+      include: {
+        status: true,
+        assignedCommercial: {
+          select: { id: true, name: true, email: true },
+        },
+        assignedTelepro: {
+          select: { id: true, name: true, email: true },
+        },
+        createdBy: {
+          select: { id: true, name: true, email: true },
+        },
+      },
+    });
+
+    // Créer les interactions pour les changements détectés
+    try {
+      // Changement de statut
+      if (statusId !== undefined && statusId !== existing.statusId) {
+        await logStatusChange(
+          id,
+          existing.statusId,
+          statusId,
+          session.user.id,
+          existing.status?.name || null,
+          contact.status?.name || null,
+        );
+
+        // Exécuter les workflows déclenchés par le changement de statut
+        try {
+          await executeWorkflowsOnStatusChanged(id, existing.statusId, statusId);
+        } catch (workflowError) {
+          // Ne pas faire échouer la mise à jour si les workflows échouent
+          console.error('Erreur lors de l\'exécution des workflows:', workflowError);
+        }
+      }
+
+      // Changement d'assignation Commercial
+      // Normaliser les valeurs pour la comparaison (null, undefined, '' sont considérés comme équivalents)
+      const normalizedExistingCommercial = existing.assignedCommercialId || null;
+      const normalizedNewCommercial = assignedCommercialId || null;
+
+      if (
+        assignedCommercialId !== undefined &&
+        normalizedExistingCommercial !== normalizedNewCommercial
+      ) {
+        await logAssignmentChange(
+          id,
+          'COMMERCIAL',
+          existing.assignedCommercialId,
+          assignedCommercialId,
+          session.user.id,
+          existing.assignedCommercial?.name || null,
+          contact.assignedCommercial?.name || null,
+        );
+      }
+
+      // Changement d'assignation Télépro
+      // Normaliser les valeurs pour la comparaison (null, undefined, '' sont considérés comme équivalents)
+      const normalizedExistingTelepro = existing.assignedTeleproId || null;
+      const normalizedNewTelepro = assignedTeleproId || null;
+
+      if (assignedTeleproId !== undefined && normalizedExistingTelepro !== normalizedNewTelepro) {
+        await logAssignmentChange(
+          id,
+          'TELEPRO',
+          existing.assignedTeleproId,
+          assignedTeleproId,
+          session.user.id,
+          existing.assignedTelepro?.name || null,
+          contact.assignedTelepro?.name || null,
+        );
+      }
+
+      // Changements de champs de contact
+      if (Object.keys(changes).length > 0) {
+        await logContactUpdate(id, changes, session.user.id);
+      }
+    } catch (error) {
+      // Ne pas faire échouer la mise à jour si l'enregistrement de l'interaction échoue
+      console.error('Erreur lors de la création des interactions:', error);
+    }
+
+    return NextResponse.json(contact);
+  } catch (error: any) {
+    console.error('Erreur lors de la mise à jour du contact:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// DELETE /api/contacts/[id] - Supprimer un contact
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  try {
+    // Vérifier que l'utilisateur est administrateur
+    const { requireAdmin } = await import('@/lib/roles');
+    await requireAdmin(request.headers);
+
+    const { id } = await params;
+
+    // Vérifier que le contact existe
+    const existing = await prisma.contact.findUnique({
+      where: { id },
+    });
+
+    if (!existing) {
+      return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
+    }
+
+    await prisma.contact.delete({
+      where: { id },
+    });
+
+    return NextResponse.json({ success: true, message: 'Contact supprimé avec succès' });
+  } catch (error: any) {
+    console.error('Erreur lors de la suppression du contact:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}