create-crm-tmp 1.1.2 → 2.0.0

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

@@ -1,193 +1,28 @@
-import { auth } from '@/lib/auth';
-import { headers } from 'next/headers';
-import { prisma } from '@/lib/prisma';
+import { getAuthUser } from '@/lib/get-auth-user';
 
-/**
- * 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);
+    const authUser = await getAuthUser();
+    if (!authUser) return false;
+    return authUser.permissions.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> {
+  ...requiredPermissions: string[]
+): Promise<Record<string, 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));
+    const authUser = await getAuthUser();
+    if (!authUser) {
+      return Object.fromEntries(requiredPermissions.map((p) => [p, false]));
     }
+    const permSet = new Set(authUser.permissions);
+    return Object.fromEntries(requiredPermissions.map((p) => [p, permSet.has(p)]));
   } 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;
+    return Object.fromEntries(requiredPermissions.map((p) => [p, false]));
   }
 }

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

@@ -81,7 +81,7 @@ export async function logContactUpdate(
       postalCode: 'Code postal',
       civility: 'Civilité',
       origin: 'Origine',
-      companyName: 'Entreprise',
+      company: 'Entreprise',
       closingReason: 'Motif de fermeture',
     };
 
@@ -103,6 +103,8 @@ export async function logContactUpdate(
 
     const formatValue = (value: any) => {
       if (value === null || value === undefined) return 'Aucun';
+      if (typeof value === 'object' && value !== null && 'name' in value)
+        return value.name ?? 'Aucun';
       return String(value);
     };
 

package/template/src/lib/contact-view-filters.ts

@@ -0,0 +1,341 @@
+import type { ViewFilter, DatePreset } from '@/types/contact-views';
+import { FRENCH_DEPARTMENTS, type Department } from '@/lib/french-regions';
+
+function startOfDay(date: Date): Date {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+function endOfDay(date: Date): Date {
+  const d = new Date(date);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+
+function getMonday(date: Date): Date {
+  const d = new Date(date);
+  const day = d.getDay();
+  const diff = d.getDate() - day + (day === 0 ? -6 : 1);
+  d.setDate(diff);
+  return startOfDay(d);
+}
+
+function getQuarterStart(date: Date): Date {
+  const month = date.getMonth();
+  const quarterStartMonth = month - (month % 3);
+  return startOfDay(new Date(date.getFullYear(), quarterStartMonth, 1));
+}
+
+function getQuarterEnd(date: Date): Date {
+  const month = date.getMonth();
+  const quarterEndMonth = month - (month % 3) + 3;
+  return endOfDay(new Date(date.getFullYear(), quarterEndMonth, 0));
+}
+
+export function resolveDatePreset(preset: DatePreset): { gte?: Date; lte?: Date } {
+  const now = new Date();
+  const today = startOfDay(now);
+
+  switch (preset) {
+    case 'today':
+      return { gte: startOfDay(today), lte: endOfDay(today) };
+    case 'yesterday': {
+      const d = new Date(today);
+      d.setDate(d.getDate() - 1);
+      return { gte: startOfDay(d), lte: endOfDay(d) };
+    }
+    case 'tomorrow': {
+      const d = new Date(today);
+      d.setDate(d.getDate() + 1);
+      return { gte: startOfDay(d), lte: endOfDay(d) };
+    }
+    case 'this_week': {
+      const monday = getMonday(today);
+      const sunday = new Date(monday);
+      sunday.setDate(sunday.getDate() + 6);
+      return { gte: monday, lte: endOfDay(sunday) };
+    }
+    case 'this_week_so_far': {
+      const monday = getMonday(today);
+      return { gte: monday, lte: endOfDay(today) };
+    }
+    case 'last_week': {
+      const monday = getMonday(today);
+      monday.setDate(monday.getDate() - 7);
+      const sunday = new Date(monday);
+      sunday.setDate(sunday.getDate() + 6);
+      return { gte: monday, lte: endOfDay(sunday) };
+    }
+    case 'next_week': {
+      const monday = getMonday(today);
+      monday.setDate(monday.getDate() + 7);
+      const sunday = new Date(monday);
+      sunday.setDate(sunday.getDate() + 6);
+      return { gte: monday, lte: endOfDay(sunday) };
+    }
+    case 'this_month':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), now.getMonth(), 1)),
+        lte: endOfDay(new Date(now.getFullYear(), now.getMonth() + 1, 0)),
+      };
+    case 'this_month_so_far':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), now.getMonth(), 1)),
+        lte: endOfDay(today),
+      };
+    case 'last_month':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), now.getMonth() - 1, 1)),
+        lte: endOfDay(new Date(now.getFullYear(), now.getMonth(), 0)),
+      };
+    case 'next_month':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), now.getMonth() + 1, 1)),
+        lte: endOfDay(new Date(now.getFullYear(), now.getMonth() + 2, 0)),
+      };
+    case 'this_quarter':
+      return { gte: getQuarterStart(now), lte: getQuarterEnd(now) };
+    case 'this_quarter_so_far':
+      return { gte: getQuarterStart(now), lte: endOfDay(today) };
+    case 'last_quarter': {
+      const prevQuarter = new Date(now);
+      prevQuarter.setMonth(prevQuarter.getMonth() - 3);
+      return {
+        gte: getQuarterStart(prevQuarter),
+        lte: getQuarterEnd(prevQuarter),
+      };
+    }
+    case 'this_year':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), 0, 1)),
+        lte: endOfDay(new Date(now.getFullYear(), 11, 31)),
+      };
+    case 'this_year_so_far':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), 0, 1)),
+        lte: endOfDay(today),
+      };
+    case 'last_year':
+      return {
+        gte: startOfDay(new Date(now.getFullYear() - 1, 0, 1)),
+        lte: endOfDay(new Date(now.getFullYear() - 1, 11, 31)),
+      };
+    case 'last_7_days':
+    case 'last_14_days':
+    case 'last_30_days':
+    case 'last_60_days':
+    case 'last_90_days':
+    case 'last_180_days':
+    case 'last_365_days': {
+      const daysMap: Record<string, number> = {
+        last_7_days: 7,
+        last_14_days: 14,
+        last_30_days: 30,
+        last_60_days: 60,
+        last_90_days: 90,
+        last_180_days: 180,
+        last_365_days: 365,
+      };
+      const d = new Date(today);
+      d.setDate(d.getDate() - daysMap[preset]);
+      return { gte: startOfDay(d), lte: endOfDay(today) };
+    }
+    default:
+      return {};
+  }
+}
+
+const departmentsByRegion = new Map<string, Department[]>();
+for (const dept of FRENCH_DEPARTMENTS) {
+  const list = departmentsByRegion.get(dept.regionCode) ?? [];
+  list.push(dept);
+  departmentsByRegion.set(dept.regionCode, list);
+}
+
+function buildPostalCodeConditions(deptCodes: string[], negate: boolean): any | null {
+  if (deptCodes.length === 0) return null;
+
+  const startsWithConditions: any[] = [];
+  const corsicaCodes: string[] = [];
+
+  for (const code of deptCodes) {
+    if (code === '2A' || code === '2B') {
+      corsicaCodes.push(code);
+    } else {
+      startsWithConditions.push({ postalCode: { startsWith: code } });
+    }
+  }
+
+  if (corsicaCodes.length > 0) {
+    if (corsicaCodes.includes('2A') && corsicaCodes.includes('2B')) {
+      startsWithConditions.push({ postalCode: { startsWith: '20' } });
+    } else if (corsicaCodes.includes('2A')) {
+      startsWithConditions.push({
+        AND: [{ postalCode: { startsWith: '20' } }, { postalCode: { lt: '20200' } }],
+      });
+    } else {
+      startsWithConditions.push({
+        AND: [{ postalCode: { startsWith: '20' } }, { postalCode: { gte: '20200' } }],
+      });
+    }
+  }
+
+  if (startsWithConditions.length === 0) return null;
+
+  const orCondition =
+    startsWithConditions.length === 1 ? startsWithConditions[0] : { OR: startsWithConditions };
+
+  return negate ? { NOT: orCondition } : orCondition;
+}
+
+function buildGeoCondition(filter: ViewFilter): any | null {
+  const { field, operator, value } = filter;
+  if (!Array.isArray(value) || value.length === 0) return null;
+
+  if (field === 'department') {
+    return buildPostalCodeConditions(value, operator === 'is_none_of');
+  }
+
+  if (field === 'region') {
+    const deptCodes: string[] = [];
+    for (const regionCode of value) {
+      const depts = departmentsByRegion.get(regionCode);
+      if (depts) {
+        for (const d of depts) deptCodes.push(d.code);
+      }
+    }
+    return buildPostalCodeConditions(deptCodes, operator === 'is_none_of');
+  }
+
+  return null;
+}
+
+function buildFieldCondition(filter: ViewFilter): any | null {
+  const { field, operator, value, preset } = filter;
+
+  if (field === 'region' || field === 'department') {
+    return buildGeoCondition(filter);
+  }
+
+  switch (operator) {
+    case 'equals': {
+      if (field === 'createdAt' || field === 'updatedAt') {
+        if (!value || typeof value !== 'string') return null;
+        const d = new Date(value);
+        if (isNaN(d.getTime())) return null;
+        return { [field]: { gte: startOfDay(d), lte: endOfDay(d) } };
+      }
+      return { [field]: value };
+    }
+
+    case 'not_equals':
+      return { NOT: { [field]: value } };
+
+    case 'contains':
+      return { [field]: { contains: value as string, mode: 'insensitive' } };
+
+    case 'not_contains':
+      return {
+        NOT: { [field]: { contains: value as string, mode: 'insensitive' } },
+      };
+
+    case 'starts_with':
+      return {
+        [field]: { startsWith: value as string, mode: 'insensitive' },
+      };
+
+    case 'ends_with':
+      return { [field]: { endsWith: value as string, mode: 'insensitive' } };
+
+    case 'is_any_of': {
+      if (!Array.isArray(value) || value.length === 0) return null;
+      const hasUnassigned = value.includes('UNASSIGNED');
+      const realValues = value.filter((v) => v !== 'UNASSIGNED');
+
+      if (hasUnassigned && realValues.length > 0) {
+        return { OR: [{ [field]: null }, { [field]: { in: realValues } }] };
+      } else if (hasUnassigned) {
+        return { [field]: null };
+      }
+      return { [field]: { in: realValues } };
+    }
+
+    case 'is_none_of': {
+      if (!Array.isArray(value) || value.length === 0) return null;
+      const hasUnassigned = value.includes('UNASSIGNED');
+      const realValues = value.filter((v) => v !== 'UNASSIGNED');
+
+      if (hasUnassigned && realValues.length > 0) {
+        return {
+          AND: [{ [field]: { not: null } }, { [field]: { notIn: realValues } }],
+        };
+      } else if (hasUnassigned) {
+        return { [field]: { not: null } };
+      }
+      return { [field]: { notIn: realValues } };
+    }
+
+    case 'gt': {
+      const d = new Date(value as string);
+      if (isNaN(d.getTime())) return null;
+      return { [field]: { gt: endOfDay(d) } };
+    }
+
+    case 'gte': {
+      const d = new Date(value as string);
+      if (isNaN(d.getTime())) return null;
+      return { [field]: { gte: startOfDay(d) } };
+    }
+
+    case 'lt': {
+      const d = new Date(value as string);
+      if (isNaN(d.getTime())) return null;
+      return { [field]: { lt: startOfDay(d) } };
+    }
+
+    case 'lte': {
+      const d = new Date(value as string);
+      if (isNaN(d.getTime())) return null;
+      return { [field]: { lte: endOfDay(d) } };
+    }
+
+    case 'between': {
+      if (!Array.isArray(value) || value.length !== 2) return null;
+      const start = new Date(value[0]);
+      const end = new Date(value[1]);
+      if (isNaN(start.getTime()) || isNaN(end.getTime())) return null;
+      return { [field]: { gte: startOfDay(start), lte: endOfDay(end) } };
+    }
+
+    case 'is_known':
+      return { [field]: { not: null } };
+
+    case 'is_unknown':
+      return { [field]: null };
+
+    case 'date_preset': {
+      if (!preset) return null;
+      const range = resolveDatePreset(preset);
+      return { [field]: range };
+    }
+
+    default:
+      return null;
+  }
+}
+
+export function buildPrismaWhereFromFilters(filters: ViewFilter[]): Record<string, any> {
+  const conditions: any[] = [];
+
+  for (const filter of filters) {
+    const condition = buildFieldCondition(filter);
+    if (condition) {
+      conditions.push(condition);
+    }
+  }
+
+  if (conditions.length === 0) return {};
+  if (conditions.length === 1) return conditions[0];
+  return { AND: conditions };
+}