@hed-hog/lms 0.0.366 → 0.0.370

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