@hed-hog/lms 0.0.366 → 0.0.370

package/src/course/course.module.ts

@@ -4,6 +4,7 @@ import { CoreModule } from '@hed-hog/core';
 import { QueueModule } from '@hed-hog/queue';
 import { forwardRef, Module } from '@nestjs/common';
 import { InstructorModule } from '../instructor/instructor.module';
+import { CourseAiUsageService } from './course-ai-usage.service';
 import { CourseLessonController } from './course-lesson.controller';
 import { CourseOperationsIntegrationService } from './course-operations-integration.service';
 import { CourseOperationsController } from './course-operations.controller';
@@ -24,6 +25,7 @@ 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';
+import { PlatformaVideoService } from '../platforma/platforma-video.service';
 
 @Module({
   imports: [
@@ -42,6 +44,7 @@ import { LmsSettingController } from './lms-setting.controller';
     LmsBulkUploadController,
   ],
   providers: [
+    CourseAiUsageService,
     CourseExportService,
     CourseExportScorm12Service,
     CourseExportScorm12WorkerService,
@@ -56,6 +59,7 @@ import { LmsSettingController } from './lms-setting.controller';
     LmsBulkUploadService,
     LmsCoursesMcpTools,
     LmsOperationsTaskSubscriber,
+    PlatformaVideoService,
   ],
   exports: [
     forwardRef(() => CourseService),

package/src/course/dto/create-course-bulk-job.dto.ts

@@ -1,10 +1,14 @@
-import { IsBoolean, IsIn, IsOptional } from 'class-validator';
+import { IsBoolean, IsIn, IsInt, IsOptional } from 'class-validator';
 
 export class CreateCourseBulkJobDto {
-  @IsIn(['transcription', 'xp_recalculation', 'video_processing'])
-  jobType: 'transcription' | 'xp_recalculation' | 'video_processing';
+  @IsIn(['transcription', 'xp_recalculation', 'video_processing', 'translate_transcription'])
+  jobType: 'transcription' | 'xp_recalculation' | 'video_processing' | 'translate_transcription';
 
   @IsBoolean()
   @IsOptional()
   reprocessAlreadyProcessed?: boolean;
+
+  @IsInt()
+  @IsOptional()
+  targetLocaleId?: number;
 }

package/src/course/dto/create-course-export.dto.ts

@@ -1,5 +1,6 @@
 import { Type } from 'class-transformer';
 import {
+  IsArray,
   IsIn,
   IsInt,
   IsOptional,
@@ -53,4 +54,9 @@ export class CreateCourseExportDto {
   @ValidateNested()
   @Type(() => ScormVisualSettingsDto)
   visualSettings?: ScormVisualSettingsDto;
+
+  @IsOptional()
+  @IsArray()
+  @IsInt({ each: true })
+  subtitleLocaleIds?: number[];
 }

package/src/course/ffmpeg.util.ts

@@ -1,65 +1,65 @@
-import { existsSync, readdirSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Resolves the ffmpeg/ffprobe binaries across environments: explicit env override first,
- * then a WinGet (Gyan.FFmpeg) lookup on Windows, finally the bare command on PATH.
- * Mirrors the resolution baked into CourseVideoHlsService so the decomposed pipeline jobs
- * (extract / split) behave identically.
- */
-export function getFfmpegCommand(): string {
-  const fromEnv = process.env.FFMPEG_PATH?.trim();
-  if (fromEnv) return fromEnv;
-  if (process.platform === 'win32') {
-    const found = findWindowsBinary('ffmpeg');
-    if (found) return found;
-  }
-  return 'ffmpeg';
-}
-
-export function getFfprobeCommand(): string {
-  const fromEnv = process.env.FFPROBE_PATH?.trim();
-  if (fromEnv) return fromEnv;
-  const ffmpegEnv = process.env.FFMPEG_PATH?.trim();
-  if (ffmpegEnv) {
-    const candidate = ffmpegEnv.replace(/ffmpeg(\.exe)?$/i, (_, ext) => `ffprobe${ext ?? ''}`);
-    if (existsSync(candidate)) return candidate;
-  }
-  if (process.platform === 'win32') {
-    const found = findWindowsBinary('ffprobe');
-    if (found) return found;
-  }
-  return 'ffprobe';
-}
-
-export function findWindowsBinary(name: 'ffmpeg' | 'ffprobe'): string | null {
-  const localAppData = process.env.LOCALAPPDATA;
-  if (!localAppData) return null;
-  const packagesRoot = join(localAppData, 'Microsoft', 'WinGet', 'Packages');
-  try {
-    const packageDirs = readdirSync(packagesRoot, { withFileTypes: true })
-      .filter((e) => e.isDirectory() && e.name.startsWith('Gyan.FFmpeg'))
-      .map((e) => join(packagesRoot, e.name))
-      .sort((a, b) => b.localeCompare(a));
-
-    for (const dir of packageDirs) {
-      const direct = join(dir, 'bin', `${name}.exe`);
-      if (existsSync(direct)) return direct;
-      try {
-        const versionDirs = readdirSync(dir, { withFileTypes: true })
-          .filter((e) => e.isDirectory() && e.name.toLowerCase().startsWith('ffmpeg-'))
-          .map((e) => join(dir, e.name))
-          .sort((a, b) => b.localeCompare(a));
-        for (const vd of versionDirs) {
-          const candidate = join(vd, 'bin', `${name}.exe`);
-          if (existsSync(candidate)) return candidate;
-        }
-      } catch {
-        /* skip */
-      }
-    }
-  } catch {
-    /* skip */
-  }
-  return null;
-}
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Resolves the ffmpeg/ffprobe binaries across environments: explicit env override first,
+ * then a WinGet (Gyan.FFmpeg) lookup on Windows, finally the bare command on PATH.
+ * Mirrors the resolution baked into CourseVideoHlsService so the decomposed pipeline jobs
+ * (extract / split) behave identically.
+ */
+export function getFfmpegCommand(): string {
+  const fromEnv = process.env.FFMPEG_PATH?.trim();
+  if (fromEnv) return fromEnv;
+  if (process.platform === 'win32') {
+    const found = findWindowsBinary('ffmpeg');
+    if (found) return found;
+  }
+  return 'ffmpeg';
+}
+
+export function getFfprobeCommand(): string {
+  const fromEnv = process.env.FFPROBE_PATH?.trim();
+  if (fromEnv) return fromEnv;
+  const ffmpegEnv = process.env.FFMPEG_PATH?.trim();
+  if (ffmpegEnv) {
+    const candidate = ffmpegEnv.replace(/ffmpeg(\.exe)?$/i, (_, ext) => `ffprobe${ext ?? ''}`);
+    if (existsSync(candidate)) return candidate;
+  }
+  if (process.platform === 'win32') {
+    const found = findWindowsBinary('ffprobe');
+    if (found) return found;
+  }
+  return 'ffprobe';
+}
+
+export function findWindowsBinary(name: 'ffmpeg' | 'ffprobe'): string | null {
+  const localAppData = process.env.LOCALAPPDATA;
+  if (!localAppData) return null;
+  const packagesRoot = join(localAppData, 'Microsoft', 'WinGet', 'Packages');
+  try {
+    const packageDirs = readdirSync(packagesRoot, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && e.name.startsWith('Gyan.FFmpeg'))
+      .map((e) => join(packagesRoot, e.name))
+      .sort((a, b) => b.localeCompare(a));
+
+    for (const dir of packageDirs) {
+      const direct = join(dir, 'bin', `${name}.exe`);
+      if (existsSync(direct)) return direct;
+      try {
+        const versionDirs = readdirSync(dir, { withFileTypes: true })
+          .filter((e) => e.isDirectory() && e.name.toLowerCase().startsWith('ffmpeg-'))
+          .map((e) => join(dir, e.name))
+          .sort((a, b) => b.localeCompare(a));
+        for (const vd of versionDirs) {
+          const candidate = join(vd, 'bin', `${name}.exe`);
+          if (existsSync(candidate)) return candidate;
+        }
+      } catch {
+        /* skip */
+      }
+    }
+  } catch {
+    /* skip */
+  }
+  return null;
+}

package/src/course/lms-bulk-upload-automation.service.ts

@@ -271,7 +271,7 @@ export class LmsBulkUploadAutomationService implements OnModuleInit {
       if (Number.isInteger(Number(payload.uploadItemId)) && Number(payload.uploadItemId) > 0) {
         await this.prisma.$executeRawUnsafe(
           `UPDATE "lms_bulk_upload_item"
-           SET "status" = 'done', "completed_at" = NOW(), "updated_at" = NOW()
+           SET "status" = 'received', "completed_at" = NOW(), "updated_at" = NOW()
            WHERE "id" = $1`,
           Number(payload.uploadItemId),
         ).catch(() => undefined);
@@ -377,7 +377,18 @@ export class LmsBulkUploadAutomationService implements OnModuleInit {
         }
 
         for (const lesson of session.course_lesson ?? []) {
-          if (this.normalizeComparableText(lesson.title) !== parsed.lessonTitle) {
+          const lessonNumeric = parsed.lessonCode?.replace(/[^0-9]/g, '') ?? '';
+          const lessonOrderCode = String(
+            Math.max(Number(lesson.order ?? 0), 0),
+          ).padStart(2, '0');
+
+          const matchesByCode =
+            Boolean(lessonNumeric) && lessonNumeric === lessonOrderCode;
+          const matchesByTitle =
+            !parsed.lessonCode &&
+            this.normalizeComparableText(lesson.title) === parsed.lessonTitle;
+
+          if (!matchesByCode && !matchesByTitle) {
             continue;
           }
 
@@ -411,15 +422,26 @@ export class LmsBulkUploadAutomationService implements OnModuleInit {
     }
 
     const RESOLUTION_SUFFIXES = new Set(['1080', '720', '480', '360', '240', '4k', '2k', 'uhd', 'fhd', 'hd', 'sd']);
-    let titleParts = parts.slice(2);
-    if (titleParts.length > 1 && RESOLUTION_SUFFIXES.has(titleParts[titleParts.length - 1])) {
-      titleParts = titleParts.slice(0, -1);
+
+    let rest = parts.slice(2);
+
+    // 4 segmentos: detecta o código da aula (ex.: "a01") como primeiro item de `rest`.
+    // Sem código da aula (formato antigo de 3 segmentos) -> lessonCode = null.
+    let lessonCode: string | null = null;
+    if (rest.length > 1 && /^a\d{2,}$/.test(rest[0])) {
+      lessonCode = rest[0];
+      rest = rest.slice(1);
+    }
+
+    if (rest.length > 1 && RESOLUTION_SUFFIXES.has(rest[rest.length - 1])) {
+      rest = rest.slice(0, -1);
     }
 
     return {
       sessionCode: this.normalizeComparableText(parts[0]),
       courseCode: this.normalizeComparableText(parts[1]),
-      lessonTitle: this.normalizeComparableText(titleParts.join('_')),
+      lessonCode,
+      lessonTitle: this.normalizeComparableText(rest.join('_')),
     };
   }
 
@@ -624,7 +646,7 @@ export class LmsBulkUploadAutomationService implements OnModuleInit {
        SET "matched_course_id" = $2,
            "matched_session_id" = $3,
            "matched_lesson_id" = $4,
-           "status" = 'received',
+           "status" = 'processing',
            "updated_at" = $5
        WHERE "id" = $1`,
       itemId,

package/src/course/lms-bulk-upload.service.ts

@@ -726,6 +726,9 @@ export class LmsBulkUploadService {
       matched_session_title: string | null;
       matched_lesson_id: number | null;
       matched_lesson_title: string | null;
+      job_status: string | null;
+      job_attempts: number | null;
+      job_max_attempts: number | null;
     }>>(
       `SELECT
         i."id",
@@ -753,7 +756,10 @@ export class LmsBulkUploadService {
         ms."id" AS matched_session_id,
         ms."title" AS matched_session_title,
         ml."id" AS matched_lesson_id,
-        ml."title" AS matched_lesson_title
+        ml."title" AS matched_lesson_title,
+        job."job_status",
+        job."job_attempts",
+        job."job_max_attempts"
       FROM "lms_bulk_upload_item" i
       JOIN "lms_bulk_upload_session" s ON s."id" = i."session_id"
       LEFT JOIN "user" u ON u."id" = s."user_id"
@@ -777,6 +783,16 @@ export class LmsBulkUploadService {
         ORDER BY ci."id" DESC
         LIMIT 1
       ) logo ON TRUE
+      LEFT JOIN LATERAL (
+        SELECT qj."status" AS job_status,
+               qj."attempts" AS job_attempts,
+               qj."max_attempts" AS job_max_attempts
+        FROM "queue_job" qj
+        WHERE qj."source_entity" = 'lms_bulk_upload_item'
+          AND qj."source_entity_id" = CAST(i."id" AS TEXT)
+        ORDER BY qj."id" DESC
+        LIMIT 1
+      ) job ON TRUE
       ${whereSql}
       ORDER BY i."updated_at" DESC
       LIMIT $${args.length + 1}
@@ -814,6 +830,9 @@ export class LmsBulkUploadService {
         matchedSessionTitle: row.matched_session_title,
         matchedLessonId: row.matched_lesson_id ? Number(row.matched_lesson_id) : null,
         matchedLessonTitle: row.matched_lesson_title,
+        jobStatus: row.job_status ?? null,
+        jobAttempts: row.job_attempts != null ? Number(row.job_attempts) : null,
+        jobMaxAttempts: row.job_max_attempts != null ? Number(row.job_max_attempts) : null,
       })),
       total,
       page,

package/src/course/subtitle.util.ts

@@ -0,0 +1,220 @@
+/**
+ * Subtitle helpers shared between the student player VTT endpoint and the
+ * SCORM export. Line breaking is a *presentation* concern: it is applied when
+ * the VTT is generated, never stored in the database, so that translations stay
+ * clean and the balancing adapts to each language's text length.
+ *
+ * Defaults follow the Netflix Timed Text Style Guide (pt-BR): max 42 chars per
+ * line, max 2 lines, balanced split that avoids ending a line on a short
+ * function word.
+ */
+
+const FUNCTION_WORDS = new Set([
+  'a', 'à', 'ao', 'aos', 'as', 'às', 'com', 'da', 'das', 'de', 'do', 'dos',
+  'e', 'em', 'na', 'nas', 'no', 'nos', 'o', 'os', 'ou', 'para', 'pela',
+  'pelas', 'pelo', 'pelos', 'por', 'que', 'se', 'um', 'uma', 'umas', 'uns',
+]);
+
+/**
+ * Returns true when the text fits in at most two lines that each respect the
+ * per-line character limit, breaking only between words. Used while grouping
+ * subtitle cues so a cue never grows past what can be displayed in two lines
+ * (measuring only the total length is not enough — a long word near the middle
+ * can force the second line over the limit).
+ */
+export function fitsInTwoLines(text: string, maxCharsPerLine = 42): boolean {
+  const clean = String(text ?? '').replace(/\s+/g, ' ').trim();
+  if (clean.length <= maxCharsPerLine) return true;
+
+  const words = clean.split(' ');
+  let line1 = '';
+  for (let i = 0; i < words.length - 1; i += 1) {
+    line1 = line1 ? `${line1} ${words[i]}` : words[i];
+    // Once line 1 overflows, later splits only make it longer — give up.
+    if (line1.length > maxCharsPerLine) break;
+    const line2 = words.slice(i + 1).join(' ');
+    if (line2.length <= maxCharsPerLine) return true;
+  }
+  return false;
+}
+
+/**
+ * Splits a single-line subtitle text into at most two balanced lines using a
+ * `\n`, respecting the per-line character limit. Returns the text unchanged
+ * when it already fits in a single line. Any existing whitespace (including
+ * stray newlines) is normalized before balancing, so it is safe to call on
+ * legacy segments too.
+ */
+export function balanceSubtitleLines(
+  text: string,
+  maxCharsPerLine = 42,
+): string {
+  const clean = String(text ?? '').replace(/\s+/g, ' ').trim();
+  if (clean.length <= maxCharsPerLine) return clean;
+
+  const words = clean.split(' ');
+  let line1 = '';
+  let best: { idx: number; cost: number } | null = null;
+
+  for (let i = 0; i < words.length - 1; i += 1) {
+    line1 = line1 ? `${line1} ${words[i]}` : words[i];
+    // Once line 1 overflows it can only get longer — stop searching.
+    if (line1.length > maxCharsPerLine) break;
+
+    const line2 = words.slice(i + 1).join(' ');
+    let cost = Math.abs(line1.length - line2.length);
+    // Strongly penalize a second line that does not fit.
+    if (line2.length > maxCharsPerLine) cost += 1000;
+    // Avoid ending the first line on a short function word.
+    const tail = (words[i] ?? '').toLowerCase().replace(/[^\p{L}]/gu, '');
+    if (FUNCTION_WORDS.has(tail)) cost += 6;
+
+    if (best === null || cost < best.cost) {
+      best = { idx: i, cost };
+    }
+  }
+
+  if (!best) return clean;
+
+  const first = words.slice(0, best.idx + 1).join(' ');
+  const second = words.slice(best.idx + 1).join(' ');
+  return `${first}\n${second}`;
+}
+
+export type TimedWord = { word: string; start: number; end: number };
+
+/**
+ * Normalizes a word for cross-transcript comparison: lowercase, strip accents
+ * and any non-letter/digit characters. Used only to decide whether two tokens
+ * are "the same" during alignment — the original (clean) text is preserved.
+ */
+function normalizeToken(word: string): string {
+  return String(word ?? '')
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9]/g, '');
+}
+
+/**
+ * Merges the *text* of a high-quality transcript (e.g. gpt-4o-transcribe, which
+ * returns no timestamps) with the *timing* of a Whisper transcript (real word
+ * timestamps). The two word sequences are aligned via LCS over normalized
+ * tokens; each clean word inherits a timestamp:
+ *   - matched   → the timed word's start/end
+ *   - inserted  → interpolated across the gap between surrounding anchors
+ *   - deleted   → the timed word is dropped (its time is absorbed by neighbours)
+ *
+ * Falls back to the raw timed words when the texts diverge too much (match ratio
+ * below `minMatchRatio`) — a slightly worse text with correct timing beats a
+ * confident-but-wrong alignment. Pure function (no I/O) for easy unit testing.
+ */
+export function alignTextToTimings(
+  timedWords: TimedWord[],
+  cleanText: string,
+  minMatchRatio = 0.5,
+): TimedWord[] {
+  const cleanWords = String(cleanText ?? '')
+    .split(/\s+/)
+    .map((w) => w.trim())
+    .filter(Boolean);
+
+  if (cleanWords.length === 0) return timedWords;
+  if (timedWords.length === 0) {
+    // No timing available — caller decides; return clean words with zero timing
+    // so they are not silently lost (buildSubtitleSegments tolerates it).
+    return cleanWords.map((word) => ({ word, start: 0, end: 0 }));
+  }
+
+  const a = timedWords.map((w) => normalizeToken(w.word));
+  const b = cleanWords.map((w) => normalizeToken(w));
+
+  // LCS table over normalized tokens.
+  const n = a.length;
+  const m = b.length;
+  const lcs: number[][] = Array.from({ length: n + 1 }, () =>
+    new Array<number>(m + 1).fill(0),
+  );
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      lcs[i][j] =
+        a[i] && a[i] === b[j]
+          ? lcs[i + 1][j + 1] + 1
+          : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+    }
+  }
+
+  // Walk the table to record, for each clean word index, the matched timed word
+  // index (or -1 when unmatched).
+  const matchOf = new Array<number>(m).fill(-1);
+  let i = 0;
+  let j = 0;
+  let matches = 0;
+  while (i < n && j < m) {
+    if (a[i] && a[i] === b[j]) {
+      matchOf[j] = i;
+      matches++;
+      i++;
+      j++;
+    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+      i++;
+    } else {
+      j++;
+    }
+  }
+
+  if (matches / m < minMatchRatio) {
+    return timedWords;
+  }
+
+  // Assign timestamps to every clean word.
+  const result: TimedWord[] = new Array(m);
+  for (let k = 0; k < m; k++) {
+    const ti = matchOf[k];
+    if (ti >= 0) {
+      result[k] = {
+        word: cleanWords[k],
+        start: timedWords[ti].start,
+        end: timedWords[ti].end,
+      };
+    } else {
+      result[k] = { word: cleanWords[k], start: NaN, end: NaN };
+    }
+  }
+
+  // Fill unmatched runs by interpolating between the surrounding anchors.
+  // Outer boundaries: leading words spread from the very first timed start,
+  // trailing words spread up to the very last timed end (so a final correction
+  // keeps the leftover audio time instead of collapsing onto the last anchor).
+  const audioStart = timedWords[0].start;
+  const audioEnd = timedWords[timedWords.length - 1].end;
+
+  let k = 0;
+  while (k < m) {
+    if (!Number.isNaN(result[k].start)) {
+      k++;
+      continue;
+    }
+    // Find the run [k, end) of unmatched words.
+    let end = k;
+    while (end < m && Number.isNaN(result[end].start)) end++;
+
+    const prevEnd = k > 0 ? result[k - 1].end : audioStart;
+    const nextStart = end < m ? result[end].start : audioEnd;
+    const span = Math.max(0, nextStart - prevEnd);
+    const count = end - k;
+    const step = count > 0 ? span / count : 0;
+
+    for (let r = 0; r < count; r++) {
+      const s = prevEnd + step * r;
+      result[k + r] = {
+        word: result[k + r].word,
+        start: s,
+        end: prevEnd + step * (r + 1),
+      };
+    }
+    k = end;
+  }
+
+  return result;
+}