create-crm-tmp 1.0.0

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

@@ -0,0 +1,482 @@
+import { prisma } from '@/lib/prisma';
+import nodemailer from 'nodemailer';
+import { decrypt } from '@/lib/encryption';
+import { replaceTemplateVariables } from '@/lib/template-variables';
+
+/**
+ * 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,
+          },
+        },
+      },
+    });
+
+    const contact = await prisma.contact.findUnique({
+      where: { id: contactId },
+      include: {
+        status: true,
+      },
+    });
+
+    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 contact créé:', error);
+  }
+}
+
+/**
+ * Exécute les workflows déclenchés par un changement de statut
+ */
+export async function executeWorkflowsOnStatusChanged(
+  contactId: string,
+  oldStatusId: string | null,
+  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',
+      },
+      include: {
+        actions: {
+          orderBy: { order: 'asc' },
+          include: {
+            emailTemplate: true,
+            newStatus: true,
+            conditionStatus: true,
+          },
+        },
+        triggerStatus: true,
+        triggerToStatus: true,
+        user: {
+          include: {
+            smtpConfig: true,
+          },
+        },
+      },
+    });
+
+    const contact = await prisma.contact.findUnique({
+      where: { id: contactId },
+      include: {
+        status: true,
+      },
+    });
+
+    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) {
+        return false;
+      }
+
+      // Si le workflow spécifie un statut cible, vérifier qu'il correspond
+      if (workflow.triggerToStatusId && newStatusId !== workflow.triggerToStatusId) {
+        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:', error);
+  }
+}
+
+/**
+ * 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
+    if (action.conditionOperator && action.conditionStatusId) {
+      const contactStatusId = contact.statusId;
+      const conditionMet =
+        action.conditionOperator === 'EQUALS'
+          ? contactStatusId === action.conditionStatusId
+          : contactStatusId !== action.conditionStatusId;
+
+      if (!conditionMet) {
+        continue; // Ignorer cette action si la condition n'est pas remplie
+      }
+    }
+
+    // Calculer la date d'exécution avec le délai
+    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);
+        break;
+      case 'SEND_SMS':
+        await executeSendSMSAction(action, workflow, contact, executeAt);
+        break;
+      case 'CHANGE_STATUS':
+        await executeChangeStatusAction(action, workflow, contactId, executeAt);
+        break;
+      case 'CREATE_TASK':
+        await executeCreateTaskAction(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"
+ */
+async function executeSendEmailAction(
+  action: any,
+  workflow: any,
+  contact: any,
+  executeAt: Date,
+) {
+  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 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,
+          actionId: action.id,
+          contactId: contact.id,
+          actionType: 'SEND_EMAIL',
+          actionData: {
+            emailTemplateId: action.emailTemplateId,
+            templateSubject: template.subject,
+            templateContent: template.content,
+            templateName: template.name,
+            smtpConfigId: workflow.user.smtpConfig.id,
+            userId: workflow.userId,
+            workflowName: workflow.name,
+          },
+          executeAt,
+        },
+      });
+    }
+  } catch (error) {
+    console.error('Erreur lors de l\'envoi de l\'email:', error);
+  }
+}
+
+/**
+ * Exécute l'action "Envoyer un SMS"
+ */
+async function executeSendSMSAction(action: any, workflow: any, contact: any, executeAt: Date) {
+  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 || '',
+    };
+
+    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,
+          actionId: action.id,
+          contactId: contact.id,
+          actionType: 'SEND_SMS',
+          actionData: {
+            smsMessage: action.smsMessage,
+            userId: workflow.userId,
+            workflowName: workflow.name,
+          },
+          executeAt,
+        },
+      });
+    }
+  } catch (error) {
+    console.error('Erreur lors de l\'envoi du SMS:', error);
+  }
+}
+
+/**
+ * Exécute l'action "Changer le statut"
+ */
+async function executeChangeStatusAction(
+  action: any,
+  workflow: any,
+  contactId: string,
+  executeAt: Date,
+) {
+  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,
+          actionType: 'CHANGE_STATUS',
+          actionData: {
+            newStatusId: action.newStatusId,
+            workflowName: workflow.name,
+          },
+          executeAt,
+        },
+      });
+    }
+  } catch (error) {
+    console.error('Erreur lors du changement de statut:', error);
+  }
+}
+
+/**
+ * Exécute l'action "Créer une tâche"
+ */
+async function executeCreateTaskAction(
+  action: any,
+  workflow: any,
+  contactId: string,
+  executeAt: Date,
+) {
+  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,
+          actionType: 'CREATE_TASK',
+          actionData: {
+            taskTitle: action.taskTitle,
+            taskDescription: action.taskDescription || '',
+            taskPriority: 'MEDIUM',
+            userId: workflow.userId,
+            workflowName: workflow.name,
+          },
+          executeAt,
+        },
+      });
+    }
+  } catch (error) {
+    console.error('Erreur lors de la création de la tâche:', error);
+  }
+}
+
+/**
+ * Fonctions d'exécution immédiate (utilisées aussi par le cron)
+ */
+
+/**
+ * Envoie un email immédiatement
+ */
+export async function sendEmailImmediate(
+  workflow: any,
+  contact: any,
+  template: any,
+  subject: string,
+  content: string,
+) {
+  try {
+    if (!workflow.user.smtpConfig) {
+      throw new Error('Configuration SMTP non trouvée');
+    }
+
+    // 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: ${template.name}`,
+        content: `Email envoyé automatiquement via le workflow "${workflow.name}"`,
+        userId: workflow.userId,
+        date: new Date(),
+      },
+    });
+  } catch (error) {
+    console.error('Erreur lors de l\'envoi de l\'email:', error);
+    throw error;
+  }
+}
+
+/**
+ * Envoie un SMS immédiatement
+ */
+export async function sendSMSImmediate(workflow: any, contact: any, message: string) {
+  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(),
+      },
+    });
+  } catch (error) {
+    console.error('Erreur lors de l\'envoi du SMS:', error);
+    throw error;
+  }
+}
+
+/**
+ * Change le statut immédiatement
+ */
+export async function changeStatusImmediate(contactId: string, newStatusId: 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;
+  }
+}
+
+/**
+ * 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;
+  }
+}
+

package/template/src/proxy.ts

@@ -0,0 +1,91 @@
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { auth } from './lib/auth';
+import { isAdmin } from './lib/roles';
+import { prisma } from './lib/prisma';
+
+// Routes qui nécessitent une authentification
+const protectedRoutes = [
+  '/dashboard',
+  '/contacts',
+  '/settings',
+  '/users',
+  '/agenda',
+  '/automatisation',
+  '/templates',
+  '/closing',
+];
+
+// Routes réservées aux admins
+const adminRoutes = ['/users'];
+
+// Routes d'authentification
+const authRoutes = ['/signin'];
+
+export async function proxy(request: NextRequest) {
+  const { pathname } = request.nextUrl;
+
+  // Vérifier la session en utilisant Better Auth
+  const session = await auth.api.getSession({
+    headers: request.headers,
+  });
+
+  let isAuthenticated = !!session;
+  let isActiveUser = true;
+
+  // Récupérer le rôle depuis la session ou depuis la base de données
+  let userRole: string | null = null;
+  if (session && session.user?.id) {
+    const dbUser = await prisma.user.findUnique({
+      where: { id: session.user.id },
+      select: { role: true, active: true },
+    });
+
+    userRole = (session.user as any).role || dbUser?.role || null;
+    isActiveUser = dbUser?.active ?? true;
+    if (!isActiveUser) {
+      isAuthenticated = false;
+    }
+  }
+
+  // Vérifier si la route actuelle est protégée
+  const isProtectedRoute = protectedRoutes.some((route) => pathname.startsWith(route));
+
+  // Vérifier si la route est réservée aux admins
+  const isAdminRoute = adminRoutes.some((route) => pathname.startsWith(route));
+
+  // Vérifier si la route actuelle est une route d'auth
+  const isAuthRoute = authRoutes.some((route) => pathname.startsWith(route));
+
+  // Si l'utilisateur n'est pas connecté et tente d'accéder à une route protégée
+  if (!isAuthenticated && isProtectedRoute) {
+    const signInUrl = new URL('/signin', request.url);
+    signInUrl.searchParams.set('callbackUrl', pathname);
+    return NextResponse.redirect(signInUrl);
+  }
+
+  // Si l'utilisateur est connecté mais n'est pas admin et tente d'accéder à une route admin
+  if (isAuthenticated && isAdminRoute && !isAdmin(userRole || undefined)) {
+    return NextResponse.redirect(new URL('/dashboard', request.url));
+  }
+
+  // Si l'utilisateur est connecté et tente d'accéder aux pages d'auth
+  if (isAuthenticated && isAuthRoute) {
+    return NextResponse.redirect(new URL('/dashboard', request.url));
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: [
+    /*
+     * Match all request paths except for the ones starting with:
+     * - api (API routes)
+     * - _next/static (static files)
+     * - _next/image (image optimization files)
+     * - favicon.ico (favicon file)
+     */
+    '/((?!api|_next/static|_next/image|favicon.ico).*)',
+  ],
+};

package/template/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}

package/template/vercel.json

@@ -0,0 +1,8 @@
+{
+  "crons": [
+    {
+      "path": "/api/workflows/process",
+      "schedule": "* * * * *"
+    }
+  ]
+}