@hed-hog/lms 0.0.349 → 0.0.350

package/src/course/course-structure.service.ts

@@ -1,12 +1,14 @@
 import { PrismaService } from '@hed-hog/api-prisma';
 import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
 import { InstructorService } from '../instructor/instructor.service';
+import { CourseOperationsIntegrationService } from './course-operations-integration.service';
 import { CreateCourseStructureLessonDto } from './dto/create-course-structure-lesson.dto';
 import { CreateCourseStructureSessionDto } from './dto/create-course-structure-session.dto';
 import { MoveLessonDto } from './dto/move-lesson.dto';
 import { PasteLessonsDto } from './dto/paste-lessons.dto';
 import { ReorderLessonsDto } from './dto/reorder-lessons.dto';
 import { ReorderSessionsDto } from './dto/reorder-sessions.dto';
+import { UpdateCourseResourcesDto } from './dto/update-course-resources.dto';
 import { UpdateCourseStructureLessonDto } from './dto/update-course-structure-lesson.dto';
 import { UpdateCourseStructureSessionDto } from './dto/update-course-structure-session.dto';
 
@@ -18,12 +20,16 @@ export class CourseStructureService {
   constructor(
     private readonly prisma: PrismaService,
     private readonly instructorService: InstructorService,
+    private readonly operationsIntegration: CourseOperationsIntegrationService,
   ) {}
 
   async getStructure(courseId: number) {
     await this.ensureCourseExists(courseId);
 
-    const [modules, instructors, courseRecord] = await Promise.all([
+    const courseResources = await this.getCourseResources(courseId);
+
+    const [modules, instructors, courseRecord, courseProjectLinks] =
+      await Promise.all([
       this.prisma.course_module.findMany({
         where: { course_id: courseId },
         orderBy: { order: 'asc' },
@@ -56,9 +62,22 @@ export class CourseStructureService {
       this.instructorService.listQualifiedInstructorOptions(['course-lessons']),
       this.prisma.course.findUnique({
         where: { id: courseId },
-        select: { id: true, slug: true, title: true, description: true },
+        select: {
+          id: true,
+          name: true,
+          slug: true,
+          title: true,
+          description: true,
+          offering_type: true,
+        },
       }),
-    ]);
+      this.operationsIntegration.getCourseProjectLinks([courseId]),
+      ]);
+
+    const lessonTaskLinks = await this.operationsIntegration.getLessonTaskLinks(
+      modules.flatMap((module) => module.course_lesson.map((lesson) => lesson.id)),
+    );
+    const courseProject = courseProjectLinks.get(courseId);
 
     const sessoes = modules.map((module, index) => ({
       id: String(module.id),
@@ -105,6 +124,10 @@ export class CourseStructureService {
             role: item.role,
             nome: this.personName(item.instructor?.person),
           })),
+          operationsTaskId: lessonTaskLinks.get(lesson.id)?.taskId ?? null,
+          operationsTaskName: lessonTaskLinks.get(lesson.id)?.taskName ?? null,
+          operationsTaskStatus:
+            lessonTaskLinks.get(lesson.id)?.taskStatus ?? null,
         };
       }),
     );
@@ -119,14 +142,63 @@ export class CourseStructureService {
       curso: courseRecord
         ? {
             id: String(courseRecord.id),
+            name: courseRecord.name ?? '',
             slug: courseRecord.slug ?? '',
             titulo: courseRecord.title,
             descricao: courseRecord.description ?? '',
+            offeringType: courseRecord.offering_type ?? 'on_demand',
+            recursos: courseResources,
+            operationsProjectId: courseProject?.projectId ?? null,
+            operationsProjectCode: courseProject?.projectCode ?? null,
+            operationsProjectName: courseProject?.projectName ?? null,
           }
         : null,
     };
   }
 
+  async getCourseResources(courseId: number) {
+    await this.ensureCourseExists(courseId);
+
+    const rows = await this.prisma.$queryRaw<
+      Array<{ id: number; title: string; file_id: number | null }>
+    >`
+      SELECT id, title, file_id
+      FROM course_file
+      WHERE course_id = ${courseId}
+      ORDER BY id DESC
+    `;
+
+    return rows.map((row) => ({
+      id: row.id,
+      nome: row.title,
+      fileId: row.file_id,
+      tipo: 'file',
+      publico: true,
+    }));
+  }
+
+  async updateCourseResources(courseId: number, dto: UpdateCourseResourcesDto) {
+    await this.ensureCourseExists(courseId);
+
+    const recursos = dto.recursos ?? [];
+
+    await this.prisma.$transaction(async (tx) => {
+      await tx.$executeRaw`
+        DELETE FROM course_file
+        WHERE course_id = ${courseId}
+      `;
+
+      for (const recurso of recursos) {
+        await tx.$executeRaw`
+          INSERT INTO course_file (course_id, title, file_id)
+          VALUES (${courseId}, ${recurso.nome}, ${recurso.fileId ?? null})
+        `;
+      }
+    });
+
+    return this.getCourseResources(courseId);
+  }
+
   async createSession(courseId: number, dto: CreateCourseStructureSessionDto) {
     await this.ensureCourseExists(courseId);
     const nextOrder = await this.nextModuleOrder(courseId);
@@ -157,6 +229,13 @@ export class CourseStructureService {
   ) {
     const module = await this.prisma.course_module.findFirst({
       where: { id: sessionId, course_id: courseId },
+      include: {
+        course: {
+          select: {
+            title: true,
+          },
+        },
+      },
     });
 
     if (!module) {
@@ -184,6 +263,13 @@ export class CourseStructureService {
   async deleteSession(courseId: number, sessionId: number) {
     const module = await this.prisma.course_module.findFirst({
       where: { id: sessionId, course_id: courseId },
+      include: {
+        course: {
+          select: {
+            title: true,
+          },
+        },
+      },
     });
 
     if (!module) {
@@ -202,28 +288,54 @@ export class CourseStructureService {
   ) {
     const module = await this.prisma.course_module.findFirst({
       where: { id: sessionId, course_id: courseId },
+      include: {
+        course: {
+          select: {
+            title: true,
+          },
+        },
+      },
     });
 
     if (!module) {
       throw new NotFoundException('Session not found for this course');
     }
 
-    const nextOrder = await this.nextLessonOrder(sessionId);
-    const mappedType = this.mapUiTypeToDbType(dto.tipo);
+    const created = await this.prisma.$transaction(async (tx) => {
+      const nextOrder = await this.nextLessonOrder(sessionId, tx);
+      const mappedType = this.mapUiTypeToDbType(dto.tipo);
 
-    const created = await this.prisma.course_lesson.create({
-      data: {
-        course_module_id: sessionId,
-        title: dto.titulo,
-        description: dto.descricaoPublica ?? null,
-        type: mappedType,
-        duration_seconds: dto.duracao * 60,
-        order: nextOrder,
-        content: this.serializeContent(dto),
-      },
-    });
+      const lesson = await tx.course_lesson.create({
+        data: {
+          course_module_id: sessionId,
+          title: dto.titulo,
+          description: dto.descricaoPublica ?? null,
+          type: mappedType,
+          duration_seconds: dto.duracao * 60,
+          order: nextOrder,
+          content: this.serializeContent(dto),
+        },
+      });
 
-    await this.syncLessonRelations(created.id, dto);
+      await this.syncLessonRelations(lesson.id, dto, tx);
+
+      const projectLinks = await this.operationsIntegration.getCourseProjectLinks(
+        [courseId],
+        tx,
+      );
+
+      await this.operationsIntegration.createTaskForLesson(tx, {
+        courseId,
+        lessonId: lesson.id,
+        projectId: projectLinks.get(courseId)?.projectId ?? null,
+        courseTitle: module.course?.title ?? null,
+        sessionTitle: module.title,
+        lessonTitle: dto.titulo,
+        lessonDescription: dto.descricaoPublica ?? null,
+      });
+
+      return lesson;
+    });
 
     return this.getLessonById(created.id);
   }
@@ -271,6 +383,7 @@ export class CourseStructureService {
     });
 
     await this.syncLessonRelations(lessonId, dto);
+    await this.operationsIntegration.syncTaskForLesson(lessonId);
 
     return this.getLessonById(updated.id);
   }
@@ -440,6 +553,11 @@ export class CourseStructureService {
     const sourceModule = await this.prisma.course_module.findFirst({
       where: { id: sessionId, course_id: courseId },
       include: {
+        course: {
+          select: {
+            title: true,
+          },
+        },
         course_lesson: {
           orderBy: { order: 'asc' },
           include: {
@@ -468,6 +586,10 @@ export class CourseStructureService {
     });
 
     const newLessons = [];
+    const projectLinks = await this.operationsIntegration.getCourseProjectLinks([
+      courseId,
+    ]);
+    const projectId = projectLinks.get(courseId)?.projectId ?? null;
     for (const lesson of sourceModule.course_lesson) {
       const lessonOrder = await this.nextLessonOrder(newModule.id);
       const newLesson = await this.prisma.course_lesson.create({
@@ -512,6 +634,16 @@ export class CourseStructureService {
         });
       }
 
+      await this.operationsIntegration.createTaskForLesson(this.prisma, {
+        courseId,
+        lessonId: newLesson.id,
+        projectId,
+        courseTitle: sourceModule.course?.title ?? null,
+        sessionTitle: newModule.title,
+        lessonTitle: newLesson.title,
+        lessonDescription: newLesson.description,
+      });
+
       newLessons.push(await this.getLessonById(newLesson.id));
     }
 
@@ -535,6 +667,16 @@ export class CourseStructureService {
         course_module: { course_id: courseId },
       },
       include: {
+        course_module: {
+          select: {
+            title: true,
+            course: {
+              select: {
+                title: true,
+              },
+            },
+          },
+        },
         course_lesson_file: true,
         course_lesson_question: true,
         course_lesson_instructor: true,
@@ -546,6 +688,10 @@ export class CourseStructureService {
     }
 
     const nextOrder = await this.nextLessonOrder(sessionId);
+    const projectLinks = await this.operationsIntegration.getCourseProjectLinks([
+      courseId,
+    ]);
+    const projectId = projectLinks.get(courseId)?.projectId ?? null;
 
     const newLesson = await this.prisma.course_lesson.create({
       data: {
@@ -589,6 +735,16 @@ export class CourseStructureService {
       });
     }
 
+    await this.operationsIntegration.createTaskForLesson(this.prisma, {
+      courseId,
+      lessonId: newLesson.id,
+      projectId,
+      courseTitle: sourceLesson.course_module?.course?.title ?? null,
+      sessionTitle: sourceLesson.course_module?.title ?? null,
+      lessonTitle: newLesson.title,
+      lessonDescription: newLesson.description,
+    });
+
     return this.getLessonById(newLesson.id);
   }
 
@@ -619,6 +775,10 @@ export class CourseStructureService {
     }
 
     const result = [];
+    const projectLinks = await this.operationsIntegration.getCourseProjectLinks([
+      courseId,
+    ]);
+    const projectId = projectLinks.get(courseId)?.projectId ?? null;
     for (const lesson of sourceLessons) {
       const lessonOrder = await this.nextLessonOrder(targetSessionId);
       const newLesson = await this.prisma.course_lesson.create({
@@ -663,19 +823,30 @@ export class CourseStructureService {
         });
       }
 
+      await this.operationsIntegration.createTaskForLesson(this.prisma, {
+        courseId,
+        lessonId: newLesson.id,
+        projectId,
+        sessionTitle: targetModule.title,
+        lessonTitle: newLesson.title,
+        lessonDescription: newLesson.description,
+      });
+
       result.push(await this.getLessonById(newLesson.id));
     }
 
     return { lessons: result };
   }
 
-  private async syncLessonRelations(    lessonId: number,
+  private async syncLessonRelations(
+    lessonId: number,
     dto: Partial<
       Pick<
       CreateCourseStructureLessonDto,
       'tipo' | 'exameVinculado' | 'instructorIds' | 'recursos'
       >
     >,
+    client: any = this.prisma,
   ) {
     const instructorIds = [...new Set(dto.instructorIds ?? [])];
 
@@ -686,7 +857,7 @@ export class CourseStructureService {
       );
     }
 
-    await this.prisma.$transaction(async (tx) => {
+    const syncWithClient = async (tx: any) => {
       await tx.course_lesson_instructor.deleteMany({
         where: { course_lesson_id: lessonId },
       });
@@ -729,7 +900,14 @@ export class CourseStructureService {
           },
         });
       }
-    });
+    };
+
+    if (typeof client?.$transaction === 'function') {
+      await client.$transaction(async (tx: any) => syncWithClient(tx));
+      return;
+    }
+
+    await syncWithClient(client);
   }
 
   private async getLessonById(lessonId: number) {
@@ -737,7 +915,15 @@ export class CourseStructureService {
       where: { id: lessonId },
       include: {
         course_module: {
-          select: { id: true },
+          select: {
+            id: true,
+            title: true,
+            course: {
+              select: {
+                title: true,
+              },
+            },
+          },
         },
         course_lesson_file: true,
         course_lesson_question: {
@@ -764,6 +950,9 @@ export class CourseStructureService {
       throw new NotFoundException('Lesson not found');
     }
 
+    const taskLinks = await this.operationsIntegration.getLessonTaskLinks([
+      lessonId,
+    ]);
     const parsedContent = this.parseLessonContent(lesson.content);
     const tipo = this.mapDbTypeToUiType(lesson.type, parsedContent?.sourceType);
 
@@ -799,6 +988,9 @@ export class CourseStructureService {
         role: item.role,
         nome: this.personName(item.instructor?.person),
       })),
+      operationsTaskId: taskLinks.get(lessonId)?.taskId ?? null,
+      operationsTaskName: taskLinks.get(lessonId)?.taskName ?? null,
+      operationsTaskStatus: taskLinks.get(lessonId)?.taskStatus ?? null,
     };
   }
 
@@ -823,8 +1015,8 @@ export class CourseStructureService {
     return (last?.order ?? 0) + 1;
   }
 
-  private async nextLessonOrder(sessionId: number) {
-    const last = await this.prisma.course_lesson.findFirst({
+  private async nextLessonOrder(sessionId: number, client: any = this.prisma) {
+    const last = await client.course_lesson.findFirst({
       where: { course_module_id: sessionId },
       orderBy: { order: 'desc' },
       select: { order: true },