@hed-hog/lms 0.0.365 → 0.0.370

package/src/enterprise/training/training-student.service.ts

@@ -302,6 +302,8 @@ export class TrainingStudentService {
 
     let completedLessonIds: number[] = [];
     let progressPercent = 0;
+    let lastLessonId: number | null = null;
+    let lastPositionSeconds = 0;
 
     if (userId) {
       const personUser = await this.prisma.person_user.findFirst({
@@ -315,11 +317,30 @@ export class TrainingStudentService {
         });
         if (enrollment) {
           progressPercent = enrollment.progress_percent ?? 0;
-          const completedRows = await this.prisma.course_lesson_progress.findMany({
-            where: { course_enrollment_id: enrollment.id, status: 'completed' },
-            select: { course_lesson_id: true },
-          });
+          const [completedRows, lastProgressRow] = await Promise.all([
+            this.prisma.course_lesson_progress.findMany({
+              where: { course_enrollment_id: enrollment.id, status: 'completed' },
+              select: { course_lesson_id: true },
+            }),
+            this.prisma.course_lesson_progress.findFirst({
+              where: {
+                course_enrollment_id: enrollment.id,
+                status: { not: 'not_started' },
+              },
+              orderBy: { updated_at: 'desc' },
+              select: {
+                course_lesson_id: true,
+                video_progress_seconds: true,
+                status: true,
+              },
+            }),
+          ]);
           completedLessonIds = completedRows.map((r) => r.course_lesson_id);
+          lastLessonId = lastProgressRow?.course_lesson_id ?? null;
+          lastPositionSeconds =
+            lastProgressRow?.status === 'in_progress'
+              ? (lastProgressRow.video_progress_seconds ?? 0)
+              : 0;
         }
       }
     }
@@ -338,6 +359,8 @@ export class TrainingStudentService {
       categoryLabel: this.formatCategoryLabel(categorySlug),
       completedLessonIds,
       progressPercent,
+      lastLessonId,
+      lastPositionSeconds,
       modules: row.course_module.map((m) => ({
         id: m.id,
         title: m.title,
@@ -355,6 +378,172 @@ export class TrainingStudentService {
     };
   }
 
+  async submitLessonAnswer(
+    userId: number,
+    lessonId: number,
+    questionId: number,
+    optionId: number | null,
+    answerText: string | null,
+  ) {
+    // Determine correctness from the selected option
+    let isCorrect: boolean | null = null;
+    if (optionId != null) {
+      const option = await (this.prisma as any).exam_option.findUnique({
+        where: { id: optionId },
+        select: { is_correct: true },
+      });
+      isCorrect = option?.is_correct ?? null;
+    }
+
+    // Upsert the answer
+    await (this.prisma as any).course_lesson_answer.upsert({
+      where: {
+        user_id_course_lesson_id_question_id: {
+          user_id: userId,
+          course_lesson_id: lessonId,
+          question_id: questionId,
+        },
+      },
+      update: {
+        exam_option_id: optionId,
+        answer_text: answerText,
+        is_correct: isCorrect,
+        updated_at: new Date(),
+      },
+      create: {
+        user_id: userId,
+        course_lesson_id: lessonId,
+        question_id: questionId,
+        exam_option_id: optionId,
+        answer_text: answerText,
+        is_correct: isCorrect,
+      },
+    });
+
+    // Check if all questions in this lesson are now answered
+    const [totalQuestions, answeredQuestions] = await Promise.all([
+      (this.prisma as any).course_lesson_question.count({
+        where: { course_lesson_id: lessonId },
+      }),
+      (this.prisma as any).course_lesson_answer.count({
+        where: { user_id: userId, course_lesson_id: lessonId },
+      }),
+    ]);
+
+    const allAnswered = totalQuestions > 0 && answeredQuestions >= totalQuestions;
+
+    if (allAnswered) {
+      await this.markLessonComplete(userId, lessonId);
+    }
+
+    return { isCorrect, allAnswered };
+  }
+
+  private async markLessonComplete(userId: number, lessonId: number) {
+    const lesson = await (this.prisma as any).course_lesson.findUnique({
+      where: { id: lessonId },
+      select: { course_module: { select: { course_id: true } } },
+    });
+
+    const personUser = await this.prisma.person_user.findFirst({
+      where: { user_id: userId },
+      select: { person_id: true },
+    });
+
+    if (!personUser || !lesson) return;
+
+    const personId = personUser.person_id;
+    const courseId: number = lesson.course_module?.course_id;
+
+    const enrollment = await (this.prisma as any).course_enrollment.findFirst({
+      where: { person_id: personId, course_id: courseId, status: { in: ['active', 'completed'] } },
+      select: { id: true },
+    });
+
+    if (!enrollment) return;
+
+    const enrollmentId: number = enrollment.id;
+
+    const existing = await (this.prisma as any).course_lesson_progress.findUnique({
+      where: {
+        course_enrollment_id_course_lesson_id: {
+          course_enrollment_id: enrollmentId,
+          course_lesson_id: lessonId,
+        },
+      },
+      select: { status: true },
+    });
+
+    if (existing?.status === 'completed') return;
+
+    await (this.prisma as any).course_lesson_progress.upsert({
+      where: {
+        course_enrollment_id_course_lesson_id: {
+          course_enrollment_id: enrollmentId,
+          course_lesson_id: lessonId,
+        },
+      },
+      create: {
+        course_enrollment_id: enrollmentId,
+        course_lesson_id: lessonId,
+        status: 'completed',
+        progress_percent: 100,
+        started_at: new Date(),
+        completed_at: new Date(),
+        time_spent_seconds: 0,
+      },
+      update: {
+        status: 'completed',
+        progress_percent: 100,
+        completed_at: new Date(),
+      },
+    });
+
+    // Sync course-level progress
+    const [totalLessons, completedLessons] = await Promise.all([
+      (this.prisma as any).course_lesson.count({
+        where: { published: true, course_module: { course_id: courseId } },
+      }),
+      (this.prisma as any).course_lesson_progress.count({
+        where: {
+          course_enrollment_id: enrollmentId,
+          status: 'completed',
+          course_lesson: { published: true, course_module: { course_id: courseId } },
+        },
+      }),
+    ]);
+
+    const progressPercent =
+      totalLessons > 0 ? Math.round((completedLessons / totalLessons) * 100) : 0;
+
+    await (this.prisma as any).course_enrollment.update({
+      where: { id: enrollmentId },
+      data: {
+        progress_percent: progressPercent,
+        ...(progressPercent === 100 ? { status: 'completed', completed_at: new Date() } : {}),
+      },
+    });
+  }
+
+  async getLessonStudentAnswers(userId: number, lessonId: number) {
+    const rows = await (this.prisma as any).course_lesson_answer.findMany({
+      where: { user_id: userId, course_lesson_id: lessonId },
+      select: {
+        question_id: true,
+        exam_option_id: true,
+        answer_text: true,
+        is_correct: true,
+      },
+    });
+
+    return rows as Array<{
+      question_id: number;
+      exam_option_id: number | null;
+      answer_text: string | null;
+      is_correct: boolean | null;
+    }>;
+  }
+
   async getLessonDetail(lessonId: number) {
     const lesson = await this.prisma.course_lesson.findFirst({
       where: { id: lessonId, published: true },
@@ -383,6 +572,35 @@ export class TrainingStudentService {
       (f) => f.file?.id && f.is_public && !f.type?.startsWith('video'),
     );
 
+    const lessonQuestions = lesson.type === 'quiz'
+      ? await this.prisma.course_lesson_question.findMany({
+          where: { course_lesson_id: lessonId },
+          orderBy: { order: 'asc' },
+          include: {
+            question: {
+              include: {
+                exam_option: { orderBy: { position: 'asc' } },
+              },
+            },
+          },
+        })
+      : [];
+
+    const questions = lessonQuestions.map((lq) => ({
+      id: lq.question.id,
+      questionType: lq.question.question_type,
+      statement: lq.question.statement,
+      explanation: lq.question.explanation,
+      points: lq.question.points,
+      options: lq.question.exam_option.map((o) => ({
+        id: o.id,
+        optionText: o.option_text,
+        isCorrect: o.is_correct,
+        feedback: o.feedback,
+        position: o.position,
+      })),
+    }));
+
     // HLS takes priority: if a video_hls file exists, use it exclusively
     const hlsFile = lesson.course_lesson_file.find((f) => f.file?.id && f.type === 'video_hls');
     if (hlsFile) {
@@ -399,6 +617,7 @@ export class TrainingStudentService {
           title: r.title,
           url: r.file?.id ? `/file/open/${r.file.id}` : null,
         })),
+        questions,
       };
     }
 
@@ -430,6 +649,7 @@ export class TrainingStudentService {
         title: r.title,
         url: r.file?.id ? `/file/open/${r.file.id}` : null,
       })),
+      questions,
     };
   }
 

package/src/lesson-xp-map/lesson-xp-ai-calculation.service.ts

@@ -10,6 +10,7 @@ import {
     OnModuleInit,
 } from '@nestjs/common';
 import axios from 'axios';
+import { CourseAiUsageService } from '../course/course-ai-usage.service';
 
 type XpSegmentAiResult = {
   startSeconds: number;
@@ -44,6 +45,8 @@ export class LessonXpAiCalculationService implements OnModuleInit, IJobHandler {
     private readonly registry: QueueHandlerRegistry,
     @Inject(forwardRef(() => DatabaseQueueProvider))
     private readonly dbQueue: DatabaseQueueProvider,
+    @Inject(forwardRef(() => CourseAiUsageService))
+    private readonly aiUsageService: CourseAiUsageService,
   ) {}
 
   onModuleInit() {
@@ -295,6 +298,17 @@ export class LessonXpAiCalculationService implements OnModuleInit, IJobHandler {
         return;
       }
 
+      // Record AI cost (gpt-4o, billed per token).
+      const xpUsage = response.data?.usage ?? {};
+      await this.aiUsageService.recordChatUsage({
+        lessonId,
+        jobType: 'xp_calculation',
+        provider: 'openai',
+        model: 'gpt-4o',
+        inputTokens: Number(xpUsage.prompt_tokens ?? 0),
+        outputTokens: Number(xpUsage.completion_tokens ?? 0),
+      });
+
       const rawSegments: any[] = Array.isArray(parsed.segments) ? parsed.segments : [];
       const areaIds = new Set(areas.map((a) => a.id));
       const skillIds = new Set(skills.map((s) => s.id));

package/src/lesson-xp-map/lesson-xp-map.module.ts

@@ -2,6 +2,7 @@ import { PrismaModule } from '@hed-hog/api-prisma';
 import { CoreModule } from '@hed-hog/core';
 import { QueueModule } from '@hed-hog/queue';
 import { forwardRef, Module } from '@nestjs/common';
+import { CourseAiUsageService } from '../course/course-ai-usage.service';
 import { LessonXpAiCalculationService } from './lesson-xp-ai-calculation.service';
 import { LessonXpMapController } from './lesson-xp-map.controller';
 import { LessonXpMapService } from './lesson-xp-map.service';
@@ -15,7 +16,7 @@ import { LessonXpSegmentService } from './lesson-xp-segment.service';
     forwardRef(() => QueueModule),
   ],
   controllers: [LessonXpMapController, LessonXpSegmentController],
-  providers: [LessonXpMapService, LessonXpSegmentService, LessonXpAiCalculationService],
+  providers: [LessonXpMapService, LessonXpSegmentService, LessonXpAiCalculationService, CourseAiUsageService],
   exports: [LessonXpMapService, LessonXpSegmentService, LessonXpAiCalculationService],
 })
 export class LessonXpMapModule {}

package/src/lms.module.ts

@@ -13,7 +13,9 @@ import { ClassGroupModule } from './class-group/class-group.module';
 import { CourseLessonDiscussionModule } from './course-lesson-discussion/course-lesson-discussion.module';
 import { CourseLessonNoteModule } from './course-lesson-note/course-lesson-note.module';
 import { LmsCommerceAccessSubscriber } from './lms-commerce-access.subscriber';
+import { CourseAiUsageService } from './course/course-ai-usage.service';
 import { CourseAudioTranscriptionService } from './course/course-audio-transcription.service';
+import { CourseTranscriptionTranslationService } from './course/course-transcription-translation.service';
 import { CourseModule } from './course/course.module';
 import { LmsDashboardModule } from './dashboard/dashboard.module';
 import { EnterpriseModule } from './enterprise/enterprise.module';
@@ -22,7 +24,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';
@@ -62,9 +69,16 @@ import { TrainingModule } from './training/training.module';
   ],
   controllers: [PlataformaController],
   providers: [
+    CourseAiUsageService,
     CourseAudioTranscriptionService,
+    CourseTranscriptionTranslationService,
     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 };
+  }
+}