@hed-hog/lms 0.0.365 → 0.0.370

package/src/certificate/certificate.service.ts

@@ -2,6 +2,7 @@ import { PrismaService } from '@hed-hog/api-prisma';
 import { FileService, IntegrationDeveloperApiService } from '@hed-hog/core';
 import {
     BadRequestException,
+    ForbiddenException,
     Inject,
     Injectable,
     NotFoundException,
@@ -18,6 +19,7 @@ type ListIssuedCertificatesParams = {
   pageSize?: number;
   search?: string;
   type?: string;
+  courseId?: number;
 };
 
 type ListCertificateTemplatesParams = {
@@ -218,6 +220,10 @@ export class LmsCertificateService {
       where.certificate_type = type;
     }
 
+    if (params.courseId) {
+      where.course_id = Number(params.courseId);
+    }
+
     if (params.search?.trim()) {
       const search = params.search.trim();
       where.OR = [
@@ -577,6 +583,99 @@ export class LmsCertificateService {
     }
   }
 
+  async listIssuedForStudent(
+    userId: number,
+    params: ListIssuedCertificatesParams,
+  ) {
+    const personId = await this.resolvePersonIdFromUser(userId);
+
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 12, 1);
+    const skip = (page - 1) * pageSize;
+
+    const where: Record<string, any> = { student_id: personId };
+    const type = this.normalizeType(params.type);
+    if (type) {
+      where.certificate_type = type;
+    }
+
+    const [certificates, total] = await Promise.all([
+      this.prisma.certificate.findMany({
+        skip,
+        take: pageSize,
+        where,
+        orderBy: [{ issued_at: 'desc' }, { id: 'desc' }],
+        include: {
+          certificate_template: {
+            select: {
+              id: true,
+              name: true,
+              status: true,
+              template_content: true,
+            },
+          },
+          course: { select: { id: true, title: true, primary_color: true } },
+          exam: { select: { id: true, title: true } },
+          course_class_group: { select: { id: true, title: true } },
+          learning_path: { select: { id: true, title: true, primary_color: true } },
+          person: { select: { id: true, name: true } },
+        },
+      }),
+      this.prisma.certificate.count({ where }),
+    ]);
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: certificates.map((cert) => this.mapIssuedCertificateWithTemplate(cert)),
+    };
+  }
+
+  async updatePublicAccessForStudent(
+    userId: number,
+    certificateId: number,
+    publicAccess: boolean,
+  ) {
+    const personId = await this.resolvePersonIdFromUser(userId);
+
+    const cert = await this.prisma.certificate.findUnique({
+      where: { id: certificateId },
+      select: { id: true, student_id: true },
+    });
+
+    if (!cert) {
+      throw new NotFoundException('Issued certificate not found');
+    }
+
+    if (cert.student_id !== personId) {
+      throw new ForbiddenException('Access denied');
+    }
+
+    return this.updatePublicAccess(certificateId, publicAccess);
+  }
+
+  private async resolvePersonIdFromUser(userId: number) {
+    const personUser = await this.prisma.person_user.findFirst({
+      where: { user_id: userId },
+      select: { person_id: true },
+    });
+
+    if (!personUser) {
+      throw new NotFoundException('No person profile found for this user');
+    }
+
+    return personUser.person_id;
+  }
+
+  private mapIssuedCertificateWithTemplate(certificate: any) {
+    return {
+      ...this.mapIssuedCertificate(certificate),
+      templateContent: certificate.certificate_template?.template_content ?? null,
+    };
+  }
+
   private normalizeType(value?: string) {
     if (!value || value === 'all') {
       return undefined;

package/src/course/course-ai-usage.service.ts

@@ -0,0 +1,221 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { SettingService } from '@hed-hog/core';
+import { Inject, Injectable, Logger, forwardRef } from '@nestjs/common';
+
+export type AiJobType = 'transcription' | 'translation' | 'xp_calculation';
+
+/**
+ * Records AI usage and cost into the `course_ai_usage` ledger so the course can
+ * report how much it spent on transcription, translation and XP jobs.
+ *
+ * Token-billed models (chat: gpt-4o-mini) are priced from the existing
+ * `ai_model_pricing` table — the OpenAI API returns token counts (`usage`), not
+ * a dollar amount, so the cost is tokens × table price. Whisper is billed per
+ * minute of audio, so it uses the `lms-whisper-price-per-minute-usd` setting.
+ *
+ * Recording never throws: cost tracking must not break the underlying job.
+ */
+@Injectable()
+export class CourseAiUsageService {
+  private readonly logger = new Logger(CourseAiUsageService.name);
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
+  ) {}
+
+  async resolveCourseIdFromLesson(lessonId: number): Promise<number | null> {
+    try {
+      const rows = await this.prisma.$queryRawUnsafe<{ course_id: number }[]>(
+        `SELECT cm.course_id
+           FROM course_lesson cl
+           JOIN course_module cm ON cm.id = cl.course_module_id
+          WHERE cl.id = $1
+          LIMIT 1`,
+        lessonId,
+      );
+      return rows[0]?.course_id ?? null;
+    } catch (error) {
+      this.logger.warn(
+        `Failed to resolve course for lesson ${lessonId}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return null;
+    }
+  }
+
+  /** Resolves the active per-million token price for a provider/model. */
+  private async getTokenPrice(
+    provider: string,
+    model: string,
+  ): Promise<{ input: number; output: number } | null> {
+    try {
+      const row = await (this.prisma as any).ai_model_pricing.findFirst({
+        where: { provider, model, is_active: true },
+        orderBy: { valid_from: 'desc' },
+      });
+      if (!row) return null;
+      return {
+        input: Number(row.price_input_per_million ?? 0),
+        output: Number(row.price_output_per_million ?? 0),
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  private async insert(params: {
+    courseId: number;
+    lessonId: number | null;
+    jobType: AiJobType;
+    provider: string;
+    model: string;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    audioSeconds: number | null;
+    costUsd: number;
+  }): Promise<void> {
+    await this.prisma.$executeRawUnsafe(
+      `INSERT INTO course_ai_usage
+         (course_id, course_lesson_id, job_type, provider, model,
+          input_tokens, output_tokens, audio_seconds, cost_usd, created_at)
+       VALUES ($1, $2, $3::course_ai_usage_job_type_enum, $4, $5, $6, $7, $8, $9, NOW())`,
+      params.courseId,
+      params.lessonId,
+      params.jobType,
+      params.provider,
+      params.model,
+      params.inputTokens,
+      params.outputTokens,
+      params.audioSeconds,
+      params.costUsd,
+    );
+  }
+
+  /** Records usage for a token-billed chat model (translation, XP). */
+  async recordChatUsage(params: {
+    courseId?: number | null;
+    lessonId: number;
+    jobType: AiJobType;
+    provider: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+  }): Promise<void> {
+    try {
+      const courseId =
+        params.courseId ?? (await this.resolveCourseIdFromLesson(params.lessonId));
+      if (!courseId) return;
+
+      const price = await this.getTokenPrice(params.provider, params.model);
+      const costUsd = price
+        ? (params.inputTokens / 1_000_000) * price.input +
+          (params.outputTokens / 1_000_000) * price.output
+        : 0;
+
+      await this.insert({
+        courseId,
+        lessonId: params.lessonId,
+        jobType: params.jobType,
+        provider: params.provider,
+        model: params.model,
+        inputTokens: params.inputTokens,
+        outputTokens: params.outputTokens,
+        audioSeconds: null,
+        costUsd,
+      });
+    } catch (error) {
+      this.logger.warn(
+        `Failed to record chat AI usage for lesson ${params.lessonId}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /** Records usage for Whisper transcription (billed per minute of audio). */
+  async recordTranscriptionUsage(params: {
+    courseId: number;
+    lessonId: number;
+    model: string;
+    audioSeconds: number;
+  }): Promise<void> {
+    try {
+      const priceSlug = `lms-transcription-price-per-second-usd-${params.model}`;
+      const settings = await this.settingService.getSettingValues([priceSlug]);
+      const pricePerSecond = Number(settings[priceSlug] ?? 0.0001);
+      const costUsd = params.audioSeconds * (Number.isFinite(pricePerSecond) && pricePerSecond > 0 ? pricePerSecond : 0.0001);
+
+      await this.insert({
+        courseId: params.courseId,
+        lessonId: params.lessonId,
+        jobType: 'transcription',
+        provider: 'openai',
+        model: params.model,
+        inputTokens: null,
+        outputTokens: null,
+        audioSeconds: params.audioSeconds,
+        costUsd,
+      });
+    } catch (error) {
+      this.logger.warn(
+        `Failed to record transcription AI usage for lesson ${params.lessonId}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /** Aggregated cost report for a course: total, by job type and by lesson. */
+  async getCourseAiCosts(courseId: number): Promise<{
+    currency: string;
+    totalCostUsd: number;
+    byJobType: Array<{ jobType: string; costUsd: number; runs: number }>;
+    byLesson: Array<{
+      lessonId: number | null;
+      lessonTitle: string | null;
+      costUsd: number;
+      runs: number;
+    }>;
+  }> {
+    const byJobType = await this.prisma.$queryRawUnsafe<
+      Array<{ job_type: string; cost_usd: number; runs: bigint }>
+    >(
+      `SELECT job_type, COALESCE(SUM(cost_usd), 0)::float8 AS cost_usd, COUNT(*) AS runs
+         FROM course_ai_usage
+        WHERE course_id = $1
+        GROUP BY job_type`,
+      courseId,
+    );
+
+    const byLesson = await this.prisma.$queryRawUnsafe<
+      Array<{ lesson_id: number | null; lesson_title: string | null; cost_usd: number; runs: bigint }>
+    >(
+      `SELECT u.course_lesson_id AS lesson_id,
+              cl.title AS lesson_title,
+              COALESCE(SUM(u.cost_usd), 0)::float8 AS cost_usd,
+              COUNT(*) AS runs
+         FROM course_ai_usage u
+         LEFT JOIN course_lesson cl ON cl.id = u.course_lesson_id
+        WHERE u.course_id = $1
+        GROUP BY u.course_lesson_id, cl.title
+        ORDER BY cost_usd DESC`,
+      courseId,
+    );
+
+    const totalCostUsd = byJobType.reduce((sum, r) => sum + Number(r.cost_usd ?? 0), 0);
+
+    return {
+      currency: 'USD',
+      totalCostUsd,
+      byJobType: byJobType.map((r) => ({
+        jobType: r.job_type,
+        costUsd: Number(r.cost_usd ?? 0),
+        runs: Number(r.runs ?? 0),
+      })),
+      byLesson: byLesson.map((r) => ({
+        lessonId: r.lesson_id,
+        lessonTitle: r.lesson_title,
+        costUsd: Number(r.cost_usd ?? 0),
+        runs: Number(r.runs ?? 0),
+      })),
+    };
+  }
+}