create-crm-tmp 1.0.0

package/template/src/lib/contact-interactions.ts

@@ -0,0 +1,371 @@
+import { prisma } from '@/lib/prisma';
+import { InteractionType } from '../../generated/prisma/client';
+
+interface CreateInteractionParams {
+  contactId: string;
+  type: InteractionType;
+  title?: string | null;
+  content: string;
+  userId: string;
+  date?: Date | null;
+  metadata?: Record<string, any>;
+}
+
+/**
+ * Crée une interaction pour un contact
+ */
+export async function createInteraction(params: CreateInteractionParams) {
+  const { contactId, type, title, content, userId, date, metadata } = params;
+
+  return await prisma.interaction.create({
+    data: {
+      contactId,
+      type,
+      title: title ?? null,
+      content,
+      userId,
+      date: date ?? null,
+      metadata: metadata ?? undefined,
+    },
+  });
+}
+
+/**
+ * Crée une interaction pour un changement de statut
+ */
+export async function logStatusChange(
+  contactId: string,
+  oldStatusId: string | null,
+  newStatusId: string | null,
+  userId: string,
+  oldStatusName?: string | null,
+  newStatusName?: string | null,
+) {
+  const oldStatus = oldStatusName || 'Aucun';
+  const newStatus = newStatusName || 'Aucun';
+
+  return await createInteraction({
+    contactId,
+    type: 'STATUS_CHANGE',
+    title: 'Changement de statut',
+    content: `Statut modifié de "${oldStatus}" à "${newStatus}"`,
+    userId,
+    metadata: {
+      oldStatusId,
+      newStatusId,
+      oldStatusName,
+      newStatusName,
+    },
+  });
+}
+
+/**
+ * Crée une interaction pour une mise à jour de contact
+ */
+export async function logContactUpdate(
+  contactId: string,
+  changes: Record<string, { old: any; new: any }>,
+  userId: string,
+) {
+  const changeDescriptions: string[] = [];
+
+  for (const [field, { old, new: newValue }] of Object.entries(changes)) {
+    const fieldNames: Record<string, string> = {
+      firstName: 'Prénom',
+      lastName: 'Nom',
+      phone: 'Téléphone',
+      secondaryPhone: 'Téléphone secondaire',
+      email: 'Email',
+      address: 'Adresse',
+      city: 'Ville',
+      postalCode: 'Code postal',
+      civility: 'Civilité',
+      origin: 'Origine',
+      companyName: 'Entreprise',
+      closingReason: 'Motif de fermeture',
+    };
+
+    const fieldName = fieldNames[field] || field;
+    // Normaliser les valeurs : null, undefined et chaînes vides sont considérés comme équivalents
+    const normalize = (value: any) => {
+      if (value === null || value === undefined) return null;
+      if (typeof value === 'string' && value.trim() === '') return null;
+      return value;
+    };
+
+    const oldNorm = normalize(old);
+    const newNorm = normalize(newValue);
+
+    // Si après normalisation il n'y a pas de vraie différence, on ignore ce champ
+    if (oldNorm === newNorm) {
+      continue;
+    }
+
+    const formatValue = (value: any) => {
+      if (value === null || value === undefined) return 'Aucun';
+      return String(value);
+    };
+
+    const oldValueStr = formatValue(oldNorm);
+    const newValueStr = formatValue(newNorm);
+
+    if (oldValueStr !== newValueStr) {
+      changeDescriptions.push(`${fieldName}: "${oldValueStr}" → "${newValueStr}"`);
+    }
+  }
+
+  if (changeDescriptions.length === 0) {
+    return null;
+  }
+
+  return await createInteraction({
+    contactId,
+    type: 'CONTACT_UPDATE',
+    title: 'Modification de la fiche contact',
+    content: changeDescriptions.join('\n'),
+    userId,
+    metadata: { changes },
+  });
+}
+
+/**
+ * Crée une interaction pour un changement d'assignation
+ */
+export async function logAssignmentChange(
+  contactId: string,
+  type: 'COMMERCIAL' | 'TELEPRO',
+  oldUserId: string | null,
+  newUserId: string | null,
+  userId: string,
+  oldUserName?: string | null,
+  newUserName?: string | null,
+) {
+  // Normaliser les valeurs pour la comparaison (null, undefined, '' sont considérés comme équivalents)
+  const normalizedOldUserId = oldUserId || null;
+  const normalizedNewUserId = newUserId || null;
+
+  // Ne créer l'interaction que si les valeurs ont réellement changé
+  if (normalizedOldUserId === normalizedNewUserId) {
+    return null;
+  }
+
+  const roleName = type === 'COMMERCIAL' ? 'Commercial' : 'Télépro';
+  const oldName = oldUserName || 'Non attribué';
+  const newName = newUserName || 'Non attribué';
+
+  return await createInteraction({
+    contactId,
+    type: 'ASSIGNMENT_CHANGE',
+    title: `Changement d'assignation ${roleName}`,
+    content: `${roleName} modifié de "${oldName}" à "${newName}"`,
+    userId,
+    metadata: {
+      assignmentType: type,
+      oldUserId,
+      newUserId,
+      oldUserName,
+      newUserName,
+    },
+  });
+}
+
+/**
+ * Crée une interaction pour la création d'un rendez-vous
+ */
+export async function logAppointmentCreated(
+  contactId: string,
+  taskId: string,
+  scheduledAt: Date,
+  title: string | null,
+  userId: string,
+) {
+  const formattedDate = scheduledAt.toLocaleDateString('fr-FR', {
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+
+  return await createInteraction({
+    contactId,
+    type: 'APPOINTMENT_CREATED',
+    title: title ?? null, // Enregistrer seulement le titre
+    content: `Rendez-vous programmé le ${formattedDate}`,
+    userId,
+    date: scheduledAt,
+    metadata: {
+      taskId,
+      scheduledAt: scheduledAt.toISOString(),
+    },
+  });
+}
+
+/**
+ * Crée une interaction pour l'annulation d'un rendez-vous
+ */
+export async function logAppointmentCancelled(
+  contactId: string,
+  taskId: string,
+  scheduledAt: Date,
+  title: string | null,
+  userId: string,
+  isGoogleMeet: boolean = false,
+) {
+  const formattedDate = scheduledAt.toLocaleDateString('fr-FR', {
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+
+  const appointmentType = isGoogleMeet ? 'Google Meet' : 'Rendez-vous';
+
+  return await createInteraction({
+    contactId,
+    type: 'APPOINTMENT_DELETED',
+    title: title ?? null, // Enregistrer seulement le titre
+    content: `${appointmentType} prévu le ${formattedDate} a été annulé.`,
+    userId,
+    date: scheduledAt,
+    metadata: {
+      taskId,
+      scheduledAt: scheduledAt.toISOString(),
+      cancelled: true,
+      isGoogleMeet,
+    },
+  });
+}
+
+/**
+ * Crée une interaction pour la modification d'un rendez-vous
+ */
+export async function logAppointmentChanged(
+  contactId: string,
+  taskId: string,
+  scheduledAt: Date,
+  title: string | null,
+  userId: string,
+  isGoogleMeet: boolean = false,
+) {
+  const formattedDate = scheduledAt.toLocaleDateString('fr-FR', {
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+
+  const appointmentType = isGoogleMeet ? 'Google Meet' : 'Rendez-vous';
+
+  return await createInteraction({
+    contactId,
+    type: 'APPOINTMENT_CHANGED',
+    title: title ?? null, // Enregistrer seulement le titre
+    content: `${appointmentType} programmé le ${formattedDate} a été modifié.`,
+    userId,
+    date: scheduledAt,
+    metadata: {
+      taskId,
+      scheduledAt: scheduledAt.toISOString(),
+      isGoogleMeet,
+    },
+  });
+}
+
+/**
+ * Crée une interaction pour l'upload d'un fichier
+ */
+export async function logFileUploaded(
+  contactId: string,
+  fileId: string,
+  fileName: string,
+  fileSize: number,
+  userId: string,
+) {
+  const formatFileSize = (bytes: number): string => {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+  };
+
+  return await createInteraction({
+    contactId,
+    type: 'FILE_UPLOADED',
+    title: null,
+    content: `Fichier "${fileName}" (${formatFileSize(fileSize)}) ajouté`,
+    userId,
+    metadata: {
+      fileId,
+      fileName,
+      fileSize,
+    },
+  });
+}
+
+/**
+ * Crée une interaction pour le remplacement d'un fichier (doublon)
+ */
+export async function logFileReplaced(
+  contactId: string,
+  fileId: string,
+  fileName: string,
+  fileSize: number,
+  userId: string,
+) {
+  const formatFileSize = (bytes: number): string => {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+  };
+
+  return await createInteraction({
+    contactId,
+    type: 'FILE_REPLACED',
+    title: null,
+    content: `Fichier "${fileName}" (${formatFileSize(fileSize)}) remplacé`,
+    userId,
+    metadata: {
+      fileId,
+      fileName,
+      fileSize,
+      replaced: true,
+    },
+  });
+}
+
+/**
+ * Crée une interaction pour la suppression d'un fichier
+ */
+export async function logFileDeleted(
+  contactId: string,
+  fileName: string,
+  fileSize: number,
+  userId: string,
+) {
+  const formatFileSize = (bytes: number): string => {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+  };
+
+  return await createInteraction({
+    contactId,
+    type: 'FILE_DELETED',
+    title: null,
+    content: `Fichier "${fileName}" (${formatFileSize(fileSize)}) supprimé`,
+    userId,
+    metadata: {
+      fileName,
+      fileSize,
+      deleted: true,
+    },
+  });
+}

package/template/src/lib/encryption.ts

@@ -0,0 +1,99 @@
+import crypto from 'crypto';
+
+const ALGORITHM = 'aes-256-gcm';
+const IV_LENGTH = 16; // 128 bits
+
+// Récupérer la clé depuis les variables d'environnement
+function getEncryptionKey(): Buffer | null {
+  const key = process.env.ENCRYPTION_KEY;
+  if (!key) {
+    console.warn("⚠️  ENCRYPTION_KEY n'est pas définie. Le chiffrement ne sera pas utilisé.");
+    return null;
+  }
+
+  // Si la clé est en hexadécimal, la convertir
+  if (key.length === 64) {
+    return Buffer.from(key, 'hex');
+  }
+
+  // Sinon, utiliser directement (mais ce n'est pas recommandé)
+  // On génère un hash pour avoir exactement 32 bytes
+  return crypto.createHash('sha256').update(key).digest();
+}
+
+/**
+ * Chiffre un texte avec AES-256-GCM
+ * @param text - Le texte à chiffrer
+ * @returns Le texte chiffré au format: iv:tag:encrypted (ou texte en clair si ENCRYPTION_KEY n'est pas définie)
+ */
+export function encrypt(text: string): string {
+  if (!text) {
+    return text;
+  }
+
+  const key = getEncryptionKey();
+
+  // Si la clé n'est pas définie, retourner le texte en clair (avec un avertissement)
+  if (!key) {
+    console.warn(
+      '⚠️  Chiffrement désactivé : ENCRYPTION_KEY non définie. Le mot de passe sera stocké en clair.',
+    );
+    return text;
+  }
+
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+
+  let encrypted = cipher.update(text, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+
+  const tag = cipher.getAuthTag();
+
+  // Retourner: iv:tag:encrypted
+  return iv.toString('hex') + ':' + tag.toString('hex') + ':' + encrypted;
+}
+
+/**
+ * Déchiffre un texte chiffré avec AES-256-GCM
+ * @param encryptedData - Le texte chiffré au format: iv:tag:encrypted
+ * @returns Le texte déchiffré
+ */
+export function decrypt(encryptedData: string): string {
+  if (!encryptedData) {
+    return encryptedData;
+  }
+
+  // Si le format ne correspond pas (ancien format non chiffré), retourner tel quel
+  const parts = encryptedData.split(':');
+  if (parts.length !== 3) {
+    // Probablement un ancien mot de passe non chiffré, retourner tel quel
+    // (pour la migration des données existantes)
+    return encryptedData;
+  }
+
+  try {
+    const key = getEncryptionKey();
+
+    // Si la clé n'est pas définie et que le texte est chiffré, on ne peut pas le déchiffrer
+    if (!key) {
+      console.warn('⚠️  Impossible de déchiffrer : ENCRYPTION_KEY non définie.');
+      return encryptedData;
+    }
+
+    const iv = Buffer.from(parts[0], 'hex');
+    const tag = Buffer.from(parts[1], 'hex');
+    const encrypted = parts[2];
+
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(tag);
+
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+
+    return decrypted;
+  } catch (error) {
+    // Si le déchiffrement échoue, retourner tel quel (pour la compatibilité)
+    console.error('Erreur lors du déchiffrement:', error);
+    return encryptedData;
+  }
+}