@hed-hog/lms 0.0.347 → 0.0.350

package/src/course-lesson-note/course-lesson-note.service.ts

@@ -0,0 +1,248 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+    ForbiddenException,
+    Injectable,
+    NotFoundException,
+} from '@nestjs/common';
+import { CreateCourseLessonNoteDto } from './dto/create-course-lesson-note.dto';
+import { UpdateCourseLessonNoteDto } from './dto/update-course-lesson-note.dto';
+
+type CourseLessonNoteRow = {
+  id: number;
+  courseLessonId: number;
+  personId: number;
+  description: string;
+  playerTimeSeconds: number;
+  frameFileId: number | null;
+  frameImageUrl: string | null;
+  createdAt: string | null;
+  updatedAt: string | null;
+};
+
+@Injectable()
+export class CourseLessonNoteService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async list(lessonId: number, userId: number) {
+    const personId = await this.assertStudentAccess(lessonId, userId);
+
+    const rows = await this.queryRows<CourseLessonNoteRow>(
+      `SELECT
+          n.id,
+          n.course_lesson_id AS "courseLessonId",
+          n.person_id AS "personId",
+          n.description,
+          n.player_time_seconds AS "playerTimeSeconds",
+          n.frame_file_id AS "frameFileId",
+          f.location AS "frameImageUrl",
+          n.created_at::text AS "createdAt",
+          n.updated_at::text AS "updatedAt"
+        FROM course_lesson_note n
+        LEFT JOIN file f ON f.id = n.frame_file_id
+       WHERE n.course_lesson_id = $1
+         AND n.person_id = $2
+       ORDER BY n.player_time_seconds ASC, n.id DESC`,
+      [lessonId, personId]
+    );
+
+    return rows.map((row) => this.mapRow(row));
+  }
+
+  async getById(lessonId: number, noteId: number, userId: number) {
+    const personId = await this.assertStudentAccess(lessonId, userId);
+    const note = await this.findOwnedNote(lessonId, noteId, personId);
+
+    if (!note) {
+      throw new NotFoundException('Note not found');
+    }
+
+    return this.mapRow(note);
+  }
+
+  async create(lessonId: number, userId: number, dto: CreateCourseLessonNoteDto) {
+    const personId = await this.assertStudentAccess(lessonId, userId);
+
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO course_lesson_note (
+          course_lesson_id,
+          person_id,
+          description,
+          player_time_seconds,
+          frame_file_id,
+          created_at,
+          updated_at
+        ) VALUES (
+          $1,
+          $2,
+          $3,
+          $4,
+          $5,
+          NOW(),
+          NOW()
+        )
+        RETURNING id`,
+      [
+        lessonId,
+        personId,
+        dto.description.trim(),
+        Number(dto.playerTimeSeconds),
+        dto.frameFileId ?? null,
+      ]
+    );
+
+    return this.getById(lessonId, created.id, userId);
+  }
+
+  async update(
+    lessonId: number,
+    noteId: number,
+    userId: number,
+    dto: UpdateCourseLessonNoteDto
+  ) {
+    const personId = await this.assertStudentAccess(lessonId, userId);
+    const note = await this.findOwnedNote(lessonId, noteId, personId);
+
+    if (!note) {
+      throw new NotFoundException('Note not found');
+    }
+
+    const updates: string[] = [];
+    const values: unknown[] = [];
+
+    if (dto.description !== undefined) {
+      updates.push(`description = ${this.param(values, dto.description.trim())}`);
+    }
+
+    if (dto.playerTimeSeconds !== undefined) {
+      updates.push(
+        `player_time_seconds = ${this.param(values, Number(dto.playerTimeSeconds))}`
+      );
+    }
+
+    if (dto.frameFileId !== undefined) {
+      updates.push(`frame_file_id = ${this.param(values, dto.frameFileId ?? null)}`);
+    }
+
+    if (updates.length > 0) {
+      values.push(noteId);
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE course_lesson_note
+            SET ${updates.join(', ')},
+                updated_at = NOW()
+          WHERE id = $${values.length}`,
+        ...values
+      );
+    }
+
+    return this.getById(lessonId, noteId, userId);
+  }
+
+  async delete(lessonId: number, noteId: number, userId: number) {
+    const personId = await this.assertStudentAccess(lessonId, userId);
+    const note = await this.findOwnedNote(lessonId, noteId, personId);
+
+    if (!note) {
+      throw new NotFoundException('Note not found');
+    }
+
+    await this.prisma.$executeRawUnsafe(
+      `DELETE FROM course_lesson_note WHERE id = $1`,
+      noteId
+    );
+  }
+
+  private async assertStudentAccess(lessonId: number, 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');
+    }
+
+    const lesson = await this.prisma.course_lesson.findUnique({
+      where: { id: lessonId },
+      select: {
+        id: true,
+        course_module: {
+          select: {
+            course_id: true,
+          },
+        },
+      },
+    });
+
+    if (!lesson?.course_module?.course_id) {
+      throw new NotFoundException('Lesson not found');
+    }
+
+    const enrollment = await this.prisma.course_enrollment.findFirst({
+      where: {
+        person_id: personUser.person_id,
+        course_id: lesson.course_module.course_id,
+        status: { not: 'cancelled' },
+      },
+      select: { id: true },
+    });
+
+    if (!enrollment) {
+      throw new ForbiddenException('You do not have access to this lesson');
+    }
+
+    return personUser.person_id;
+  }
+
+  private async findOwnedNote(
+    lessonId: number,
+    noteId: number,
+    personId: number
+  ) {
+    return this.querySingle<CourseLessonNoteRow>(
+      `SELECT
+          n.id,
+          n.course_lesson_id AS "courseLessonId",
+          n.person_id AS "personId",
+          n.description,
+          n.player_time_seconds AS "playerTimeSeconds",
+          n.frame_file_id AS "frameFileId",
+          f.location AS "frameImageUrl",
+          n.created_at::text AS "createdAt",
+          n.updated_at::text AS "updatedAt"
+        FROM course_lesson_note n
+        LEFT JOIN file f ON f.id = n.frame_file_id
+       WHERE n.id = $1
+         AND n.course_lesson_id = $2
+         AND n.person_id = $3`,
+      [noteId, lessonId, personId]
+    );
+  }
+
+  private mapRow(row: CourseLessonNoteRow) {
+    return {
+      id: row.id,
+      courseLessonId: row.courseLessonId,
+      personId: row.personId,
+      description: row.description,
+      playerTimeSeconds: Number(row.playerTimeSeconds ?? 0),
+      frameFileId: row.frameFileId,
+      frameImageUrl: row.frameImageUrl,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  private param(values: unknown[], value: unknown) {
+    values.push(value);
+    return `$${values.length}`;
+  }
+
+  private async queryRows<T>(query: string, values: unknown[] = []) {
+    return this.prisma.$queryRawUnsafe<T[]>(query, ...values);
+  }
+
+  private async querySingle<T>(query: string, values: unknown[] = []) {
+    const rows = await this.prisma.$queryRawUnsafe<T[]>(query, ...values);
+    return rows[0] ?? null;
+  }
+}

package/src/course-lesson-note/dto/create-course-lesson-note.dto.ts

@@ -0,0 +1,16 @@
+import { IsInt, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class CreateCourseLessonNoteDto {
+  @IsString()
+  @MaxLength(5000)
+  description: string;
+
+  @IsInt()
+  @Min(0)
+  playerTimeSeconds: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  frameFileId?: number | null;
+}

package/src/course-lesson-note/dto/update-course-lesson-note.dto.ts

@@ -0,0 +1,18 @@
+import { IsInt, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class UpdateCourseLessonNoteDto {
+  @IsOptional()
+  @IsString()
+  @MaxLength(5000)
+  description?: string;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  playerTimeSeconds?: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  frameFileId?: number | null;
+}

package/src/dashboard/dashboard.mcp-tools.ts

@@ -0,0 +1,23 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { LmsDashboardService } from './dashboard.service';
+
+@Injectable()
+export class LmsDashboardMcpTools {
+  constructor(private readonly dashboardService: LmsDashboardService) {}
+
+  @McpTool({
+    name: 'lms.dashboard.get',
+    description: 'Returns the LMS admin dashboard data: KPIs, charts, calendar events, latest enrollments, and upcoming classes.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        locale: { type: 'string', description: 'Locale code for labels (e.g. pt-BR, en-US). Defaults to pt-BR.' },
+      },
+    },
+    readOnly: true,
+  })
+  async getDashboard(args: { locale?: string }, context: McpContext): Promise<any> {
+    return this.dashboardService.getDashboard(args.locale ?? context.locale);
+  }
+}

package/src/dashboard/dashboard.module.ts

@@ -1,12 +1,13 @@
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
 import { LmsDashboardController } from './dashboard.controller';
+import { LmsDashboardMcpTools } from './dashboard.mcp-tools';
 import { LmsDashboardService } from './dashboard.service';
 
 @Module({
   imports: [forwardRef(() => PrismaModule)],
   controllers: [LmsDashboardController],
-  providers: [LmsDashboardService],
+  providers: [LmsDashboardService, LmsDashboardMcpTools],
   exports: [forwardRef(() => LmsDashboardService)],
 })
 export class LmsDashboardModule {}