create-crm-tmp 2.0.0 → 2.1.0

package/template/src/contexts/task-reminder-context.tsx

@@ -1,20 +1,23 @@
 'use client';
 
-import React, { createContext, useContext, useEffect, useRef, useState } from 'react';
+import React, { createContext, useContext, useEffect, useMemo, useRef, useState } from 'react';
 import { useSession } from '@/lib/auth-client';
-import { useUserRole } from '@/hooks/use-user-role';
-import Link from 'next/link';
-import { Bell, X } from 'lucide-react';
+import { useAppToast } from '@/contexts/app-toast-context';
+import { REMINDERS_POLL_INTERVAL_MS, REMINDERS_REFRESH_EVENT } from '@/lib/reminder-state';
 
-type Task = {
+type Reminder = {
   id: string;
-  type: 'CALL' | 'MEETING' | 'EMAIL' | 'OTHER';
+  kind: 'due' | 'reminder';
+  type: 'CALL' | 'MEETING' | 'EMAIL' | 'OTHER' | 'VIDEO_CONFERENCE';
   title: string | null;
   description: string;
   priority: 'LOW' | 'MEDIUM' | 'HIGH' | 'URGENT';
   scheduledAt: string;
-  completed: boolean;
-  reminderMinutesBefore?: number | null;
+  reminderTime: string;
+  reminderMinutesBefore: number | null;
+  isRead: boolean;
+  isDismissed: boolean;
+  isClearedByCutoff: boolean;
   contact: {
     id: string;
     firstName: string | null;
@@ -31,11 +34,12 @@ type TaskReminderContextValue = {
 
 const TaskReminderContext = createContext<TaskReminderContextValue | undefined>(undefined);
 
-const TASK_TYPE_LABELS: Record<Task['type'], string> = {
+const TASK_TYPE_LABELS: Record<Reminder['type'], string> = {
   CALL: 'Appel téléphonique',
   MEETING: 'RDV',
   EMAIL: 'Email',
   OTHER: 'Autre',
+  VIDEO_CONFERENCE: 'Google Meet',
 };
 
 function formatTime(dateString: string) {
@@ -45,189 +49,159 @@ function formatTime(dateString: string) {
   });
 }
 
-export function TaskReminderProvider({ children }: { children: React.ReactNode }) {
+export function TaskReminderProvider({ children }: Readonly<{ children: React.ReactNode }>) {
   const { data: session } = useSession();
-  const { isAdmin } = useUserRole();
-  const [tasks, setTasks] = useState<Task[]>([]);
+  const toast = useAppToast();
+  const [reminders, setReminders] = useState<Reminder[]>([]);
   const [notifications, setNotifications] = useState<Notification[]>([]);
-  const notifiedKeysRef = useRef<Set<string>>(new Set());
+  const activeToastIdsRef = useRef<Map<string, string>>(new Map());
+
+  const markReminderState = async (reminderId: string, status: 'READ' | 'DISMISSED') => {
+    try {
+      await fetch('/api/reminders/state', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ reminderId, status }),
+      });
+    } catch (error) {
+      console.error("Erreur lors de la synchronisation de l'état du rappel:", error);
+    }
+  };
 
-  // Charger les tâches pertinentes pour les rappels
+  // Charger les rappels synchronisés avec le backend (polling + onglet + refresh explicite)
   useEffect(() => {
     if (!session) return;
 
-    const fetchTasks = async () => {
+    const fetchReminders = async () => {
       try {
-        const now = new Date();
-        const start = new Date(now);
-        start.setDate(start.getDate() - 1); // hier
-        const end = new Date(now);
-        end.setDate(end.getDate() + 1); // demain
-
-        const params = new URLSearchParams({
-          startDate: start.toISOString(),
-          endDate: end.toISOString(),
-        });
-
-        const response = await fetch(`/api/tasks?${params.toString()}`);
+        const response = await fetch('/api/reminders');
         if (response.ok) {
-          const data = await response.json();
-          setTasks(data);
+          const data = (await response.json()) as Reminder[];
+          setReminders(data);
         }
       } catch (error) {
-        console.error('Erreur lors du chargement des tâches pour les rappels:', error);
+        console.error('Erreur lors du chargement des rappels:', error);
       }
     };
 
-    fetchTasks();
-    const interval = setInterval(fetchTasks, 5 * 60 * 1000); // rafraîchir toutes les 5 min
-    return () => clearInterval(interval);
-  }, [session, isAdmin]);
+    void fetchReminders();
+    const interval = setInterval(fetchReminders, REMINDERS_POLL_INTERVAL_MS);
+
+    const onVisible = () => {
+      if (document.visibilityState === 'visible') {
+        void fetchReminders();
+      }
+    };
+    const onRefresh = () => void fetchReminders();
+
+    document.addEventListener('visibilitychange', onVisible);
+    globalThis.addEventListener(REMINDERS_REFRESH_EVENT, onRefresh);
+    return () => {
+      clearInterval(interval);
+      document.removeEventListener('visibilitychange', onVisible);
+      globalThis.removeEventListener(REMINDERS_REFRESH_EVENT, onRefresh);
+    };
+  }, [session]);
 
-  // Supprimer les notifications des tâches qui n'existent plus
+  // Afficher/retirer les toasts selon la source reminders + états read/dismissed
   useEffect(() => {
     if (!session) return;
 
-    const taskIds = new Set(tasks.map((task) => task.id));
-    setNotifications((prev) =>
-      prev.filter((notif) => {
-        // Extraire l'ID de la tâche depuis l'ID de la notification
-        // Format: `${task.id}-due` ou `${task.id}-reminder`
-        let taskId: string;
-        if (notif.id.endsWith('-due')) {
-          taskId = notif.id.slice(0, -4); // Retirer '-due'
-        } else if (notif.id.endsWith('-reminder')) {
-          taskId = notif.id.slice(0, -9); // Retirer '-reminder'
-        } else {
-          // Format inattendu, on garde la notification pour éviter de la supprimer par erreur
-          return true;
-        }
-        return taskIds.has(taskId);
-      }),
-    );
-
-    // Nettoyer aussi les clés de notification des tâches supprimées
-    const validKeys = new Set<string>();
-    tasks.forEach((task) => {
-      validKeys.add(`${task.id}-due`);
-      validKeys.add(`${task.id}-reminder`);
+    const activeReminderIds = new Set<string>();
+    const visibleNotifications: Notification[] = [];
+
+    reminders.forEach((reminder) => {
+      if (reminder.isDismissed || reminder.isRead || reminder.isClearedByCutoff) return;
+      activeReminderIds.add(reminder.id);
+      const notification: Notification = {
+        id: reminder.id,
+        message:
+          reminder.kind === 'due'
+            ? `Vous avez une tâche maintenant : ${
+                reminder.title || TASK_TYPE_LABELS[reminder.type]
+              } (${formatTime(reminder.scheduledAt)})`
+            : `Rappel dans ${reminder.reminderMinutesBefore} min : ${
+                reminder.title || TASK_TYPE_LABELS[reminder.type]
+              } (${formatTime(reminder.scheduledAt)})`,
+        link: reminder.contact ? `/contacts/${reminder.contact.id}` : undefined,
+      };
+      visibleNotifications.push(notification);
+
+      if (activeToastIdsRef.current.has(reminder.id)) return;
+      const toastId = toast.persistent(reminder.kind === 'due' ? 'warning' : 'info', notification.message, {
+        actionLink: notification.link,
+        actionLabel: notification.link ? 'Ouvrir le contact' : undefined,
+        onDismiss: () => {
+          activeToastIdsRef.current.delete(reminder.id);
+          setNotifications((prev) => prev.filter((n) => n.id !== reminder.id));
+          void markReminderState(reminder.id, 'DISMISSED');
+        },
+      });
+      activeToastIdsRef.current.set(reminder.id, toastId);
     });
-    notifiedKeysRef.current = new Set(
-      Array.from(notifiedKeysRef.current).filter((key) => validKeys.has(key)),
-    );
-  }, [tasks, session]);
 
-  // Génération des notifications
-  useEffect(() => {
-    if (!session) return;
+    // Si un rappel a disparu de la source serveur (clear-all, read, etc), on ferme le toast lié.
+    Array.from(activeToastIdsRef.current.entries()).forEach(([reminderId, toastId]) => {
+      if (activeReminderIds.has(reminderId)) return;
+      toast.dismissById(toastId);
+      activeToastIdsRef.current.delete(reminderId);
+    });
 
-    const interval = setInterval(() => {
-      const now = new Date();
-      const newNotifications: Notification[] = [];
-      const notified = new Set(notifiedKeysRef.current);
-
-      tasks.forEach((task) => {
-        if (task.completed) return;
-        const scheduled = new Date(task.scheduledAt);
-
-        // Notification à l'heure exacte de la tâche (fenêtre de 5 minutes)
-        const dueKey = `${task.id}-due`;
-        const diffMs = now.getTime() - scheduled.getTime();
-        if (diffMs >= 0 && diffMs < 5 * 60 * 1000 && !notified.has(dueKey)) {
-          notified.add(dueKey);
-          newNotifications.push({
-            id: dueKey,
-            message: `Vous avez une tâche maintenant : ${
-              task.title || TASK_TYPE_LABELS[task.type]
-            } (${formatTime(task.scheduledAt)})`,
-            link: task.contact ? `/contacts/${task.contact.id}` : undefined,
-          });
-        }
+    setNotifications(visibleNotifications);
+  }, [reminders, session, toast]);
 
-        // Notification de rappel avant l'heure
-        if (task.reminderMinutesBefore != null && task.reminderMinutesBefore > 0) {
-          const reminderMs = task.reminderMinutesBefore * 60 * 1000;
-          const reminderTime = new Date(scheduled.getTime() - reminderMs);
-          const reminderKey = `${task.id}-reminder`;
-          const diffReminderMs = now.getTime() - reminderTime.getTime();
-
-          if (
-            diffReminderMs >= 0 &&
-            diffReminderMs < 5 * 60 * 1000 &&
-            now < scheduled &&
-            !notified.has(reminderKey)
-          ) {
-            notified.add(reminderKey);
-            newNotifications.push({
-              id: reminderKey,
-              message: `Rappel dans ${task.reminderMinutesBefore} min : ${
-                task.title || TASK_TYPE_LABELS[task.type]
-              } (${formatTime(task.scheduledAt)})`,
-              link: task.contact ? `/contacts/${task.contact.id}` : undefined,
-            });
-          }
-        }
+  // Réagir au clear-all lancé depuis la cloche
+  useEffect(() => {
+    const handleRemindersCleared = () => {
+      Array.from(activeToastIdsRef.current.values()).forEach((toastId) => {
+        toast.dismissById(toastId);
       });
+      activeToastIdsRef.current.clear();
+      setNotifications([]);
+      setReminders([]);
+    };
 
-      if (newNotifications.length > 0) {
-        setNotifications((prev) => [...prev, ...newNotifications]);
-        notifiedKeysRef.current = notified;
+    globalThis.addEventListener('reminders:cleared', handleRemindersCleared as EventListener);
+    return () => {
+      globalThis.removeEventListener('reminders:cleared', handleRemindersCleared as EventListener);
+    };
+  }, [toast]);
 
-        // Faire disparaître automatiquement les nouvelles notifications après 5 secondes
-        newNotifications.forEach((notif) => {
-          setTimeout(() => {
-            setNotifications((prev) => prev.filter((n) => n.id !== notif.id));
-          }, 5000);
-        });
+  useEffect(() => {
+    const handleReminderRead = (event: Event) => {
+      const customEvent = event as CustomEvent<{ reminderId?: string }>;
+      const reminderId = customEvent.detail?.reminderId;
+      if (!reminderId) return;
+      const toastId = activeToastIdsRef.current.get(reminderId);
+      if (toastId) {
+        toast.dismissById(toastId);
+        activeToastIdsRef.current.delete(reminderId);
       }
-    }, 60 * 1000); // vérif toutes les minutes
+      setNotifications((prev) => prev.filter((n) => n.id !== reminderId));
+    };
 
-    return () => clearInterval(interval);
-  }, [tasks, session]);
+    globalThis.addEventListener('reminders:read', handleReminderRead as EventListener);
+    return () => {
+      globalThis.removeEventListener('reminders:read', handleReminderRead as EventListener);
+    };
+  }, [toast]);
 
   const dismissNotification = (id: string) => {
+    const toastId = activeToastIdsRef.current.get(id);
+    if (toastId) {
+      toast.dismissById(toastId);
+      activeToastIdsRef.current.delete(id);
+    }
     setNotifications((prev) => prev.filter((n) => n.id !== id));
+    void markReminderState(id, 'DISMISSED');
   };
 
-  return (
-    <TaskReminderContext.Provider value={{ notifications, dismissNotification }}>
-      {children}
-      {notifications.length > 0 && (
-        <div className="pointer-events-none fixed right-4 bottom-4 z-50 space-y-3">
-          {notifications.map((notif) => (
-            <div
-              key={notif.id}
-              className="pointer-events-auto flex max-w-sm items-start gap-3 rounded-xl border border-blue-200 bg-card p-4 shadow-(--shadow-dropdown)"
-            >
-              <div className="mt-0.5 rounded-full bg-blue-100 p-2 text-blue-700">
-                <Bell className="h-4 w-4" />
-              </div>
-              <div className="flex-1">
-                <p className="text-sm font-medium text-foreground">Rappel de tâche</p>
-                <p className="mt-1 text-sm text-muted-foreground">{notif.message}</p>
-                {notif.link && (
-                  <Link
-                    href={notif.link}
-                    className="mt-2 inline-flex text-xs font-medium text-blue-700 hover:text-blue-800"
-                  >
-                    Ouvrir le contact
-                  </Link>
-                )}
-              </div>
-              <button
-                type="button"
-                onClick={() => dismissNotification(notif.id)}
-                className="ml-2 inline-flex h-6 w-6 cursor-pointer items-center justify-center rounded-full text-muted-foreground hover:bg-muted hover:text-foreground"
-              >
-                <span className="sr-only">Fermer</span>
-                <X />
-              </button>
-            </div>
-          ))}
-        </div>
-      )}
-    </TaskReminderContext.Provider>
+  const contextValue = useMemo(
+    () => ({ notifications, dismissNotification }),
+    [notifications],
   );
+
+  return <TaskReminderContext.Provider value={contextValue}>{children}</TaskReminderContext.Provider>;
 }
 
 export function useTaskReminders() {

package/template/src/contexts/view-as-context.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import React, { createContext, useContext, useState } from 'react';
+import React, { createContext, useContext, useState, useEffect } from 'react';
 import {
   safeLocalStorageGet,
   safeLocalStorageSet,
@@ -29,9 +29,35 @@ interface ViewAsContextType {
 const ViewAsContext = createContext<ViewAsContextType | undefined>(undefined);
 
 export function ViewAsProvider({ children }: { children: React.ReactNode }) {
-  const [viewAsUser, setViewAsUserState] = useState<User | null>(() =>
-    safeLocalStorageGet<User | null>('viewAsUser', null),
-  );
+  const [viewAsUser, setViewAsUserState] = useState<User | null>(null);
+
+  // On mount, check if a viewAsUserId is stored and fetch the full user data
+  useEffect(() => {
+    const storedUserId = safeLocalStorageGet<string | null>(
+      'viewAsUserId',
+      null,
+    );
+    if (storedUserId) {
+      fetch('/api/users/list')
+        .then((res) => (res.ok ? res.json() : Promise.reject()))
+        .then((users: User[]) => {
+          const found = users.find((u) => u.id === storedUserId);
+          if (found) {
+            setViewAsUserState({
+              ...found,
+              permissions: found.customRole?.permissions || [],
+            });
+          } else {
+            // User no longer exists or is inaccessible — clear stale ID
+            safeLocalStorageRemove('viewAsUserId');
+          }
+        })
+        .catch(() => {
+          // API error — clear stale ID to avoid broken state
+          safeLocalStorageRemove('viewAsUserId');
+        });
+    }
+  }, []);
 
   const setViewAsUser = (user: User | null) => {
     // Si l'utilisateur a un customRole, copier les permissions dans un champ direct pour faciliter l'accès
@@ -44,9 +70,10 @@ export function ViewAsProvider({ children }: { children: React.ReactNode }) {
 
     setViewAsUserState(userWithPermissions);
     if (userWithPermissions) {
-      safeLocalStorageSet('viewAsUser', userWithPermissions);
+      // Only persist the user ID — never store permissions in localStorage
+      safeLocalStorageSet('viewAsUserId', userWithPermissions.id);
     } else {
-      safeLocalStorageRemove('viewAsUser');
+      safeLocalStorageRemove('viewAsUserId');
     }
   };
 

package/template/src/hooks/use-focus-trap.ts

@@ -7,7 +7,7 @@ const FOCUSABLE_SELECTOR =
 
 function getFocusables(container: HTMLElement): HTMLElement[] {
   return Array.from(container.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)).filter(
-    (el) => !el.hasAttribute('disabled') && el.offsetParent !== null
+    (el) => !el.hasAttribute('disabled') && el.offsetParent !== null,
   );
 }
 
@@ -18,7 +18,7 @@ export function useFocusTrap(
     onClose?: () => void;
     initialFocusRef?: React.RefObject<HTMLElement | null>;
     skipInitialFocus?: boolean;
-  }
+  },
 ) {
   const prevFocusRef = useRef<HTMLElement | null>(null);
   const onCloseRef = useRef(options?.onClose);

package/template/src/hooks/useIntegrationNotifications.ts

@@ -0,0 +1,49 @@
+'use client';
+
+import { useEffect, useRef } from 'react';
+import { useUserRole } from '@/hooks/use-user-role';
+
+const POLL_INTERVAL_MS = 30_000;
+
+/**
+ * Polls integration import notifications for admins (e.g. background imports).
+ * Toasts have been removed to avoid accumulation on the page.
+ */
+export function useIntegrationNotifications() {
+  const { isAdmin } = useUserRole();
+  const lastPollRef = useRef<string>(new Date().toISOString());
+  const mountedRef = useRef(true);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!isAdmin) return;
+
+    const poll = async () => {
+      const since = lastPollRef.current;
+      try {
+        const res = await fetch(
+          `/api/settings/integrations/notifications?since=${encodeURIComponent(since)}`,
+        );
+        if (!mountedRef.current) return;
+        await res.json();
+        lastPollRef.current = new Date().toISOString();
+      } catch {
+        // Ignore errors (e.g. network), next poll will retry
+      }
+    };
+
+    const interval = setInterval(poll, POLL_INTERVAL_MS);
+    const timeout = setTimeout(poll, 5000);
+
+    return () => {
+      clearInterval(interval);
+      clearTimeout(timeout);
+    };
+  }, [isAdmin]);
+}

package/template/src/lib/auth.ts

@@ -12,9 +12,16 @@ export const auth = betterAuth({
   database: prismaAdapter(prisma, {
     provider: 'postgresql',
   }),
+  // Désactivé pour que la révocation des sessions (deleteMany) soit effective immédiatement.
+  // Avec le cache cookie JWE par défaut, get-session peut ignorer la base tant que le cookie est valide.
+  session: {
+    cookieCache: {
+      enabled: false,
+    },
+  },
   emailAndPassword: {
     enabled: true,
-    minPasswordLength: 6,
+    minPasswordLength: 12,
     password: {
       hash(password) {
         return hashPassword(password);

package/template/src/lib/config-links.ts

@@ -0,0 +1,14 @@
+/**
+ * Liens vers les sections de configuration dans les paramètres.
+ * Utilisés pour rediriger l'utilisateur quand une action nécessite une config manquante.
+ */
+export const CONFIG_LINKS = {
+  /** Configuration SMTP (Paramètres Système) */
+  smtp: '/settings?section=system',
+  /** Google Calendar & Meet (Intégrations) */
+  googleCalendar: '/settings?section=integrations',
+  /** Google Sheets (Intégrations) */
+  googleSheet: '/settings?section=integrations',
+} as const;
+
+export type ConfigType = keyof typeof CONFIG_LINKS;

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

@@ -1,5 +1,83 @@
 import { prisma } from '@/lib/prisma';
 
+async function getOrCreateDuplicateStatus(db: any) {
+  let duplicateStatus = await db.status.findUnique({
+    where: { name: 'Doublon' },
+  });
+
+  if (duplicateStatus && !duplicateStatus.isSystem) {
+    duplicateStatus = await db.status.update({
+      where: { id: duplicateStatus.id },
+      data: { isSystem: true },
+    });
+  }
+
+  if (!duplicateStatus) {
+    const lastStatus = await db.status.findFirst({
+      orderBy: { order: 'desc' },
+    });
+    const newOrder = lastStatus ? lastStatus.order + 1 : 100;
+
+    duplicateStatus = await db.status.create({
+      data: {
+        name: 'Doublon',
+        color: '#EF4444',
+        order: newOrder,
+        isSystem: true,
+      },
+    });
+  }
+
+  return duplicateStatus;
+}
+
+export async function markContactAsDuplicate(
+  contactId: string,
+  origin: string | null | undefined,
+  userId: string,
+  db: any = prisma,
+): Promise<void> {
+  const duplicateStatus = await getOrCreateDuplicateStatus(db);
+
+  const duplicateCount = await db.interaction.count({
+    where: {
+      contactId,
+      type: 'NOTE',
+      title: 'Contact enregistré à nouveau',
+    },
+  });
+
+  const occurrenceNumber = duplicateCount + 2; // +2 car c'est la 2ème fois minimum
+
+  await db.contact.update({
+    where: { id: contactId },
+    data: {
+      statusId: duplicateStatus.id,
+      updatedAt: new Date(),
+    },
+  });
+
+  await db.interaction.create({
+    data: {
+      contactId,
+      type: 'NOTE',
+      title: 'Contact enregistré à nouveau',
+      content: `Ce contact a été enregistré une ${occurrenceNumber}${occurrenceNumber === 1 ? 'ère' : 'ème'} fois${origin ? ` depuis ${origin}` : ''} le ${new Date().toLocaleDateString(
+        'fr-FR',
+        {
+          day: 'numeric',
+          month: 'long',
+          year: 'numeric',
+          hour: '2-digit',
+          minute: '2-digit',
+        },
+      )}.`,
+      userId: userId,
+      date: new Date(),
+    },
+  });
+}
+
 /**
  * Détecte et gère les doublons de contacts basés sur nom, prénom ET email
  * Si un doublon est trouvé :
@@ -46,67 +124,7 @@ export async function handleContactDuplicate(
     return null;
   }
 
-  // Récupérer ou créer le statut "Doublon"
-  let duplicateStatus = await prisma.status.findUnique({
-    where: { name: 'Doublon' },
-  });
-
-  if (!duplicateStatus) {
-    // Créer le statut Doublon s'il n'existe pas
-    const lastStatus = await prisma.status.findFirst({
-      orderBy: { order: 'desc' },
-    });
-    const newOrder = lastStatus ? lastStatus.order + 1 : 100;
-
-    duplicateStatus = await prisma.status.create({
-      data: {
-        name: 'Doublon',
-        color: '#EF4444', // Rouge pour indiquer un problème
-        order: newOrder,
-      },
-    });
-  }
-
-  // Compter combien de fois ce contact a été enregistré (en comptant les notes "Contact enregistré à nouveau")
-  const duplicateCount = await prisma.interaction.count({
-    where: {
-      contactId: existingContact.id,
-      type: 'NOTE',
-      title: 'Contact enregistré à nouveau',
-    },
-  });
-
-  const occurrenceNumber = duplicateCount + 2; // +2 car c'est la 2ème fois minimum (1ère création + cette fois)
-
-  // Mettre à jour le contact : changer le statut en Doublon et mettre à jour updatedAt
-  await prisma.contact.update({
-    where: { id: existingContact.id },
-    data: {
-      statusId: duplicateStatus.id,
-      updatedAt: new Date(), // Pour remonter le contact en haut du tableau
-    },
-  });
-
-  // Ajouter une note indiquant que le contact a été enregistré une énième fois
-  await prisma.interaction.create({
-    data: {
-      contactId: existingContact.id,
-      type: 'NOTE',
-      title: 'Contact enregistré à nouveau',
-      content: `Ce contact a été enregistré une ${occurrenceNumber}${occurrenceNumber === 1 ? 'ère' : 'ème'} fois${origin ? ` depuis ${origin}` : ''} le ${new Date().toLocaleDateString(
-        'fr-FR',
-        {
-          day: 'numeric',
-          month: 'long',
-          year: 'numeric',
-          hour: '2-digit',
-          minute: '2-digit',
-        },
-      )}.`,
-      userId: userId,
-      date: new Date(),
-    },
-  });
+  await markContactAsDuplicate(existingContact.id, origin, userId, prisma);
 
   return existingContact.id;
 }