create-crm-tmp 1.1.2 → 2.0.0

package/template/src/app/api/contacts/route.ts

@@ -1,9 +1,32 @@
 import { NextRequest, NextResponse } from 'next/server';
+import { z } from 'zod';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
 import { handleContactDuplicate } from '@/lib/contact-duplicate';
 import { executeWorkflowsOnContactCreated } from '@/lib/workflow-executor';
 import { normalizePhoneNumber } from '@/lib/utils';
+import { buildPrismaWhereFromFilters } from '@/lib/contact-view-filters';
+import type { ViewFilter, ViewSortConfig } from '@/types/contact-views';
+
+const createContactSchema = z.object({
+  civility: z.enum(['M', 'MME', 'MLLE']).optional().nullable(),
+  firstName: z.string().trim().min(1).optional().nullable(),
+  lastName: z.string().trim().min(1).optional().nullable(),
+  phone: z.string().trim().min(3, 'Le téléphone est obligatoire'),
+  secondaryPhone: z.string().trim().optional().nullable(),
+  email: z.string().email().optional().nullable(),
+  address: z.string().optional().nullable(),
+  city: z.string().optional().nullable(),
+  postalCode: z.string().optional().nullable(),
+  origin: z.string().optional().nullable(),
+  companyId: z.string().optional().nullable(),
+  jobTitle: z.string().trim().optional().nullable(),
+  statusId: z.string().optional().nullable(),
+  closingReason: z.string().optional().nullable(),
+  assignedCommercialId: z.string().optional().nullable(),
+  assignedTeleproId: z.string().optional().nullable(),
+});
 
 // GET /api/contacts - Récupérer tous les contacts avec filtres
 export async function GET(request: NextRequest) {
@@ -16,8 +39,24 @@ export async function GET(request: NextRequest) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const [canViewAll, canViewOwn, canViewUnassigned] = await Promise.all([
+      checkPermission('contacts.view_all'),
+      checkPermission('contacts.view_own'),
+      checkPermission('contacts.view_unassigned'),
+    ]);
+
+    if (!canViewAll && !canViewOwn) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { searchParams } = new URL(request.url);
     const search = searchParams.get('search') || '';
+    const viewId = searchParams.get('viewId');
+    const filtersParam = searchParams.get('filters');
+    const statusIds = searchParams.get('statusIds');
+    const assignedCommercialIds = searchParams.get('assignedCommercialIds');
+    const assignedTeleproIds = searchParams.get('assignedTeleproIds');
+    const origins = searchParams.get('origins');
     const statusId = searchParams.get('statusId');
     const assignedCommercialId = searchParams.get('assignedCommercialId');
     const assignedTeleproId = searchParams.get('assignedTeleproId');
@@ -26,40 +65,122 @@ export async function GET(request: NextRequest) {
     const createdAtEnd = searchParams.get('createdAtEnd');
     const updatedAtStart = searchParams.get('updatedAtStart');
     const updatedAtEnd = searchParams.get('updatedAtEnd');
-    // const isCompany = searchParams.get('isCompany');
-    const page = parseInt(searchParams.get('page') || '1');
-    const limit = parseInt(searchParams.get('limit') || '50');
+    const sortFieldParam = searchParams.get('sortField');
+    const sortDirParam = searchParams.get('sortDir');
+    const page = Number.parseInt(searchParams.get('page') || '1');
+    const limit = Number.parseInt(searchParams.get('limit') || '50');
     const skip = (page - 1) * limit;
 
-    // Construire les filtres
     const where: any = {};
+    let viewSortConfig: ViewSortConfig | null = null;
 
-    if (search) {
-      where.OR = [
-        { firstName: { contains: search, mode: 'insensitive' } },
-        { lastName: { contains: search, mode: 'insensitive' } },
-        { email: { contains: search, mode: 'insensitive' } },
-        { phone: { contains: search, mode: 'insensitive' } },
+    // Resolve view filters if viewId or inline filters are provided
+    if (viewId) {
+      const view = await prisma.contactView.findUnique({ where: { id: viewId } });
+      if (view && (view.userId === session.user.id || view.isPublic)) {
+        const viewFilters = (view.filters ?? []) as unknown as ViewFilter[];
+        const viewWhere = buildPrismaWhereFromFilters(viewFilters);
+        if (Object.keys(viewWhere).length > 0) {
+          where.AND = where.AND || [];
+          where.AND.push(viewWhere);
+        }
+        if (view.sortConfig) {
+          viewSortConfig = view.sortConfig as unknown as ViewSortConfig;
+        }
+      }
+    } else if (filtersParam) {
+      try {
+        const parsedFilters = JSON.parse(filtersParam) as ViewFilter[];
+        if (Array.isArray(parsedFilters) && parsedFilters.length > 0) {
+          const filtersWhere = buildPrismaWhereFromFilters(parsedFilters);
+          if (Object.keys(filtersWhere).length > 0) {
+            where.AND = where.AND || [];
+            where.AND.push(filtersWhere);
+          }
+        }
+      } catch {
+        // Invalid JSON, ignore
+      }
+    }
+
+    if (!canViewAll && canViewOwn) {
+      const ownershipConditions: any[] = [
+        { assignedCommercialId: session.user.id },
+        { assignedTeleproId: session.user.id },
+        { createdById: session.user.id },
       ];
+      if (canViewUnassigned) {
+        ownershipConditions.push({
+          AND: [{ assignedCommercialId: null }, { assignedTeleproId: null }],
+        });
+      }
+      where.AND = where.AND || [];
+      where.AND.push({ OR: ownershipConditions });
     }
 
-    if (statusId) {
+    if (search) {
+      where.AND = where.AND || [];
+      where.AND.push({
+        OR: [
+          { firstName: { contains: search, mode: 'insensitive' } },
+          { lastName: { contains: search, mode: 'insensitive' } },
+          { email: { contains: search, mode: 'insensitive' } },
+          { phone: { contains: search, mode: 'insensitive' } },
+        ],
+      });
+    }
+
+    // Legacy query-param filters (rétrocompatibilité)
+    if (statusIds) {
+      const ids = statusIds.split(',').filter(Boolean);
+      where.statusId = ids.length === 1 ? ids[0] : { in: ids };
+    } else if (statusId) {
       where.statusId = statusId;
     }
 
-    if (assignedCommercialId) {
+    if (assignedCommercialIds) {
+      const ids = assignedCommercialIds.split(',').filter(Boolean);
+      const hasUnassigned = ids.includes('UNASSIGNED');
+      const realIds = ids.filter((id) => id !== 'UNASSIGNED');
+      if (hasUnassigned && realIds.length > 0) {
+        where.AND = where.AND || [];
+        where.AND.push({
+          OR: [{ assignedCommercialId: null }, { assignedCommercialId: { in: realIds } }],
+        });
+      } else if (hasUnassigned) {
+        where.assignedCommercialId = null;
+      } else {
+        where.assignedCommercialId = realIds.length === 1 ? realIds[0] : { in: realIds };
+      }
+    } else if (assignedCommercialId) {
       where.assignedCommercialId = assignedCommercialId;
     }
 
-    if (assignedTeleproId) {
+    if (assignedTeleproIds) {
+      const ids = assignedTeleproIds.split(',').filter(Boolean);
+      const hasUnassigned = ids.includes('UNASSIGNED');
+      const realIds = ids.filter((id) => id !== 'UNASSIGNED');
+      if (hasUnassigned && realIds.length > 0) {
+        where.AND = where.AND || [];
+        where.AND.push({
+          OR: [{ assignedTeleproId: null }, { assignedTeleproId: { in: realIds } }],
+        });
+      } else if (hasUnassigned) {
+        where.assignedTeleproId = null;
+      } else {
+        where.assignedTeleproId = realIds.length === 1 ? realIds[0] : { in: realIds };
+      }
+    } else if (assignedTeleproId) {
       where.assignedTeleproId = assignedTeleproId;
     }
 
-    if (origin) {
+    if (origins) {
+      const vals = origins.split(',').filter(Boolean);
+      where.origin = vals.length === 1 ? vals[0] : { in: vals };
+    } else if (origin) {
       where.origin = origin;
     }
 
-    // Filtres de date pour createdAt
     if (createdAtStart || createdAtEnd) {
       where.createdAt = {};
       if (createdAtStart) {
@@ -69,7 +190,6 @@ export async function GET(request: NextRequest) {
         }
       }
       if (createdAtEnd) {
-        // Ajouter 23h59m59s pour inclure toute la journée
         const endDate = new Date(createdAtEnd);
         if (!isNaN(endDate.getTime())) {
           endDate.setHours(23, 59, 59, 999);
@@ -78,7 +198,6 @@ export async function GET(request: NextRequest) {
       }
     }
 
-    // Filtres de date pour updatedAt
     if (updatedAtStart || updatedAtEnd) {
       where.updatedAt = {};
       if (updatedAtStart) {
@@ -88,7 +207,6 @@ export async function GET(request: NextRequest) {
         }
       }
       if (updatedAtEnd) {
-        // Ajouter 23h59m59s pour inclure toute la journée
         const endDate = new Date(updatedAtEnd);
         if (!isNaN(endDate.getTime())) {
           endDate.setHours(23, 59, 59, 999);
@@ -97,21 +215,20 @@ export async function GET(request: NextRequest) {
       }
     }
 
-    // if (isCompany === 'true') {
-    //   where = { ...where, isCompany: true };
-    // }
+    // Determine sort order: explicit param > view config > default
+    let orderBy: any = { createdAt: 'desc' as const };
+    if (sortFieldParam && sortDirParam) {
+      orderBy = { [sortFieldParam]: sortDirParam };
+    } else if (viewSortConfig) {
+      orderBy = { [viewSortConfig.field]: viewSortConfig.direction };
+    }
 
     const [contacts, total] = await Promise.all([
       prisma.contact.findMany({
-        where: {
-          ...where,
-          isCompany: false,
-        },
+        where,
         include: {
           status: true,
-          companyRelation: {
-            select: { id: true, firstName: true, lastName: true, isCompany: true },
-          },
+          company: { select: { id: true, name: true } },
           assignedCommercial: {
             select: { id: true, name: true, email: true },
           },
@@ -121,12 +238,34 @@ export async function GET(request: NextRequest) {
           createdBy: {
             select: { id: true, name: true, email: true },
           },
+          tourLinks: {
+            include: {
+              tour: {
+                select: {
+                  id: true,
+                  number: true,
+                },
+              },
+            },
+          },
+          transactions: {
+            select: {
+              id: true,
+              status: true,
+              totalAmountCents: true,
+              createdAt: true,
+            },
+            orderBy: {
+              createdAt: 'desc',
+            },
+            take: 1,
+          },
         },
-        orderBy: { createdAt: 'desc' },
+        orderBy,
         skip,
         take: limit,
       }),
-      prisma.contact.count({ where: { ...where, isCompany: false } }),
+      prisma.contact.count({ where }),
     ]);
 
     return NextResponse.json({
@@ -155,7 +294,24 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
-    const body = await request.json();
+    const canCreate = await checkPermission('contacts.create');
+    if (!canCreate) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    const json = await request.json();
+    const parseResult = createContactSchema.safeParse(json);
+
+    if (!parseResult.success) {
+      return NextResponse.json(
+        {
+          error: 'Données invalides',
+          details: parseResult.error.flatten(),
+        },
+        { status: 400 },
+      );
+    }
+
     const {
       civility,
       firstName,
@@ -167,19 +323,13 @@ export async function POST(request: NextRequest) {
       city,
       postalCode,
       origin,
-      companyName,
-      isCompany,
       companyId,
+      jobTitle,
       statusId,
       closingReason,
       assignedCommercialId,
       assignedTeleproId,
-    } = body;
-
-    // Validation
-    if (!phone) {
-      return NextResponse.json({ error: 'Le téléphone est obligatoire' }, { status: 400 });
-    }
+    } = parseResult.data;
 
     // Vérifier si c'est un doublon (nom, prénom ET email)
     const duplicateContactId = await handleContactDuplicate(
@@ -196,9 +346,7 @@ export async function POST(request: NextRequest) {
         where: { id: duplicateContactId },
         include: {
           status: true,
-          companyRelation: {
-            select: { id: true, firstName: true, lastName: true, isCompany: true },
-          },
+          company: { select: { id: true, name: true } },
           assignedCommercial: {
             select: { id: true, name: true, email: true },
           },
@@ -216,7 +364,7 @@ export async function POST(request: NextRequest) {
     // Sinon, créer un nouveau contact
     const contact = await prisma.contact.create({
       data: {
-        civility: civility || null,
+        civility: civility ?? null,
         firstName: firstName || null,
         lastName: lastName || null,
         phone: normalizePhoneNumber(phone),
@@ -226,9 +374,8 @@ export async function POST(request: NextRequest) {
         city: city || null,
         postalCode: postalCode || null,
         origin: origin || null,
-        companyName: companyName || null,
-        isCompany: isCompany === true,
         companyId: companyId || null,
+        jobTitle: jobTitle || null,
         statusId: statusId || null,
         closingReason: closingReason || null,
         assignedCommercialId: assignedCommercialId || null,
@@ -252,9 +399,7 @@ export async function POST(request: NextRequest) {
       },
       include: {
         status: true,
-        companyRelation: {
-          select: { id: true, firstName: true, lastName: true, isCompany: true },
-        },
+        company: { select: { id: true, name: true } },
         assignedCommercial: {
           select: { id: true, name: true, email: true },
         },
@@ -278,6 +423,14 @@ export async function POST(request: NextRequest) {
     return NextResponse.json(contact, { status: 201 });
   } catch (error: any) {
     console.error('Erreur lors de la création du contact:', error);
-    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+    return NextResponse.json(
+      {
+        error:
+          process.env.NODE_ENV === 'development'
+            ? error.message || 'Erreur serveur'
+            : 'Erreur serveur',
+      },
+      { status: 500 },
+    );
   }
 }

package/template/src/app/api/dashboard/stats/route.ts

@@ -1,304 +1,21 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { auth } from '@/lib/auth';
-import { headers } from 'next/headers';
-import { prisma } from '@/lib/prisma';
-import { checkPermission } from '@/lib/check-permission';
+import { NextResponse } from 'next/server';
+import { getAuthUser } from '@/lib/get-auth-user';
+import { getDashboardStats } from '@/lib/dashboard-stats';
 
-export async function GET(req: NextRequest) {
+export async function GET() {
   try {
-    const session = await auth.api.getSession({
-      headers: await headers(),
-    });
+    const authUser = await getAuthUser();
 
-    if (!session) {
+    if (!authUser) {
       return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
     }
 
-    // Vérifier la permission d'accès au tableau de bord
-    const canView = await checkPermission('dashboard.view');
-    if (!canView) {
+    if (!authUser.permissions.includes('dashboard.view')) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
     }
 
-    const userId = session.user.id;
-    const userRole = session.user.role;
-
-    // Déterminer les contacts visibles selon le rôle
-    const contactFilter =
-      userRole === 'ADMIN'
-        ? {}
-        : userRole === 'MANAGER'
-          ? {}
-          : userRole === 'COMMERCIAL'
-            ? { assignedCommercialId: userId }
-            : userRole === 'TELEPRO'
-              ? { assignedTeleproId: userId }
-              : { createdById: userId };
-
-    // 1. Total des contacts
-    const totalContacts = await prisma.contact.count({
-      where: contactFilter,
-    });
-
-    // 2. Contacts créés ce mois
-    const startOfMonth = new Date();
-    startOfMonth.setDate(1);
-    startOfMonth.setHours(0, 0, 0, 0);
-
-    const contactsThisMonth = await prisma.contact.count({
-      where: {
-        ...contactFilter,
-        createdAt: { gte: startOfMonth },
-      },
-    });
-
-    const lastMonthStart = new Date(startOfMonth);
-    lastMonthStart.setMonth(lastMonthStart.getMonth() - 1);
-
-    const contactsLastMonth = await prisma.contact.count({
-      where: {
-        ...contactFilter,
-        createdAt: {
-          gte: lastMonthStart,
-          lt: startOfMonth,
-        },
-      },
-    });
-
-    const contactsGrowth =
-      contactsLastMonth > 0
-        ? ((contactsThisMonth - contactsLastMonth) / contactsLastMonth) * 100
-        : 0;
-
-    // 3. Contacts par mois (12 derniers mois)
-    const monthsData = [];
-    for (let i = 11; i >= 0; i--) {
-      const monthStart = new Date();
-      monthStart.setMonth(monthStart.getMonth() - i);
-      monthStart.setDate(1);
-      monthStart.setHours(0, 0, 0, 0);
-
-      const monthEnd = new Date(monthStart);
-      monthEnd.setMonth(monthEnd.getMonth() + 1);
-
-      const count = await prisma.contact.count({
-        where: {
-          ...contactFilter,
-          createdAt: {
-            gte: monthStart,
-            lt: monthEnd,
-          },
-        },
-      });
-
-      monthsData.push({
-        month: monthStart.toLocaleString('fr-FR', { month: 'short' }),
-        count,
-      });
-    }
-
-    // 4. Répartition par statut (pour le radar chart)
-    const statusDistribution = await prisma.contact.groupBy({
-      by: ['statusId'],
-      where: contactFilter,
-      _count: true,
-    });
-
-    const statuses = await prisma.status.findMany();
-    const statusData = statuses.map((status) => ({
-      name: status.name,
-      value: statusDistribution.find((s) => s.statusId === status.id)?._count || 0,
-    }));
-
-    // 5. Tâches à venir (Top tasks)
-    const upcomingTasks = await prisma.task.findMany({
-      where: {
-        assignedUserId: userId,
-        completed: false,
-        scheduledAt: { gte: new Date() },
-      },
-      include: {
-        contact: true,
-        assignedUser: true,
-      },
-      orderBy: { scheduledAt: 'asc' },
-      take: 6,
-    });
-
-    // 6. Interactions récentes
-    const recentInteractions = await prisma.interaction.findMany({
-      where: {
-        userId,
-      },
-      include: {
-        contact: true,
-        user: true,
-      },
-      orderBy: { createdAt: 'desc' },
-      take: 5,
-    });
-
-    // 7. Statistiques des tâches
-    const totalTasks = await prisma.task.count({
-      where: { assignedUserId: userId },
-    });
-
-    const completedTasks = await prisma.task.count({
-      where: {
-        assignedUserId: userId,
-        completed: true,
-      },
-    });
-
-    const pendingTasks = totalTasks - completedTasks;
-
-    // 8. Tâches par type ce mois
-    const tasksThisMonthByType = await prisma.task.groupBy({
-      by: ['type'],
-      where: {
-        assignedUserId: userId,
-        createdAt: { gte: startOfMonth },
-      },
-      _count: true,
-    });
-
-    const tasksByType = tasksThisMonthByType.map((t) => ({
-      type: t.type,
-      count: t._count,
-    }));
-
-    // 9. Interactions par type ce mois
-    const interactionsThisMonth = await prisma.interaction.groupBy({
-      by: ['type'],
-      where: {
-        userId,
-        createdAt: { gte: startOfMonth },
-      },
-      _count: true,
-    });
-
-    const interactionsByType = interactionsThisMonth.map((i) => ({
-      type: i.type,
-      count: i._count,
-    }));
-
-    // 10. Activité des 7 derniers jours
-    const last7Days = [];
-    for (let i = 6; i >= 0; i--) {
-      const dayStart = new Date();
-      dayStart.setDate(dayStart.getDate() - i);
-      dayStart.setHours(0, 0, 0, 0);
-
-      const dayEnd = new Date(dayStart);
-      dayEnd.setDate(dayEnd.getDate() + 1);
-
-      const interactionsCount = await prisma.interaction.count({
-        where: {
-          userId,
-          createdAt: {
-            gte: dayStart,
-            lt: dayEnd,
-          },
-        },
-      });
-
-      const tasksCount = await prisma.task.count({
-        where: {
-          assignedUserId: userId,
-          createdAt: {
-            gte: dayStart,
-            lt: dayEnd,
-          },
-        },
-      });
-
-      last7Days.push({
-        date: dayStart.toLocaleDateString('fr-FR', {
-          day: 'numeric',
-          month: 'short',
-        }),
-        interactions: interactionsCount,
-        tasks: tasksCount,
-      });
-    }
-
-    // 11. Top contacts (ceux avec le plus d'interactions)
-    const topContacts = await prisma.contact.findMany({
-      where: contactFilter,
-      include: {
-        _count: {
-          select: { interactions: true },
-        },
-        status: true,
-        assignedCommercial: true,
-        assignedTelepro: true,
-      },
-      orderBy: {
-        createdAt: 'desc',
-      },
-      take: 4,
-    });
-
-    return NextResponse.json({
-      overview: {
-        totalContacts,
-        contactsThisMonth,
-        contactsGrowth: Math.round(contactsGrowth * 10) / 10,
-        monthsData,
-      },
-      statusDistribution: statusData,
-      tasks: {
-        total: totalTasks,
-        completed: completedTasks,
-        pending: pendingTasks,
-        upcoming: upcomingTasks.map((task) => ({
-          id: task.id,
-          title: task.title || 'Sans titre',
-          description: task.description,
-          type: task.type,
-          scheduledAt: task.scheduledAt,
-          contact: task.contact
-            ? {
-                id: task.contact.id,
-                name:
-                  `${task.contact.firstName || ''} ${task.contact.lastName || ''}`.trim() ||
-                  task.contact.phone,
-              }
-            : null,
-          priority: task.priority,
-        })),
-        byType: tasksByType,
-      },
-      interactions: {
-        recent: recentInteractions.map((interaction) => ({
-          id: interaction.id,
-          type: interaction.type,
-          title: interaction.title,
-          content: interaction.content,
-          date: interaction.date || interaction.createdAt,
-          contact: {
-            id: interaction.contact.id,
-            name:
-              `${interaction.contact.firstName || ''} ${interaction.contact.lastName || ''}`.trim() ||
-              interaction.contact.phone,
-          },
-        })),
-        byType: interactionsByType,
-      },
-      activity: {
-        last7Days,
-      },
-      topContacts: topContacts.map((contact) => ({
-        id: contact.id,
-        name: `${contact.firstName || ''} ${contact.lastName || ''}`.trim() || contact.phone,
-        phone: contact.phone,
-        email: contact.email,
-        status: contact.status?.name || 'Non défini',
-        interactionsCount: contact._count.interactions,
-        assignedCommercial: contact.assignedCommercial?.name,
-        assignedTelepro: contact.assignedTelepro?.name,
-      })),
-    });
+    const stats = await getDashboardStats(authUser.session.user.id, authUser.permissions);
+    return NextResponse.json(stats);
   } catch (error) {
     console.error('Erreur lors de la récupération des statistiques:', error);
     return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });