@hed-hog/lms 0.0.358 → 0.0.364

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

@@ -1,6 +1,7 @@
 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 { CreateCourseLessonFrameDto } from './dto/create-course-lesson-frame.dto';
@@ -33,11 +34,14 @@ 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,
   ) {}
 
   async getStructure(courseId: number) {
@@ -1151,6 +1155,175 @@ 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 bulkEnqueueJobs(
+    courseId: number,
+    jobType: 'transcription' | 'xp_recalculation',
+    userId: number,
+  ): 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 {
+      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<

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

@@ -13,7 +13,7 @@ import {
 import { execFile } from 'child_process';
 import { existsSync, promises as fs, readdirSync } from 'fs';
 import { tmpdir } from 'os';
-import { basename, join } from 'path';
+import { basename, extname, join } from 'path';
 import { promisify } from 'util';
 
 export const LMS_VIDEO_CONVERSION_JOB = 'lms.video.convert';
@@ -32,6 +32,20 @@ type LessonFrameResult = {
 
 const execFileAsync = promisify(execFile);
 
+const VIDEO_FILE_EXTENSIONS = new Set([
+  '.mp4',
+  '.m4v',
+  '.mov',
+  '.mkv',
+  '.webm',
+  '.avi',
+  '.wmv',
+  '.flv',
+  '.ogv',
+  '.m2ts',
+  '.ts',
+]);
+
 type NotificationContext = {
   userId: number;
   notificationId: number;
@@ -187,7 +201,7 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
     }
 
     const mimetype = original.file_mimetype?.name ?? '';
-    if (!mimetype.startsWith('video/')) {
+    if (!this.isVideoOriginalFile(mimetype, original.filename, original.path)) {
       throw new BadRequestException('Original file must be a video');
     }
 
@@ -257,7 +271,14 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
 
   async handle(job: {
     id: number;
+    type: string;
+    queue_name: string;
     payload: Record<string, any>;
+    attempts: number;
+    max_attempts: number;
+    source_module?: string | null;
+    source_entity?: string | null;
+    source_entity_id?: string | null;
   }): Promise<any> {
     const { courseId, sessionId, lessonId, originalFileId, profiles, overwrite } =
       job.payload as {
@@ -299,6 +320,14 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
       throw new Error('Course has no active profiles to process');
     }
 
+    const workerConcurrency =
+      parseInt(process.env.QUEUE_WORKER_CONCURRENCY ?? '1', 10) || 1;
+    const queueDef = await (this.prisma as any).queue_definition.findUnique({
+      where: { name: LMS_VIDEO_CONVERSION_JOB },
+      select: { max_concurrency: true },
+    });
+    const queueMaxConcurrency: number | null = queueDef?.max_concurrency ?? null;
+
     const maxInputBytes = this.getPositiveIntegerEnv('LMS_VIDEO_MAX_INPUT_BYTES');
     const ffmpegTimeoutMs =
       this.getPositiveIntegerEnv('LMS_VIDEO_FFMPEG_TIMEOUT_MS') ?? 1000 * 60 * 60;
@@ -333,12 +362,17 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
       maxInputBytes ? { maxBytes: maxInputBytes } : undefined,
     );
 
+    const inputSizeBytes = downloadedOriginal.size;
+    const inputSizeMb = parseFloat((inputSizeBytes / (1024 * 1024)).toFixed(2));
+
     this.logger.log(
-      `Queue job ${job.id}: original file downloaded (lesson=${lessonId}, size=${downloadedOriginal.size})`,
+      `Queue job ${job.id}: original file downloaded (lesson=${lessonId}, size=${inputSizeBytes})`,
     );
-    await emitProgress('Vídeo original baixado. Lendo duração...', {
+    await emitProgress(`Vídeo original baixado (${inputSizeMb} MB). Lendo duração...`, {
       phase: 'probe_duration',
       lessonId,
+      inputSizeBytes,
+      inputSizeMb,
     });
 
     let probedDuration: number | null = null;
@@ -368,10 +402,65 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
       uploadMBps: number;
       totalMs: number;
     }> = [];
+
+    const buildMetrics = () => ({
+      totalMs: Date.now() - jobStartedAt,
+      totalOutputBytes: results.reduce((acc, item) => acc + item.outputBytes, 0),
+      inputSizeBytes,
+      inputSizeMb,
+      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,
+      workerConcurrency,
+      queueMaxConcurrency,
+    });
     let frameResults: LessonFrameResult[] = [];
 
+    // On retries (attempts > 1), skip profiles that were already successfully
+    // converted and uploaded in a previous attempt of this same job.
+    const alreadyDoneProfileIds = new Set<number>();
+    if (job.attempts > 1) {
+      const existingFiles = await (this.prisma as any).course_lesson_file.findMany({
+        where: {
+          course_lesson_id: lessonId,
+          type: { startsWith: 'video_profile:' },
+        },
+        select: { type: true },
+      });
+      for (const f of existingFiles as Array<{ type: string }>) {
+        const profileId = parseInt(f.type.split(':')[1], 10);
+        if (!isNaN(profileId)) alreadyDoneProfileIds.add(profileId);
+      }
+      if (alreadyDoneProfileIds.size > 0) {
+        this.logger.log(
+          `Queue job ${job.id}: retry attempt ${job.attempts}, skipping already-converted profiles: [${[...alreadyDoneProfileIds].join(', ')}]`,
+        );
+      }
+    }
+
     try {
       for (const profile of profilesToProcess) {
+        if (alreadyDoneProfileIds.has(profile.id)) {
+          await emitProgress(
+            `Perfil ${profile.name || profile.id} já convertido em tentativa anterior, pulando.`,
+            { phase: 'skip_profile', profileId: profile.id, profileName: profile.name },
+          );
+          continue;
+        }
+
         const profileStartedAt = Date.now();
         const outputPath = join(
           workDir,
@@ -381,7 +470,7 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
           `Queue job ${job.id}: converting profile ${profile.id} for lesson ${lessonId}`,
         );
         await emitProgress(
-          `Convertendo vídeo para o perfil ${profile.name || profile.id}...`,
+          `Convertendo vídeo para o perfil ${profile.name || profile.id} (entrada: ${inputSizeMb} MB)...`,
           {
             phase: 'convert_profile',
             lessonId,
@@ -389,6 +478,7 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
             profileName: profile.name,
             profileIndex: results.length + 1,
             profileCount: profilesToProcess.length,
+            inputSizeMb,
           },
         );
         this.logger.debug(
@@ -529,28 +619,7 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
           extractedFrames: frameResults.length,
           frames: frameResults,
           transcriptionJobId: transcriptionJob.id,
-          metrics: {
-            totalMs: Date.now() - jobStartedAt,
-            totalOutputBytes: results.reduce((acc, item) => acc + item.outputBytes, 0),
-            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,
-          },
+          metrics: buildMetrics(),
         };
       } else {
         let transcriptionSkipReason = 'audio extraction returned no file id';
@@ -617,28 +686,7 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
               extractedFrames: frameResults.length,
               frames: frameResults,
               transcriptionJobId: transcriptionJob.id,
-              metrics: {
-                totalMs: Date.now() - jobStartedAt,
-                totalOutputBytes: results.reduce((acc, item) => acc + item.outputBytes, 0),
-                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,
-              },
+              metrics: buildMetrics(),
             };
           }
         } catch (fallbackError) {
@@ -693,11 +741,8 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
       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})`,
+      `Queue job ${job.id}: LMS conversion finished (lesson=${lessonId}, profiles=${results.length})`,
     );
 
     if (notificationContext) {
@@ -717,28 +762,7 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
       extractedFrames: frameResults.length,
       frames: frameResults,
       transcriptionJobId: null,
-      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,
-      },
+      metrics: buildMetrics(),
     };
   }
 
@@ -1378,4 +1402,18 @@ export class CourseVideoConversionService implements OnModuleInit, IJobHandler {
       return null;
     }
   }
+
+  private isVideoOriginalFile(
+    mimetype?: string | null,
+    filename?: string | null,
+    path?: string | null,
+  ): boolean {
+    if (typeof mimetype === 'string' && mimetype.startsWith('video/')) {
+      return true;
+    }
+
+    const candidateName = filename ?? path ?? '';
+    const extension = extname(candidateName).toLowerCase();
+    return VIDEO_FILE_EXTENSIONS.has(extension);
+  }
 }

package/src/course/course.controller.ts

@@ -1,5 +1,5 @@
 
-import { Role } from '@hed-hog/api';
+import { Role, User } from '@hed-hog/api';
 import {
     Body,
     Controller,
@@ -15,6 +15,7 @@ import {
 } from '@nestjs/common';
 import { CourseService } from './course.service';
 import { CreateCourseDto } from './dto/create-course.dto';
+import { CleanupCourseStorageDto } from './dto/cleanup-course-storage.dto';
 import { UpdateCourseDto } from './dto/update-course.dto';
 
 @Role()
@@ -64,6 +65,24 @@ export class CourseController {
     return this.courseService.stats();
   }
 
+  @Get(':id/overview')
+  getCourseContentOverview(@Param('id', ParseIntPipe) id: number) {
+    return this.courseService.getCourseContentOverview(id);
+  }
+
+  @Post(':id/storage/cleanup')
+  cleanupCourseStorageCategory(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: CleanupCourseStorageDto,
+    @User() user: any,
+  ) {
+    return this.courseService.enqueueStorageCategoryCleanup(
+      id,
+      body.category,
+      Number(user?.id || 0) || null,
+    );
+  }
+
   @Get(':id')
   getById(@Param('id', ParseIntPipe) id: number) {
     return this.courseService.getById(id);
@@ -83,8 +102,8 @@ export class CourseController {
   }
 
   @Delete(':id')
-  remove(@Param('id', ParseIntPipe) id: number) {
-    return this.courseService.remove(id);
+  remove(@Param('id', ParseIntPipe) id: number, @User() user: any) {
+    return this.courseService.remove(id, Number(user?.id || 0) || null);
   }
 
   @Get(':courseId/video-resolution-profiles')

package/src/course/course.module.ts

@@ -4,16 +4,19 @@ import { QueueModule } from '@hed-hog/queue';
 import { forwardRef, Module } from '@nestjs/common';
 import { InstructorModule } from '../instructor/instructor.module';
 import { CourseLessonController } from './course-lesson.controller';
-import { CourseOperationsController } from './course-operations.controller';
 import { CourseOperationsIntegrationService } from './course-operations-integration.service';
+import { CourseOperationsController } from './course-operations.controller';
 import { CourseStructureController } from './course-structure.controller';
-import { LmsSettingController } from './lms-setting.controller';
 import { CourseStructureService } from './course-structure.service';
 import { CourseVideoConversionService } from './course-video-conversion.service';
 import { CourseController } from './course.controller';
 import { LmsCoursesMcpTools } from './course.mcp-tools';
+import { LmsBulkUploadInfraService } from './lms-bulk-upload-infra.service';
 import { CourseService } from './course.service';
+import { LmsBulkUploadController } from './lms-bulk-upload.controller';
+import { LmsBulkUploadService } from './lms-bulk-upload.service';
 import { LmsOperationsTaskSubscriber } from './lms-operations-task.subscriber';
+import { LmsSettingController } from './lms-setting.controller';
 
 @Module({
   imports: [
@@ -22,12 +25,21 @@ import { LmsOperationsTaskSubscriber } from './lms-operations-task.subscriber';
     forwardRef(() => CoreModule),
     forwardRef(() => QueueModule),
   ],
-  controllers: [CourseController, CourseStructureController, CourseLessonController, LmsSettingController, CourseOperationsController],
+  controllers: [
+    CourseController,
+    CourseStructureController,
+    CourseLessonController,
+    LmsSettingController,
+    CourseOperationsController,
+    LmsBulkUploadController,
+  ],
   providers: [
     CourseOperationsIntegrationService,
     CourseService,
     CourseStructureService,
     CourseVideoConversionService,
+    LmsBulkUploadInfraService,
+    LmsBulkUploadService,
     LmsCoursesMcpTools,
     LmsOperationsTaskSubscriber,
   ],