@hed-hog/lms 0.0.365 → 0.0.370

package/src/course/course.service.ts

@@ -1905,6 +1905,7 @@ export class CourseService implements OnModuleInit, IJobHandler {
       extractedImageCount,
       resourceFileCount,
       storageRows,
+      videoFileRows,
     ] = await Promise.all([
       this.prisma.course_module.count({ where: { course_id: courseId } }),
       this.prisma.course_lesson.findMany({
@@ -1930,6 +1931,17 @@ export class CourseService implements OnModuleInit, IJobHandler {
         },
       }),
       this.getCourseStorageRows(courseId),
+      this.prisma.course_lesson_file.findMany({
+        where: {
+          course_lesson: { course_module: { course_id: courseId } },
+          OR: [
+            { type: 'video_original' },
+            { type: { startsWith: 'video_profile:' } },
+          ],
+          file_id: { not: null },
+        },
+        select: { course_lesson_id: true, type: true },
+      }),
     ]);
 
     const transcriptionLessonIds = new Set(
@@ -1937,10 +1949,23 @@ export class CourseService implements OnModuleInit, IJobHandler {
     );
     const xpLessonIds = new Set(xpMapRows.map((r) => r.course_lesson_id));
 
+    const videoOriginalLessonIds = new Set(
+      videoFileRows
+        .filter((r) => r.type === 'video_original')
+        .map((r) => r.course_lesson_id),
+    );
+    const videoProfileLessonIds = new Set(
+      videoFileRows
+        .filter((r) => r.type?.startsWith('video_profile:'))
+        .map((r) => r.course_lesson_id),
+    );
+
     const lessonsByType = { video: 0, questao: 0, post: 0 };
     let publishedLessonCount = 0;
     let videoWithTranscription = 0;
     let videoWithXp = 0;
+    let videoWithVideo = 0;
+    let videoWithProcessedVideo = 0;
 
     const categoryOrder = [
       'video_original',
@@ -2009,8 +2034,9 @@ export class CourseService implements OnModuleInit, IJobHandler {
       if (lesson.published) publishedLessonCount++;
 
       let sourceType: string | undefined;
+      let parsed: Record<string, unknown> | null = null;
       try {
-        const parsed = lesson.content
+        parsed = lesson.content
           ? (JSON.parse(lesson.content as string) as Record<string, unknown>)
           : null;
         sourceType =
@@ -2041,6 +2067,23 @@ export class CourseService implements OnModuleInit, IJobHandler {
       if (uiType === 'video') {
         if (transcriptionLessonIds.has(lesson.id)) videoWithTranscription++;
         if (xpLessonIds.has(lesson.id)) videoWithXp++;
+
+        const videoUrl =
+          typeof parsed?.videoUrl === 'string' ? parsed.videoUrl : '';
+        const videoProvedor =
+          typeof parsed?.videoProvedor === 'string'
+            ? parsed.videoProvedor
+            : 'file_storage';
+
+        const hasVideo =
+          videoUrl.length > 0 || videoOriginalLessonIds.has(lesson.id);
+        const isProcessed =
+          videoProvedor !== 'file_storage'
+            ? videoUrl.length > 0
+            : videoProfileLessonIds.has(lesson.id);
+
+        if (hasVideo) videoWithVideo++;
+        if (isProcessed) videoWithProcessedVideo++;
       }
     }
 
@@ -2055,6 +2098,8 @@ export class CourseService implements OnModuleInit, IJobHandler {
         lessonCount: lessonsByType.video,
         withTranscription: videoWithTranscription,
         withXp: videoWithXp,
+        withVideo: videoWithVideo,
+        withProcessedVideo: videoWithProcessedVideo,
       },
       media: { extractedImageCount },
       resources: { fileCount: resourceFileCount },

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

@@ -0,0 +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;
+}

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

@@ -21,6 +21,7 @@ import { tmpdir } from 'os';
 import { basename, extname, join } from 'path';
 import { Readable } from 'stream';
 import { pipeline } from 'stream/promises';
+import { CourseVideoAgentPipelineService } from './course-video-agent-pipeline.service';
 import { CourseVideoConversionService } from './course-video-conversion.service';
 import { CourseVideoHlsService } from './course-video-hls.service';
 import {
@@ -62,6 +63,8 @@ export class LmsBulkUploadAutomationService implements OnModuleInit {
     private readonly courseVideoConversionService: CourseVideoConversionService,
     @Inject(forwardRef(() => CourseVideoHlsService))
     private readonly courseVideoHlsService: CourseVideoHlsService,
+    @Inject(forwardRef(() => CourseVideoAgentPipelineService))
+    private readonly courseVideoAgentPipelineService: CourseVideoAgentPipelineService,
   ) {}
 
   onModuleInit(): void {
@@ -257,7 +260,7 @@ export class LmsBulkUploadAutomationService implements OnModuleInit {
         },
       );
 
-      await this.courseVideoHlsService.enqueueHls({
+      await this.courseVideoAgentPipelineService.startProcessing({
         userId,
         courseId,
         sessionId,
@@ -268,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);
@@ -374,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;
           }
 
@@ -408,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('_')),
     };
   }
 
@@ -621,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;
+}