create-crm-tmp 1.1.3 → 2.1.0

package/template/src/app/api/workflows/process/route.ts

@@ -1,6 +1,13 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { prisma } from '@/lib/prisma';
-import { changeStatusImmediate, createTaskImmediate } from '@/lib/workflow-executor';
+import {
+  changeStatusImmediate,
+  createTaskImmediate,
+  assignContactImmediate,
+  addNoteImmediate,
+  notifyUserImmediate,
+  getContactVariables,
+} from '@/lib/workflow-executor';
 import { decrypt } from '@/lib/encryption';
 import nodemailer from 'nodemailer';
 import { replaceTemplateVariables } from '@/lib/template-variables';
@@ -8,183 +15,534 @@ import { replaceTemplateVariables } from '@/lib/template-variables';
 /**
  * GET /api/workflows/process
  * Endpoint appelé par Vercel Cron pour traiter les actions planifiées
+ * et les workflows TIME_BASED
  */
 export async function GET(request: NextRequest) {
   try {
-    // Vérifier l'authentification Vercel Cron
-    // Vercel envoie automatiquement le header Authorization: Bearer <secret>
-    // si CRON_SECRET est défini dans les variables d'environnement
+    const isDevelopment = process.env.NODE_ENV === 'development';
     const cronSecret = process.env.CRON_SECRET;
+    const authHeader = request.headers.get('authorization');
 
-    if (cronSecret) {
-      const authHeader = request.headers.get('authorization');
-      const expectedAuth = `Bearer ${cronSecret}`;
-
-      if (authHeader !== expectedAuth) {
-        // En développement, on peut être plus permissif pour les tests
-        const isDevelopment = process.env.NODE_ENV === 'development';
+    if (!cronSecret && !isDevelopment) {
+      return NextResponse.json(
+        { error: 'Unauthorized - CRON_SECRET manquant en production' },
+        { status: 401 },
+      );
+    }
 
-        if (!isDevelopment) {
-          return NextResponse.json(
-            { error: 'Unauthorized - Secret manquant ou invalide' },
-            { status: 401 },
-          );
-        }
-      }
+    if (cronSecret && authHeader !== `Bearer ${cronSecret}` && !isDevelopment) {
+      return NextResponse.json(
+        { error: 'Unauthorized - Secret manquant ou invalide' },
+        { status: 401 },
+      );
     }
 
-    // Récupérer les actions à exécuter maintenant
-    // On utilise une petite marge de 5 secondes pour éviter les problèmes de timing
     const now = new Date();
-    const margin = new Date(now.getTime() + 5000); // 5 secondes de marge
 
-    const actionsToExecute = await prisma.scheduledWorkflowAction.findMany({
-      where: {
-        executed: false,
-        executeAt: {
-          lte: margin, // Date d'exécution <= maintenant + marge
+    // 1) Traiter les actions planifiées (scheduled)
+    const scheduledResults = await processScheduledActions(now);
+
+    // 2) Traiter les workflows TIME_BASED
+    const timeBasedResults = await processTimeBasedWorkflows(now);
+
+    return NextResponse.json({
+      success: true,
+      scheduled: scheduledResults,
+      timeBased: timeBasedResults,
+      timestamp: now.toISOString(),
+      executionTime: `${Date.now() - now.getTime()}ms`,
+    });
+  } catch (error: any) {
+    console.error('Erreur lors du traitement des workflows:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Traitement des actions planifiées (scheduled)
+// ---------------------------------------------------------------------------
+
+async function processScheduledActions(now: Date) {
+  const margin = new Date(now.getTime() + 5000);
+
+  const actionsToExecute = await prisma.scheduledWorkflowAction.findMany({
+    where: {
+      executed: false,
+      executeAt: { lte: margin },
+    },
+    include: {
+      contact: {
+        include: {
+          status: true,
+          company: { select: { name: true, address: true, city: true, postalCode: true } },
+          assignedCommercial: { select: { name: true } },
+          assignedTelepro: { select: { name: true } },
         },
       },
-      include: {
-        contact: {
-          include: {
-            status: true,
-          },
+      workflow: {
+        include: {
+          user: { include: { smtpConfig: true } },
         },
-        workflow: {
-          include: {
-            user: {
-              include: {
-                smtpConfig: true,
-              },
+      },
+    },
+    orderBy: { executeAt: 'asc' },
+    take: 50,
+  });
+
+  if (actionsToExecute.length === 0) {
+    return { processed: 0, success: 0, failed: 0, errors: [] };
+  }
+
+  const results = {
+    processed: actionsToExecute.length,
+    success: 0,
+    failed: 0,
+    errors: [] as Array<{ id: string; error: string }>,
+  };
+
+  for (const scheduledAction of actionsToExecute) {
+    try {
+      const actionData = scheduledAction.actionData as any;
+      const contact = scheduledAction.contact;
+      const workflow = scheduledAction.workflow;
+
+      switch (scheduledAction.actionType) {
+        case 'SEND_EMAIL':
+          await executeScheduledEmail(scheduledAction, actionData, contact, workflow);
+          break;
+
+        case 'SEND_SMS':
+          await executeScheduledSMS(scheduledAction, actionData, contact, workflow);
+          break;
+
+        case 'CHANGE_STATUS':
+          await changeStatusImmediate(contact.id, actionData.newStatusId);
+          break;
+
+        case 'CREATE_TASK':
+          await createTaskImmediate(
+            {
+              taskTitle: actionData.taskTitle,
+              taskDescription: actionData.taskDescription,
+              taskType: actionData.taskType,
+              taskPriority: actionData.taskPriority,
+              taskAssignedUserId: actionData.taskAssignedUserId,
             },
-          },
+            workflow,
+            contact.id,
+            scheduledAction.executeAt,
+          );
+          break;
+
+        case 'ASSIGN_CONTACT':
+          await assignContactImmediate(
+            contact.id,
+            actionData.assignCommercialId,
+            actionData.assignTeleproId,
+          );
+          break;
+
+        case 'ADD_NOTE': {
+          const variables = getContactVariables(contact);
+          const noteContent = replaceTemplateVariables(actionData.noteContent || '', variables);
+          await addNoteImmediate(
+            contact.id,
+            noteContent,
+            actionData.userId || workflow.userId,
+            actionData.workflowName || workflow.name,
+          );
+          break;
+        }
+
+        case 'NOTIFY_USER':
+          await notifyUserImmediate(
+            {
+              notifyUserId: actionData.notifyUserId,
+              taskTitle: actionData.taskTitle,
+              taskDescription: actionData.taskDescription,
+            },
+            workflow,
+            contact.id,
+            scheduledAction.executeAt,
+          );
+          break;
+
+        case 'WAIT':
+          break;
+
+        default:
+          throw new Error(`Type d'action inconnu: ${scheduledAction.actionType}`);
+      }
+
+      await prisma.scheduledWorkflowAction.update({
+        where: { id: scheduledAction.id },
+        data: { executed: true, executedAt: new Date() },
+      });
+
+      results.success++;
+    } catch (error: any) {
+      const errorMessage = error.message || 'Erreur inconnue';
+
+      console.error(
+        `[Workflow Cron] Erreur lors de l'exécution de l'action ${scheduledAction.id}:`,
+        {
+          actionType: scheduledAction.actionType,
+          contactId: scheduledAction.contactId,
+          workflowId: scheduledAction.workflowId,
+          error: errorMessage,
         },
-      },
-      orderBy: {
-        executeAt: 'asc', // Traiter les actions dans l'ordre chronologique
-      },
-      take: 50, // Limiter à 50 actions par exécution pour éviter les timeouts (limite Vercel: 60s)
-    });
+      );
 
-    if (actionsToExecute.length === 0) {
-      return NextResponse.json({
-        success: true,
-        processed: 0,
-        message: 'Aucune action à exécuter',
-        timestamp: now.toISOString(),
+      const truncatedError =
+        errorMessage.length > 500 ? errorMessage.substring(0, 500) + '...' : errorMessage;
+
+      await prisma.scheduledWorkflowAction.update({
+        where: { id: scheduledAction.id },
+        data: { executed: true, executedAt: new Date(), error: truncatedError },
       });
+
+      results.failed++;
+      results.errors.push({ id: scheduledAction.id, error: truncatedError });
     }
+  }
 
-    const results = {
-      success: 0,
-      failed: 0,
-      errors: [] as Array<{ id: string; error: string }>,
-    };
+  return results;
+}
 
-    // Exécuter chaque action
-    for (const scheduledAction of actionsToExecute) {
-      try {
-        const actionData = scheduledAction.actionData as any;
-        const contact = scheduledAction.contact;
-        const workflow = scheduledAction.workflow;
+// ---------------------------------------------------------------------------
+// Traitement des workflows TIME_BASED
+// ---------------------------------------------------------------------------
+
+async function processTimeBasedWorkflows(now: Date) {
+  const workflows = await prisma.workflow.findMany({
+    where: { active: true, triggerType: 'TIME_BASED' },
+    include: {
+      actions: {
+        orderBy: { order: 'asc' },
+        include: {
+          emailTemplate: true,
+          newStatus: true,
+          conditionStatus: true,
+        },
+      },
+      user: { include: { smtpConfig: true } },
+    },
+  });
 
-        switch (scheduledAction.actionType) {
-          case 'SEND_EMAIL':
-            await executeScheduledEmail(scheduledAction, actionData, contact, workflow);
-            break;
+  if (workflows.length === 0) {
+    return { processed: 0, triggered: 0 };
+  }
 
-          case 'SEND_SMS':
-            await executeScheduledSMS(scheduledAction, actionData, contact, workflow);
-            break;
+  let triggered = 0;
 
-          case 'CHANGE_STATUS':
-            await changeStatusImmediate(contact.id, actionData.newStatusId);
-            break;
+  for (const workflow of workflows) {
+    try {
+      const delayMs =
+        (workflow.triggerTimeDays || 0) * 24 * 60 * 60 * 1000 +
+        (workflow.triggerTimeHours || 0) * 60 * 60 * 1000;
 
-          case 'CREATE_TASK':
-            await createTaskImmediate(
-              {
-                taskTitle: actionData.taskTitle,
-                taskDescription: actionData.taskDescription,
-              },
-              workflow,
-              contact.id,
-              scheduledAction.executeAt,
-            );
-            break;
+      if (delayMs <= 0) continue;
 
-          case 'WAIT':
-            // L'action "Attendre" ne fait rien, elle est juste là pour le délai
-            break;
+      const thresholdDate = new Date(now.getTime() - delayMs);
+      const windowStart = new Date(thresholdDate.getTime() - 120_000); // 2 min window
 
-          default:
-            throw new Error(`Type d'action inconnu: ${scheduledAction.actionType}`);
-        }
+      const contacts = await findContactsForTimeBased(
+        workflow.triggerTimeReference,
+        windowStart,
+        thresholdDate,
+      );
 
-        // Marquer comme exécutée
-        await prisma.scheduledWorkflowAction.update({
-          where: { id: scheduledAction.id },
-          data: {
-            executed: true,
-            executedAt: new Date(),
+      for (const contact of contacts) {
+        const alreadyTriggered = await prisma.scheduledWorkflowAction.findFirst({
+          where: {
+            workflowId: workflow.id,
+            contactId: contact.id,
+            createdAt: { gte: new Date(now.getTime() - 24 * 60 * 60 * 1000) },
           },
         });
 
-        results.success++;
-      } catch (error: any) {
-        const errorMessage = error.message || 'Erreur inconnue';
-        const errorStack = error.stack || '';
-
-        console.error(
-          `[Workflow Cron] Erreur lors de l'exécution de l'action ${scheduledAction.id}:`,
-          {
-            actionType: scheduledAction.actionType,
-            contactId: scheduledAction.contactId,
-            workflowId: scheduledAction.workflowId,
-            error: errorMessage,
-            stack: errorStack,
-          },
-        );
-
-        // Marquer comme échouée avec le message d'erreur
-        // On limite la taille du message d'erreur pour éviter les problèmes de base de données
-        const truncatedError =
-          errorMessage.length > 500 ? errorMessage.substring(0, 500) + '...' : errorMessage;
-
-        await prisma.scheduledWorkflowAction.update({
-          where: { id: scheduledAction.id },
-          data: {
-            executed: true, // Marquer comme exécutée pour ne pas réessayer indéfiniment
-            executedAt: new Date(),
-            error: truncatedError,
-          },
-        });
+        if (alreadyTriggered) continue;
 
-        results.failed++;
-        results.errors.push({
-          id: scheduledAction.id,
-          error: truncatedError,
-        });
+        const { executeWorkflowActions } = await getExecuteWorkflowActions();
+        await executeWorkflowActions(workflow, contact.id, contact);
+        triggered++;
       }
+    } catch (error) {
+      console.error(`[TIME_BASED] Erreur pour workflow ${workflow.id}:`, error);
     }
+  }
 
-    return NextResponse.json({
-      success: true,
-      processed: actionsToExecute.length,
-      results,
-      timestamp: now.toISOString(),
-      executionTime: `${Date.now() - now.getTime()}ms`,
-    });
-  } catch (error: any) {
-    console.error('Erreur lors du traitement des workflows:', error);
-    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  return { processed: workflows.length, triggered };
+}
+
+async function findContactsForTimeBased(
+  reference: string | null,
+  windowStart: Date,
+  windowEnd: Date,
+) {
+  switch (reference) {
+    case 'LAST_STATUS_CHANGE': {
+      const interactions = await prisma.interaction.findMany({
+        where: {
+          type: 'STATUS_CHANGE',
+          createdAt: { gte: windowStart, lte: windowEnd },
+        },
+        select: { contactId: true },
+        distinct: ['contactId'],
+        take: 50,
+      });
+      const contactIds = interactions.map((i) => i.contactId);
+      if (contactIds.length === 0) return [];
+      return prisma.contact.findMany({
+        where: { id: { in: contactIds } },
+        include: { status: true, company: { select: { name: true, id: true } } },
+      });
+    }
+
+    case 'LAST_INTERACTION': {
+      const contacts = await prisma.$queryRaw<Array<{ id: string }>>`
+        SELECT c.id FROM contact c
+        WHERE (
+          SELECT MAX(i."createdAt") FROM interaction i WHERE i."contactId" = c.id
+        ) BETWEEN ${windowStart} AND ${windowEnd}
+        LIMIT 50
+      `;
+      if (contacts.length === 0) return [];
+      return prisma.contact.findMany({
+        where: { id: { in: contacts.map((c) => c.id) } },
+        include: { status: true, company: { select: { name: true, id: true } } },
+      });
+    }
+
+    case 'CONTACT_CREATED_DATE':
+    default: {
+      return prisma.contact.findMany({
+        where: { createdAt: { gte: windowStart, lte: windowEnd } },
+        include: { status: true, company: { select: { name: true, id: true } } },
+        take: 50,
+      });
+    }
   }
 }
 
-/**
- * Exécute une action email planifiée
- */
+async function getExecuteWorkflowActions() {
+  const mod = await import('@/lib/workflow-executor');
+  return {
+    executeWorkflowActions: async (workflow: any, contactId: string, contact: any) => {
+      for (const action of workflow.actions) {
+        if (action.conditionOperator && action.conditionStatusId) {
+          const conditionMet =
+            action.conditionOperator === 'EQUALS'
+              ? contact.statusId === action.conditionStatusId
+              : contact.statusId !== action.conditionStatusId;
+          if (!conditionMet) continue;
+        }
+        if (action.conditionOrigin && (contact.origin || '') !== action.conditionOrigin) continue;
+        if (action.conditionHasCompany === true && !contact.companyId) continue;
+        if (action.conditionHasCompany === false && contact.companyId) continue;
+
+        const delayMs =
+          (action.delayDays || 0) * 24 * 60 * 60 * 1000 + (action.delayHours || 0) * 60 * 60 * 1000;
+        const executeAt = new Date(Date.now() + delayMs);
+
+        const variables = getContactVariables(contact);
+
+        switch (action.actionType) {
+          case 'SEND_EMAIL':
+            if (action.emailTemplate && workflow.user.smtpConfig) {
+              const subject = replaceTemplateVariables(
+                action.emailTemplate.subject || '',
+                variables,
+              );
+              const content = replaceTemplateVariables(
+                action.emailTemplate.content || '',
+                variables,
+              );
+              if (executeAt <= new Date()) {
+                await mod.sendEmailImmediate(
+                  workflow,
+                  contact,
+                  action.emailTemplate,
+                  subject,
+                  content,
+                );
+              } else {
+                await prisma.scheduledWorkflowAction.create({
+                  data: {
+                    workflowId: workflow.id,
+                    actionId: action.id,
+                    contactId: contact.id,
+                    actionType: 'SEND_EMAIL',
+                    actionData: {
+                      emailTemplateId: action.emailTemplateId,
+                      templateSubject: action.emailTemplate.subject,
+                      templateContent: action.emailTemplate.content,
+                      templateName: action.emailTemplate.name,
+                      smtpConfigId: workflow.user.smtpConfig.id,
+                      userId: workflow.userId,
+                      workflowName: workflow.name,
+                    },
+                    executeAt,
+                  },
+                });
+              }
+            }
+            break;
+          case 'CHANGE_STATUS':
+            if (action.newStatusId) {
+              if (executeAt <= new Date()) {
+                await mod.changeStatusImmediate(contactId, action.newStatusId);
+              } else {
+                await prisma.scheduledWorkflowAction.create({
+                  data: {
+                    workflowId: workflow.id,
+                    actionId: action.id,
+                    contactId,
+                    actionType: 'CHANGE_STATUS',
+                    actionData: { newStatusId: action.newStatusId, workflowName: workflow.name },
+                    executeAt,
+                  },
+                });
+              }
+            }
+            break;
+          case 'CREATE_TASK':
+            if (action.taskTitle) {
+              if (executeAt <= new Date()) {
+                await mod.createTaskImmediate(action, workflow, contactId, executeAt);
+              } else {
+                await prisma.scheduledWorkflowAction.create({
+                  data: {
+                    workflowId: workflow.id,
+                    actionId: action.id,
+                    contactId,
+                    actionType: 'CREATE_TASK',
+                    actionData: {
+                      taskTitle: action.taskTitle,
+                      taskDescription: action.taskDescription || '',
+                      taskType: action.taskType || 'OTHER',
+                      taskPriority: action.taskPriority || 'MEDIUM',
+                      taskAssignedUserId: action.taskAssignedUserId || workflow.userId,
+                      userId: workflow.userId,
+                      workflowName: workflow.name,
+                    },
+                    executeAt,
+                  },
+                });
+              }
+            }
+            break;
+          case 'ASSIGN_CONTACT':
+            if (action.assignCommercialId || action.assignTeleproId) {
+              if (executeAt <= new Date()) {
+                await mod.assignContactImmediate(
+                  contactId,
+                  action.assignCommercialId,
+                  action.assignTeleproId,
+                );
+              } else {
+                await prisma.scheduledWorkflowAction.create({
+                  data: {
+                    workflowId: workflow.id,
+                    actionId: action.id,
+                    contactId,
+                    actionType: 'ASSIGN_CONTACT',
+                    actionData: {
+                      assignCommercialId: action.assignCommercialId,
+                      assignTeleproId: action.assignTeleproId,
+                      workflowName: workflow.name,
+                    },
+                    executeAt,
+                  },
+                });
+              }
+            }
+            break;
+          case 'ADD_NOTE':
+            if (action.noteContent) {
+              const noteContent = replaceTemplateVariables(action.noteContent, variables);
+              if (executeAt <= new Date()) {
+                await mod.addNoteImmediate(contactId, noteContent, workflow.userId, workflow.name);
+              } else {
+                await prisma.scheduledWorkflowAction.create({
+                  data: {
+                    workflowId: workflow.id,
+                    actionId: action.id,
+                    contactId,
+                    actionType: 'ADD_NOTE',
+                    actionData: {
+                      noteContent: action.noteContent,
+                      userId: workflow.userId,
+                      workflowName: workflow.name,
+                    },
+                    executeAt,
+                  },
+                });
+              }
+            }
+            break;
+          case 'NOTIFY_USER':
+            if (action.notifyUserId && action.taskTitle) {
+              if (executeAt <= new Date()) {
+                await mod.notifyUserImmediate(action, workflow, contactId, executeAt);
+              } else {
+                await prisma.scheduledWorkflowAction.create({
+                  data: {
+                    workflowId: workflow.id,
+                    actionId: action.id,
+                    contactId,
+                    actionType: 'NOTIFY_USER',
+                    actionData: {
+                      notifyUserId: action.notifyUserId,
+                      taskTitle: action.taskTitle,
+                      taskDescription: action.taskDescription || '',
+                      userId: workflow.userId,
+                      workflowName: workflow.name,
+                    },
+                    executeAt,
+                  },
+                });
+              }
+            }
+            break;
+          case 'SEND_SMS':
+            if (action.smsMessage && contact.phone) {
+              let message = action.smsMessage;
+              for (const [key, value] of Object.entries(variables)) {
+                message = message.replaceAll(`{${key}}`, value as string);
+              }
+              if (executeAt <= new Date()) {
+                await mod.sendSMSImmediate(workflow, contact, message);
+              } else {
+                await prisma.scheduledWorkflowAction.create({
+                  data: {
+                    workflowId: workflow.id,
+                    actionId: action.id,
+                    contactId: contact.id,
+                    actionType: 'SEND_SMS',
+                    actionData: {
+                      smsMessage: action.smsMessage,
+                      userId: workflow.userId,
+                      workflowName: workflow.name,
+                    },
+                    executeAt,
+                  },
+                });
+              }
+            }
+            break;
+          case 'WAIT':
+            break;
+        }
+      }
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers scheduled email / SMS
+// ---------------------------------------------------------------------------
+
 async function executeScheduledEmail(
   scheduledAction: any,
   actionData: any,
@@ -195,40 +553,23 @@ async function executeScheduledEmail(
     throw new Error('Configuration SMTP non trouvée');
   }
 
-  // Remplacer les variables dans le sujet et le contenu
-  const variables = {
-    firstName: contact.firstName || '',
-    lastName: contact.lastName || '',
-    civility: contact.civility || '',
-    email: contact.email || '',
-    phone: contact.phone || '',
-    secondaryPhone: contact.secondaryPhone || '',
-    address: contact.address || '',
-    city: contact.city || '',
-    postalCode: contact.postalCode || '',
-    companyName: contact.companyName || '',
-  };
+  const variables = getContactVariables(contact);
 
   const subject = replaceTemplateVariables(actionData.templateSubject || '', variables);
   const content = replaceTemplateVariables(actionData.templateContent || '', variables);
 
-  // Déchiffrer le mot de passe SMTP
   let password: string;
   try {
     password = decrypt(workflow.user.smtpConfig.password);
-  } catch (error) {
+  } catch {
     password = workflow.user.smtpConfig.password;
   }
 
-  // Créer le transporteur SMTP
   const transporter = nodemailer.createTransport({
     host: workflow.user.smtpConfig.host,
     port: workflow.user.smtpConfig.port,
     secure: workflow.user.smtpConfig.secure,
-    auth: {
-      user: workflow.user.smtpConfig.username,
-      pass: password,
-    },
+    auth: { user: workflow.user.smtpConfig.username, pass: password },
   });
 
   await transporter.sendMail({
@@ -240,7 +581,6 @@ async function executeScheduledEmail(
     html: content,
   });
 
-  // Créer une interaction pour tracer l'email envoyé
   await prisma.interaction.create({
     data: {
       contactId: contact.id,
@@ -253,32 +593,27 @@ async function executeScheduledEmail(
   });
 }
 
-/**
- * Exécute une action SMS planifiée
- */
 async function executeScheduledSMS(
   scheduledAction: any,
   actionData: any,
   contact: any,
   workflow: any,
 ) {
-  // Remplacer les variables dans le message
   let message = actionData.smsMessage || '';
   const variables: Record<string, string> = {
     firstName: contact.firstName || '',
     lastName: contact.lastName || '',
     email: contact.email || '',
     phone: contact.phone || '',
-    companyName: contact.companyName || '',
+    companyName: contact.company?.name || '',
   };
 
   for (const [key, value] of Object.entries(variables)) {
-    message = message.replace(new RegExp(`{${key}}`, 'g'), value);
+    message = message.replaceAll(`{${key}}`, value);
   }
 
-  // TODO: Implémenter l'envoi de SMS (nécessite une API SMS)
+  console.log(`SMS à envoyer à ${contact.phone}: ${message}`);
 
-  // Créer une interaction pour tracer le SMS
   await prisma.interaction.create({
     data: {
       contactId: contact.id,