create-crm-tmp 1.1.2 → 2.0.0

package/template/src/lib/workflow-executor.ts

@@ -3,39 +3,55 @@ import nodemailer from 'nodemailer';
 import { decrypt } from '@/lib/encryption';
 import { replaceTemplateVariables } from '@/lib/template-variables';
 
+const WORKFLOW_INCLUDE = {
+  actions: {
+    orderBy: { order: 'asc' as const },
+    include: {
+      emailTemplate: true,
+      newStatus: true,
+      conditionStatus: true,
+    },
+  },
+  user: {
+    include: {
+      smtpConfig: true,
+    },
+  },
+};
+
+const CONTACT_INCLUDE = {
+  status: true,
+  company: { select: { name: true, id: true } },
+};
+
+function getContactVariables(contact: any) {
+  return {
+    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.company?.name || '',
+  };
+}
+
 /**
  * Exécute les workflows déclenchés par la création d'un contact
  */
 export async function executeWorkflowsOnContactCreated(contactId: string) {
   try {
-    // Récupérer tous les workflows actifs avec le déclencheur CONTACT_CREATED
     const workflows = await prisma.workflow.findMany({
-      where: {
-        active: true,
-        triggerType: 'CONTACT_CREATED',
-      },
-      include: {
-        actions: {
-          orderBy: { order: 'asc' },
-          include: {
-            emailTemplate: true,
-            newStatus: true,
-            conditionStatus: true,
-          },
-        },
-        user: {
-          include: {
-            smtpConfig: true,
-          },
-        },
-      },
+      where: { active: true, triggerType: 'CONTACT_CREATED' },
+      include: WORKFLOW_INCLUDE,
     });
 
     const contact = await prisma.contact.findUnique({
       where: { id: contactId },
-      include: {
-        status: true,
-      },
+      include: CONTACT_INCLUDE,
     });
 
     if (!contact) return;
@@ -57,52 +73,56 @@ export async function executeWorkflowsOnStatusChanged(
   newStatusId: string | null,
 ) {
   try {
-    // Récupérer tous les workflows actifs avec le déclencheur STATUS_CHANGED
     const workflows = await prisma.workflow.findMany({
-      where: {
-        active: true,
-        triggerType: 'STATUS_CHANGED',
-      },
+      where: { active: true, triggerType: 'STATUS_CHANGED' },
       include: {
-        actions: {
-          orderBy: { order: 'asc' },
-          include: {
-            emailTemplate: true,
-            newStatus: true,
-            conditionStatus: true,
-          },
-        },
+        ...WORKFLOW_INCLUDE,
         triggerStatus: true,
         triggerToStatus: true,
-        user: {
-          include: {
-            smtpConfig: true,
-          },
-        },
       },
     });
 
     const contact = await prisma.contact.findUnique({
       where: { id: contactId },
-      include: {
-        status: true,
-      },
+      include: CONTACT_INCLUDE,
     });
 
     if (!contact) return;
 
-    // Filtrer les workflows qui correspondent aux conditions de déclenchement
     const matchingWorkflows = workflows.filter((workflow) => {
-      // Si le workflow spécifie un statut source, vérifier qu'il correspond
-      if (workflow.triggerFromStatusId && oldStatusId !== workflow.triggerFromStatusId) {
+      if (workflow.triggerFromStatusId && oldStatusId !== workflow.triggerFromStatusId)
         return false;
-      }
+      if (workflow.triggerToStatusId && newStatusId !== workflow.triggerToStatusId) return false;
+      return true;
+    });
 
-      // Si le workflow spécifie un statut cible, vérifier qu'il correspond
-      if (workflow.triggerToStatusId && newStatusId !== workflow.triggerToStatusId) {
-        return false;
-      }
+    for (const workflow of matchingWorkflows) {
+      await executeWorkflowActions(workflow, contactId, contact);
+    }
+  } catch (error) {
+    console.error("Erreur lors de l'exécution des workflows pour changement de statut:", error);
+  }
+}
+
+/**
+ * Exécute les workflows déclenchés par la complétion d'une tâche
+ */
+export async function executeWorkflowsOnTaskCompleted(contactId: string, taskType: string) {
+  try {
+    const workflows = await prisma.workflow.findMany({
+      where: { active: true, triggerType: 'TASK_COMPLETED' },
+      include: WORKFLOW_INCLUDE,
+    });
 
+    const contact = await prisma.contact.findUnique({
+      where: { id: contactId },
+      include: CONTACT_INCLUDE,
+    });
+
+    if (!contact) return;
+
+    const matchingWorkflows = workflows.filter((workflow) => {
+      if (workflow.triggerTaskType && workflow.triggerTaskType !== taskType) return false;
       return true;
     });
 
@@ -110,34 +130,155 @@ export async function executeWorkflowsOnStatusChanged(
       await executeWorkflowActions(workflow, contactId, contact);
     }
   } catch (error) {
-    console.error("Erreur lors de l'exécution des workflows pour changement de statut:", error);
+    console.error("Erreur lors de l'exécution des workflows pour tâche complétée:", error);
+  }
+}
+
+/**
+ * Exécute les workflows déclenchés par la création d'une transaction
+ */
+export async function executeWorkflowsOnTransactionCreated(contactId: string) {
+  try {
+    const workflows = await prisma.workflow.findMany({
+      where: { active: true, triggerType: 'TRANSACTION_CREATED' },
+      include: WORKFLOW_INCLUDE,
+    });
+
+    const contact = await prisma.contact.findUnique({
+      where: { id: contactId },
+      include: CONTACT_INCLUDE,
+    });
+
+    if (!contact) return;
+
+    for (const workflow of workflows) {
+      await executeWorkflowActions(workflow, contactId, contact);
+    }
+  } catch (error) {
+    console.error("Erreur lors de l'exécution des workflows pour transaction créée:", error);
   }
 }
 
+/**
+ * Exécute les workflows déclenchés par un changement de statut de transaction
+ */
+export async function executeWorkflowsOnTransactionStatusChanged(
+  contactId: string,
+  oldStatus: string | null,
+  newStatus: string,
+) {
+  try {
+    const workflows = await prisma.workflow.findMany({
+      where: { active: true, triggerType: 'TRANSACTION_STATUS_CHANGED' },
+      include: WORKFLOW_INCLUDE,
+    });
+
+    const contact = await prisma.contact.findUnique({
+      where: { id: contactId },
+      include: CONTACT_INCLUDE,
+    });
+
+    if (!contact) return;
+
+    const matchingWorkflows = workflows.filter((workflow) => {
+      if (
+        workflow.triggerTransactionFromStatus &&
+        oldStatus !== workflow.triggerTransactionFromStatus
+      )
+        return false;
+      if (workflow.triggerTransactionToStatus && newStatus !== workflow.triggerTransactionToStatus)
+        return false;
+      return true;
+    });
+
+    for (const workflow of matchingWorkflows) {
+      await executeWorkflowActions(workflow, contactId, contact);
+    }
+  } catch (error) {
+    console.error(
+      "Erreur lors de l'exécution des workflows pour changement de statut de transaction:",
+      error,
+    );
+  }
+}
+
+/**
+ * Exécute les workflows déclenchés par un changement d'assignation
+ */
+export async function executeWorkflowsOnAssignmentChanged(contactId: string) {
+  try {
+    const workflows = await prisma.workflow.findMany({
+      where: { active: true, triggerType: 'CONTACT_ASSIGNMENT_CHANGED' },
+      include: WORKFLOW_INCLUDE,
+    });
+
+    const contact = await prisma.contact.findUnique({
+      where: { id: contactId },
+      include: CONTACT_INCLUDE,
+    });
+
+    if (!contact) return;
+
+    for (const workflow of workflows) {
+      await executeWorkflowActions(workflow, contactId, contact);
+    }
+  } catch (error) {
+    console.error("Erreur lors de l'exécution des workflows pour changement d'assignation:", error);
+  }
+}
+
+/**
+ * Exécute manuellement un workflow sur un contact
+ */
+export async function executeWorkflowManually(workflowId: string, contactId: string) {
+  const workflow = await prisma.workflow.findUnique({
+    where: { id: workflowId },
+    include: WORKFLOW_INCLUDE,
+  });
+
+  if (!workflow || !workflow.active || workflow.triggerType !== 'MANUAL') {
+    throw new Error('Workflow introuvable, inactif ou non manuel');
+  }
+
+  const contact = await prisma.contact.findUnique({
+    where: { id: contactId },
+    include: CONTACT_INCLUDE,
+  });
+
+  if (!contact) {
+    throw new Error('Contact introuvable');
+  }
+
+  await executeWorkflowActions(workflow, contactId, contact);
+}
+
 /**
  * Exécute les actions d'un workflow pour un contact
  */
 async function executeWorkflowActions(workflow: any, contactId: string, contact: any) {
   for (const action of workflow.actions) {
-    // Vérifier la condition si elle existe
+    // Vérifier la condition statut
     if (action.conditionOperator && action.conditionStatusId) {
-      const contactStatusId = contact.statusId;
       const conditionMet =
         action.conditionOperator === 'EQUALS'
-          ? contactStatusId === action.conditionStatusId
-          : contactStatusId !== action.conditionStatusId;
+          ? contact.statusId === action.conditionStatusId
+          : contact.statusId !== action.conditionStatusId;
+      if (!conditionMet) continue;
+    }
 
-      if (!conditionMet) {
-        continue; // Ignorer cette action si la condition n'est pas remplie
-      }
+    // Vérifier la condition origine
+    if (action.conditionOrigin) {
+      if ((contact.origin || '') !== action.conditionOrigin) continue;
     }
 
-    // Calculer la date d'exécution avec le délai
+    // Vérifier la condition société
+    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);
 
-    // Exécuter l'action selon son type
     switch (action.actionType) {
       case 'SEND_EMAIL':
         await executeSendEmailAction(action, workflow, contact, executeAt);
@@ -151,47 +292,39 @@ async function executeWorkflowActions(workflow: any, contactId: string, contact:
       case 'CREATE_TASK':
         await executeCreateTaskAction(action, workflow, contactId, executeAt);
         break;
+      case 'ASSIGN_CONTACT':
+        await executeAssignContactAction(action, workflow, contactId, executeAt);
+        break;
+      case 'ADD_NOTE':
+        await executeAddNoteAction(action, workflow, contactId, contact, executeAt);
+        break;
+      case 'NOTIFY_USER':
+        await executeNotifyUserAction(action, workflow, contactId, executeAt);
+        break;
       case 'WAIT':
-        // L'action "Attendre" est gérée par le délai, rien à faire ici
         break;
     }
   }
 }
 
-/**
- * Exécute l'action "Envoyer un email"
- */
+// ---------------------------------------------------------------------------
+// Actions
+// ---------------------------------------------------------------------------
+
 async function executeSendEmailAction(action: any, workflow: any, contact: any, executeAt: Date) {
-  if (!action.emailTemplateId || !workflow.user.smtpConfig) {
-    return;
-  }
+  if (!action.emailTemplateId || !workflow.user.smtpConfig) return;
 
   try {
     const template = action.emailTemplate;
     if (!template) return;
 
-    // Préparer les variables de template (même logique que l'envoi manuel)
-    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(template.subject || '', variables);
     const content = replaceTemplateVariables(template.content || '', variables);
 
-    // Si le délai est 0, envoyer immédiatement, sinon planifier
     if (executeAt <= new Date()) {
       await sendEmailImmediate(workflow, contact, template, subject, content);
     } else {
-      // Planifier l'action pour exécution différée
       await prisma.scheduledWorkflowAction.create({
         data: {
           workflowId: workflow.id,
@@ -216,34 +349,19 @@ async function executeSendEmailAction(action: any, workflow: any, contact: any,
   }
 }
 
-/**
- * Exécute l'action "Envoyer un SMS"
- */
 async function executeSendSMSAction(action: any, workflow: any, contact: any, executeAt: Date) {
-  if (!action.smsMessage || !contact.phone) {
-    return;
-  }
+  if (!action.smsMessage || !contact.phone) return;
 
   try {
-    // Remplacer les variables dans le message
     let message = action.smsMessage;
-    const variables: Record<string, string> = {
-      firstName: contact.firstName || '',
-      lastName: contact.lastName || '',
-      email: contact.email || '',
-      phone: contact.phone || '',
-      companyName: contact.companyName || '',
-    };
-
+    const variables: Record<string, string> = getContactVariables(contact);
     for (const [key, value] of Object.entries(variables)) {
       message = message.replace(new RegExp(`{${key}}`, 'g'), value);
     }
 
-    // Si le délai est 0, envoyer immédiatement
     if (executeAt <= new Date()) {
       await sendSMSImmediate(workflow, contact, message);
     } else {
-      // Planifier l'action pour exécution différée
       await prisma.scheduledWorkflowAction.create({
         data: {
           workflowId: workflow.id,
@@ -264,35 +382,25 @@ async function executeSendSMSAction(action: any, workflow: any, contact: any, ex
   }
 }
 
-/**
- * Exécute l'action "Changer le statut"
- */
 async function executeChangeStatusAction(
   action: any,
   workflow: any,
   contactId: string,
   executeAt: Date,
 ) {
-  if (!action.newStatusId) {
-    return;
-  }
+  if (!action.newStatusId) return;
 
   try {
-    // Si le délai est 0, changer immédiatement
     if (executeAt <= new Date()) {
       await changeStatusImmediate(contactId, action.newStatusId);
     } else {
-      // Planifier l'action pour exécution différée
       await prisma.scheduledWorkflowAction.create({
         data: {
           workflowId: workflow.id,
           actionId: action.id,
-          contactId: contactId,
+          contactId,
           actionType: 'CHANGE_STATUS',
-          actionData: {
-            newStatusId: action.newStatusId,
-            workflowName: workflow.name,
-          },
+          actionData: { newStatusId: action.newStatusId, workflowName: workflow.name },
           executeAt,
         },
       });
@@ -302,35 +410,30 @@ async function executeChangeStatusAction(
   }
 }
 
-/**
- * Exécute l'action "Créer une tâche"
- */
 async function executeCreateTaskAction(
   action: any,
   workflow: any,
   contactId: string,
   executeAt: Date,
 ) {
-  if (!action.taskTitle) {
-    return;
-  }
+  if (!action.taskTitle) return;
 
   try {
-    // Si le délai est 0, créer immédiatement
     if (executeAt <= new Date()) {
       await createTaskImmediate(action, workflow, contactId, executeAt);
     } else {
-      // Planifier l'action pour exécution différée
       await prisma.scheduledWorkflowAction.create({
         data: {
           workflowId: workflow.id,
           actionId: action.id,
-          contactId: contactId,
+          contactId,
           actionType: 'CREATE_TASK',
           actionData: {
             taskTitle: action.taskTitle,
             taskDescription: action.taskDescription || '',
-            taskPriority: 'MEDIUM',
+            taskType: action.taskType || 'OTHER',
+            taskPriority: action.taskPriority || 'MEDIUM',
+            taskAssignedUserId: action.taskAssignedUserId || workflow.userId,
             userId: workflow.userId,
             workflowName: workflow.name,
           },
@@ -343,134 +446,247 @@ async function executeCreateTaskAction(
   }
 }
 
-/**
- * Fonctions d'exécution immédiate (utilisées aussi par le cron)
- */
-
-/**
- * Envoie un email immédiatement
- */
-export async function sendEmailImmediate(
+async function executeAssignContactAction(
+  action: any,
   workflow: any,
-  contact: any,
-  template: any,
-  subject: string,
-  content: string,
+  contactId: string,
+  executeAt: Date,
 ) {
-  try {
-    if (!workflow.user.smtpConfig) {
-      throw new Error('Configuration SMTP non trouvée');
-    }
+  if (!action.assignCommercialId && !action.assignTeleproId) return;
 
-    // Déchiffrer le mot de passe SMTP
-    let password: string;
-    try {
-      password = decrypt(workflow.user.smtpConfig.password);
-    } catch (error) {
-      password = workflow.user.smtpConfig.password;
+  try {
+    if (executeAt <= new Date()) {
+      await 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,
+        },
+      });
     }
+  } catch (error) {
+    console.error("Erreur lors de l'assignation du contact:", error);
+  }
+}
 
-    // 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,
-      },
-    });
+async function executeAddNoteAction(
+  action: any,
+  workflow: any,
+  contactId: string,
+  contact: any,
+  executeAt: Date,
+) {
+  if (!action.noteContent) return;
 
-    await transporter.sendMail({
-      from: workflow.user.smtpConfig.fromName
-        ? `"${workflow.user.smtpConfig.fromName}" <${workflow.user.smtpConfig.fromEmail}>`
-        : workflow.user.smtpConfig.fromEmail,
-      to: contact.email,
-      subject,
-      html: content,
-    });
+  try {
+    const variables = getContactVariables(contact);
+    const content = replaceTemplateVariables(action.noteContent, variables);
 
-    // Créer une interaction pour tracer l'email envoyé
-    await prisma.interaction.create({
-      data: {
-        contactId: contact.id,
-        type: 'EMAIL',
-        title: `Email automatique: ${template.name}`,
-        content: `Email envoyé automatiquement via le workflow "${workflow.name}"`,
-        userId: workflow.userId,
-        date: new Date(),
-      },
-    });
+    if (executeAt <= new Date()) {
+      await addNoteImmediate(contactId, content, 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,
+        },
+      });
+    }
   } catch (error) {
-    console.error("Erreur lors de l'envoi de l'email:", error);
-    throw error;
+    console.error("Erreur lors de l'ajout de la note:", error);
   }
 }
 
-/**
- * Envoie un SMS immédiatement
- */
-export async function sendSMSImmediate(workflow: any, contact: any, message: string) {
+async function executeNotifyUserAction(
+  action: any,
+  workflow: any,
+  contactId: string,
+  executeAt: Date,
+) {
+  if (!action.notifyUserId || !action.taskTitle) return;
+
   try {
-    // 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,
-        type: 'SMS',
-        title: 'SMS automatique',
-        content: message,
-        userId: workflow.userId,
-        date: new Date(),
-      },
-    });
+    if (executeAt <= new Date()) {
+      await 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,
+        },
+      });
+    }
   } catch (error) {
-    console.error("Erreur lors de l'envoi du SMS:", error);
-    throw error;
+    console.error("Erreur lors de la notification de l'utilisateur:", error);
   }
 }
 
-/**
- * Change le statut immédiatement
- */
-export async function changeStatusImmediate(contactId: string, newStatusId: string) {
+// ---------------------------------------------------------------------------
+// Fonctions d'exécution immédiate (utilisées aussi par le cron)
+// ---------------------------------------------------------------------------
+
+export async function sendEmailImmediate(
+  workflow: any,
+  contact: any,
+  template: any,
+  subject: string,
+  content: string,
+) {
+  if (!workflow.user.smtpConfig) {
+    throw new Error('Configuration SMTP non trouvée');
+  }
+
+  let password: string;
   try {
-    await prisma.contact.update({
-      where: { id: contactId },
-      data: { statusId: newStatusId },
-    });
-  } catch (error) {
-    console.error('Erreur lors du changement de statut:', error);
-    throw error;
+    password = decrypt(workflow.user.smtpConfig.password);
+  } catch {
+    password = workflow.user.smtpConfig.password;
   }
+
+  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 },
+  });
+
+  await transporter.sendMail({
+    from: workflow.user.smtpConfig.fromName
+      ? `"${workflow.user.smtpConfig.fromName}" <${workflow.user.smtpConfig.fromEmail}>`
+      : workflow.user.smtpConfig.fromEmail,
+    to: contact.email,
+    subject,
+    html: content,
+  });
+
+  await prisma.interaction.create({
+    data: {
+      contactId: contact.id,
+      type: 'EMAIL',
+      title: `Email automatique: ${template.name}`,
+      content: `Email envoyé automatiquement via le workflow "${workflow.name}"`,
+      userId: workflow.userId,
+      date: new Date(),
+    },
+  });
+}
+
+export async function sendSMSImmediate(workflow: any, contact: any, message: string) {
+  console.log(`SMS à envoyer à ${contact.phone}: ${message}`);
+
+  await prisma.interaction.create({
+    data: {
+      contactId: contact.id,
+      type: 'SMS',
+      title: 'SMS automatique',
+      content: message,
+      userId: workflow.userId,
+      date: new Date(),
+    },
+  });
+}
+
+export async function changeStatusImmediate(contactId: string, newStatusId: string) {
+  await prisma.contact.update({
+    where: { id: contactId },
+    data: { statusId: newStatusId },
+  });
 }
 
-/**
- * Crée une tâche immédiatement
- */
 export async function createTaskImmediate(
   action: any,
   workflow: any,
   contactId: string,
   scheduledAt: Date,
 ) {
-  try {
-    await prisma.task.create({
-      data: {
-        type: 'OTHER',
-        title: action.taskTitle,
-        description: action.taskDescription || '',
-        priority: 'MEDIUM',
-        scheduledAt,
-        contactId: contactId,
-        assignedUserId: workflow.userId,
-        createdById: workflow.userId,
-      },
-    });
-  } catch (error) {
-    console.error('Erreur lors de la création de la tâche:', error);
-    throw error;
-  }
+  await prisma.task.create({
+    data: {
+      type: action.taskType || 'OTHER',
+      title: action.taskTitle,
+      description: action.taskDescription || '',
+      priority: action.taskPriority || 'MEDIUM',
+      scheduledAt,
+      contactId,
+      assignedUserId: action.taskAssignedUserId || workflow.userId,
+      createdById: workflow.userId,
+    },
+  });
+}
+
+export async function assignContactImmediate(
+  contactId: string,
+  commercialId?: string | null,
+  teleproId?: string | null,
+) {
+  const data: any = {};
+  if (commercialId !== undefined && commercialId !== null) data.assignedCommercialId = commercialId;
+  if (teleproId !== undefined && teleproId !== null) data.assignedTeleproId = teleproId;
+  if (Object.keys(data).length === 0) return;
+
+  await prisma.contact.update({ where: { id: contactId }, data });
+}
+
+export async function addNoteImmediate(
+  contactId: string,
+  content: string,
+  userId: string | null,
+  workflowName: string,
+) {
+  await prisma.interaction.create({
+    data: {
+      contactId,
+      type: 'NOTE',
+      title: `Note automatique (${workflowName})`,
+      content,
+      userId,
+      date: new Date(),
+    },
+  });
+}
+
+export async function notifyUserImmediate(
+  action: any,
+  workflow: any,
+  contactId: string,
+  scheduledAt: Date,
+) {
+  await prisma.task.create({
+    data: {
+      type: 'OTHER',
+      title: action.taskTitle,
+      description: action.taskDescription || '',
+      priority: 'MEDIUM',
+      scheduledAt,
+      contactId,
+      assignedUserId: action.notifyUserId,
+      createdById: workflow.userId,
+    },
+  });
 }