@hed-hog/lms 0.0.365 → 0.0.366

package/src/course/course.module.ts

@@ -1,3 +1,4 @@
+import { AgentModule } from '@hed-hog/agent';
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { CoreModule } from '@hed-hog/core';
 import { QueueModule } from '@hed-hog/queue';
@@ -8,6 +9,7 @@ import { CourseOperationsIntegrationService } from './course-operations-integrat
 import { CourseOperationsController } from './course-operations.controller';
 import { CourseStructureController } from './course-structure.controller';
 import { CourseStructureService } from './course-structure.service';
+import { CourseVideoAgentPipelineService } from './course-video-agent-pipeline.service';
 import { CourseVideoConversionService } from './course-video-conversion.service';
 import { CourseVideoHlsService } from './course-video-hls.service';
 import { CourseExportScorm12Service } from './course-export-scorm12.service';
@@ -29,6 +31,7 @@ import { LmsSettingController } from './lms-setting.controller';
     forwardRef(() => InstructorModule),
     forwardRef(() => CoreModule),
     forwardRef(() => QueueModule),
+    forwardRef(() => AgentModule),
   ],
   controllers: [
     CourseController,
@@ -45,6 +48,7 @@ import { LmsSettingController } from './lms-setting.controller';
     CourseOperationsIntegrationService,
     CourseService,
     CourseStructureService,
+    CourseVideoAgentPipelineService,
     CourseVideoConversionService,
     CourseVideoHlsService,
     LmsBulkUploadAutomationService,
@@ -58,6 +62,7 @@ import { LmsSettingController } from './lms-setting.controller';
     forwardRef(() => CourseStructureService),
     forwardRef(() => CourseVideoConversionService),
     forwardRef(() => CourseVideoHlsService),
+    CourseVideoAgentPipelineService,
   ],
 })
 export class CourseModule {}

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/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,

package/src/lms.module.ts

@@ -22,7 +22,12 @@ import { EvaluationModule } from './evaluation/evaluation.module';
 import { ExamModule } from './exam/exam.module';
 import { InstructorModule } from './instructor/instructor.module';
 import { LessonXpMapModule } from './lesson-xp-map/lesson-xp-map.module';
+import { EmitCertificateHandler } from './platforma/handlers/emit-certificate.handler';
+import { LessonHeartbeatHandler } from './platforma/handlers/lesson-heartbeat.handler';
 import { PlataformaController } from './platforma/platforma.controller';
+import { PlatformaHeartbeatService } from './platforma/platforma-heartbeat.service';
+import { PlatformaPerformanceService } from './platforma/platforma-performance.service';
+import { PlatformaSearchService } from './platforma/platforma-search.service';
 import { PlatformaVideoService } from './platforma/platforma-video.service';
 import { StudentXpModule } from './student-xp/student-xp.module';
 import { XpCatalogModule } from './xp-catalog/xp-catalog.module';
@@ -65,6 +70,11 @@ import { TrainingModule } from './training/training.module';
     CourseAudioTranscriptionService,
     PlatformaService,
     PlatformaVideoService,
+    PlatformaHeartbeatService,
+    PlatformaPerformanceService,
+    PlatformaSearchService,
+    LessonHeartbeatHandler,
+    EmitCertificateHandler,
     LmsCommerceAccessSubscriber,
   ],
   exports: [

package/src/platforma/dto/heartbeat.dto.ts

@@ -0,0 +1,30 @@
+import { IsBoolean, IsInt, IsOptional, IsString, Max, Min } from 'class-validator';
+
+export class HeartbeatDto {
+  @IsInt()
+  lessonId: number;
+
+  @IsInt()
+  @Min(0)
+  positionSeconds: number;
+
+  @IsOptional()
+  @IsString()
+  sessionId?: string;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(10000)
+  screenWidth?: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(10000)
+  screenHeight?: number;
+
+  @IsOptional()
+  @IsBoolean()
+  isTouch?: boolean;
+}

package/src/platforma/handlers/emit-certificate.handler.ts

@@ -0,0 +1,117 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { IJobHandler, QueueHandlerRegistry } from '@hed-hog/queue';
+import { Inject, Injectable, Logger, OnModuleInit, forwardRef } from '@nestjs/common';
+import { randomBytes } from 'crypto';
+
+export const EMIT_CERTIFICATE_JOB = 'lms.emit_certificate';
+
+@Injectable()
+export class EmitCertificateHandler implements OnModuleInit, IJobHandler {
+  private readonly logger = new Logger(EmitCertificateHandler.name);
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => QueueHandlerRegistry))
+    private readonly registry: QueueHandlerRegistry,
+  ) {}
+
+  onModuleInit() {
+    this.registry.register(EMIT_CERTIFICATE_JOB, this);
+    this.logger.log(`Registered handler for "${EMIT_CERTIFICATE_JOB}"`);
+  }
+
+  async handle(job: { payload: Record<string, any> }) {
+    const { enrollmentId, courseId, personId } = job.payload as {
+      enrollmentId: number;
+      courseId: number;
+      personId: number;
+    };
+
+    // Idempotency guard — re-entrancy safe
+    const enrollment = await (this.prisma as any).course_enrollment.findUnique({
+      where: { id: enrollmentId },
+      select: { certificate_issued_at: true, completed_at: true, final_score: true },
+    });
+
+    if (!enrollment) {
+      this.logger.warn(`Enrollment ${enrollmentId} not found, skipping certificate`);
+      return { skipped: true };
+    }
+
+    if (enrollment.certificate_issued_at) {
+      this.logger.log(`Certificate already issued for enrollment ${enrollmentId}`);
+      return { skipped: true, alreadyIssued: true };
+    }
+
+    const [person, course] = await Promise.all([
+      this.prisma.person.findUnique({
+        where: { id: personId },
+        select: { name: true },
+      }),
+      (this.prisma as any).course.findUnique({
+        where: { id: courseId },
+        select: {
+          title: true,
+          certificate_workload: true,
+          has_certificate: true,
+          certificate_template_id: true,
+        },
+      }),
+    ]);
+
+    if (!person || !course) {
+      this.logger.warn(`Person or course not found (enrollment ${enrollmentId})`);
+      return { skipped: true };
+    }
+
+    if (!course.has_certificate || !course.certificate_template_id) {
+      this.logger.log(`Course ${courseId} does not issue certificates`);
+      return { skipped: true };
+    }
+
+    // Compute workload hours from lesson durations when not set on the course
+    let workloadHours: number = course.certificate_workload ?? 0;
+    if (!workloadHours) {
+      const agg = await (this.prisma as any).course_lesson.aggregate({
+        where: { published: true, course_module: { course_id: courseId } },
+        _sum: { duration_seconds: true },
+      });
+      const totalSeconds = (agg._sum?.duration_seconds as number) ?? 0;
+      workloadHours = Math.max(1, Math.ceil(totalSeconds / 3600));
+    }
+
+    const issuedAt = new Date();
+    const verificationCode = randomBytes(12).toString('hex').toUpperCase();
+
+    await (this.prisma as any).certificate.create({
+      data: {
+        verification_code: verificationCode,
+        student_id: personId,
+        course_enrollment_id: enrollmentId,
+        course_id: courseId,
+        certificate_template_id: course.certificate_template_id,
+        certificate_type: 'course',
+        student_name: person.name ?? '',
+        course_name: course.title ?? '',
+        workload_hours: workloadHours,
+        issued_at: issuedAt,
+        completed_at: enrollment.completed_at ?? issuedAt,
+        final_score: enrollment.final_score ?? null,
+        public_access: false,
+      },
+    });
+
+    // Mark enrollment as issued — prevents duplicate certificates on any future re-run
+    await (this.prisma as any).course_enrollment.update({
+      where: { id: enrollmentId },
+      data: { certificate_issued_at: issuedAt },
+    });
+
+    this.logger.log(
+      `Certificate issued — enrollment=${enrollmentId} course=${courseId} code=${verificationCode}`,
+    );
+
+    return { verificationCode };
+  }
+}