@hed-hog/lms 0.0.353 → 0.0.355

package/src/course/course-audio-transcription.service.ts

@@ -0,0 +1,393 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { FileService, NotificationService, SettingService } from '@hed-hog/core';
+import { IJobHandler, QueueHandlerRegistry } from '@hed-hog/queue';
+import {
+    Inject,
+    Injectable,
+    Logger,
+    OnModuleInit,
+    forwardRef,
+} from '@nestjs/common';
+import axios from 'axios';
+import { execFile } from 'child_process';
+import { promises as fs } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { promisify } from 'util';
+
+const execFileAsync = promisify(execFile);
+
+type NotificationContext = {
+  userId: number;
+  notificationId: number;
+};
+
+@Injectable()
+export class CourseAudioTranscriptionService implements OnModuleInit, IJobHandler {
+  private readonly logger = new Logger(CourseAudioTranscriptionService.name);
+
+  private async createProgressEvent(
+    queueJobId: number,
+    message: string,
+    metadata?: Record<string, unknown>,
+  ): Promise<void> {
+    try {
+      await (this.prismaService as any).queue_job_event.create({
+        data: {
+          queue_job_id: queueJobId,
+          event_type: 'started',
+          message,
+          ...(metadata ? { metadata } : {}),
+        },
+      });
+    } catch (error) {
+      this.logger.warn(
+        `Queue job ${queueJobId}: failed to persist transcription progress event "${message}": ${error instanceof Error ? error.message : 'unknown error'}`,
+      );
+    }
+  }
+
+  private resolveNotificationProgress(metadata?: Record<string, unknown>): number {
+    const phase = String(metadata?.phase ?? '');
+
+    if (phase === 'transcription_download_audio') return 92;
+    if (phase === 'transcription_split_audio') return 94;
+    if (phase === 'transcription_split_done') return 96;
+    if (phase === 'transcription_ai_chunk') {
+      const chunkIndex = Number(metadata?.chunkIndex ?? 0);
+      const chunkCount = Number(metadata?.chunkCount ?? 0);
+      if (chunkIndex > 0 && chunkCount > 0) {
+        const ratio = Math.min(1, Math.max(0, chunkIndex / chunkCount));
+        return 96 + Math.round(ratio * 3);
+      }
+      return 98;
+    }
+    if (phase === 'transcription_save') return 99;
+    if (phase === 'transcription_done') return 100;
+
+    return 95;
+  }
+
+  private async updateAsyncNotification(
+    context: NotificationContext,
+    progress: number,
+    body: string,
+    success?: boolean,
+  ): Promise<void> {
+    try {
+      await this.notificationService.updateProgress(
+        context.userId,
+        context.notificationId,
+        {
+          progress,
+          body,
+          ...(success != null ? { success } : {}),
+        },
+      );
+    } catch (error) {
+      this.logger.warn(
+        `Failed to update async notification ${context.notificationId} for user ${context.userId}: ${error instanceof Error ? error.message : 'unknown error'}`,
+      );
+    }
+  }
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
+    @Inject(forwardRef(() => FileService))
+    private readonly fileService: FileService,
+    @Inject(forwardRef(() => NotificationService))
+    private readonly notificationService: NotificationService,
+    @Inject(forwardRef(() => QueueHandlerRegistry))
+    private readonly registry: QueueHandlerRegistry,
+  ) {}
+
+  onModuleInit() {
+    this.registry.register('lms.audio.transcribe', this);
+    this.logger.log('Registered handler for "lms.audio.transcribe"');
+  }
+
+  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<void> {
+    const { courseId, lessonId, audioFileId, parentJobId, notificationId, notificationUserId } = job.payload as {
+      courseId: number;
+      lessonId: number;
+      audioFileId: number;
+      parentJobId?: number;
+      notificationId?: number;
+      notificationUserId?: number;
+    };
+
+    const notificationContext: NotificationContext | undefined =
+      Number.isInteger(Number(notificationId)) &&
+      Number.isInteger(Number(notificationUserId))
+        ? {
+            notificationId: Number(notificationId),
+            userId: Number(notificationUserId),
+          }
+        : undefined;
+
+    const emitProgress = async (message: string, metadata?: Record<string, unknown>) => {
+      await this.createProgressEvent(job.id, message, metadata);
+      if (parentJobId) {
+        await this.createProgressEvent(parentJobId, message, metadata);
+      }
+      if (notificationContext) {
+        await this.updateAsyncNotification(
+          notificationContext,
+          this.resolveNotificationProgress(metadata),
+          message,
+        );
+      }
+    };
+
+    const settings = await this.settingService.getSettingValues([
+      'ai-openai-api-key',
+      'ai-openai-api-key-enabled',
+      'lms-audio-transcription-enabled',
+    ]);
+    const apiKey = settings['ai-openai-api-key'] as string;
+    const enabled = settings['ai-openai-api-key-enabled'];
+    const transcriptionEnabled = settings['lms-audio-transcription-enabled'] !== false;
+
+    if (!transcriptionEnabled) {
+      this.logger.warn(
+        `Transcription skipped for lesson ${lessonId}: disabled by lms-audio-transcription-enabled setting`,
+      );
+      if (notificationContext) {
+        await this.updateAsyncNotification(
+          notificationContext,
+          100,
+          'Transcrição desabilitada nas configurações do LMS.',
+          false,
+        );
+      }
+      return;
+    }
+
+    if (!enabled || !apiKey) {
+      this.logger.warn(
+        `Transcription skipped for lesson ${lessonId}: OpenAI key not configured`,
+      );
+      if (notificationContext) {
+        await this.updateAsyncNotification(
+          notificationContext,
+          100,
+          'Transcrição não iniciada: chave da IA não configurada.',
+          false,
+        );
+      }
+      return;
+    }
+
+    const course = await (this.prismaService as any).course.findUnique({
+      where: { id: courseId },
+      include: { locale: true },
+    });
+    const language = course?.locale?.code ?? 'pt';
+
+    const tempDir = join(tmpdir(), `lms-transcribe-${lessonId}-${Date.now()}`);
+    await fs.mkdir(tempDir, { recursive: true });
+
+    try {
+      const sourceAudioPath = join(tempDir, `audio_${lessonId}.source`);
+      const normalizedAudioPath = join(tempDir, `audio_${lessonId}.normalized.mp3`);
+      await emitProgress('Baixando áudio para transcrição...', {
+        phase: 'transcription_download_audio',
+        lessonId,
+        audioFileId,
+      });
+      await this.fileService.downloadToPath(audioFileId, sourceAudioPath);
+
+      await emitProgress('Normalizando áudio para transcrição...', {
+        phase: 'transcription_split_audio',
+        lessonId,
+      });
+      await execFileAsync(
+        'ffmpeg',
+        [
+          '-y',
+          '-i',
+          sourceAudioPath,
+          '-ar',
+          '16000',
+          '-ac',
+          '1',
+          '-c:a',
+          'libmp3lame',
+          '-b:a',
+          '32k',
+          normalizedAudioPath,
+        ],
+        {
+          maxBuffer: 1024 * 1024 * 20,
+          windowsHide: true,
+        },
+      );
+
+      const chunkPattern = join(tempDir, 'chunk_%04d.mp3');
+      await emitProgress('Dividindo áudio em partes para transcrição...', {
+        phase: 'transcription_split_audio',
+        lessonId,
+      });
+      await execFileAsync(
+        'ffmpeg',
+        [
+          '-y',
+          '-i',
+          normalizedAudioPath,
+          '-f',
+          'segment',
+          '-segment_time',
+          '60',
+          '-ar',
+          '16000',
+          '-ac',
+          '1',
+          '-c:a',
+          'libmp3lame',
+          '-b:a',
+          '32k',
+          chunkPattern,
+        ],
+        {
+          maxBuffer: 1024 * 1024 * 20,
+          windowsHide: true,
+        },
+      );
+
+      const allFiles = await fs.readdir(tempDir);
+      const chunks = allFiles
+        .filter((name) => name.startsWith('chunk_') && name.endsWith('.mp3'))
+        .sort((a, b) => a.localeCompare(b));
+      await emitProgress(`Áudio dividido em ${chunks.length} parte(s).`, {
+        phase: 'transcription_split_done',
+        lessonId,
+        chunks: chunks.length,
+      });
+
+      const allSegments: Array<{
+        course_lesson_id: number;
+        start_seconds: number;
+        end_seconds: number;
+        text: string;
+      }> = [];
+
+      for (let i = 0; i < chunks.length; i += 1) {
+        const chunkName = chunks[i];
+        if (!chunkName) continue;
+        await emitProgress(
+          `Transcrevendo com IA a parte ${i + 1} de ${chunks.length}...`,
+          {
+            phase: 'transcription_ai_chunk',
+            lessonId,
+            chunkIndex: i + 1,
+            chunkCount: chunks.length,
+          },
+        );
+
+        const chunkPath = join(tempDir, chunkName);
+        const offsetSeconds = i * 60;
+        const chunkBuffer = await fs.readFile(chunkPath);
+
+        const formData = new FormData();
+        formData.append(
+          'file',
+          new Blob([chunkBuffer], { type: 'audio/mpeg' }),
+          chunkName,
+        );
+        formData.append('model', 'whisper-1');
+        formData.append('response_format', 'verbose_json');
+        formData.append('language', language);
+
+        const headers: Record<string, string> = {
+          Authorization: `Bearer ${apiKey}`,
+        };
+        const maybeHeaders = (formData as any).getHeaders?.();
+        if (maybeHeaders && typeof maybeHeaders === 'object') {
+          Object.assign(headers, maybeHeaders);
+        }
+
+        const response = await axios.post(
+          'https://api.openai.com/v1/audio/transcriptions',
+          formData,
+          { headers },
+        );
+
+        const segments = response.data?.segments ?? [];
+        for (const segment of segments) {
+          const text = String(segment?.text ?? '').trim();
+          if (!text) continue;
+
+          allSegments.push({
+            course_lesson_id: lessonId,
+            start_seconds: offsetSeconds + Number(segment?.start ?? 0),
+            end_seconds: offsetSeconds + Number(segment?.end ?? 0),
+            text,
+          });
+        }
+      }
+
+      await emitProgress('Salvando transcrição gerada pela IA...', {
+        phase: 'transcription_save',
+        lessonId,
+        segments: allSegments.length,
+      });
+      await this.prismaService.$transaction([
+        (this.prismaService as any).course_lesson_transcription_segment.deleteMany({
+          where: { course_lesson_id: lessonId },
+        }),
+        (this.prismaService as any).course_lesson_transcription_segment.createMany({
+          data: allSegments,
+        }),
+      ]);
+
+      this.logger.log(
+        `Transcription saved for lesson ${lessonId}: ${allSegments.length} segments`,
+      );
+      await emitProgress(
+        `Transcrição concluída com ${allSegments.length} segmento(s).`,
+        {
+          phase: 'transcription_done',
+          lessonId,
+          segments: allSegments.length,
+        },
+      );
+      if (notificationContext) {
+        await this.updateAsyncNotification(
+          notificationContext,
+          100,
+          `Transcrição concluída com ${allSegments.length} segmento(s).`,
+          true,
+        );
+      }
+    } catch (error) {
+      if (notificationContext) {
+        const message =
+          error instanceof Error && error.message
+            ? error.message
+            : 'Falha ao transcrever o áudio.';
+        await this.updateAsyncNotification(
+          notificationContext,
+          100,
+          `Falha na transcrição: ${message}`,
+          false,
+        );
+      }
+      throw error;
+    } finally {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    }
+  }
+}

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

@@ -0,0 +1,28 @@
+import { Role } from '@hed-hog/api';
+import { Body, Controller, Get, Param, ParseIntPipe, Put } from '@nestjs/common';
+import { CourseStructureService } from './course-structure.service';
+import { UpdateTranscriptionSegmentsDTO } from './dto/update-transcription-segments.dto';
+
+@Role()
+@Controller('lms/lessons')
+export class CourseLessonController {
+  constructor(private readonly courseStructureService: CourseStructureService) {}
+
+  @Get(':id/transcription-segments')
+  getTranscriptionSegments(@Param('id', ParseIntPipe) id: number) {
+    return this.courseStructureService.getTranscriptionSegments(id);
+  }
+
+  @Put(':id/transcription-segments')
+  updateTranscriptionSegments(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateTranscriptionSegmentsDTO,
+  ) {
+    return this.courseStructureService.updateTranscriptionSegments(id, dto);
+  }
+
+  @Get(':id/audio-files')
+  getAudioFiles(@Param('id', ParseIntPipe) id: number) {
+    return this.courseStructureService.getAudioFiles(id);
+  }
+}

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

@@ -1,4 +1,4 @@
-import { Role } from '@hed-hog/api';
+import { Role, User } from '@hed-hog/api';
 import {
     Body,
     Controller,
@@ -11,15 +11,17 @@ import {
 } from '@nestjs/common';
 import { CourseStructureService } from './course-structure.service';
 import { CourseVideoConversionService } from './course-video-conversion.service';
+import { CreateCourseLessonFrameDto } from './dto/create-course-lesson-frame.dto';
 import {
-  CreateCourseStructureLessonDto,
-  CreateLessonVideoConversionDto,
+    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';
 import { ReorderLessonsDto } from './dto/reorder-lessons.dto';
 import { ReorderSessionsDto } from './dto/reorder-sessions.dto';
+import { UpdateCourseLessonFrameDto } from './dto/update-course-lesson-frame.dto';
 import { UpdateCourseResourcesDto } from './dto/update-course-resources.dto';
 import { UpdateCourseStructureLessonDto } from './dto/update-course-structure-lesson.dto';
 import { UpdateCourseStructureSessionDto } from './dto/update-course-structure-session.dto';
@@ -151,12 +153,14 @@ export class CourseStructureController {
 
   @Post('sessions/:sessionId/lessons/:lessonId/video-conversions')
   createLessonVideoConversion(
+    @User() { id: userId },
     @Param('id', ParseIntPipe) courseId: number,
     @Param('sessionId', ParseIntPipe) sessionId: number,
     @Param('lessonId', ParseIntPipe) lessonId: number,
     @Body() dto: CreateLessonVideoConversionDto,
   ) {
     return this.courseVideoConversionService.enqueueConversion({
+      userId,
       courseId,
       sessionId,
       lessonId,
@@ -173,6 +177,48 @@ export class CourseStructureController {
     return this.courseStructureService.deleteLesson(courseId, sessionId, lessonId);
   }
 
+  @Delete('sessions/:sessionId/lessons/:lessonId/frames/:frameId')
+  deleteLessonFrame(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @Param('frameId', ParseIntPipe) frameId: number,
+  ) {
+    return this.courseStructureService.deleteLessonFrame(courseId, sessionId, lessonId, frameId);
+  }
+
+  @Post('sessions/:sessionId/lessons/:lessonId/frames')
+  createLessonFrame(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @Body() dto: CreateCourseLessonFrameDto,
+  ) {
+    return this.courseStructureService.createLessonFrame(
+      courseId,
+      sessionId,
+      lessonId,
+      dto,
+    );
+  }
+
+  @Patch('sessions/:sessionId/lessons/:lessonId/frames/:frameId')
+  updateLessonFrame(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @Param('frameId', ParseIntPipe) frameId: number,
+    @Body() dto: UpdateCourseLessonFrameDto,
+  ) {
+    return this.courseStructureService.updateLessonFrame(
+      courseId,
+      sessionId,
+      lessonId,
+      frameId,
+      dto,
+    );
+  }
+
   @Post('sessions/:sessionId/lessons/:lessonId/duplicate')
   duplicateLesson(
     @Param('id', ParseIntPipe) courseId: number,