Refactor event handling and user management: Replace direct database calls with service layer methods for events, user profiles, and preferences, enhancing code organization and maintainability. Update API routes to utilize new services for event registration, feedback, and user statistics, ensuring a consistent approach across the application.

app/api/admin/events/[id]/route.ts

@@ -1,7 +1,8 @@
 import { NextResponse } from "next/server";
 import { auth } from "@/lib/auth";
-import { prisma } from "@/lib/prisma";
-import { Role, EventType } from "@/prisma/generated/prisma/client";
+import { eventService } from "@/services/events/event.service";
+import { Role } from "@/prisma/generated/prisma/client";
+import { ValidationError, NotFoundError } from "@/services/errors";
 
 export async function PUT(
   request: Request,
@@ -19,63 +20,27 @@ export async function PUT(
     const { date, name, description, type, room, time, maxPlaces } = body;
     // Le statut est ignoré s'il est fourni, il sera calculé automatiquement
 
-    // Vérifier que l'événement existe
-    const existingEvent = await prisma.event.findUnique({
-      where: { id },
-    });
-
-    if (!existingEvent) {
-      return NextResponse.json(
-        { error: "Événement non trouvé" },
-        { status: 404 }
-      );
-    }
-
-    const updateData: {
-      date?: Date;
-      name?: string;
-      description?: string;
-      type?: EventType;
-      room?: string | null;
-      time?: string | null;
-      maxPlaces?: number | null;
-    } = {};
-
-    if (date !== undefined) {
-      const eventDate = new Date(date);
-      if (isNaN(eventDate.getTime())) {
-        return NextResponse.json(
-          { error: "Format de date invalide" },
-          { status: 400 }
-        );
-      }
-      updateData.date = eventDate;
-    }
-    if (name !== undefined) updateData.name = name;
-    if (description !== undefined) updateData.description = description;
-    if (type !== undefined) {
-      if (!Object.values(EventType).includes(type)) {
-        return NextResponse.json(
-          { error: "Type d'événement invalide" },
-          { status: 400 }
-        );
-      }
-      updateData.type = type as EventType;
-    }
-    // Le statut est toujours calculé automatiquement, on ignore s'il est fourni
-    if (room !== undefined) updateData.room = room || null;
-    if (time !== undefined) updateData.time = time || null;
-    if (maxPlaces !== undefined)
-      updateData.maxPlaces = maxPlaces ? parseInt(maxPlaces) : null;
-
-    const event = await prisma.event.update({
-      where: { id },
-      data: updateData,
+    const event = await eventService.validateAndUpdateEvent(id, {
+      date,
+      name,
+      description,
+      type,
+      room,
+      time,
+      maxPlaces,
     });
 
     return NextResponse.json(event);
   } catch (error) {
     console.error("Error updating event:", error);
+
+    if (error instanceof ValidationError) {
+      return NextResponse.json({ error: error.message }, { status: 400 });
+    }
+    if (error instanceof NotFoundError) {
+      return NextResponse.json({ error: error.message }, { status: 404 });
+    }
+
     return NextResponse.json(
       { error: "Erreur lors de la mise à jour de l'événement" },
       { status: 500 }
@@ -97,9 +62,7 @@ export async function DELETE(
     const { id } = await params;
 
     // Vérifier que l'événement existe
-    const existingEvent = await prisma.event.findUnique({
-      where: { id },
-    });
+    const existingEvent = await eventService.getEventById(id);
 
     if (!existingEvent) {
       return NextResponse.json(
@@ -108,9 +71,7 @@ export async function DELETE(
       );
     }
 
-    await prisma.event.delete({
-      where: { id },
-    });
+    await eventService.deleteEvent(id);
 
     return NextResponse.json({ success: true });
   } catch (error) {

app/api/admin/events/route.ts

@@ -1,8 +1,8 @@
 import { NextResponse } from "next/server";
 import { auth } from "@/lib/auth";
-import { prisma } from "@/lib/prisma";
-import { Role, EventType } from "@/prisma/generated/prisma/client";
-import { calculateEventStatus } from "@/lib/eventStatus";
+import { eventService } from "@/services/events/event.service";
+import { Role } from "@/prisma/generated/prisma/client";
+import { ValidationError } from "@/services/errors";
 
 export async function GET() {
   try {
@@ -12,34 +12,22 @@ export async function GET() {
       return NextResponse.json({ error: "Accès refusé" }, { status: 403 });
     }
 
-    const events = await prisma.event.findMany({
-      orderBy: {
-        date: "desc",
-      },
-      include: {
-        _count: {
-          select: {
-            registrations: true,
-          },
-        },
-      },
-    });
+    const events = await eventService.getEventsWithStatus();
 
-    // Transformer les données pour inclure le nombre d'inscriptions
-    // Le statut est calculé automatiquement en fonction de la date
+    // Transformer les données pour la sérialisation
     const eventsWithCount = events.map((event) => ({
       id: event.id,
       date: event.date.toISOString(),
       name: event.name,
       description: event.description,
       type: event.type,
-      status: calculateEventStatus(event.date),
+      status: event.status,
       room: event.room,
       time: event.time,
       maxPlaces: event.maxPlaces,
       createdAt: event.createdAt.toISOString(),
       updatedAt: event.updatedAt.toISOString(),
-      registrationsCount: event._count.registrations,
+      registrationsCount: event.registrationsCount,
     }));
 
     return NextResponse.json(eventsWithCount);
@@ -63,45 +51,24 @@ export async function POST(request: Request) {
     const body = await request.json();
     const { date, name, description, type, room, time, maxPlaces } = body;
 
-    if (!date || !name || !description || !type) {
-      return NextResponse.json(
-        { error: "Tous les champs sont requis" },
-        { status: 400 }
-      );
-    }
-
-    // Convertir la date string en Date object
-    const eventDate = new Date(date);
-    if (isNaN(eventDate.getTime())) {
-      return NextResponse.json(
-        { error: "Format de date invalide" },
-        { status: 400 }
-      );
-    }
-
-    // Valider les enums
-    if (!Object.values(EventType).includes(type)) {
-      return NextResponse.json(
-        { error: "Type d'événement invalide" },
-        { status: 400 }
-      );
-    }
-
-    const event = await prisma.event.create({
-      data: {
-        date: eventDate,
-        name,
-        description,
-        type: type as EventType,
-        room: room || null,
-        time: time || null,
-        maxPlaces: maxPlaces ? parseInt(maxPlaces) : null,
-      },
+    const event = await eventService.validateAndCreateEvent({
+      date,
+      name,
+      description,
+      type,
+      room,
+      time,
+      maxPlaces,
     });
 
     return NextResponse.json(event);
   } catch (error) {
     console.error("Error creating event:", error);
+
+    if (error instanceof ValidationError) {
+      return NextResponse.json({ error: error.message }, { status: 400 });
+    }
+
     return NextResponse.json(
       { error: "Erreur lors de la création de l'événement" },
       { status: 500 }