@hed-hog/lms 0.0.349 → 0.0.351

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 ?? []);
+  }
 }