@hed-hog/lms 0.0.361 → 0.0.365

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-lesson.controller.ts

@@ -1,5 +1,5 @@
 import { Role } from '@hed-hog/api';
-import { Body, Controller, Get, Param, ParseIntPipe, Put } from '@nestjs/common';
+import { Body, Controller, Get, Param, ParseIntPipe, Post, Put } from '@nestjs/common';
 import { CourseStructureService } from './course-structure.service';
 import { UpdateTranscriptionSegmentsDTO } from './dto/update-transcription-segments.dto';
 
@@ -25,4 +25,9 @@ export class CourseLessonController {
   getAudioFiles(@Param('id', ParseIntPipe) id: number) {
     return this.courseStructureService.getAudioFiles(id);
   }
+
+  @Post(':id/transcription/start')
+  startTranscription(@Param('id', ParseIntPipe) id: number) {
+    return this.courseStructureService.startTranscription(id);
+  }
 }

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

@@ -11,6 +11,8 @@ import {
 } from '@nestjs/common';
 import { CourseStructureService } from './course-structure.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 {
     CreateCourseStructureLessonDto,
@@ -32,6 +34,7 @@ export class CourseStructureController {
   constructor(
     private readonly courseStructureService: CourseStructureService,
     private readonly courseVideoConversionService: CourseVideoConversionService,
+    private readonly courseVideoHlsService: CourseVideoHlsService,
   ) {}
 
   @Get()
@@ -159,7 +162,7 @@ export class CourseStructureController {
     @Param('lessonId', ParseIntPipe) lessonId: number,
     @Body() dto: CreateLessonVideoConversionDto,
   ) {
-    return this.courseVideoConversionService.enqueueConversion({
+    return this.courseVideoHlsService.enqueueHls({
       userId,
       courseId,
       sessionId,
@@ -227,4 +230,23 @@ 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,
+      dto.reprocessAlreadyProcessed,
+    );
+  }
 }

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

@@ -1,8 +1,10 @@
 import { PrismaService } from '@hed-hog/api-prisma';
 import { FileService } from '@hed-hog/core';
-import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+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';
@@ -16,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'
@@ -26,6 +28,7 @@ type LessonProductionStatus =
   | 'publicada';
 type LessonFileType =
   | 'video_original'
+  | 'video_hls'
   | `video_profile:${number}`
   | 'lesson_audio'
   | 'student_download'
@@ -33,11 +36,15 @@ type LessonFileType =
 
 @Injectable()
 export class CourseStructureService {
+  private readonly logger = new Logger(CourseStructureService.name);
+
   constructor(
     private readonly prisma: PrismaService,
     private readonly fileService: FileService,
     private readonly instructorService: InstructorService,
     private readonly operationsIntegration: CourseOperationsIntegrationService,
+    private readonly queueJob: QueueJobService,
+    private readonly courseVideoHlsService: CourseVideoHlsService,
   ) {}
 
   async getStructure(courseId: number) {
@@ -98,6 +105,7 @@ export class CourseStructureService {
           title: true,
           description: true,
           offering_type: true,
+          status: true,
         },
       }),
       this.operationsIntegration.getCourseProjectLinks([courseId]),
@@ -142,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)
@@ -199,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,
@@ -1151,6 +1160,260 @@ export class CourseStructureService {
     });
   }
 
+  async startTranscription(lessonId: number) {
+    const lesson = await (this.prisma as any).course_lesson.findUnique({
+      where: { id: lessonId },
+      select: { id: true, course_module: { select: { course_id: true } } },
+    });
+
+    if (!lesson) {
+      throw new NotFoundException(`Lesson ${lessonId} not found`);
+    }
+
+    const audioFiles = await this.getAudioFiles(lessonId);
+
+    if (!audioFiles.length) {
+      throw new BadRequestException('No audio file found for this lesson. Upload or convert a video first.');
+    }
+
+    const audioFileId = audioFiles[audioFiles.length - 1].file_id;
+
+    const job = await this.queueJob.enqueue({
+      type: 'lms.audio.transcribe',
+      queueName: 'lms.audio.transcribe',
+      payload: {
+        courseId: lesson.course_module.course_id,
+        lessonId,
+        audioFileId,
+      },
+      sourceModule: 'lms',
+      sourceEntity: 'course_lesson',
+      sourceEntityId: String(lessonId),
+      maxAttempts: 3,
+    });
+
+    const startedOnDemand = await this.startTranscriptionOnDemandIfNeeded(job.id);
+
+    if (startedOnDemand) {
+      return { queueJobId: job.id, status: 'processing' };
+    }
+
+    return { queueJobId: job.id, status: job.status };
+  }
+
+  private async startTranscriptionOnDemandIfNeeded(jobId: number): Promise<boolean> {
+    const freshWorkerCutoff = new Date(Date.now() - 2 * 60 * 1000);
+
+    const onlineWorkers = await (this.prisma as any).queue_worker_heartbeat.count({
+      where: {
+        status: 'online',
+        last_heartbeat_at: { gte: freshWorkerCutoff },
+      },
+    });
+
+    if (onlineWorkers > 0) {
+      return false;
+    }
+
+    void this.queueJob
+      .execute(jobId, undefined, 15 * 60 * 1000)
+      .then(() => {
+        this.logger.debug(
+          `Started on-demand transcription execution for queue job ${jobId} because no online workers were found.`,
+        );
+      })
+      .catch((error: unknown) => {
+        this.logger.warn(
+          `Failed to execute transcription job ${jobId} on-demand fallback: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      });
+
+    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' | 'video_processing',
+    userId: number,
+    reprocessAlreadyProcessed?: boolean,
+  ): Promise<{
+    queued: number;
+    skipped: number;
+    skippedWithoutTranscription: number;
+    warnings: string[];
+  }> {
+    const lessons = await (this.prisma as any).course_lesson.findMany({
+      where: {
+        course_module: { course_id: courseId },
+      },
+      select: { id: true },
+    });
+
+    let queued = 0;
+    let skipped = 0;
+    let skippedWithoutTranscription = 0;
+    const warnings: string[] = [];
+
+    if (jobType === 'transcription') {
+      for (const lesson of lessons) {
+        const audioFiles = await (this.prisma as any).course_lesson_file.findMany({
+          where: { course_lesson_id: lesson.id, type: 'lesson_audio' },
+          select: { file_id: true },
+          orderBy: { created_at: 'asc' },
+        });
+
+        if (!audioFiles.length) {
+          skipped++;
+          continue;
+        }
+
+        const audioFileId = audioFiles[audioFiles.length - 1].file_id;
+        await this.queueJob.enqueue({
+          type: 'lms.audio.transcribe',
+          queueName: 'lms.audio.transcribe',
+          payload: { courseId, lessonId: lesson.id, audioFileId },
+          sourceModule: 'lms',
+          sourceEntity: 'course_lesson',
+          sourceEntityId: String(lesson.id),
+          maxAttempts: 3,
+        });
+        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({
+          where: { course_lesson_id: lesson.id },
+          select: { id: true },
+        });
+
+        if (!segments) {
+          skippedWithoutTranscription++;
+          skipped++;
+          continue;
+        }
+
+        let xpMap = await (this.prisma as any).lesson_xp_map.findFirst({
+          where: { course_lesson_id: lesson.id },
+          select: { id: true },
+        });
+
+        if (!xpMap) {
+          const created = await (this.prisma as any).lesson_xp_map.create({
+            data: {
+              course_lesson_id: lesson.id,
+              status: 'pending',
+            },
+            select: { id: true },
+          });
+          xpMap = created;
+        }
+
+        await this.queueJob.enqueue({
+          type: 'lms.lesson.xp.calculate',
+          queueName: 'lms.lesson.xp.calculate',
+          payload: { lessonId: lesson.id, mapId: xpMap.id, userId },
+          sourceModule: 'lms',
+          sourceEntity: 'course_lesson',
+          sourceEntityId: String(lesson.id),
+          maxAttempts: 3,
+        });
+        queued++;
+      }
+
+      if (skippedWithoutTranscription > 0) {
+        warnings.push(
+          `${skippedWithoutTranscription} aula(s) sem transcrição foram ignoradas. Gere a transcrição antes de recalcular o XP.`,
+        );
+      }
+    }
+
+    return { queued, skipped, skippedWithoutTranscription, warnings };
+  }
+
   private async syncLessonRelations(
     lessonId: number,
     dto: Partial<
@@ -1292,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)
@@ -1365,8 +1628,7 @@ export class CourseStructureService {
     if (
       sourceType === 'video' ||
       sourceType === 'questao' ||
-      sourceType === 'post' ||
-      sourceType === 'exercicio'
+      sourceType === 'post'
     ) {
       return sourceType;
     }
@@ -1404,7 +1666,7 @@ export class CourseStructureService {
       }
     }
 
-    if (data.tipo === 'post' || data.tipo === 'exercicio') {
+    if (data.tipo === 'post') {
       payload.conteudoPost = data.conteudoPost ?? '';
     }
 
@@ -1537,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) {