create-crm-tmp 1.0.0

package/template/src/hooks/use-user-role.ts

@@ -0,0 +1,82 @@
+'use client';
+
+import { useSession } from '@/lib/auth-client';
+import { useEffect, useState } from 'react';
+import { useViewAs } from '@/contexts/view-as-context';
+
+/**
+ * Hook personnalisé pour récupérer les permissions de l'utilisateur via son profil
+ * Les droits sont déterminés par le profil assigné, pas par un rôle
+ * Supporte le mode "vue en tant que" pour les admins
+ */
+export function useUserRole() {
+  const { data: session, isPending } = useSession();
+  const { viewAsUser, isViewingAsOther } = useViewAs();
+  const [permissions, setPermissions] = useState<string[]>([]);
+  const [realUserPermissions, setRealUserPermissions] = useState<string[]>([]); // Permissions de l'utilisateur réellement connecté
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    if (isPending) return;
+
+    if (!session?.user) {
+      setPermissions([]);
+      setRealUserPermissions([]);
+      setLoading(false);
+      return;
+    }
+
+    // Récupérer les permissions de l'utilisateur depuis l'API
+    const fetchUserPermissions = async () => {
+      try {
+        const response = await fetch('/api/users/me');
+        if (response.ok) {
+          const userData = await response.json();
+          const userPerms = (userData.customRole?.permissions as string[]) || [];
+
+          // Toujours stocker les permissions réelles de l'utilisateur connecté
+          setRealUserPermissions(userPerms);
+
+          // Si on est en mode "vue en tant que", utiliser les permissions de l'utilisateur visualisé
+          if (isViewingAsOther && viewAsUser?.permissions) {
+            setPermissions(viewAsUser.permissions);
+          } else {
+            setPermissions(userPerms);
+          }
+        } else {
+          setPermissions([]);
+          setRealUserPermissions([]);
+        }
+      } catch (error) {
+        console.error('Erreur lors de la récupération des permissions:', error);
+        setPermissions([]);
+        setRealUserPermissions([]);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchUserPermissions();
+  }, [session, isPending, isViewingAsOther, viewAsUser]);
+
+  // Helper pour vérifier une permission
+  const hasPermission = (permission: string) => permissions.includes(permission);
+  const hasRealPermission = (permission: string) => realUserPermissions.includes(permission);
+
+  return {
+    permissions,
+    realUserPermissions,
+    hasPermission,
+    hasRealPermission,
+    // Helpers de compatibilité basés sur les permissions
+    isAdmin: hasPermission('users.manage_roles'), // Admin = peut gérer les rôles
+    isRealAdmin: hasRealPermission('users.manage_roles'), // True seulement si l'utilisateur connecté peut gérer les rôles
+    isManager: hasPermission('users.view'), // Manager = peut voir les utilisateurs
+    isCommercial: hasPermission('contacts.view_own'), // Commercial = peut voir ses contacts
+    isTelepro: hasPermission('contacts.view_own'), // Télépro = peut voir ses contacts
+    isLoading: loading || isPending,
+    currentUserId: isViewingAsOther ? viewAsUser?.id : session?.user?.id,
+    // Rôle par défaut pour compatibilité
+    role: 'USER',
+  };
+}

package/template/src/lib/audit-log.ts

@@ -0,0 +1,45 @@
+import { prisma } from '@/lib/prisma';
+
+export type AuditEntityType = 'USER' | 'ROLE';
+
+export type AuditAction =
+  | 'USER_CREATED'
+  | 'USER_UPDATED'
+  | 'ROLE_CREATED'
+  | 'ROLE_UPDATED'
+  | 'ROLE_DELETED';
+
+interface LogAuditParams {
+  actorId?: string | null;
+  targetUserId?: string | null;
+  action: AuditAction;
+  entityType: AuditEntityType;
+  entityId?: string | null;
+  metadata?: Record<string, any>;
+}
+
+export async function logAudit({
+  actorId,
+  targetUserId,
+  action,
+  entityType,
+  entityId,
+  metadata,
+}: LogAuditParams) {
+  try {
+    await prisma.auditLog.create({
+      data: {
+        actorId: actorId || null,
+        targetUserId: targetUserId || null,
+        action,
+        entityType,
+        entityId: entityId || null,
+        metadata: metadata || undefined,
+      },
+    });
+  } catch (error) {
+    console.error('Erreur lors de la création du log d’audit:', error);
+  }
+}
+
+

package/template/src/lib/auth-client.ts

@@ -0,0 +1,16 @@
+import { createAuthClient } from 'better-auth/react';
+
+// Utiliser NEXT_PUBLIC_APP_URL si défini, sinon utiliser l'origine du navigateur
+// Cela permet de fonctionner automatiquement en production sans configuration supplémentaire
+const getBaseURL = () => {
+  if (typeof window !== 'undefined') {
+    return process.env.NEXT_PUBLIC_APP_URL || window.location.origin;
+  }
+  return process.env.NEXT_PUBLIC_APP_URL || process.env.BETTER_AUTH_URL || 'http://localhost:3000';
+};
+
+export const authClient = createAuthClient({
+  baseURL: getBaseURL(),
+});
+
+export const { signIn, signUp, signOut, useSession } = authClient;

package/template/src/lib/auth.ts

@@ -0,0 +1,35 @@
+import { betterAuth } from 'better-auth';
+import { prismaAdapter } from 'better-auth/adapters/prisma';
+import { prisma } from './prisma';
+import { hash, compare } from 'bcryptjs';
+
+export const hashPassword = (password: string) => hash(password, 10);
+
+export const auth = betterAuth({
+  baseURL:
+    process.env.BETTER_AUTH_URL || process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000',
+  basePath: '/api/auth',
+  database: prismaAdapter(prisma, {
+    provider: 'postgresql',
+  }),
+  emailAndPassword: {
+    enabled: true,
+    minPasswordLength: 6,
+    password: {
+      hash(password) {
+        return hashPassword(password);
+      },
+      verify(data) {
+        return compare(data.password, data.hash);
+      },
+    },
+  },
+  user: {
+    additionalFields: {
+      role: {
+        type: 'string',
+        required: false,
+      },
+    },
+  },
+});

package/template/src/lib/check-permission.ts

@@ -0,0 +1,193 @@
+import { auth } from '@/lib/auth';
+import { headers } from 'next/headers';
+import { prisma } from '@/lib/prisma';
+
+/**
+ * Vérifie si l'utilisateur actuel a une permission spécifique
+ * @param requiredPermission - Code de la permission à vérifier
+ * @returns true si l'utilisateur a la permission, false sinon
+ */
+export async function checkPermission(requiredPermission: string): Promise<boolean> {
+  try {
+    const session = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    if (!session) {
+      return false;
+    }
+
+    const userId = session.user.id;
+
+    // Récupérer l'utilisateur avec son profil personnalisé si applicable
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        customRole: true,
+      },
+    });
+
+    if (!user) {
+      return false;
+    }
+
+    // Les permissions viennent uniquement du profil assigné
+    if (!user.customRole) {
+      // Aucun profil assigné = aucune permission
+      return false;
+    }
+
+    const userPermissions = user.customRole.permissions as string[];
+
+    // Vérifier si la permission est dans la liste
+    return userPermissions.includes(requiredPermission);
+  } catch (error) {
+    console.error('Erreur lors de la vérification des permissions:', error);
+    return false;
+  }
+}
+
+/**
+ * Vérifie si l'utilisateur actuel a plusieurs permissions
+ * @param requiredPermissions - Tableau des codes de permissions à vérifier
+ * @param requireAll - Si true, toutes les permissions sont requises. Si false, au moins une est requise
+ * @returns true si l'utilisateur a les permissions, false sinon
+ */
+export async function checkPermissions(
+  requiredPermissions: string[],
+  requireAll: boolean = true,
+): Promise<boolean> {
+  try {
+    const session = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    if (!session) {
+      return false;
+    }
+
+    const userId = session.user.id;
+
+    // Récupérer l'utilisateur avec son profil personnalisé si applicable
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        customRole: true,
+      },
+    });
+
+    if (!user) {
+      return false;
+    }
+
+    // Les permissions viennent uniquement du profil assigné
+    if (!user.customRole) {
+      // Aucun profil assigné = aucune permission
+      return false;
+    }
+
+    const userPermissions = user.customRole.permissions as string[];
+
+    // Vérifier les permissions
+    if (requireAll) {
+      return requiredPermissions.every((perm) => userPermissions.includes(perm));
+    } else {
+      return requiredPermissions.some((perm) => userPermissions.includes(perm));
+    }
+  } catch (error) {
+    console.error('Erreur lors de la vérification des permissions:', error);
+    return false;
+  }
+}
+
+/**
+ * Récupère toutes les permissions de l'utilisateur actuel
+ * @returns Tableau des codes de permissions de l'utilisateur
+ */
+export async function getUserPermissions(): Promise<string[]> {
+  try {
+    const session = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    if (!session) {
+      return [];
+    }
+
+    const userId = session.user.id;
+
+    // Récupérer l'utilisateur avec son profil personnalisé si applicable
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        customRole: true,
+      },
+    });
+
+    if (!user) {
+      return [];
+    }
+
+    // Les permissions viennent uniquement du profil assigné
+    if (!user.customRole) {
+      // Aucun profil assigné = aucune permission
+      return [];
+    }
+
+    return user.customRole.permissions as string[];
+  } catch (error) {
+    console.error('Erreur lors de la récupération des permissions:', error);
+    return [];
+  }
+}
+
+/**
+ * Middleware pour protéger une route API avec des permissions
+ * Exemple d'utilisation :
+ *
+ * export async function GET(req: NextRequest) {
+ *   const hasPermission = await requirePermission('contacts.view_all');
+ *   if (!hasPermission) {
+ *     return NextResponse.json({ error: 'Non autorisé' }, { status: 403 });
+ *   }
+ *   // ... reste du code
+ * }
+ */
+export async function requirePermission(requiredPermission: string): Promise<boolean> {
+  return checkPermission(requiredPermission);
+}
+
+/**
+ * Helper pour vérifier si un utilisateur est admin
+ * Un admin est un utilisateur avec un profil ayant toutes les permissions
+ */
+export async function isAdmin(): Promise<boolean> {
+  try {
+    const session = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    if (!session) {
+      return false;
+    }
+
+    const userId = session.user.id;
+
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        customRole: true,
+      },
+    });
+
+    if (!user || !user.customRole) {
+      return false;
+    }
+
+    // Vérifier si le profil a la permission de gestion des utilisateurs
+    const permissions = user.customRole.permissions as string[];
+    return permissions.includes('users.manage_roles');
+  } catch (error) {
+    return false;
+  }
+}

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

@@ -0,0 +1,112 @@
+import { prisma } from '@/lib/prisma';
+
+/**
+ * Détecte et gère les doublons de contacts basés sur nom, prénom ET email
+ * Si un doublon est trouvé :
+ * - Change le statut en "Doublon"
+ * - Met à jour updatedAt pour remonter le contact en haut
+ * - Ajoute une note indiquant que le contact a été enregistré une énième fois
+ *
+ * @param firstName - Prénom du contact
+ * @param lastName - Nom du contact
+ * @param email - Email du contact
+ * @param origin - Origine du contact (pour la note)
+ * @param userId - ID de l'utilisateur qui crée le contact
+ * @returns L'ID du contact existant (doublon) ou null si aucun doublon
+ */
+export async function handleContactDuplicate(
+  firstName: string | null | undefined,
+  lastName: string | null | undefined,
+  email: string | null | undefined,
+  origin: string | null | undefined,
+  userId: string,
+): Promise<string | null> {
+  // Normaliser les valeurs pour la comparaison
+  const normalizedFirstName = firstName?.trim().toLowerCase() || null;
+  const normalizedLastName = lastName?.trim().toLowerCase() || null;
+  const normalizedEmail = email?.trim().toLowerCase() || null;
+
+  // Si on n'a pas au moins nom, prénom ET email, on ne peut pas détecter de doublon
+  if (!normalizedFirstName || !normalizedLastName || !normalizedEmail) {
+    return null;
+  }
+
+  // Chercher un contact existant avec le même nom, prénom ET email
+  const existingContact = await prisma.contact.findFirst({
+    where: {
+      AND: [
+        { firstName: { equals: normalizedFirstName, mode: 'insensitive' } },
+        { lastName: { equals: normalizedLastName, mode: 'insensitive' } },
+        { email: { equals: normalizedEmail, mode: 'insensitive' } },
+      ],
+    },
+  });
+
+  if (!existingContact) {
+    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(),
+    },
+  });
+
+  return existingContact.id;
+}