@hed-hog/lms 0.0.350 → 0.0.353

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

@@ -10,7 +10,11 @@ import {
     Post,
 } from '@nestjs/common';
 import { CourseStructureService } from './course-structure.service';
-import { CreateCourseStructureLessonDto } from './dto/create-course-structure-lesson.dto';
+import { CourseVideoConversionService } from './course-video-conversion.service';
+import {
+  CreateCourseStructureLessonDto,
+  CreateLessonVideoConversionDto,
+} 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';
@@ -23,7 +27,10 @@ import { UpdateCourseStructureSessionDto } from './dto/update-course-structure-s
 @Role()
 @Controller('lms/courses/:id/structure')
 export class CourseStructureController {
-  constructor(private readonly courseStructureService: CourseStructureService) {}
+  constructor(
+    private readonly courseStructureService: CourseStructureService,
+    private readonly courseVideoConversionService: CourseVideoConversionService,
+  ) {}
 
   @Get()
   getStructure(@Param('id', ParseIntPipe) courseId: number) {
@@ -142,6 +149,21 @@ export class CourseStructureController {
     return this.courseStructureService.moveLesson(courseId, sessionId, lessonId, dto);
   }
 
+  @Post('sessions/:sessionId/lessons/:lessonId/video-conversions')
+  createLessonVideoConversion(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @Body() dto: CreateLessonVideoConversionDto,
+  ) {
+    return this.courseVideoConversionService.enqueueConversion({
+      courseId,
+      sessionId,
+      lessonId,
+      originalFileId: dto.originalFileId,
+    });
+  }
+
   @Delete('sessions/:sessionId/lessons/:lessonId')
   deleteLesson(
     @Param('id', ParseIntPipe) courseId: number,

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

@@ -105,6 +105,7 @@ export class CourseStructureService {
           videoUrl: parsedContent?.videoUrl,
           duracaoAutomatica: parsedContent?.duracaoAutomatica,
           transcricao: parsedContent?.transcricao,
+          videoConversionJobId: parsedContent?.videoConversionJobId,
           exameVinculado:
             parsedContent?.exameVinculado != null
               ? String(parsedContent.exameVinculado)
@@ -115,9 +116,10 @@ export class CourseStructureService {
           recursos: lesson.course_lesson_file.map((fileLink) => ({
             id: String(fileLink.id),
             nome: fileLink.title,
+            fileId: fileLink.file_id,
             tamanho: '',
-            tipo: '',
-            publico: true,
+            tipo: (fileLink as any).tipo ?? '',
+            publico: (fileLink as any).publico ?? true,
           })),
           instrutores: lesson.course_lesson_instructor.map((item) => ({
             id: String(item.instructor_id),
@@ -375,6 +377,7 @@ export class CourseStructureService {
           videoUrl: dto.videoUrl,
           duracaoAutomatica: dto.duracaoAutomatica,
           transcricao: dto.transcricao,
+          videoConversionJobId: dto.videoConversionJobId,
           conteudoPost: dto.conteudoPost,
           exameVinculado: dto.exameVinculado,
           descricaoPrivada: dto.descricaoPrivada,
@@ -610,6 +613,8 @@ export class CourseStructureService {
             course_lesson_id: newLesson.id,
             title: f.title,
             file_id: f.file_id,
+            tipo: (f as any).tipo ?? null,
+            publico: (f as any).publico ?? true,
           })),
         });
       }
@@ -711,6 +716,8 @@ export class CourseStructureService {
           course_lesson_id: newLesson.id,
           title: f.title,
           file_id: f.file_id,
+          tipo: (f as any).tipo ?? null,
+          publico: (f as any).publico ?? true,
         })),
       });
     }
@@ -799,6 +806,8 @@ export class CourseStructureService {
             course_lesson_id: newLesson.id,
             title: f.title,
             file_id: f.file_id,
+            tipo: (f as any).tipo ?? null,
+            publico: (f as any).publico ?? true,
           })),
         });
       }
@@ -883,6 +892,8 @@ export class CourseStructureService {
             course_lesson_id: lessonId,
             title: recurso.nome,
             file_id: recurso.fileId ?? null,
+            tipo: recurso.tipo ?? null,
+            publico: recurso.publico ?? true,
           })),
         });
       }
@@ -969,6 +980,7 @@ export class CourseStructureService {
       videoUrl: parsedContent?.videoUrl,
       duracaoAutomatica: parsedContent?.duracaoAutomatica,
       transcricao: parsedContent?.transcricao,
+      videoConversionJobId: parsedContent?.videoConversionJobId,
       exameVinculado:
         parsedContent?.exameVinculado != null
           ? String(parsedContent.exameVinculado)
@@ -979,9 +991,10 @@ export class CourseStructureService {
       recursos: lesson.course_lesson_file.map((fileLink) => ({
         id: String(fileLink.id),
         nome: fileLink.title,
+        fileId: fileLink.file_id,
         tamanho: '',
-        tipo: '',
-        publico: true,
+        tipo: (fileLink as any).tipo ?? '',
+        publico: (fileLink as any).publico ?? true,
       })),
       instrutores: lesson.course_lesson_instructor.map((item) => ({
         id: String(item.instructor_id),
@@ -1055,6 +1068,7 @@ export class CourseStructureService {
     videoUrl?: string;
     duracaoAutomatica?: boolean;
     transcricao?: string;
+    videoConversionJobId?: number;
     conteudoPost?: string;
     exameVinculado?: number;
     descricaoPrivada?: string;
@@ -1069,6 +1083,9 @@ export class CourseStructureService {
       payload.videoUrl = data.videoUrl ?? '';
       payload.duracaoAutomatica = data.duracaoAutomatica ?? false;
       payload.transcricao = data.transcricao ?? '';
+      if (data.videoConversionJobId != null) {
+        payload.videoConversionJobId = data.videoConversionJobId;
+      }
     }
 
     if (data.tipo === 'post' || data.tipo === 'exercicio') {

package/src/course/course-video-conversion.service.ts

@@ -0,0 +1,415 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { FileService } from '@hed-hog/core';
+import { IJobHandler, QueueHandlerRegistry, QueueJobService } from '@hed-hog/queue';
+import {
+    BadRequestException,
+    Inject,
+    Injectable,
+    Logger,
+    NotFoundException,
+    OnModuleInit,
+    forwardRef,
+} from '@nestjs/common';
+import { execFile } from 'child_process';
+import { promises as fs } from 'fs';
+import { tmpdir } from 'os';
+import { basename, join } from 'path';
+import { promisify } from 'util';
+
+export const LMS_VIDEO_CONVERSION_JOB = 'lms.video.convert';
+
+type VideoProfilePayload = {
+  id: number;
+  name: string;
+  ffmpeg_params: string;
+};
+
+const execFileAsync = promisify(execFile);
+
+@Injectable()
+export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
+  private readonly logger = new Logger(CourseVideoConversionService.name);
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => FileService))
+    private readonly fileService: FileService,
+    @Inject(forwardRef(() => QueueHandlerRegistry))
+    private readonly registry: QueueHandlerRegistry,
+    @Inject(forwardRef(() => QueueJobService))
+    private readonly queueJob: QueueJobService,
+  ) {}
+
+  onModuleInit() {
+    this.registry.register(LMS_VIDEO_CONVERSION_JOB, this);
+    this.logger.log(`Registered handler for "${LMS_VIDEO_CONVERSION_JOB}"`);
+  }
+
+  async enqueueConversion(params: {
+    courseId: number;
+    sessionId: number;
+    lessonId: number;
+    originalFileId: number;
+  }) {
+    const lesson = await (this.prisma as any).course_lesson.findFirst({
+      where: {
+        id: params.lessonId,
+        course_module_id: params.sessionId,
+        course_module: { course_id: params.courseId },
+      },
+      include: { course_module: true },
+    });
+
+    if (!lesson) {
+      throw new NotFoundException('Lesson not found for this course session');
+    }
+
+    const content = this.parseContent(lesson.content);
+    if (lesson.type !== 'video' || content?.sourceType !== 'video') {
+      throw new BadRequestException('Video conversion is only available for video lessons');
+    }
+
+    if (content?.videoProvedor !== 'file_storage') {
+      throw new BadRequestException('Video conversion requires File Storage provider');
+    }
+
+    const original = await (this.prisma as any).file.findUnique({
+      where: { id: params.originalFileId },
+      include: { file_mimetype: true },
+    });
+
+    if (!original) {
+      throw new NotFoundException('Original video file not found');
+    }
+
+    const mimetype = original.file_mimetype?.name ?? '';
+    if (!mimetype.startsWith('video/')) {
+      throw new BadRequestException('Original file must be a video');
+    }
+
+    const profiles = await this.getCourseProfiles(params.courseId);
+    if (profiles.length === 0) {
+      throw new BadRequestException('Course has no video resolution profiles');
+    }
+
+    await this.upsertLessonFile({
+      lessonId: params.lessonId,
+      type: 'video_original',
+      fileId: params.originalFileId,
+      title: original.filename ?? `Original video ${params.originalFileId}`,
+      public: false,
+      overwrite: true,
+    });
+
+    const job = await this.queueJob.enqueue({
+      type: LMS_VIDEO_CONVERSION_JOB,
+      queueName: LMS_VIDEO_CONVERSION_JOB,
+      payload: {
+        courseId: params.courseId,
+        sessionId: params.sessionId,
+        lessonId: params.lessonId,
+        originalFileId: params.originalFileId,
+        profiles,
+        overwrite: true,
+      },
+      sourceModule: 'lms',
+      sourceEntity: 'course_lesson',
+      sourceEntityId: String(params.lessonId),
+      maxAttempts: 3,
+    });
+
+    await (this.prisma as any).course_lesson.update({
+      where: { id: params.lessonId },
+      data: {
+        content: JSON.stringify({
+          ...(content ?? {}),
+          sourceType: 'video',
+          videoConversionJobId: job.id,
+        }),
+      },
+    });
+
+    return { queueJobId: job.id, status: 'queued' };
+  }
+
+  async handle(job: {
+    id: number;
+    payload: Record<string, any>;
+  }): Promise<any> {
+    const { courseId, sessionId, lessonId, originalFileId, profiles, overwrite } =
+      job.payload as {
+        courseId?: number;
+        sessionId?: number;
+        lessonId?: number;
+        originalFileId?: number;
+        profiles?: VideoProfilePayload[];
+        overwrite?: boolean;
+      };
+
+    if (!courseId || !sessionId || !lessonId || !originalFileId || !profiles?.length) {
+      throw new Error('Invalid LMS video conversion payload');
+    }
+
+    const currentProfiles = await this.getCourseProfiles(courseId);
+    const profileIds = new Set(currentProfiles.map((profile) => profile.id));
+    const profilesToProcess = profiles.filter((profile) => profileIds.has(profile.id));
+
+    if (profilesToProcess.length === 0) {
+      throw new Error('Course has no active profiles to process');
+    }
+
+    const maxInputBytes = this.getPositiveIntegerEnv('LMS_VIDEO_MAX_INPUT_BYTES');
+    const ffmpegTimeoutMs =
+      this.getPositiveIntegerEnv('LMS_VIDEO_FFMPEG_TIMEOUT_MS') ?? 1000 * 60 * 60;
+
+    const workDir = await fs.mkdtemp(join(tmpdir(), `lms-video-${job.id}-`));
+    const inputPath = join(workDir, `original-${originalFileId}.mp4`);
+
+    this.logger.log(
+      `Queue job ${job.id}: starting LMS video conversion (lesson=${lessonId}, profiles=${profilesToProcess.length})`,
+    );
+
+    const downloadedOriginal = await this.fileService.downloadToPath(
+      originalFileId,
+      inputPath,
+      maxInputBytes ? { maxBytes: maxInputBytes } : undefined,
+    );
+
+    this.logger.log(
+      `Queue job ${job.id}: original file downloaded (lesson=${lessonId}, size=${downloadedOriginal.size})`,
+    );
+
+    const jobStartedAt = Date.now();
+    const results: Array<{
+      profileId: number;
+      fileId: number;
+      outputBytes: number;
+      conversionMs: number;
+      conversionMBps: number;
+      uploadMs: number;
+      uploadMBps: number;
+      totalMs: number;
+    }> = [];
+
+    try {
+      for (const profile of profilesToProcess) {
+        const profileStartedAt = Date.now();
+        const outputPath = join(
+          workDir,
+          `${this.slugify(profile.name || String(profile.id))}-${profile.id}.mp4`,
+        );
+        this.logger.log(
+          `Queue job ${job.id}: converting profile ${profile.id} for lesson ${lessonId}`,
+        );
+
+        const conversionStartedAt = Date.now();
+        await this.convert(inputPath, outputPath, profile.ffmpeg_params, ffmpegTimeoutMs);
+        const conversionMs = Date.now() - conversionStartedAt;
+
+        const outputStats = await fs.stat(outputPath);
+
+        const uploadStartedAt = Date.now();
+        const uploaded = await this.fileService.uploadFromPath('lms/lessons/videos', outputPath, {
+          originalname: basename(outputPath),
+          mimetype: 'video/mp4',
+        });
+        const uploadMs = Date.now() - uploadStartedAt;
+        const totalMs = Date.now() - profileStartedAt;
+        const conversionMBps = this.calculateMBps(outputStats.size, conversionMs);
+        const uploadMBps = this.calculateMBps(outputStats.size, uploadMs);
+
+        await this.upsertLessonFile({
+          lessonId,
+          type: this.profileResourceType(profile.id),
+          fileId: uploaded.id,
+          title: uploaded.filename ?? basename(outputPath),
+          public: false,
+          overwrite: overwrite !== false,
+        });
+
+        results.push({
+          profileId: profile.id,
+          fileId: uploaded.id,
+          outputBytes: outputStats.size,
+          conversionMs,
+          conversionMBps,
+          uploadMs,
+          uploadMBps,
+          totalMs,
+        });
+
+        this.logger.log(
+          `Queue job ${job.id}: profile ${profile.id} done for lesson ${lessonId} (fileId=${uploaded.id}, outputBytes=${outputStats.size}, conversionMs=${conversionMs}, conversionMBps=${conversionMBps.toFixed(2)}, uploadMs=${uploadMs}, uploadMBps=${uploadMBps.toFixed(2)}, totalMs=${totalMs})`,
+        );
+      }
+    } finally {
+      await fs.rm(workDir, { recursive: true, force: true }).catch(() => undefined);
+      this.logger.log(`Queue job ${job.id}: cleaned temporary folder ${workDir}`);
+    }
+
+    const totalMs = Date.now() - jobStartedAt;
+    const totalOutputBytes = results.reduce((acc, item) => acc + item.outputBytes, 0);
+
+    this.logger.log(
+      `Queue job ${job.id}: LMS conversion finished (lesson=${lessonId}, profiles=${results.length}, totalMs=${totalMs}, totalOutputBytes=${totalOutputBytes})`,
+    );
+
+    return {
+      lessonId,
+      converted: results.length,
+      results,
+      metrics: {
+        totalMs,
+        totalOutputBytes,
+        averageProfileMs:
+          results.length > 0
+            ? Math.round(results.reduce((acc, item) => acc + item.totalMs, 0) / results.length)
+            : 0,
+        averageConversionMBps:
+          results.length > 0
+            ? Number(
+                (
+                  results.reduce((acc, item) => acc + item.conversionMBps, 0) / results.length
+                ).toFixed(2),
+              )
+            : 0,
+        averageUploadMBps:
+          results.length > 0
+            ? Number(
+                (results.reduce((acc, item) => acc + item.uploadMBps, 0) / results.length).toFixed(2),
+              )
+            : 0,
+      },
+    };
+  }
+
+  private async getCourseProfiles(courseId: number): Promise<VideoProfilePayload[]> {
+    const rows = await (this.prisma as any).course_video_resolution_profile.findMany({
+      where: { course_id: courseId },
+      include: { video_resolution_profile: true },
+      orderBy: { video_resolution_profile: { name: 'asc' } },
+    });
+
+    return (rows as any[])
+      .map((row) => row.video_resolution_profile)
+      .filter((profile) => profile?.status !== 'inactive')
+      .map((profile) => ({
+        id: Number(profile.id),
+        name: profile.name,
+        ffmpeg_params: profile.ffmpeg_params,
+      }));
+  }
+
+  private async upsertLessonFile(params: {
+    lessonId: number;
+    type: string;
+    fileId: number;
+    title: string;
+    public: boolean;
+    overwrite: boolean;
+  }) {
+    if (params.overwrite) {
+      await (this.prisma as any).course_lesson_file.deleteMany({
+        where: {
+          course_lesson_id: params.lessonId,
+          tipo: params.type,
+        },
+      });
+    }
+
+    return (this.prisma as any).course_lesson_file.create({
+      data: {
+        course_lesson_id: params.lessonId,
+        file_id: params.fileId,
+        title: params.title,
+        tipo: params.type,
+        publico: params.public,
+      },
+    });
+  }
+
+  private async convert(
+    inputPath: string,
+    outputPath: string,
+    params: string,
+    timeoutMs: number,
+  ) {
+    const args = ['-y', '-i', inputPath, ...this.splitFfmpegParams(params), outputPath];
+    try {
+      await execFileAsync('ffmpeg', args, {
+        maxBuffer: 1024 * 1024 * 20,
+        timeout: timeoutMs,
+        windowsHide: true,
+      });
+    } catch (error: any) {
+      if (error?.killed && error?.signal === 'SIGTERM') {
+        throw new Error(`FFmpeg timed out after ${timeoutMs}ms`);
+      }
+      throw error;
+    }
+  }
+
+  private getPositiveIntegerEnv(name: string): number | undefined {
+    const raw = process.env[name];
+    if (!raw) {
+      return undefined;
+    }
+
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value <= 0) {
+      return undefined;
+    }
+
+    return Math.floor(value);
+  }
+
+  private calculateMBps(bytes: number, durationMs: number): number {
+    if (!Number.isFinite(bytes) || bytes <= 0) {
+      return 0;
+    }
+
+    if (!Number.isFinite(durationMs) || durationMs <= 0) {
+      return 0;
+    }
+
+    const seconds = durationMs / 1000;
+    return Number((bytes / (1024 * 1024) / seconds).toFixed(2));
+  }
+
+  private splitFfmpegParams(params: string): string[] {
+    const result: string[] = [];
+    const pattern = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    let match: RegExpExecArray | null;
+
+    while ((match = pattern.exec(params ?? ''))) {
+      result.push(match[1] ?? match[2] ?? match[3] ?? '');
+    }
+
+    return result.filter(Boolean);
+  }
+
+  private profileResourceType(profileId: number) {
+    return `video_profile:${profileId}`;
+  }
+
+  private slugify(value: string) {
+    return (
+      value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'video'
+    );
+  }
+
+  private parseContent(content?: string | null): any {
+    if (!content) return null;
+    try {
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+}

package/src/course/course.controller.ts

@@ -5,6 +5,8 @@ import {
     Controller,
     Delete,
     Get,
+    HttpCode,
+    HttpStatus,
     Param,
     ParseIntPipe,
     Patch,
@@ -84,4 +86,20 @@ export class CourseController {
   remove(@Param('id', ParseIntPipe) id: number) {
     return this.courseService.remove(id);
   }
+
+  @Get(':courseId/video-resolution-profiles')
+  getCourseVideoProfiles(
+    @Param('courseId', ParseIntPipe) courseId: number,
+  ) {
+    return this.courseService.getCourseVideoProfiles(courseId);
+  }
+
+  @Post(':courseId/video-resolution-profiles/sync')
+  @HttpCode(HttpStatus.OK)
+  syncCourseVideoProfiles(
+    @Param('courseId', ParseIntPipe) courseId: number,
+    @Body() body: { profileIds: number[] },
+  ) {
+    return this.courseService.syncCourseVideoProfiles(courseId, body.profileIds ?? []);
+  }
 }

package/src/course/course.module.ts

@@ -1,22 +1,35 @@
 import { PrismaModule } from '@hed-hog/api-prisma';
+import { CoreModule } from '@hed-hog/core';
+import { QueueModule } from '@hed-hog/queue';
 import { forwardRef, Module } from '@nestjs/common';
 import { CourseOperationsIntegrationService } from './course-operations-integration.service';
 import { CourseStructureController } from './course-structure.controller';
 import { CourseStructureService } from './course-structure.service';
+import { CourseVideoConversionService } from './course-video-conversion.service';
 import { LmsCoursesMcpTools } from './course.mcp-tools';
 import { CourseController } from './course.controller';
 import { CourseService } from './course.service';
 import { InstructorModule } from '../instructor/instructor.module';
 
 @Module({
-  imports: [forwardRef(() => PrismaModule), forwardRef(() => InstructorModule)],
+  imports: [
+    forwardRef(() => PrismaModule),
+    forwardRef(() => InstructorModule),
+    forwardRef(() => CoreModule),
+    forwardRef(() => QueueModule),
+  ],
   controllers: [CourseController, CourseStructureController],
   providers: [
     CourseOperationsIntegrationService,
     CourseService,
     CourseStructureService,
+    CourseVideoConversionService,
     LmsCoursesMcpTools,
   ],
-  exports: [forwardRef(() => CourseService), forwardRef(() => CourseStructureService)],
+  exports: [
+    forwardRef(() => CourseService),
+    forwardRef(() => CourseStructureService),
+    forwardRef(() => CourseVideoConversionService),
+  ],
 })
 export class CourseModule {}