create-crm-tmp 1.0.0

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

@@ -0,0 +1,293 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { changeStatusImmediate, createTaskImmediate } from '@/lib/workflow-executor';
+import { decrypt } from '@/lib/encryption';
+import nodemailer from 'nodemailer';
+import { replaceTemplateVariables } from '@/lib/template-variables';
+
+/**
+ * GET /api/workflows/process
+ * Endpoint appelé par Vercel Cron pour traiter les actions planifiées
+ */
+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 cronSecret = process.env.CRON_SECRET;
+
+    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 (!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
+        },
+      },
+      include: {
+        contact: {
+          include: {
+            status: true,
+          },
+        },
+        workflow: {
+          include: {
+            user: {
+              include: {
+                smtpConfig: true,
+              },
+            },
+          },
+        },
+      },
+      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 results = {
+      success: 0,
+      failed: 0,
+      errors: [] as Array<{ id: string; error: string }>,
+    };
+
+    // Exécuter chaque action
+    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,
+              },
+              workflow,
+              contact.id,
+              scheduledAction.executeAt,
+            );
+            break;
+
+          case 'WAIT':
+            // L'action "Attendre" ne fait rien, elle est juste là pour le délai
+            break;
+
+          default:
+            throw new Error(`Type d'action inconnu: ${scheduledAction.actionType}`);
+        }
+
+        // Marquer comme exécutée
+        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';
+        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,
+          },
+        });
+
+        results.failed++;
+        results.errors.push({
+          id: scheduledAction.id,
+          error: truncatedError,
+        });
+      }
+    }
+
+    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 });
+  }
+}
+
+/**
+ * Exécute une action email planifiée
+ */
+async function executeScheduledEmail(
+  scheduledAction: any,
+  actionData: any,
+  contact: any,
+  workflow: any,
+) {
+  if (!workflow.user.smtpConfig) {
+    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 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) {
+    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,
+    },
+  });
+
+  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,
+  });
+
+  // Créer une interaction pour tracer l'email envoyé
+  await prisma.interaction.create({
+    data: {
+      contactId: contact.id,
+      type: 'EMAIL',
+      title: `Email automatique: ${actionData.templateName || 'Template'}`,
+      content: `Email envoyé automatiquement via le workflow "${actionData.workflowName || workflow.name}"`,
+      userId: actionData.userId || workflow.userId,
+      date: new Date(),
+    },
+  });
+}
+
+/**
+ * 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 || '',
+  };
+
+  for (const [key, value] of Object.entries(variables)) {
+    message = message.replace(new RegExp(`{${key}}`, 'g'), 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,
+      type: 'SMS',
+      title: 'SMS automatique',
+      content: message,
+      userId: actionData.userId || workflow.userId,
+      date: new Date(),
+    },
+  });
+}

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

@@ -0,0 +1,124 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+// GET /api/workflows - Récupérer tous les workflows 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 workflows = await prisma.workflow.findMany({
+      where: {
+        userId: session.user.id,
+      },
+      include: {
+        actions: {
+          orderBy: { order: 'asc' },
+          include: {
+            emailTemplate: true,
+            newStatus: true,
+            conditionStatus: true,
+          },
+        },
+        triggerStatus: true,
+        triggerToStatus: true,
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+
+    return NextResponse.json(workflows);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des workflows:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// POST /api/workflows - Créer un nouveau workflow
+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 {
+      name,
+      description,
+      active = true,
+      triggerType,
+      triggerFromStatusId,
+      triggerToStatusId,
+      triggerTimeDays,
+      triggerTimeHours,
+      actions = [],
+    } = body;
+
+    // Validation
+    if (!name || !triggerType) {
+      return NextResponse.json(
+        { error: 'Le nom et le type de déclencheur sont requis' },
+        { status: 400 },
+      );
+    }
+
+    // Créer le workflow
+    const workflow = await prisma.workflow.create({
+      data: {
+        name,
+        description: description || null,
+        active,
+        userId: session.user.id,
+        triggerType,
+        triggerFromStatusId: triggerFromStatusId || null,
+        triggerToStatusId: triggerToStatusId || null,
+        triggerTimeDays: triggerTimeDays || null,
+        triggerTimeHours: triggerTimeHours || null,
+        actions: {
+          create: actions.map((action: any, index: number) => ({
+            actionType: action.actionType,
+            order: index,
+            delayDays: action.delayDays || 0,
+            delayHours: action.delayHours || 0,
+            emailTemplateId: action.emailTemplateId || null,
+            smsMessage: action.smsMessage || null,
+            newStatusId: action.newStatusId || null,
+            taskTitle: action.taskTitle || null,
+            taskDescription: action.taskDescription || null,
+            conditionOperator: action.conditionOperator || null,
+            conditionStatusId: action.conditionStatusId || null,
+          })),
+        },
+      },
+      include: {
+        actions: {
+          orderBy: { order: 'asc' },
+          include: {
+            emailTemplate: true,
+            newStatus: true,
+            conditionStatus: true,
+          },
+        },
+        triggerStatus: true,
+        triggerToStatus: true,
+      },
+    });
+
+    return NextResponse.json(workflow, { status: 201 });
+  } catch (error: any) {
+    console.error('Erreur lors de la création du workflow:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+