Merge pull request #67 from AlessGarau/develop

HOTFIX: fix possible duplicate lessons without room id because of opt…

Author: mirandalucas52

packages/client/src/api/endpoints/planning.ts

@@ -35,6 +35,7 @@ export const planningApi = {
     uploadLessons: async (file: File): Promise<{
         message: string;
         importedCount: number;
+        updatedCount: number;
         skippedCount: number;
         errors: Array<{ row: number; field?: string; message: string }>;
         optimization?: {

packages/client/src/pages/PlanningPage.tsx

@@ -59,11 +59,22 @@ const PlanningPage = () => {
         ...planningQueryOptions.uploadLessons(),
         onSuccess: (data) => {
             let message = `Fichier importé avec succès ! `;
+            const parts: string[] = [];
+
             if (data.importedCount > 0) {
-                message += `${data.importedCount} cours ajoutés`;
+                parts.push(`${data.importedCount} cours ajoutés`);
+            }
+            if (data.updatedCount > 0) {
+                parts.push(`${data.updatedCount} cours mis à jour`);
             }
             if (data.skippedCount > 0) {
-                message += data.importedCount > 0 ? ` et ${data.skippedCount} cours ignorés (déjà existants)` : `${data.skippedCount} cours ignorés (déjà existants)`;
+                parts.push(`${data.skippedCount} cours ignorés (aucun changement car déjà existant)`);
+            }
+
+            if (parts.length > 0) {
+                message += parts.join(', ');
+            } else {
+                message = 'Aucun changement détecté dans le fichier importé.';
             }
 
             toast.success(message);
@@ -177,11 +188,11 @@ const PlanningPage = () => {
                 </div>
                 <div className="flex gap-2">
                     <Button
-                        label={isMdScreen ? "Télécharger" : undefined}
+                        label={isMdScreen ? "Exemple excel" : undefined}
                         icon={DownloadIcon}
                         onClick={() => downloadTemplateMutation.mutate()}
                         disabled={downloadTemplateMutation.isPending}
-                        tooltip={!isMdScreen ? "Télécharger le modèle" : undefined}
+                        tooltip={!isMdScreen ? "Télécharger un exemple d'excel" : undefined}
                     />
                     <Button
                         label={isMdScreen ? "Importer une feuille" : undefined}

packages/server/src/feature/lesson/Repository.ts

@@ -1,6 +1,6 @@
 import { Service } from "typedi";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { between, eq, and, inArray } from "drizzle-orm";
+import { between, eq, and, inArray, lt, gt  } from "drizzle-orm";
 import { database } from "../../../database/database";
 import { lessonTable } from "../../../database/schema/lesson";
 import { roomTable } from "../../../database/schema/room";
@@ -114,6 +114,21 @@ export class LessonRepository implements ILessonRepository {
     return result[0] || null;
   }
 
+  async findOverlappingLessons(classId: string, startTime: Date, endTime: Date): Promise<Lesson[]> {
+    const result = await this.db
+      .select()
+      .from(lessonTable)
+      .where(
+        and(
+          eq(lessonTable.class_id, classId),
+          lt(lessonTable.start_time, endTime),
+          gt(lessonTable.end_time, startTime),
+        ),
+      );
+
+    return result;
+  }
+
   async getLessonById(lessonId: string): Promise<Lesson | null> {
     const result = await this.db
       .select()
@@ -131,23 +146,44 @@ export class LessonRepository implements ILessonRepository {
   }
 
   async updateLesson(lessonId: string, data: UpdateLessonData): Promise<Lesson> {
-    const [startHour, startMinute] = data.startTime.split(":").map(Number);
-    const [endHour, endMinute] = data.endTime.split(":").map(Number);
-
-    const startDate = new Date(data.date);
-    startDate.setHours(startHour, startMinute, 0, 0);
-
-    const endDate = new Date(data.date);
-    endDate.setHours(endHour, endMinute, 0, 0);
+    const updateData: Partial<{
+      title: string;
+      room_id: string | undefined;
+      start_time: Date;
+      end_time: Date;
+    }> = {};
+    
+    if (data.title !== undefined) {
+      updateData.title = data.title;
+    }
+    
+    if (data.roomId !== undefined && data.roomId !== null) {
+      updateData.room_id = data.roomId;
+    }
+    
+    if (data.startTime !== undefined && data.endTime !== undefined) {
+      if (data.startTime instanceof Date) {
+        updateData.start_time = data.startTime;
+      } else if (typeof data.startTime === "string" && data.date) {
+        const [startHour, startMinute] = data.startTime.split(":").map(Number);
+        const startDate = new Date(data.date);
+        startDate.setHours(startHour, startMinute, 0, 0);
+        updateData.start_time = startDate;
+      }
+      
+      if (data.endTime instanceof Date) {
+        updateData.end_time = data.endTime;
+      } else if (typeof data.endTime === "string" && data.date) {
+        const [endHour, endMinute] = data.endTime.split(":").map(Number);
+        const endDate = new Date(data.date);
+        endDate.setHours(endHour, endMinute, 0, 0);
+        updateData.end_time = endDate;
+      }
+    }
 
     const result = await this.db
       .update(lessonTable)
-      .set({
-        title: data.title,
-        room_id: data.roomId,
-        start_time: startDate,
-        end_time: endDate,
-      })
+      .set(updateData)
       .where(eq(lessonTable.id, lessonId))
       .returning();
 

packages/server/src/feature/lesson/interface/IRepository.ts

@@ -18,12 +18,12 @@ export interface CreateLessonData {
 }
 
 export interface UpdateLessonData {
-  title: string;
-  roomId: string;
-  startTime: string;
-  endTime: string;
-  dayOfWeek: string;
-  date: string;
+  title?: string;
+  roomId?: string | null;
+  startTime?: string | Date;
+  endTime?: string | Date;
+  dayOfWeek?: string;
+  date?: string;
 }
 
 export interface ILessonRepository {

packages/server/src/feature/planning/Controller.ts

@@ -76,8 +76,10 @@ export class PlanningController {
     return reply.status(200).send({
       message: PlanningMessage.LESSONS_IMPORTED_SUCCESSFULLY,
       importedCount: importResult.importedCount,
+      updatedCount: importResult.updatedCount,
       skippedCount: importResult.skippedCount,
       errors: importResult.errors,
+      optimization: importResult.optimization,
     });
 
   }

packages/server/src/feature/planning/Interactor.ts

@@ -4,6 +4,7 @@ import { PlanningError } from "./../../middleware/error/planningError";
 import { RoomRepository } from "../room/Repository";
 import { LessonRepository } from "../lesson/Repository";
 import { ClassRepository } from "../class/Repository";
+import { UserRepository } from "../user/Repository";
 import { RoomError } from "../../middleware/error/roomError";
 import { LessonError } from "../../middleware/error/lessonError";
 import { WeeklyPlanningData, ImportResult, ImportError, ImportedLesson, ImportedLessonSchema, PlanningFilterOptions } from "./validate";
@@ -19,6 +20,7 @@ export class PlanningInteractor implements IPlanningInteractor {
     private roomRepository: RoomRepository,
     private lessonRepository: LessonRepository,
     private classRepository: ClassRepository,
+    private userRepository: UserRepository,
     private optimizationService: OptimizationService,
   ) { }
 
@@ -66,6 +68,7 @@ export class PlanningInteractor implements IPlanningInteractor {
   async importLessonsFromTemplate(fileBuffer: Buffer): Promise<ImportResult> {
     const errors: ImportError[] = [];
     let importedCount = 0;
+    let updatedCount = 0;
     let skippedCount = 0;
     let earliestDate: Date | null = null;
     let latestDate: Date | null = null;
@@ -157,30 +160,114 @@ export class PlanningInteractor implements IPlanningInteractor {
           continue;
         }
 
-        const existingLesson = await this.lessonRepository.findLessonByDetails(
+        let teacherId: string | null = null;
+        if (validatedLesson.teacherName && validatedLesson.teacherName.trim()) {
+          const nameParts = validatedLesson.teacherName.trim().split(" ");
+          if (nameParts.length >= 2) {
+            const firstName = nameParts[0];
+            const lastName = nameParts.slice(1).join(" ");
+            const teacher = await this.userRepository.findTeacherByName(firstName, lastName);
+            if (teacher) {
+              teacherId = teacher.id;
+            } else {
+              errors.push({
+                row: rowIndex + 1,
+                field: "teacher_name",
+                message: `Teacher "${validatedLesson.teacherName}" not found`,
+              });
+            }
+          }
+        }
+
+        const overlappingLessons = await this.lessonRepository.findOverlappingLessons(
           classEntity.id,
           startDateTime,
           endDateTime,
         );
 
-        if (existingLesson) {
-          skippedCount++;
-        } else {
-          await this.lessonRepository.createLesson({
+        const lessonsToDelete = overlappingLessons.filter(lesson => !lesson.room_id);
+        for (const lessonToDelete of lessonsToDelete) {
+          await this.lessonRepository.deleteLesson(lessonToDelete.id);
+        }
+
+        const lessonsWithRoom = overlappingLessons.filter(lesson => lesson.room_id);
+        
+        let lessonCreated = false;
+        
+        if (lessonsWithRoom.length > 0) {
+          if (lessonsWithRoom.length > 1) {
+            errors.push({
+              row: rowIndex + 1,
+              field: "time",
+              message: "Multiple lessons with rooms overlap this time slot. Using the first one.",
+            });
+          }
+          
+          const lessonToUpdate = lessonsWithRoom[0];
+          
+          // Check if there are actual changes
+          const hasTimeChanged = lessonToUpdate.start_time.getTime() !== startDateTime.getTime() || 
+                                lessonToUpdate.end_time.getTime() !== endDateTime.getTime();
+          const hasTitleChanged = lessonToUpdate.title !== validatedLesson.title;
+          
+          // Get current teacher to check if it changed
+          const lessonWithRelations = await this.lessonRepository.getLessonWithRelations(lessonToUpdate.id);
+          const currentTeacherId = lessonWithRelations?.users?.[0]?.id;
+          const hasTeacherChanged = teacherId && teacherId !== currentTeacherId;
+          
+          if (hasTimeChanged || hasTitleChanged || hasTeacherChanged) {
+            // There are changes - update the lesson
+            const updateData: any = {};
+            if (hasTimeChanged) {
+              updateData.startTime = startDateTime;
+              updateData.endTime = endDateTime;
+            }
+            if (hasTitleChanged) {
+              updateData.title = validatedLesson.title;
+            }
+            
+            if (Object.keys(updateData).length > 0) {
+              await this.lessonRepository.updateLesson(lessonToUpdate.id, updateData);
+            }
+            
+            if (hasTeacherChanged && teacherId) {
+              await this.lessonRepository.updateLessonTeacher(lessonToUpdate.id, teacherId);
+            }
+            
+            updatedCount++;
+            
+            if (!earliestDate || startDateTime < earliestDate) {
+              earliestDate = startDateTime;
+            }
+            if (!latestDate || endDateTime > latestDate) {
+              latestDate = endDateTime;
+            }
+          } else {
+            skippedCount++;
+          }
+          
+          lessonCreated = true;
+        }
+
+        if (!lessonCreated) {
+          const newLesson = await this.lessonRepository.createLesson({
             title: validatedLesson.title,
             startTime: startDateTime,
             endTime: endDateTime,
             classId: classEntity.id,
             roomId: null,
           });
+          if (teacherId) {
+            await this.lessonRepository.updateLessonTeacher(newLesson.id, teacherId);
+          }
           importedCount++;
+        }
 
-          if (!earliestDate || startDateTime < earliestDate) {
-            earliestDate = startDateTime;
-          }
-          if (!latestDate || endDateTime > latestDate) {
-            latestDate = endDateTime;
-          }
+        if (!earliestDate || startDateTime < earliestDate) {
+          earliestDate = startDateTime;
+        }
+        if (!latestDate || endDateTime > latestDate) {
+          latestDate = endDateTime;
         }
       } catch (error) {
         if (error instanceof Error) {
@@ -194,7 +281,7 @@ export class PlanningInteractor implements IPlanningInteractor {
 
     let optimizationStatus = undefined;
 
-    if (importedCount > 0 && earliestDate && latestDate) {
+    if ((importedCount > 0 || updatedCount > 0) && earliestDate && latestDate) {
       try {
         await this.optimizationService.optimizeDateRange(earliestDate, latestDate);
         optimizationStatus = { status: "success" as const };
@@ -209,6 +296,7 @@ export class PlanningInteractor implements IPlanningInteractor {
 
     return {
       importedCount,
+      updatedCount,
       skippedCount,
       errors,
       optimization: optimizationStatus,

packages/server/src/feature/planning/validate.ts

@@ -67,6 +67,7 @@ const OptimizationStatusSchema = z.object({
 
 export const ImportResultSchema = z.object({
   importedCount: z.number(),
+  updatedCount: z.number(),
   skippedCount: z.number(),
   errors: z.array(ImportErrorSchema),
   optimization: OptimizationStatusSchema.optional(),
@@ -75,6 +76,7 @@ export const ImportResultSchema = z.object({
 export const ImportLessonResponseSchema = z.object({
   message: z.string(),
   importedCount: z.number(),
+  updatedCount: z.number(),
   skippedCount: z.number(),
   errors: z.array(ImportErrorSchema),
   optimization: OptimizationStatusSchema.optional(),