@hed-hog/lms 0.0.364 → 0.0.366

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

@@ -0,0 +1,280 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  FileService,
+  NotificationActionType,
+  NotificationService,
+  NotificationType,
+} from '@hed-hog/core';
+import { QueueJobService } from '@hed-hog/queue';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+  forwardRef,
+} from '@nestjs/common';
+import { CreateCourseExportDto } from './dto/create-course-export.dto';
+
+export const LMS_COURSE_EXPORT_SCORM12_JOB = 'lms.course.export.scorm12';
+
+export type VideoLessonWithFile = {
+  id: number;
+  title: string;
+  order: number;
+  content: string | null;
+  duration_seconds: number | null;
+  session: {
+    id: number;
+    title: string;
+    order: number;
+  };
+  files: {
+    id: number;
+    file_id: number | null;
+    type: string;
+    file: {
+      id: number;
+      path: string;
+      size: number | null;
+    } | null;
+  }[];
+};
+
+@Injectable()
+export class CourseExportService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => QueueJobService))
+    private readonly queueJob: QueueJobService,
+    @Inject(forwardRef(() => NotificationService))
+    private readonly notificationService: NotificationService,
+    @Inject(forwardRef(() => FileService))
+    private readonly fileService: FileService,
+  ) {}
+
+  async deleteExport(courseId: number, exportId: number): Promise<void> {
+    const record = await this.prisma.course_export.findUnique({
+      where: { id: exportId },
+      select: { id: true, course_id: true, status: true, file_id: true },
+    });
+
+    if (!record || record.course_id !== courseId) {
+      throw new NotFoundException('Exportação não encontrada.');
+    }
+
+    if (record.status === 'pending' || record.status === 'processing') {
+      throw new BadRequestException(
+        'Não é possível excluir uma exportação em andamento.',
+      );
+    }
+
+    if (record.file_id) {
+      await this.fileService
+        .delete('pt', { ids: [record.file_id] })
+        .catch(() => undefined);
+    }
+
+    await this.prisma.course_export.delete({ where: { id: exportId } });
+  }
+
+  async listExports(courseId: number) {
+    return this.prisma.course_export.findMany({
+      where: { course_id: courseId },
+      orderBy: { created_at: 'desc' },
+      include: {
+        user: {
+          select: {
+            id: true,
+            name: true,
+            photo_id: true,
+          },
+        },
+        file: {
+          select: {
+            id: true,
+            path: true,
+            filename: true,
+            size: true,
+          },
+        },
+      },
+    });
+  }
+
+  async enqueueScorm12Export(
+    courseId: number,
+    userId: number,
+    dto: CreateCourseExportDto,
+  ) {
+    const settings = {
+      visual: { ...(dto.visualSettings ?? {}) },
+    };
+
+    const exportRecord = await this.prisma.course_export.create({
+      data: {
+        course_id: courseId,
+        user_id: userId,
+        format: dto.format,
+        status: 'pending',
+        settings,
+      },
+    });
+
+    const course = await this.prisma.course.findUnique({
+      where: { id: courseId },
+      select: { title: true, name: true },
+    });
+    const courseTitle = course?.title || course?.name || `Curso ${courseId}`;
+
+    const notification = await this.notificationService.create({
+      user_id: userId,
+      title: `Exportando "${courseTitle}" — SCORM 1.2`,
+      body: 'Aguardando início do processamento...',
+      type: NotificationType.Progress,
+      progress: 1,
+      auto_remove: false,
+      action_type: NotificationActionType.Url,
+      action_url: `/lms/courses/${courseId}?tab=exportacoes`,
+      started_at: new Date().toISOString(),
+    });
+
+    const job = await this.queueJob.enqueue(
+      {
+        type: LMS_COURSE_EXPORT_SCORM12_JOB,
+        queueName: LMS_COURSE_EXPORT_SCORM12_JOB,
+        payload: {
+          exportId: exportRecord.id,
+          courseId,
+          userId,
+          notificationId: notification.id,
+          settings,
+        },
+        sourceModule: 'lms',
+        sourceEntity: 'course_export',
+        sourceEntityId: String(exportRecord.id),
+        maxAttempts: 3,
+      },
+      userId,
+    );
+
+    await this.prisma.course_export.update({
+      where: { id: exportRecord.id },
+      data: {
+        queue_job_id: job.id,
+        notification_id: notification.id,
+      },
+    });
+
+    return {
+      exportId: exportRecord.id,
+      queueJobId: job.id,
+      notificationId: notification.id,
+    };
+  }
+
+  async markStarted(exportId: number) {
+    await this.prisma.course_export.update({
+      where: { id: exportId },
+      data: {
+        status: 'processing',
+        started_at: new Date(),
+      },
+    });
+  }
+
+  async markCompleted(
+    exportId: number,
+    fileId: number,
+    durationSeconds: number,
+  ) {
+    await this.prisma.course_export.update({
+      where: { id: exportId },
+      data: {
+        status: 'completed',
+        file_id: fileId,
+        duration_seconds: durationSeconds,
+        finished_at: new Date(),
+      },
+    });
+  }
+
+  async markFailed(exportId: number, errorMessage: string) {
+    await this.prisma.course_export.update({
+      where: { id: exportId },
+      data: {
+        status: 'failed',
+        error_message: errorMessage,
+        finished_at: new Date(),
+      },
+    });
+  }
+
+  async getCourseVideoLessons(courseId: number): Promise<VideoLessonWithFile[]> {
+    const lessons = await this.prisma.course_lesson.findMany({
+      where: {
+        type: 'video',
+        course_module: {
+          course_id: courseId,
+        },
+      },
+      orderBy: [
+        { course_module: { order: 'asc' } },
+        { order: 'asc' },
+      ],
+      include: {
+        course_module: {
+          select: { id: true, title: true, order: true },
+        },
+        course_lesson_file: {
+          where: {
+            type: {
+              in: ['video_original', 'video_hls', 'video_profile:720p', 'video_profile:1080p'],
+            },
+          },
+          include: {
+            file: {
+              select: { id: true, path: true, size: true },
+            },
+          },
+          orderBy: { id: 'asc' },
+        },
+      },
+    });
+
+    return lessons.map((l) => ({
+      id: l.id,
+      title: l.title,
+      order: l.order,
+      content: l.content,
+      duration_seconds: l.duration_seconds,
+      session: {
+        id: l.course_module.id,
+        title: l.course_module.title,
+        order: l.course_module.order,
+      },
+      files: l.course_lesson_file.map((f) => ({
+        id: f.id,
+        file_id: f.file_id,
+        type: f.type,
+        file: f.file
+          ? { id: f.file.id, path: f.file.path, size: f.file.size }
+          : null,
+      })),
+    }));
+  }
+
+  getBestVideoFile(lesson: VideoLessonWithFile) {
+    const priority = [
+      'video_profile:720p',
+      'video_profile:1080p',
+      'video_original',
+      'video_hls',
+    ];
+    for (const p of priority) {
+      const f = lesson.files.find((f) => f.type === p && f.file_id && f.file);
+      if (f) return f;
+    }
+    return lesson.files.find((f) => f.file_id && f.file) ?? null;
+  }
+}

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

@@ -10,7 +10,9 @@ import {
     Post,
 } from '@nestjs/common';
 import { CourseStructureService } from './course-structure.service';
+import { CourseVideoAgentPipelineService } from './course-video-agent-pipeline.service';
 import { CourseVideoConversionService } from './course-video-conversion.service';
+import { CourseVideoHlsService } from './course-video-hls.service';
 import { CreateCourseBulkJobDto } from './dto/create-course-bulk-job.dto';
 import { CreateCourseLessonFrameDto } from './dto/create-course-lesson-frame.dto';
 import {
@@ -33,6 +35,8 @@ export class CourseStructureController {
   constructor(
     private readonly courseStructureService: CourseStructureService,
     private readonly courseVideoConversionService: CourseVideoConversionService,
+    private readonly courseVideoHlsService: CourseVideoHlsService,
+    private readonly courseVideoAgentPipelineService: CourseVideoAgentPipelineService,
   ) {}
 
   @Get()
@@ -160,7 +164,7 @@ export class CourseStructureController {
     @Param('lessonId', ParseIntPipe) lessonId: number,
     @Body() dto: CreateLessonVideoConversionDto,
   ) {
-    return this.courseVideoConversionService.enqueueConversion({
+    return this.courseVideoAgentPipelineService.startProcessing({
       userId,
       courseId,
       sessionId,
@@ -229,12 +233,22 @@ export class CourseStructureController {
     return this.courseStructureService.duplicateLesson(courseId, sessionId, lessonId);
   }
 
+  @Get('video-processing-stats')
+  getVideoProcessingStats(@Param('id', ParseIntPipe) courseId: number) {
+    return this.courseStructureService.getVideoProcessingStats(courseId);
+  }
+
   @Post('bulk-jobs')
   createBulkJobs(
     @User() user: any,
     @Param('id', ParseIntPipe) courseId: number,
     @Body() dto: CreateCourseBulkJobDto,
   ) {
-    return this.courseStructureService.bulkEnqueueJobs(courseId, dto.jobType, user?.id ?? 0);
+    return this.courseStructureService.bulkEnqueueJobs(
+      courseId,
+      dto.jobType,
+      user?.id ?? 0,
+      dto.reprocessAlreadyProcessed,
+    );
   }
 }

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

@@ -4,6 +4,7 @@ import { QueueJobService } from '@hed-hog/queue';
 import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { InstructorService } from '../instructor/instructor.service';
 import { CourseOperationsIntegrationService } from './course-operations-integration.service';
+import { CourseVideoHlsService } from './course-video-hls.service';
 import { CreateCourseLessonFrameDto } from './dto/create-course-lesson-frame.dto';
 import { CreateCourseStructureLessonDto } from './dto/create-course-structure-lesson.dto';
 import { CreateCourseStructureSessionDto } from './dto/create-course-structure-session.dto';
@@ -17,7 +18,7 @@ import { UpdateCourseStructureLessonDto } from './dto/update-course-structure-le
 import { UpdateCourseStructureSessionDto } from './dto/update-course-structure-session.dto';
 import { UpdateTranscriptionSegmentsDTO } from './dto/update-transcription-segments.dto';
 
-type LessonUiType = 'video' | 'questao' | 'post' | 'exercicio';
+type LessonUiType = 'video' | 'questao' | 'post';
 type LessonDbType = 'video' | 'text' | 'quiz';
 type LessonProductionStatus =
   | 'preparada'
@@ -27,6 +28,7 @@ type LessonProductionStatus =
   | 'publicada';
 type LessonFileType =
   | 'video_original'
+  | 'video_hls'
   | `video_profile:${number}`
   | 'lesson_audio'
   | 'student_download'
@@ -42,6 +44,7 @@ export class CourseStructureService {
     private readonly instructorService: InstructorService,
     private readonly operationsIntegration: CourseOperationsIntegrationService,
     private readonly queueJob: QueueJobService,
+    private readonly courseVideoHlsService: CourseVideoHlsService,
   ) {}
 
   async getStructure(courseId: number) {
@@ -102,6 +105,7 @@ export class CourseStructureService {
           title: true,
           description: true,
           offering_type: true,
+          status: true,
         },
       }),
       this.operationsIntegration.getCourseProjectLinks([courseId]),
@@ -146,7 +150,7 @@ export class CourseStructureService {
           videoUrl: parsedContent?.videoUrl,
           duracaoAutomatica: parsedContent?.duracaoAutomatica,
           transcricao: parsedContent?.transcricao,
-          videoConversionJobId: parsedContent?.videoConversionJobId,
+          videoConversionJobId: parsedContent?.videoConversionJobId ?? parsedContent?.videoHlsJobId,
           exameVinculado:
             parsedContent?.exameVinculado != null
               ? String(parsedContent.exameVinculado)
@@ -203,6 +207,7 @@ export class CourseStructureService {
             titulo: courseRecord.title,
             descricao: courseRecord.description ?? '',
             offeringType: courseRecord.offering_type ?? 'on_demand',
+            status: courseRecord.status ?? 'draft',
             recursos: courseResources,
             operationsProjectId: courseProject?.projectId ?? null,
             operationsProjectCode: courseProject?.projectCode ?? null,
@@ -1226,10 +1231,48 @@ export class CourseStructureService {
     return true;
   }
 
+  async getVideoProcessingStats(courseId: number): Promise<{
+    withOriginal: number;
+    withoutOriginal: number;
+    alreadyProcessed: number;
+  }> {
+    const lessons = await (this.prisma as any).course_lesson.findMany({
+      where: {
+        type: 'video',
+        course_module: { course_id: courseId },
+      },
+      select: {
+        id: true,
+        course_lesson_file: { select: { type: true } },
+      },
+    });
+
+    let withOriginal = 0;
+    let withoutOriginal = 0;
+    let alreadyProcessed = 0;
+
+    for (const lesson of lessons) {
+      const files: { type: string }[] = lesson.course_lesson_file;
+      const hasOriginal = files.some((f) => f.type === 'video_original');
+      if (!hasOriginal) {
+        withoutOriginal++;
+        continue;
+      }
+      withOriginal++;
+      const hasProcessed = files.some(
+        (f) => f.type === 'video_hls' || f.type.startsWith('video_profile:'),
+      );
+      if (hasProcessed) alreadyProcessed++;
+    }
+
+    return { withOriginal, withoutOriginal, alreadyProcessed };
+  }
+
   async bulkEnqueueJobs(
     courseId: number,
-    jobType: 'transcription' | 'xp_recalculation',
+    jobType: 'transcription' | 'xp_recalculation' | 'video_processing',
     userId: number,
+    reprocessAlreadyProcessed?: boolean,
   ): Promise<{
     queued: number;
     skipped: number;
@@ -1273,6 +1316,53 @@ export class CourseStructureService {
         });
         queued++;
       }
+    } else if (jobType === 'video_processing') {
+      const videoLessons = await (this.prisma as any).course_lesson.findMany({
+        where: {
+          type: 'video',
+          course_module: { course_id: courseId },
+        },
+        select: {
+          id: true,
+          course_module_id: true,
+          course_lesson_file: { select: { type: true, file_id: true } },
+        },
+      });
+
+      for (const lesson of videoLessons) {
+        const files: { type: string; file_id: number }[] = lesson.course_lesson_file;
+        const originalFile = files.find((f) => f.type === 'video_original');
+
+        if (!originalFile) {
+          skipped++;
+          continue;
+        }
+
+        const isAlreadyProcessed = files.some(
+          (f) => f.type === 'video_hls' || f.type.startsWith('video_profile:'),
+        );
+
+        if (isAlreadyProcessed && !reprocessAlreadyProcessed) {
+          skipped++;
+          continue;
+        }
+
+        try {
+          await this.courseVideoHlsService.enqueueHls({
+            userId,
+            courseId,
+            sessionId: lesson.course_module_id,
+            lessonId: lesson.id,
+            originalFileId: originalFile.file_id,
+          });
+          queued++;
+        } catch (err: unknown) {
+          this.logger.warn(
+            `bulkEnqueueJobs(video_processing): skipped lesson ${lesson.id} — ${err instanceof Error ? err.message : String(err)}`,
+          );
+          skipped++;
+        }
+      }
     } else {
       for (const lesson of lessons) {
         const segments = await (this.prisma as any).course_lesson_transcription_segment.findFirst({
@@ -1465,7 +1555,7 @@ export class CourseStructureService {
       videoUrl: parsedContent?.videoUrl,
       duracaoAutomatica: parsedContent?.duracaoAutomatica,
       transcricao: parsedContent?.transcricao,
-      videoConversionJobId: parsedContent?.videoConversionJobId,
+      videoConversionJobId: parsedContent?.videoConversionJobId ?? parsedContent?.videoHlsJobId,
       exameVinculado:
         parsedContent?.exameVinculado != null
           ? String(parsedContent.exameVinculado)
@@ -1538,8 +1628,7 @@ export class CourseStructureService {
     if (
       sourceType === 'video' ||
       sourceType === 'questao' ||
-      sourceType === 'post' ||
-      sourceType === 'exercicio'
+      sourceType === 'post'
     ) {
       return sourceType;
     }
@@ -1577,7 +1666,7 @@ export class CourseStructureService {
       }
     }
 
-    if (data.tipo === 'post' || data.tipo === 'exercicio') {
+    if (data.tipo === 'post') {
       payload.conteudoPost = data.conteudoPost ?? '';
     }
 
@@ -1710,6 +1799,10 @@ export class CourseStructureService {
       return 'video_original';
     }
 
+    if (value === 'video_hls') {
+      return 'video_hls';
+    }
+
     if (value?.startsWith('video_profile:')) {
       const profileId = Number(value.replace('video_profile:', ''));
       if (Number.isInteger(profileId) && profileId > 0) {