@hed-hog/lms 0.0.331 → 0.0.347

package/src/training/training.service.ts

@@ -12,6 +12,80 @@ export class TrainingService {
     private readonly integrationApi: IntegrationDeveloperApiService,
   ) {}
 
+  private normalizeProgressMode(value?: string | null) {
+    if (!value) return undefined;
+    const normalized = value.trim().toLowerCase();
+
+    if (normalized === 'free' || normalized === 'livre') return 'free';
+    if (normalized === 'sequential' || normalized === 'sequencial') {
+      return 'sequential';
+    }
+
+    return undefined;
+  }
+
+  private progressModeToPt(value?: string | null) {
+    return this.normalizeProgressMode(value) === 'free' ? 'livre' : 'sequencial';
+  }
+
+  private async getTrainingExtras(ids: number[]) {
+    const extrasById = new Map<number, { progress_mode?: 'sequential' | 'free' | null }>();
+
+    const normalizedIds = ids
+      .map((id) => Number(id))
+      .filter((id) => Number.isInteger(id) && id > 0);
+
+    if (normalizedIds.length === 0) {
+      return extrasById;
+    }
+
+    try {
+      const rows = (await this.prisma.$queryRawUnsafe(
+        `
+          SELECT id, progress_mode
+          FROM learning_path
+          WHERE id IN (${normalizedIds.join(',')})
+        `,
+      )) as Array<{
+        id: number;
+        progress_mode: 'sequential' | 'free' | null;
+      }>;
+
+      for (const row of rows) {
+        extrasById.set(row.id, {
+          progress_mode: row.progress_mode,
+        });
+      }
+    } catch {
+      return extrasById;
+    }
+
+    return extrasById;
+  }
+
+  private async persistTrainingProgressMode(
+    id: number,
+    progressMode?: 'sequential' | 'free',
+  ) {
+    if (progressMode === undefined) {
+      return;
+    }
+
+    try {
+      await this.prisma.$executeRawUnsafe(
+        `
+          UPDATE learning_path
+          SET progress_mode = $1
+          WHERE id = $2
+        `,
+        progressMode,
+        id,
+      );
+    } catch {
+      // Some environments may still be behind the current learning_path schema.
+    }
+  }
+
   async list(params: {
     page?: number;
     pageSize?: number;
@@ -110,12 +184,14 @@ export class TrainingService {
       this.prisma.learning_path.count({ where }),
     ]);
 
+    const extrasById = await this.getTrainingExtras(paths.map((path) => path.id));
+
     return {
       total,
       page,
       pageSize,
       lastPage: Math.max(1, Math.ceil(total / pageSize)),
-      data: paths.map((path) => this.mapTraining(path)),
+      data: paths.map((path) => this.mapTraining(path, extrasById.get(path.id))),
     };
   }
 
@@ -179,7 +255,9 @@ export class TrainingService {
     });
 
     if (!path) return null;
-    return this.mapTraining(path);
+
+    const extrasById = await this.getTrainingExtras([id]);
+    return this.mapTraining(path, extrasById.get(id));
   }
 
   async create(dto: CreateTrainingDto) {
@@ -187,6 +265,8 @@ export class TrainingService {
     const stepItems = this.resolveIncomingSteps(dto);
     const normalizedLevel = this.normalizeLevel(dto.level) ?? 'beginner';
     const normalizedStatus = this.normalizeStatus(dto.status) ?? 'draft';
+    const normalizedProgressMode =
+      this.normalizeProgressMode(dto.progressMode) ?? 'sequential';
 
     const created = await this.prisma.learning_path.create({
       data: {
@@ -242,7 +322,14 @@ export class TrainingService {
       },
     });
 
-    const trainingResult = this.mapTraining(created);
+    await this.persistTrainingProgressMode(created.id, normalizedProgressMode);
+
+    const extrasById = await this.getTrainingExtras([created.id]);
+
+    const trainingResult = this.mapTraining(
+      created,
+      extrasById.get(created.id),
+    );
 
     await this.integrationApi.publishEvent({
       eventName: 'lms.training.created',
@@ -262,6 +349,10 @@ export class TrainingService {
       dto.level !== undefined ? this.normalizeLevel(dto.level) : undefined;
     const normalizedStatus =
       dto.status !== undefined ? this.normalizeStatus(dto.status) : undefined;
+    const normalizedProgressMode =
+      dto.progressMode !== undefined
+        ? this.normalizeProgressMode(dto.progressMode)
+        : undefined;
 
     if (stepsWereProvided) {
       await this.prisma.learning_path_step.deleteMany({
@@ -329,7 +420,11 @@ export class TrainingService {
       },
     });
 
-    const updateTrainingResult = this.mapTraining(updated);
+    await this.persistTrainingProgressMode(id, normalizedProgressMode);
+
+    const extrasById = await this.getTrainingExtras([id]);
+
+    const updateTrainingResult = this.mapTraining(updated, extrasById.get(id));
 
     await this.integrationApi.publishEvent({
       eventName: 'lms.training.updated',
@@ -356,7 +451,10 @@ export class TrainingService {
     return { success: true };
   }
 
-  private mapTraining(path: any) {
+  private mapTraining(
+    path: any,
+    extras?: { progress_mode?: 'sequential' | 'free' | null },
+  ) {
     const steps = [...(path.learning_path_step ?? [])].sort(
       (a: any, b: any) => (a?.order ?? 0) - (b?.order ?? 0),
     );
@@ -419,6 +517,7 @@ export class TrainingService {
       courseIds,
       examIds,
       items,
+      progressionMode: this.progressModeToPt(extras?.progress_mode),
       cargaTotal,
       alunos: path._count?.learning_path_enrollment ?? 0,
       status: this.statusToPt(path.status),