create-crm-tmp 1.1.3 → 2.1.0

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 });

package/template/src/app/api/dashboard/widgets/[id]/route.ts

@@ -4,7 +4,6 @@ import { headers } from 'next/headers';
 import { prisma } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
 
-// DELETE - Supprimer un widget
 export async function DELETE(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
   try {
     const session = await auth.api.getSession({
@@ -15,7 +14,6 @@ export async function DELETE(req: NextRequest, { params }: { params: Promise<{ i
       return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
     }
 
-    // Vérifier la permission de gestion des widgets
     const canManage = await checkPermission('dashboard.widgets.manage');
     if (!canManage) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
@@ -23,7 +21,6 @@ export async function DELETE(req: NextRequest, { params }: { params: Promise<{ i
 
     const { id } = await params;
 
-    // Vérifier que le widget appartient à l'utilisateur
     const widget = await prisma.dashboardWidget.findFirst({
       where: {
         id,

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

@@ -5,7 +5,6 @@ import { prisma } from '@/lib/prisma';
 import { DEFAULT_WIDGETS } from '@/lib/default-widgets';
 import { checkPermission } from '@/lib/check-permission';
 
-// GET - Récupérer les widgets de l'utilisateur
 export async function GET() {
   try {
     const session = await auth.api.getSession({
@@ -16,17 +15,33 @@ export async function GET() {
       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) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
     }
 
-    const widgets = await prisma.dashboardWidget.findMany({
+    let widgets = await prisma.dashboardWidget.findMany({
       where: { userId: session.user.id },
       orderBy: [{ y: 'asc' }, { x: 'asc' }],
     });
 
+    if (widgets.length === 0) {
+      widgets = await prisma.$transaction(
+        DEFAULT_WIDGETS.map((dw) =>
+          prisma.dashboardWidget.create({
+            data: {
+              userId: session.user.id,
+              type: dw.type,
+              x: dw.x,
+              y: dw.y,
+              w: dw.w,
+              h: dw.h,
+            },
+          }),
+        ),
+      );
+    }
+
     return NextResponse.json(widgets);
   } catch (error) {
     console.error('Erreur lors de la récupération des widgets:', error);
@@ -34,7 +49,6 @@ export async function GET() {
   }
 }
 
-// POST - Créer un widget (ou initialiser le layout par défaut)
 export async function POST(req: NextRequest) {
   try {
     const session = await auth.api.getSession({
@@ -45,7 +59,6 @@ export async function POST(req: NextRequest) {
       return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
     }
 
-    // Vérifier la permission de gestion des widgets
     const canManage = await checkPermission('dashboard.widgets.manage');
     if (!canManage) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
@@ -53,20 +66,11 @@ export async function POST(req: NextRequest) {
 
     const body = await req.json();
 
-    // Si c'est une initialisation par défaut
     if (body.initDefault) {
-      const existing = await prisma.dashboardWidget.count({
+      await prisma.dashboardWidget.deleteMany({
         where: { userId: session.user.id },
       });
 
-      if (existing > 0) {
-        const widgets = await prisma.dashboardWidget.findMany({
-          where: { userId: session.user.id },
-          orderBy: [{ y: 'asc' }, { x: 'asc' }],
-        });
-        return NextResponse.json(widgets);
-      }
-
       const created = await prisma.$transaction(
         DEFAULT_WIDGETS.map((dw) =>
           prisma.dashboardWidget.create({
@@ -85,7 +89,6 @@ export async function POST(req: NextRequest) {
       return NextResponse.json(created, { status: 201 });
     }
 
-    // Création d'un widget unique
     const {
       type,
       x,
@@ -104,7 +107,6 @@ export async function POST(req: NextRequest) {
       return NextResponse.json({ error: 'Le type de widget est requis' }, { status: 400 });
     }
 
-    // Calculer la position Y max pour placer le nouveau widget en bas
     const lastWidget = await prisma.dashboardWidget.findFirst({
       where: { userId: session.user.id },
       orderBy: { y: 'desc' },
@@ -130,7 +132,6 @@ export async function POST(req: NextRequest) {
   }
 }
 
-// PUT - Mettre à jour les positions des widgets (batch)
 export async function PUT(req: NextRequest) {
   try {
     const session = await auth.api.getSession({
@@ -141,7 +142,6 @@ export async function PUT(req: NextRequest) {
       return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
     }
 
-    // Vérifier la permission de gestion des widgets
     const canManage = await checkPermission('dashboard.widgets.manage');
     if (!canManage) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });

package/template/src/app/api/dev/reminders/test/route.ts

@@ -0,0 +1,114 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+type TestReminderBody = {
+  title?: string;
+  description?: string;
+  scheduledAt?: string;
+  reminderMinutesBefore?: number;
+  sendNow?: boolean;
+  contactId?: string;
+};
+
+// WARNING: This endpoint is for local development only.
+// It is protected by NODE_ENV and an optional DEV_API_SECRET.
+// Never expose dev endpoints in production builds.
+export async function POST(request: NextRequest) {
+  if (
+    process.env.NODE_ENV !== 'development' ||
+    (process.env.DEV_API_SECRET &&
+      process.env.DEV_API_SECRET !== request.headers.get('x-dev-secret'))
+  ) {
+    return NextResponse.json({ error: 'Not found' }, { status: 404 });
+  }
+
+  try {
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const body = (await request.json().catch(() => ({}))) as TestReminderBody;
+    const title = body.title?.trim() || 'Rappel de test';
+    const description = body.description?.trim() || 'Rappel généré en mode développement.';
+    const reminderMinutesBefore =
+      typeof body.reminderMinutesBefore === 'number' &&
+      Number.isInteger(body.reminderMinutesBefore) &&
+      body.reminderMinutesBefore > 0
+        ? body.reminderMinutesBefore
+        : 5;
+
+    const parsedDate = body.scheduledAt ? new Date(body.scheduledAt) : null;
+    const scheduledAt =
+      parsedDate && !Number.isNaN(parsedDate.getTime())
+        ? parsedDate
+        : new Date(Date.now() + (reminderMinutesBefore + 1) * 60 * 1000);
+
+    const normalizedContactId =
+      typeof body.contactId === 'string' && body.contactId.trim() !== '' ? body.contactId.trim() : null;
+    let contact:
+      | {
+          id: string;
+          firstName: string | null;
+          lastName: string | null;
+        }
+      | null = null;
+    if (normalizedContactId) {
+      contact = await prisma.contact.findUnique({
+        where: { id: normalizedContactId },
+        select: { id: true, firstName: true, lastName: true },
+      });
+      if (!contact) {
+        return NextResponse.json({ error: 'Contact introuvable.' }, { status: 404 });
+      }
+    }
+
+    const task = await prisma.task.create({
+      data: {
+        type: 'OTHER',
+        title,
+        description,
+        priority: 'MEDIUM',
+        scheduledAt,
+        reminderMinutesBefore,
+        assignedUserId: session.user.id,
+        createdById: session.user.id,
+        contactId: contact?.id ?? null,
+      },
+      select: {
+        id: true,
+        title: true,
+        scheduledAt: true,
+        reminderMinutesBefore: true,
+        contact: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+          },
+        },
+      },
+    });
+
+    const sendNow = body.sendNow === true;
+    const immediateNotification = sendNow
+      ? {
+          tone: 'warning' as const,
+          message: `Test immédiat: ${task.title || 'Rappel'} (${task.reminderMinutesBefore} min avant)`,
+          link: task.contact ? `/contacts/${task.contact.id}` : undefined,
+          actionLabel: task.contact ? 'Ouvrir le contact' : undefined,
+        }
+      : null;
+
+    return NextResponse.json({
+      success: true,
+      task,
+      immediateNotification,
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la création du rappel de test:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+

package/template/src/app/api/editor/upload-image/route.ts

@@ -0,0 +1,61 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import {
+  BUCKETS,
+  buildEditorImagePath,
+  createSignedUploadUrl,
+} from '@/lib/supabase-storage';
+
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+
+// POST /api/editor/upload-image - Créer une URL d'upload signée pour une image éditeur
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const body = await request.json();
+    const { fileName, fileSize, mimeType } = body;
+
+    if (!fileName || typeof fileSize !== 'number' || !mimeType) {
+      return NextResponse.json(
+        { error: 'Champs requis: fileName, fileSize (number), mimeType' },
+        { status: 400 },
+      );
+    }
+
+    const ALLOWED_IMAGE_TYPES = ['image/jpeg', 'image/png', 'image/webp', 'image/gif'];
+    if (!ALLOWED_IMAGE_TYPES.includes(mimeType)) {
+      return NextResponse.json(
+        { error: 'Seuls les formats JPEG, PNG, WebP et GIF sont acceptés' },
+        { status: 400 },
+      );
+    }
+
+    if (fileSize > MAX_FILE_SIZE) {
+      return NextResponse.json(
+        { error: 'Image trop volumineuse. Taille maximale: 10MB' },
+        { status: 400 },
+      );
+    }
+
+    const storagePath = buildEditorImagePath(fileName);
+    const result = await createSignedUploadUrl(BUCKETS.EDITOR_IMAGES, storagePath);
+
+    const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL!;
+    const publicUrl = `${supabaseUrl}/storage/v1/object/public/${BUCKETS.EDITOR_IMAGES}/${storagePath}`;
+
+    return NextResponse.json({
+      ...result,
+      publicUrl,
+    });
+  } catch (error: unknown) {
+    console.error("Erreur lors de la création de l'URL d'upload image:", error);
+    const message = error instanceof Error ? error.message : 'Erreur serveur';
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/template/src/app/api/integrations/google-sheet/jobs/[jobId]/route.ts

@@ -0,0 +1,47 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { checkPermission } from '@/lib/check-permission';
+import { prisma } from '@/lib/prisma';
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ jobId: string }> },
+) {
+  try {
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { jobId } = await params;
+    const job = await prisma.googleSheetSyncJob.findUnique({
+      where: { id: jobId },
+    });
+
+    if (!job) {
+      return NextResponse.json({ error: 'Job introuvable' }, { status: 404 });
+    }
+    const isOwner = job.requestedByUserId === session.user.id;
+    const isScheduledOrSystem = job.requestedByUserId === null;
+    const canManageIntegrations = await checkPermission('integrations.google_sheets.manage');
+    if (!isOwner && !isScheduledOrSystem && !canManageIntegrations) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    return NextResponse.json({
+      id: job.id,
+      status: job.status,
+      triggerType: job.triggerType,
+      configId: job.configId,
+      startedAt: job.startedAt,
+      finishedAt: job.finishedAt,
+      error: job.error,
+      result: job.result,
+      createdAt: job.createdAt,
+      updatedAt: job.updatedAt,
+    });
+  } catch (error) {
+    console.error('Erreur lecture job Google Sheet:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}