@hed-hog/lms 0.0.365 → 0.0.370

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

@@ -3,6 +3,7 @@ import { FileService } from '@hed-hog/core';
 import { QueueJobService } from '@hed-hog/queue';
 import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { InstructorService } from '../instructor/instructor.service';
+import { CourseAiUsageService } from './course-ai-usage.service';
 import { CourseOperationsIntegrationService } from './course-operations-integration.service';
 import { CourseVideoHlsService } from './course-video-hls.service';
 import { CreateCourseLessonFrameDto } from './dto/create-course-lesson-frame.dto';
@@ -45,8 +46,13 @@ export class CourseStructureService {
     private readonly operationsIntegration: CourseOperationsIntegrationService,
     private readonly queueJob: QueueJobService,
     private readonly courseVideoHlsService: CourseVideoHlsService,
+    private readonly aiUsageService: CourseAiUsageService,
   ) {}
 
+  getCourseAiCosts(courseId: number) {
+    return this.aiUsageService.getCourseAiCosts(courseId);
+  }
+
   async getStructure(courseId: number) {
     await this.ensureCourseExists(courseId);
 
@@ -61,7 +67,9 @@ export class CourseStructureService {
           course_lesson: {
             orderBy: { order: 'asc' },
             include: {
-              course_lesson_file: true,
+              course_lesson_file: {
+                include: { file: { select: { size: true } } },
+              },
               course_lesson_video_frame: {
                 orderBy: { id: 'asc' },
                 include: {
@@ -162,11 +170,12 @@ export class CourseStructureService {
             parsedContent?.statusProducao,
           ),
           published: lessonPublishedById.get(lesson.id) ?? false,
+          temTranscricao: Boolean((lesson as any).has_transcription),
           recursos: lesson.course_lesson_file.map((fileLink) => ({
             id: String(fileLink.id),
             nome: fileLink.title,
             fileId: fileLink.file_id,
-            tamanho: '',
+            tamanho: fileLink.file?.size ?? 0,
             type: this.readLessonFileType(fileLink),
             is_public: this.readLessonFileVisibility(fileLink),
           })),
@@ -1114,12 +1123,17 @@ export class CourseStructureService {
     return { lessons: result };
   }
 
-  async getTranscriptionSegments(lessonId: number) {
+  async getTranscriptionSegments(lessonId: number, localeId?: number | null) {
+    const where: Record<string, any> = { course_lesson_id: lessonId };
+    if (localeId !== undefined) {
+      where.locale_id = localeId ?? null;
+    }
     return (this.prisma as any).course_lesson_transcription_segment.findMany({
-      where: { course_lesson_id: lessonId },
+      where,
       orderBy: { start_seconds: 'asc' },
       select: {
         id: true,
+        locale_id: true,
         start_seconds: true,
         end_seconds: true,
         text: true,
@@ -1127,17 +1141,44 @@ export class CourseStructureService {
     });
   }
 
+  async getAvailableTranscriptionLocales(lessonId: number) {
+    const rows = await (this.prisma as any).course_lesson_transcription_segment.findMany({
+      where: { course_lesson_id: lessonId },
+      select: { locale_id: true },
+      distinct: ['locale_id'],
+    });
+
+    const localeIds: (number | null)[] = rows.map((r: any) => r.locale_id);
+
+    const locales = await Promise.all(
+      localeIds.map(async (id) => {
+        if (id === null) return { id: null, code: null, name: null, region: null };
+        const locale = await (this.prisma as any).locale.findUnique({
+          where: { id },
+          select: { id: true, code: true, name: true, region: true },
+        });
+        return locale ?? { id, code: null, name: null, region: null };
+      }),
+    );
+
+    return locales;
+  }
+
   async updateTranscriptionSegments(
     lessonId: number,
     dto: UpdateTranscriptionSegmentsDTO,
+    localeId?: number | null,
   ) {
+    const where: Record<string, any> = { course_lesson_id: lessonId };
+    if (localeId !== undefined) {
+      where.locale_id = localeId ?? null;
+    }
     return this.prisma.$transaction([
-      (this.prisma as any).course_lesson_transcription_segment.deleteMany({
-        where: { course_lesson_id: lessonId },
-      }),
+      (this.prisma as any).course_lesson_transcription_segment.deleteMany({ where }),
       (this.prisma as any).course_lesson_transcription_segment.createMany({
         data: (dto.segments ?? []).map((segment) => ({
           course_lesson_id: lessonId,
+          locale_id: localeId ?? null,
           start_seconds: segment.startSeconds,
           end_seconds: segment.endSeconds,
           text: segment.text,
@@ -1146,6 +1187,69 @@ export class CourseStructureService {
     ]);
   }
 
+  async deleteTranscriptionLocale(lessonId: number, localeId: number | null) {
+    const result = await (this.prisma as any).course_lesson_transcription_segment.deleteMany({
+      where: { course_lesson_id: lessonId, locale_id: localeId },
+    });
+    return { success: true, deleted: result.count };
+  }
+
+  async deleteAllCourseTranscriptions(courseId: number) {
+    const lessons = await (this.prisma as any).course_lesson.findMany({
+      where: { course_module: { course_id: courseId } },
+      select: { id: true },
+    });
+    const lessonIds = lessons.map((l: any) => l.id);
+    if (lessonIds.length === 0) {
+      return { success: true, deleted: 0 };
+    }
+    const result = await (this.prisma as any).course_lesson_transcription_segment.deleteMany({
+      where: { course_lesson_id: { in: lessonIds } },
+    });
+    return { success: true, deleted: result.count };
+  }
+
+  async translateTranscription(
+    lessonId: number,
+    sourceLocaleId: number | null,
+    targetLocaleId: number,
+    notificationId?: number,
+    notificationUserId?: number,
+  ) {
+    const lesson = await (this.prisma as any).course_lesson.findUnique({
+      where: { id: lessonId },
+      select: { id: true },
+    });
+
+    if (!lesson) {
+      throw new NotFoundException(`Lesson ${lessonId} not found`);
+    }
+
+    const job = await this.queueJob.enqueue({
+      type: 'lms.transcription.translate',
+      queueName: 'lms.transcription.translate',
+      payload: {
+        lessonId,
+        sourceLocaleId,
+        targetLocaleId,
+        ...(notificationId != null ? { notificationId } : {}),
+        ...(notificationUserId != null ? { notificationUserId } : {}),
+      },
+      sourceModule: 'lms',
+      sourceEntity: 'course_lesson',
+      sourceEntityId: `${lessonId}:${targetLocaleId}`,
+      maxAttempts: 3,
+    });
+
+    const startedOnDemand = await this.startTranscriptionOnDemandIfNeeded(job.id);
+
+    if (startedOnDemand) {
+      return { queueJobId: job.id, status: 'processing' };
+    }
+
+    return { queueJobId: job.id, status: job.status };
+  }
+
   async getAudioFiles(lessonId: number) {
     return (this.prisma as any).course_lesson_file.findMany({
       where: {
@@ -1270,9 +1374,10 @@ export class CourseStructureService {
 
   async bulkEnqueueJobs(
     courseId: number,
-    jobType: 'transcription' | 'xp_recalculation' | 'video_processing',
+    jobType: 'transcription' | 'xp_recalculation' | 'video_processing' | 'translate_transcription',
     userId: number,
     reprocessAlreadyProcessed?: boolean,
+    targetLocaleId?: number,
   ): Promise<{
     queued: number;
     skipped: number;
@@ -1363,7 +1468,7 @@ export class CourseStructureService {
           skipped++;
         }
       }
-    } else {
+    } else if (jobType === 'xp_recalculation') {
       for (const lesson of lessons) {
         const segments = await (this.prisma as any).course_lesson_transcription_segment.findFirst({
           where: { course_lesson_id: lesson.id },
@@ -1409,11 +1514,78 @@ export class CourseStructureService {
           `${skippedWithoutTranscription} aula(s) sem transcrição foram ignoradas. Gere a transcrição antes de recalcular o XP.`,
         );
       }
+    } else if (jobType === 'translate_transcription') {
+      if (!targetLocaleId) {
+        warnings.push('targetLocaleId é obrigatório para o job de tradução em massa.');
+        return { queued, skipped, skippedWithoutTranscription, warnings };
+      }
+
+      for (const lesson of lessons) {
+        const sourceSegment = await (this.prisma as any).course_lesson_transcription_segment.findFirst({
+          where: {
+            course_lesson_id: lesson.id,
+            NOT: { locale_id: targetLocaleId },
+          },
+          select: { id: true, locale_id: true },
+          orderBy: { id: 'asc' },
+        });
+
+        if (!sourceSegment) {
+          skipped++;
+          skippedWithoutTranscription++;
+          continue;
+        }
+
+        await this.queueJob.enqueue({
+          type: 'lms.transcription.translate',
+          queueName: 'lms.transcription.translate',
+          payload: {
+            lessonId: lesson.id,
+            sourceLocaleId: sourceSegment.locale_id ?? null,
+            targetLocaleId,
+          },
+          sourceModule: 'lms',
+          sourceEntity: 'course_lesson',
+          sourceEntityId: `${lesson.id}:${targetLocaleId}`,
+          maxAttempts: 3,
+        });
+        queued++;
+      }
+
+      if (skippedWithoutTranscription > 0) {
+        warnings.push(
+          `${skippedWithoutTranscription} aula(s) sem transcrição foram ignoradas.`,
+        );
+      }
     }
 
     return { queued, skipped, skippedWithoutTranscription, warnings };
   }
 
+  async getCourseTranscriptionLocales(courseId: number) {
+    const rows = await (this.prisma as any).course_lesson_transcription_segment.findMany({
+      where: {
+        course_lesson: {
+          course_module: { course_id: courseId },
+        },
+      },
+      select: { locale_id: true },
+      distinct: ['locale_id'],
+    });
+
+    const localeIds = (rows as Array<{ locale_id: number | null }>)
+      .map((r) => r.locale_id)
+      .filter((id): id is number => id !== null);
+
+    if (localeIds.length === 0) return [];
+
+    return (this.prisma as any).locale.findMany({
+      where: { id: { in: localeIds } },
+      select: { id: true, code: true, name: true, region: true },
+      orderBy: { name: 'asc' },
+    });
+  }
+
   private async syncLessonRelations(
     lessonId: number,
     dto: Partial<
@@ -1510,7 +1682,9 @@ export class CourseStructureService {
             },
           },
         },
-        course_lesson_file: true,
+        course_lesson_file: {
+          include: { file: { select: { size: true } } },
+        },
         course_lesson_question: {
           orderBy: { order: 'asc' },
         },

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

@@ -0,0 +1,293 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { buildAiConfigFromIntegration, NotificationService, SettingService } from '@hed-hog/core';
+import { DatabaseQueueProvider, IJobHandler, NonRetryableError, QueueHandlerRegistry } from '@hed-hog/queue';
+import {
+  Inject,
+  Injectable,
+  Logger,
+  OnModuleInit,
+  forwardRef,
+} from '@nestjs/common';
+import axios from 'axios';
+import { CourseAiUsageService } from './course-ai-usage.service';
+
+const BATCH_SIZE = 50;
+
+@Injectable()
+export class CourseTranscriptionTranslationService implements OnModuleInit, IJobHandler {
+  private readonly logger = new Logger(CourseTranscriptionTranslationService.name);
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
+    @Inject(forwardRef(() => NotificationService))
+    private readonly notificationService: NotificationService,
+    @Inject(forwardRef(() => QueueHandlerRegistry))
+    private readonly registry: QueueHandlerRegistry,
+    @Inject(forwardRef(() => DatabaseQueueProvider))
+    private readonly dbQueue: DatabaseQueueProvider,
+    @Inject(forwardRef(() => CourseAiUsageService))
+    private readonly aiUsageService: CourseAiUsageService,
+  ) {}
+
+  onModuleInit() {
+    this.registry.register('lms.transcription.translate', this);
+    this.logger.log('Registered handler for "lms.transcription.translate"');
+  }
+
+  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 translation progress event "${message}": ${error instanceof Error ? error.message : 'unknown error'}`,
+      );
+    }
+  }
+
+  private async updateNotification(
+    userId: number,
+    notificationId: number,
+    progress: number,
+    body: string,
+    success?: boolean,
+  ): Promise<void> {
+    try {
+      await this.notificationService.updateProgress(userId, notificationId, {
+        progress,
+        body,
+        ...(success != null ? { success } : {}),
+      });
+    } catch (error) {
+      this.logger.warn(
+        `Failed to update notification ${notificationId} for user ${userId}: ${error instanceof Error ? error.message : 'unknown error'}`,
+      );
+    }
+  }
+
+  private async translateBatch(
+    texts: string[],
+    targetLangName: string,
+    apiKey: string,
+  ): Promise<{ translations: string[]; inputTokens: number; outputTokens: number }> {
+    const prompt = [
+      `Translate the following subtitle segments to ${targetLangName}.`,
+      `Return ONLY a JSON array of strings with the same number of elements, in the same order.`,
+      `Do not add explanations. Preserve punctuation and formatting.`,
+      ``,
+      `Input:`,
+      JSON.stringify(texts),
+    ].join('\n');
+
+    const response = await axios.post(
+      'https://api.openai.com/v1/chat/completions',
+      {
+        model: 'gpt-4o-mini',
+        messages: [{ role: 'user', content: prompt }],
+        temperature: 0.2,
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        timeout: 120_000,
+      },
+    );
+
+    const content: string = response.data?.choices?.[0]?.message?.content ?? '[]';
+    const start = content.indexOf('[');
+    const end = content.lastIndexOf(']');
+    if (start === -1 || end === -1) {
+      throw new Error(`AI response did not contain a JSON array: ${content.slice(0, 200)}`);
+    }
+    const parsed: unknown = JSON.parse(content.slice(start, end + 1));
+    if (!Array.isArray(parsed)) {
+      throw new Error('AI translation response is not an array');
+    }
+    const usage = response.data?.usage ?? {};
+    return {
+      translations: parsed.map((v) => String(v)),
+      inputTokens: Number(usage.prompt_tokens ?? 0),
+      outputTokens: Number(usage.completion_tokens ?? 0),
+    };
+  }
+
+  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 { lessonId, sourceLocaleId, targetLocaleId, notificationId, notificationUserId } =
+      job.payload as {
+        lessonId: number;
+        sourceLocaleId: number | null;
+        targetLocaleId: number;
+        notificationId?: number;
+        notificationUserId?: number;
+      };
+
+    const hasNotification =
+      Number.isInteger(Number(notificationId)) &&
+      Number.isInteger(Number(notificationUserId));
+
+    const emitProgress = async (message: string, progress: number, success?: boolean) => {
+      await this.createProgressEvent(job.id, message);
+      if (hasNotification) {
+        await this.updateNotification(
+          Number(notificationUserId),
+          Number(notificationId),
+          progress,
+          message,
+          success,
+        );
+      }
+    };
+
+    const settings = await this.settingService.getSettingValues(['ai-openai-profile-id']);
+    const profileId = Number(settings['ai-openai-profile-id']);
+    let apiKey = '';
+
+    if (profileId) {
+      const profile = await (this.prismaService as any).integration_profile.findUnique({
+        where: { id: profileId },
+        include: { integration_provider: { select: { slug: true } } },
+      });
+      if (profile) {
+        apiKey = buildAiConfigFromIntegration(
+          profile.integration_provider.slug,
+          profile.config,
+        ).apiKey;
+      }
+    }
+
+    if (!apiKey) {
+      const msg = profileId
+        ? `Perfil de IA (id=${profileId}) não encontrado ou sem chave OpenAI configurada.`
+        : `Tradução requer um perfil OpenAI configurado. Acesse Settings → LMS → ai-openai-profile-id.`;
+      await emitProgress(msg, 100, false);
+      throw new NonRetryableError(msg);
+    }
+
+    const targetLocale = await (this.prismaService as any).locale.findUnique({
+      where: { id: targetLocaleId },
+      select: { id: true, code: true, name: true },
+    });
+
+    if (!targetLocale) {
+      const msg = `Locale alvo (id=${targetLocaleId}) não encontrado.`;
+      await emitProgress(msg, 100, false);
+      throw new NonRetryableError(msg);
+    }
+
+    const sourceWhere: Record<string, any> = { course_lesson_id: lessonId };
+    if (sourceLocaleId !== null && sourceLocaleId !== undefined) {
+      sourceWhere.locale_id = sourceLocaleId;
+    } else {
+      sourceWhere.locale_id = null;
+    }
+
+    const sourceSegments = await (this.prismaService as any).course_lesson_transcription_segment.findMany({
+      where: sourceWhere,
+      orderBy: { start_seconds: 'asc' },
+      select: { id: true, start_seconds: true, end_seconds: true, text: true },
+    });
+
+    if (!sourceSegments.length) {
+      const msg = `Nenhum segmento de transcrição encontrado para a aula ${lessonId} no idioma fonte.`;
+      await emitProgress(msg, 100, false);
+      throw new NonRetryableError(msg);
+    }
+
+    await emitProgress(
+      `Iniciando tradução de ${sourceSegments.length} segmento(s) para ${targetLocale.name}...`,
+      10,
+    );
+
+    const targetLangName = targetLocale.name ?? targetLocale.code;
+    const translatedTexts: string[] = [];
+    const totalBatches = Math.ceil(sourceSegments.length / BATCH_SIZE);
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+
+    for (let i = 0; i < sourceSegments.length; i += BATCH_SIZE) {
+      const batch = sourceSegments.slice(i, i + BATCH_SIZE);
+      const batchIndex = Math.floor(i / BATCH_SIZE) + 1;
+
+      await emitProgress(
+        `Traduzindo lote ${batchIndex}/${totalBatches}...`,
+        10 + Math.round((batchIndex / totalBatches) * 80),
+      );
+
+      const batchTexts: string[] = batch.map((s: any) => s.text);
+      const batchResult = await this.translateBatch(batchTexts, targetLangName, apiKey);
+      const batchTranslated = batchResult.translations;
+      totalInputTokens += batchResult.inputTokens;
+      totalOutputTokens += batchResult.outputTokens;
+
+      if (batchTranslated.length !== batchTexts.length) {
+        this.logger.warn(
+          `Batch ${batchIndex}: expected ${batchTexts.length} translations, got ${batchTranslated.length} — padding missing entries with source text`,
+        );
+        while (batchTranslated.length < batchTexts.length) {
+          batchTranslated.push(batchTexts[batchTranslated.length] ?? '');
+        }
+        batchTranslated.splice(batchTexts.length);
+      }
+
+      translatedTexts.push(...batchTranslated);
+    }
+
+    await emitProgress('Salvando segmentos traduzidos...', 95);
+
+    const translatedSegments = sourceSegments.map((seg: any, idx: number) => ({
+      course_lesson_id: lessonId,
+      locale_id: targetLocaleId,
+      start_seconds: seg.start_seconds,
+      end_seconds: seg.end_seconds,
+      text: translatedTexts[idx] ?? seg.text,
+    }));
+
+    await this.prismaService.$transaction([
+      (this.prismaService as any).course_lesson_transcription_segment.deleteMany({
+        where: { course_lesson_id: lessonId, locale_id: targetLocaleId },
+      }),
+      (this.prismaService as any).course_lesson_transcription_segment.createMany({
+        data: translatedSegments,
+      }),
+    ]);
+
+    // Record AI cost (gpt-4o-mini, billed per token).
+    await this.aiUsageService.recordChatUsage({
+      lessonId,
+      jobType: 'translation',
+      provider: 'openai',
+      model: 'gpt-4o-mini',
+      inputTokens: totalInputTokens,
+      outputTokens: totalOutputTokens,
+    });
+
+    const doneMsg = `Tradução concluída: ${translatedSegments.length} segmento(s) em ${targetLocale.name}.`;
+    this.logger.log(doneMsg);
+    await emitProgress(doneMsg, 100, true);
+  }
+}