@hed-hog/lms 0.0.365 → 0.0.370

package/src/training/training.service.ts

@@ -1,7 +1,7 @@
 import { PrismaService } from '@hed-hog/api-prisma';
 import { IntegrationDeveloperApiService } from '@hed-hog/core';
 import { Inject, Injectable, forwardRef } from '@nestjs/common';
-import { CreateTrainingDto, LearningPathItemDto } from './dto/create-training.dto';
+import { CreateTrainingDto, LearningPathItemDto, LearningPathModuleDto } from './dto/create-training.dto';
 import { UpdateTrainingDto } from './dto/update-training.dto';
 
 @Injectable()
@@ -63,6 +63,35 @@ export class TrainingService {
     return extrasById;
   }
 
+  private async getTrainingCertificateTemplate(id: number): Promise<{
+    id: number;
+    name: string;
+    template_content: string;
+    status: string;
+  } | null> {
+    try {
+      const rows = (await this.prisma.$queryRawUnsafe(
+        `
+          SELECT ct.id, ct.name, ct.template_content, ct.status
+          FROM learning_path lp
+          JOIN certificate_template ct ON ct.id = lp.certificate_template_id
+          WHERE lp.id = $1
+          LIMIT 1
+        `,
+        id,
+      )) as Array<{
+        id: number;
+        name: string;
+        template_content: string;
+        status: string;
+      }>;
+
+      return rows[0] ?? null;
+    } catch {
+      return null;
+    }
+  }
+
   private async persistTrainingProgressMode(
     id: number,
     progressMode?: 'sequential' | 'free',
@@ -86,6 +115,29 @@ export class TrainingService {
     }
   }
 
+  private async persistTrainingCertificateTemplateId(
+    id: number,
+    certificateTemplateId?: number | null,
+  ) {
+    if (certificateTemplateId === undefined) {
+      return;
+    }
+
+    try {
+      await this.prisma.$executeRawUnsafe(
+        `
+          UPDATE learning_path
+          SET certificate_template_id = $1
+          WHERE id = $2
+        `,
+        certificateTemplateId ?? null,
+        id,
+      );
+    } catch {
+      // Some environments may still be behind the current learning_path schema.
+    }
+  }
+
   async list(params: {
     page?: number;
     pageSize?: number;
@@ -147,32 +199,43 @@ export class TrainingService {
         where,
         orderBy: { created_at: 'desc' },
         include: {
-          learning_path_step: {
+          learning_path_module: {
             orderBy: { order: 'asc' },
             include: {
-              course: {
-                select: {
-                  id: true,
-                  title: true,
-                  duration_hours: true,
-                  course_category: {
-                    include: {
-                      category: {
-                        select: { slug: true },
+              learning_path_step: {
+                orderBy: { order: 'asc' },
+                include: {
+                  course: {
+                    select: {
+                      id: true,
+                      title: true,
+                      duration_hours: true,
+                      course_category: {
+                        include: {
+                          category: {
+                            select: { slug: true },
+                          },
+                        },
                       },
                     },
                   },
-                },
-              },
-              exam: {
-                select: {
-                  id: true,
-                  title: true,
-                  time_limit_minutes: true,
+                  exam: {
+                    select: {
+                      id: true,
+                      title: true,
+                      time_limit_minutes: true,
+                    },
+                  },
                 },
               },
             },
           },
+          learning_path_image: {
+            where: { image_type: { slug: 'learning-path-banner' } },
+            include: { file: { select: { id: true } } },
+            orderBy: [{ is_primary: 'desc' as const }, { order: 'asc' as const }],
+            take: 1,
+          },
           _count: {
             select: {
               learning_path_enrollment: true,
@@ -216,35 +279,54 @@ export class TrainingService {
   }
 
   async getById(id: number) {
-    const path = await this.prisma.learning_path.findUnique({
-      where: { id },
+    const stepInclude = {
+      orderBy: { order: 'asc' as const },
       include: {
-        learning_path_step: {
-          orderBy: { order: 'asc' },
-          include: {
-            course: {
-              select: {
-                id: true,
-                title: true,
-                duration_hours: true,
-                course_category: {
-                  include: {
-                    category: {
-                      select: { slug: true },
-                    },
-                  },
+        course: {
+          select: {
+            id: true,
+            title: true,
+            duration_hours: true,
+            course_category: {
+              include: {
+                category: {
+                  select: { slug: true },
                 },
               },
             },
-            exam: {
-              select: {
-                id: true,
-                title: true,
-                time_limit_minutes: true,
-              },
+            course_image: {
+              where: { image_type: { slug: 'course-logo' } },
+              select: { file: { select: { id: true } } },
+              orderBy: { order: 'asc' as const },
+              take: 1,
             },
           },
         },
+        exam: {
+          select: {
+            id: true,
+            title: true,
+            time_limit_minutes: true,
+          },
+        },
+      },
+    };
+
+    const path = await this.prisma.learning_path.findUnique({
+      where: { id },
+      include: {
+        learning_path_module: {
+          orderBy: { order: 'asc' },
+          include: {
+            learning_path_step: stepInclude,
+          },
+        },
+        learning_path_image: {
+          where: { image_type: { slug: 'learning-path-banner' } },
+          include: { file: { select: { id: true } } },
+          orderBy: [{ is_primary: 'desc' as const }, { order: 'asc' as const }],
+          take: 1,
+        },
         _count: {
           select: {
             learning_path_enrollment: true,
@@ -256,13 +338,17 @@ export class TrainingService {
 
     if (!path) return null;
 
-    const extrasById = await this.getTrainingExtras([id]);
-    return this.mapTraining(path, extrasById.get(id));
+    const [extrasById, certificateTemplate] = await Promise.all([
+      this.getTrainingExtras([id]),
+      this.getTrainingCertificateTemplate(id),
+    ]);
+    return this.mapTraining(path, extrasById.get(id), certificateTemplate);
   }
 
   async create(dto: CreateTrainingDto) {
     const slug = dto.slug?.trim() || this.slugify(dto.title);
-    const stepItems = this.resolveIncomingSteps(dto);
+    const hasModules = (dto.modules?.length ?? 0) > 0;
+    const stepItems = hasModules ? [] : this.resolveIncomingSteps(dto);
     const normalizedLevel = this.normalizeLevel(dto.level) ?? 'beginner';
     const normalizedStatus = this.normalizeStatus(dto.status) ?? 'draft';
     const normalizedProgressMode =
@@ -278,41 +364,8 @@ export class TrainingService {
         status: normalizedStatus,
         ...(dto.primaryColor !== undefined && { primary_color: dto.primaryColor }),
         ...(dto.secondaryColor !== undefined && { secondary_color: dto.secondaryColor }),
-        ...(stepItems.length > 0 && {
-          learning_path_step: {
-            create: stepItems.map((item, index) =>
-              this.toLearningPathCreateStep(item, index),
-            ),
-          },
-        }),
       },
       include: {
-        learning_path_step: {
-          orderBy: { order: 'asc' },
-          include: {
-            course: {
-              select: {
-                id: true,
-                title: true,
-                duration_hours: true,
-                course_category: {
-                  include: {
-                    category: {
-                      select: { slug: true },
-                    },
-                  },
-                },
-              },
-            },
-            exam: {
-              select: {
-                id: true,
-                title: true,
-                time_limit_minutes: true,
-              },
-            },
-          },
-        },
         _count: {
           select: {
             learning_path_enrollment: true,
@@ -322,14 +375,48 @@ export class TrainingService {
       },
     });
 
+    if (hasModules) {
+      const resolvedModules = this.resolveIncomingModules(dto.modules!);
+      for (const mod of resolvedModules) {
+        await this.prisma.learning_path_module.create({
+          data: {
+            learning_path_id: created.id,
+            title: mod.title,
+            description: mod.description,
+            order: mod.order,
+            learning_path_step: {
+              create: mod.items.map((item) => ({
+                ...this.toLearningPathCreateStep(item, item.order),
+                learning_path_id: created.id,
+              })),
+            },
+          },
+        });
+      }
+    } else if (stepItems.length > 0) {
+      await this.prisma.learning_path_module.create({
+        data: {
+          learning_path_id: created.id,
+          title: '',
+          order: 0,
+          learning_path_step: {
+            create: stepItems.map((item, index) => ({
+              ...this.toLearningPathCreateStep(item, index),
+              learning_path_id: created.id,
+            })),
+          },
+        },
+      });
+    }
+
     await this.persistTrainingProgressMode(created.id, normalizedProgressMode);
+    await this.persistTrainingCertificateTemplateId(created.id, dto.certificateTemplateId);
 
-    const extrasById = await this.getTrainingExtras([created.id]);
+    if (dto.bannerFileId !== undefined) {
+      await this.syncLearningPathImage(created.id, dto.bannerFileId);
+    }
 
-    const trainingResult = this.mapTraining(
-      created,
-      extrasById.get(created.id),
-    );
+    const result = await this.getById(created.id);
 
     await this.integrationApi.publishEvent({
       eventName: 'lms.training.created',
@@ -339,12 +426,13 @@ export class TrainingService {
       payload: { id: created.id, title: dto.title, slug, status: normalizedStatus },
     }).catch(() => null);
 
-    return trainingResult;
+    return result;
   }
 
   async update(id: number, dto: UpdateTrainingDto) {
-    const stepItems = this.resolveIncomingSteps(dto);
-    const stepsWereProvided = dto.items !== undefined || dto.courseIds !== undefined;
+    const modulesWereProvided = dto.modules !== undefined;
+    const stepsWereProvided = !modulesWereProvided && (dto.items !== undefined || dto.courseIds !== undefined);
+    const stepItems = stepsWereProvided ? this.resolveIncomingSteps(dto) : [];
     const normalizedLevel =
       dto.level !== undefined ? this.normalizeLevel(dto.level) : undefined;
     const normalizedStatus =
@@ -354,15 +442,18 @@ export class TrainingService {
         ? this.normalizeProgressMode(dto.progressMode)
         : undefined;
 
-    if (stepsWereProvided) {
+    if (modulesWereProvided) {
+      // Delete all modules — CASCADE removes their steps automatically
+      await this.prisma.learning_path_module.deleteMany({
+        where: { learning_path_id: id },
+      });
+    } else if (stepsWereProvided) {
       await this.prisma.learning_path_step.deleteMany({
-        where: {
-          learning_path_id: id,
-        },
+        where: { learning_path_id: id },
       });
     }
 
-    const updated = await this.prisma.learning_path.update({
+    await this.prisma.learning_path.update({
       where: { id },
       data: {
         ...(dto.title !== undefined && { title: dto.title }),
@@ -375,56 +466,53 @@ export class TrainingService {
         ...(normalizedStatus !== undefined && { status: normalizedStatus }),
         ...(dto.primaryColor !== undefined && { primary_color: dto.primaryColor }),
         ...(dto.secondaryColor !== undefined && { secondary_color: dto.secondaryColor }),
-        ...(stepsWereProvided &&
-          stepItems.length > 0 && {
-            learning_path_step: {
-              create: stepItems.map((item, index) =>
-                this.toLearningPathCreateStep(item, index),
-              ),
-            },
-          }),
       },
-      include: {
-        learning_path_step: {
-          orderBy: { order: 'asc' },
-          include: {
-            course: {
-              select: {
-                id: true,
-                title: true,
-                duration_hours: true,
-                course_category: {
-                  include: {
-                    category: {
-                      select: { slug: true },
-                    },
-                  },
-                },
-              },
-            },
-            exam: {
-              select: {
-                id: true,
-                title: true,
-                time_limit_minutes: true,
-              },
+    });
+
+    if (modulesWereProvided) {
+      const resolvedModules = this.resolveIncomingModules(dto.modules!);
+      for (const mod of resolvedModules) {
+        await this.prisma.learning_path_module.create({
+          data: {
+            learning_path_id: id,
+            title: mod.title,
+            description: mod.description,
+            order: mod.order,
+            learning_path_step: {
+              create: mod.items.map((item) => ({
+                ...this.toLearningPathCreateStep(item, item.order),
+                learning_path_id: id,
+              })),
             },
           },
-        },
-        _count: {
-          select: {
-            learning_path_enrollment: true,
-            learning_path_step: true,
+        });
+      }
+    } else if (stepsWereProvided && stepItems.length > 0) {
+      await this.prisma.learning_path_module.create({
+        data: {
+          learning_path_id: id,
+          title: '',
+          order: 0,
+          learning_path_step: {
+            create: stepItems.map((item, index) => ({
+              ...this.toLearningPathCreateStep(item, index),
+              learning_path_id: id,
+            })),
           },
         },
-      },
-    });
+      });
+    }
 
     await this.persistTrainingProgressMode(id, normalizedProgressMode);
+    if (dto.certificateTemplateId !== undefined) {
+      await this.persistTrainingCertificateTemplateId(id, dto.certificateTemplateId);
+    }
 
-    const extrasById = await this.getTrainingExtras([id]);
+    if (dto.bannerFileId !== undefined) {
+      await this.syncLearningPathImage(id, dto.bannerFileId);
+    }
 
-    const updateTrainingResult = this.mapTraining(updated, extrasById.get(id));
+    const updateTrainingResult = await this.getById(id);
 
     await this.integrationApi.publishEvent({
       eventName: 'lms.training.updated',
@@ -451,15 +539,53 @@ export class TrainingService {
     return { success: true };
   }
 
+  private mapStep(step: any, index: number) {
+    if (step?.course) {
+      const logoFileId = step.course.course_image?.[0]?.file?.id ?? null;
+      return {
+        id: step.id,
+        type: 'course' as const,
+        itemId: step.course.id,
+        title: step.course.title,
+        durationHours: step.course.duration_hours ?? 0,
+        order: step.order ?? index,
+        isRequired: step.is_required !== false,
+        logoImage: logoFileId ? `/file/open/${logoFileId}` : null,
+      };
+    }
+    if (step?.exam) {
+      return {
+        id: step.id,
+        type: 'exam' as const,
+        itemId: step.exam.id,
+        title: step.exam.title,
+        durationMinutes: step.exam.time_limit_minutes ?? 0,
+        order: step.order ?? index,
+        isRequired: step.is_required !== false,
+        logoImage: null,
+      };
+    }
+    return null;
+  }
+
   private mapTraining(
     path: any,
     extras?: { progress_mode?: 'sequential' | 'free' | null },
+    certificateTemplate?: { id: number; name: string; template_content: string; status: string } | null,
   ) {
-    const steps = [...(path.learning_path_step ?? [])].sort(
+    const modulesRaw = [...(path.learning_path_module ?? [])].sort(
       (a: any, b: any) => (a?.order ?? 0) - (b?.order ?? 0),
     );
-    const courseSteps = steps.filter((step: any) => step?.course);
-    const examSteps = steps.filter((step: any) => step?.exam);
+
+    // All steps across all modules (flattened, for backward-compat fields)
+    const allSteps = modulesRaw.flatMap((mod: any) =>
+      [...(mod.learning_path_step ?? [])].sort(
+        (a: any, b: any) => (a?.order ?? 0) - (b?.order ?? 0),
+      ),
+    );
+
+    const courseSteps = allSteps.filter((step: any) => step?.course);
+    const examSteps = allSteps.filter((step: any) => step?.exam);
 
     const courses = courseSteps.map((step: any) => step.course.title);
     const exams = examSteps.map((step: any) => step.exam.title);
@@ -470,40 +596,25 @@ export class TrainingService {
       0,
     );
 
-    const firstCategorySlug = steps
+    const firstCategorySlug = allSteps
       .flatMap((step: any) => step.course?.course_category ?? [])
       .map((item: any) => item.category?.slug)
       .find(Boolean);
 
-    const items = steps
-      .map((step: any, index: number) => {
-        if (step?.course) {
-          return {
-            id: step.id,
-            type: 'course' as const,
-            itemId: step.course.id,
-            title: step.course.title,
-            durationHours: step.course.duration_hours ?? 0,
-            order: step.order ?? index,
-            isRequired: step.is_required !== false,
-          };
-        }
-
-        if (step?.exam) {
-          return {
-            id: step.id,
-            type: 'exam' as const,
-            itemId: step.exam.id,
-            title: step.exam.title,
-            durationMinutes: step.exam.time_limit_minutes ?? 0,
-            order: step.order ?? index,
-            isRequired: step.is_required !== false,
-          };
-        }
-
-        return null;
-      })
-      .filter(Boolean);
+    const items = allSteps.map(this.mapStep.bind(this)).filter(Boolean);
+
+    const modules = modulesRaw.map((mod: any, modIndex: number) => ({
+      id: mod.id,
+      title: mod.title,
+      description: mod.description ?? null,
+      order: mod.order ?? modIndex,
+      items: [...(mod.learning_path_step ?? [])]
+        .sort((a: any, b: any) => (a?.order ?? 0) - (b?.order ?? 0))
+        .map(this.mapStep.bind(this))
+        .filter(Boolean),
+    }));
+
+    const bannerImage = (path.learning_path_image ?? [])[0];
 
     return {
       id: path.id,
@@ -517,6 +628,7 @@ export class TrainingService {
       courseIds,
       examIds,
       items,
+      modules,
       progressionMode: this.progressModeToPt(extras?.progress_mode),
       cargaTotal,
       alunos: path._count?.learning_path_enrollment ?? 0,
@@ -524,12 +636,21 @@ export class TrainingService {
       criadoEm: path.created_at,
       primaryColor: path.primary_color ?? undefined,
       secondaryColor: path.secondary_color ?? undefined,
+      bannerFileId: bannerImage?.file?.id ?? null,
       code: this.idToCode(path.id),
       slug: path.slug,
       level: path.level,
       statusRaw: path.status,
       students: path._count?.learning_path_enrollment ?? 0,
       createdAt: path.created_at,
+      certificateTemplate: certificateTemplate
+        ? {
+            id: certificateTemplate.id,
+            name: certificateTemplate.name,
+            templateContent: certificateTemplate.template_content,
+            status: certificateTemplate.status,
+          }
+        : null,
     };
   }
 
@@ -574,6 +695,27 @@ export class TrainingService {
     }));
   }
 
+  private resolveIncomingModules(modules: LearningPathModuleDto[]) {
+    return modules.map((mod, i) => ({
+      title: mod.title,
+      description: mod.description,
+      order: Number.isFinite(mod.order) ? (mod.order as number) : i,
+      items: (mod.items ?? [])
+        .map((item, j) => ({
+          type: item.type,
+          itemId: Number(item.itemId),
+          order: Number.isFinite(item.order) ? (item.order as number) : j,
+          isRequired: item.isRequired !== false,
+        }))
+        .filter(
+          (item) =>
+            (item.type === 'course' || item.type === 'exam') &&
+            Number.isFinite(item.itemId) &&
+            item.itemId > 0,
+        ),
+    }));
+  }
+
   private toLearningPathCreateStep(
     item: {
       type: 'course' | 'exam';
@@ -704,4 +846,59 @@ export class TrainingService {
   private idToCode(id: number) {
     return `TR-${String(id).padStart(3, '0')}`;
   }
+
+  private async syncLearningPathImage(pathId: number, fileId: number | null) {
+    const imageType = await this.prisma.image_type.findFirst({
+      where: { slug: 'learning-path-banner', applies_to_learning_path: true },
+      select: { id: true },
+    });
+
+    if (!imageType) return;
+
+    if (fileId === null) {
+      await this.prisma.learning_path_image.deleteMany({
+        where: { learning_path_id: pathId, image_type_id: imageType.id },
+      });
+      return;
+    }
+
+    const normalizedFileId = Number(fileId);
+    if (!Number.isInteger(normalizedFileId) || normalizedFileId <= 0) return;
+
+    const file = await this.prisma.file.findUnique({
+      where: { id: normalizedFileId },
+      select: { id: true },
+    });
+    if (!file) return;
+
+    const existing = await this.prisma.learning_path_image.findMany({
+      where: { learning_path_id: pathId, image_type_id: imageType.id },
+      orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
+      select: { id: true },
+    });
+
+    if (existing.length > 0) {
+      const [primary, ...duplicates] = existing;
+      await this.prisma.learning_path_image.update({
+        where: { id: primary.id },
+        data: { file_id: normalizedFileId, is_primary: true },
+      });
+      if (duplicates.length > 0) {
+        await this.prisma.learning_path_image.deleteMany({
+          where: { id: { in: duplicates.map((r) => r.id) } },
+        });
+      }
+      return;
+    }
+
+    await this.prisma.learning_path_image.create({
+      data: {
+        learning_path_id: pathId,
+        file_id: normalizedFileId,
+        image_type_id: imageType.id,
+        order: 0,
+        is_primary: true,
+      },
+    });
+  }
 }