@hed-hog/lms 0.0.349 → 0.0.350

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

@@ -0,0 +1,354 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { CreateCourseLessonDiscussionTopicDto } from './dto/create-course-lesson-discussion-topic.dto';
+
+type DiscussionRow = {
+  id: number;
+  lessonId: number;
+  personId: number;
+  parentTopicId: number | null;
+  content: string;
+  playerTimeSeconds: number;
+  likesCount: number;
+  likedByMe: boolean;
+  createdAt: string | null;
+  updatedAt: string | null;
+  authorName: string | null;
+};
+
+export type DiscussionNode = {
+  id: number;
+  lessonId: number;
+  personId: number;
+  parentTopicId: number | null;
+  content: string;
+  playerTimeSeconds: number;
+  likesCount: number;
+  likedByMe: boolean;
+  createdAt: string | null;
+  updatedAt: string | null;
+  author: {
+    personId: number;
+    name: string | null;
+  };
+  replies: DiscussionNode[];
+};
+
+@Injectable()
+export class CourseLessonDiscussionService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async listTopics(lessonId: number, userId: number) {
+    const personId = await this.assertStudentAccess(lessonId, userId);
+
+    const rows = await this.queryRows<DiscussionRow>(
+      `SELECT
+          t.id,
+          t.course_lesson_id AS "lessonId",
+          t.person_id AS "personId",
+          t.parent_topic_id AS "parentTopicId",
+          t.content,
+          t.player_time_seconds AS "playerTimeSeconds",
+          t.created_at::text AS "createdAt",
+          t.updated_at::text AS "updatedAt",
+          p.name AS "authorName",
+          COALESCE(
+            (
+              SELECT COUNT(*)
+              FROM course_lesson_discussion_like l
+              WHERE l.topic_id = t.id
+            ),
+            0
+          )::int AS "likesCount",
+          EXISTS(
+            SELECT 1
+            FROM course_lesson_discussion_like l
+            WHERE l.topic_id = t.id
+              AND l.person_id = $2
+          ) AS "likedByMe"
+        FROM course_lesson_discussion_topic t
+        JOIN person p ON p.id = t.person_id
+       WHERE t.course_lesson_id = $1
+       ORDER BY t.created_at ASC, t.id ASC`,
+      [lessonId, personId]
+    );
+
+    const tree = this.buildTree(rows.map((row) => this.mapRow(row)));
+
+    return {
+      lessonId,
+      totalTopics: rows.length,
+      topics: tree,
+    };
+  }
+
+  async createTopic(
+    lessonId: number,
+    userId: number,
+    dto: CreateCourseLessonDiscussionTopicDto
+  ) {
+    const personId = await this.assertStudentAccess(lessonId, userId);
+
+    if (dto.parentTopicId) {
+      const parent = await this.querySingle<{ id: number }>(
+        `SELECT id
+           FROM course_lesson_discussion_topic
+          WHERE id = $1
+            AND course_lesson_id = $2`,
+        [dto.parentTopicId, lessonId]
+      );
+
+      if (!parent) {
+        throw new NotFoundException('Parent topic not found');
+      }
+    }
+
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO course_lesson_discussion_topic (
+          course_lesson_id,
+          person_id,
+          parent_topic_id,
+          content,
+          player_time_seconds,
+          created_at,
+          updated_at
+        ) VALUES (
+          $1,
+          $2,
+          $3,
+          $4,
+          $5,
+          NOW(),
+          NOW()
+        )
+        RETURNING id`,
+      [
+        lessonId,
+        personId,
+        dto.parentTopicId ?? null,
+        this.sanitizeHtml(dto.content),
+        Number(dto.playerTimeSeconds),
+      ]
+    );
+
+    return this.getTopicById(lessonId, created.id, personId);
+  }
+
+  async likeTopic(lessonId: number, topicId: number, userId: number) {
+    const personId = await this.assertStudentAccess(lessonId, userId);
+    await this.assertTopicBelongsToLesson(lessonId, topicId);
+
+    await this.prisma.$executeRawUnsafe(
+      `INSERT INTO course_lesson_discussion_like (
+          topic_id,
+          person_id,
+          created_at
+        ) VALUES (
+          $1,
+          $2,
+          NOW()
+        )
+        ON CONFLICT (topic_id, person_id) DO NOTHING`,
+      topicId,
+      personId
+    );
+
+    return this.getLikeStatus(topicId, personId);
+  }
+
+  async unlikeTopic(lessonId: number, topicId: number, userId: number) {
+    const personId = await this.assertStudentAccess(lessonId, userId);
+    await this.assertTopicBelongsToLesson(lessonId, topicId);
+
+    await this.prisma.$executeRawUnsafe(
+      `DELETE FROM course_lesson_discussion_like
+        WHERE topic_id = $1
+          AND person_id = $2`,
+      topicId,
+      personId
+    );
+
+    return this.getLikeStatus(topicId, personId);
+  }
+
+  private async getTopicById(lessonId: number, topicId: number, viewerPersonId: number) {
+    const row = await this.querySingle<DiscussionRow>(
+      `SELECT
+          t.id,
+          t.course_lesson_id AS "lessonId",
+          t.person_id AS "personId",
+          t.parent_topic_id AS "parentTopicId",
+          t.content,
+          t.player_time_seconds AS "playerTimeSeconds",
+          t.created_at::text AS "createdAt",
+          t.updated_at::text AS "updatedAt",
+          p.name AS "authorName",
+          COALESCE(
+            (
+              SELECT COUNT(*)
+              FROM course_lesson_discussion_like l
+              WHERE l.topic_id = t.id
+            ),
+            0
+          )::int AS "likesCount",
+          EXISTS(
+            SELECT 1
+            FROM course_lesson_discussion_like l
+            WHERE l.topic_id = t.id
+              AND l.person_id = $2
+          ) AS "likedByMe"
+        FROM course_lesson_discussion_topic t
+        JOIN person p ON p.id = t.person_id
+       WHERE t.id = $1
+         AND t.course_lesson_id = $3`,
+      [topicId, viewerPersonId, lessonId]
+    );
+
+    if (!row) {
+      throw new NotFoundException('Topic not found');
+    }
+
+    return this.mapRow(row);
+  }
+
+  private async getLikeStatus(topicId: number, personId: number) {
+    const status = await this.querySingle<{ likesCount: number; likedByMe: boolean }>(
+      `SELECT
+          COALESCE((SELECT COUNT(*) FROM course_lesson_discussion_like WHERE topic_id = $1), 0)::int AS "likesCount",
+          EXISTS(
+            SELECT 1
+            FROM course_lesson_discussion_like
+            WHERE topic_id = $1
+              AND person_id = $2
+          ) AS "likedByMe"`,
+      [topicId, personId]
+    );
+
+    return {
+      topicId,
+      likesCount: Number(status?.likesCount ?? 0),
+      likedByMe: Boolean(status?.likedByMe),
+    };
+  }
+
+  private buildTree(nodes: DiscussionNode[]) {
+    const byId = new Map<number, DiscussionNode>();
+    const roots: DiscussionNode[] = [];
+
+    for (const node of nodes) {
+      byId.set(node.id, node);
+    }
+
+    for (const node of nodes) {
+      if (node.parentTopicId && byId.has(node.parentTopicId)) {
+        byId.get(node.parentTopicId)?.replies.push(node);
+      } else {
+        roots.push(node);
+      }
+    }
+
+    return roots;
+  }
+
+  private mapRow(row: DiscussionRow): DiscussionNode {
+    return {
+      id: row.id,
+      lessonId: row.lessonId,
+      personId: row.personId,
+      parentTopicId: row.parentTopicId,
+      content: row.content,
+      playerTimeSeconds: Number(row.playerTimeSeconds ?? 0),
+      likesCount: Number(row.likesCount ?? 0),
+      likedByMe: Boolean(row.likedByMe),
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+      author: {
+        personId: row.personId,
+        name: row.authorName,
+      },
+      replies: [],
+    };
+  }
+
+  private sanitizeHtml(content: string) {
+    const trimmed = content.trim();
+
+    const noScripts = trimmed
+      .replace(/<script[\s\S]*?>[\s\S]*?<\/script>/gi, '')
+      .replace(/<style[\s\S]*?>[\s\S]*?<\/style>/gi, '');
+
+    const noInlineEvents = noScripts.replace(/\son\w+=("[^"]*"|'[^']*'|[^\s>]+)/gi, '');
+    const safeLinks = noInlineEvents.replace(/javascript:/gi, '');
+
+    return safeLinks;
+  }
+
+  private async assertTopicBelongsToLesson(lessonId: number, topicId: number) {
+    const topic = await this.querySingle<{ id: number }>(
+      `SELECT id
+         FROM course_lesson_discussion_topic
+        WHERE id = $1
+          AND course_lesson_id = $2`,
+      [topicId, lessonId]
+    );
+
+    if (!topic) {
+      throw new NotFoundException('Topic not found');
+    }
+  }
+
+  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 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-discussion/dto/create-course-lesson-discussion-topic.dto.ts

@@ -0,0 +1,16 @@
+import { IsInt, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class CreateCourseLessonDiscussionTopicDto {
+  @IsString()
+  @MaxLength(20000)
+  content: string;
+
+  @IsInt()
+  @Min(0)
+  playerTimeSeconds: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  parentTopicId?: number;
+}

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

@@ -0,0 +1,68 @@
+import { Role, User } from '@hed-hog/api';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    HttpCode,
+    HttpStatus,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+} from '@nestjs/common';
+import { CourseLessonNoteService } from './course-lesson-note.service';
+import { CreateCourseLessonNoteDto } from './dto/create-course-lesson-note.dto';
+import { UpdateCourseLessonNoteDto } from './dto/update-course-lesson-note.dto';
+
+@Role()
+@Controller('lms/course-lessons/:lessonId/notes')
+export class CourseLessonNoteController {
+  constructor(private readonly noteService: CourseLessonNoteService) {}
+
+  @Get()
+  list(
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @User('id') userId: number
+  ) {
+    return this.noteService.list(lessonId, userId);
+  }
+
+  @Get(':id')
+  getById(
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @Param('id', ParseIntPipe) id: number,
+    @User('id') userId: number
+  ) {
+    return this.noteService.getById(lessonId, id, userId);
+  }
+
+  @Post()
+  create(
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @User('id') userId: number,
+    @Body() dto: CreateCourseLessonNoteDto
+  ) {
+    return this.noteService.create(lessonId, userId, dto);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @Param('id', ParseIntPipe) id: number,
+    @User('id') userId: number,
+    @Body() dto: UpdateCourseLessonNoteDto
+  ) {
+    return this.noteService.update(lessonId, id, userId, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @Param('id', ParseIntPipe) id: number,
+    @User('id') userId: number
+  ) {
+    return this.noteService.delete(lessonId, id, userId);
+  }
+}

package/src/course-lesson-note/course-lesson-note.mcp-tools.ts

@@ -0,0 +1,96 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { CourseLessonNoteService } from './course-lesson-note.service';
+
+@Injectable()
+export class LmsCourseLessonNoteMcpTools {
+  constructor(private readonly noteService: CourseLessonNoteService) {}
+
+  @McpTool({
+    name: 'lms.lesson-notes.list',
+    description: "Lists the authenticated user's notes for a course lesson, ordered by player timestamp.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        lessonId: { type: 'number', description: 'Course lesson ID' },
+      },
+      required: ['lessonId'],
+    },
+    readOnly: true,
+  })
+  async listNotes(args: { lessonId: number }, context: McpContext): Promise<any> {
+    return this.noteService.list(args.lessonId, context.userId);
+  }
+
+  @McpTool({
+    name: 'lms.lesson-notes.get',
+    description: "Returns a single note by ID for the authenticated user.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        lessonId: { type: 'number', description: 'Course lesson ID' },
+        id: { type: 'number', description: 'Note ID' },
+      },
+      required: ['lessonId', 'id'],
+    },
+    readOnly: true,
+  })
+  async getNote(args: { lessonId: number; id: number }, context: McpContext): Promise<any> {
+    return this.noteService.getById(args.lessonId, args.id, context.userId);
+  }
+
+  @McpTool({
+    name: 'lms.lesson-notes.create',
+    description: 'Creates a new note on a course lesson for the authenticated user.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        lessonId: { type: 'number', description: 'Course lesson ID' },
+        description: { type: 'string', description: 'Note text content (max 5000 chars)' },
+        playerTimeSeconds: { type: 'number', description: 'Video player timestamp in seconds' },
+        frameFileId: { type: 'number', description: 'Screenshot frame file ID (optional)' },
+      },
+      required: ['lessonId', 'description', 'playerTimeSeconds'],
+    },
+  })
+  async createNote(args: { lessonId: number; [key: string]: any }, context: McpContext): Promise<any> {
+    const { lessonId, ...dto } = args;
+    return this.noteService.create(lessonId, context.userId, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.lesson-notes.update',
+    description: "Updates one of the authenticated user's lesson notes.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        lessonId: { type: 'number', description: 'Course lesson ID' },
+        id: { type: 'number', description: 'Note ID' },
+        description: { type: 'string', description: 'Note text content' },
+        playerTimeSeconds: { type: 'number', description: 'Video player timestamp in seconds' },
+        frameFileId: { type: 'number', description: 'Screenshot frame file ID' },
+      },
+      required: ['lessonId', 'id'],
+    },
+  })
+  async updateNote(args: { lessonId: number; id: number; [key: string]: any }, context: McpContext): Promise<any> {
+    const { lessonId, id, ...dto } = args;
+    return this.noteService.update(lessonId, id, context.userId, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.lesson-notes.delete',
+    description: "Deletes one of the authenticated user's lesson notes.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        lessonId: { type: 'number', description: 'Course lesson ID' },
+        id: { type: 'number', description: 'Note ID' },
+      },
+      required: ['lessonId', 'id'],
+    },
+  })
+  async deleteNote(args: { lessonId: number; id: number }, context: McpContext): Promise<any> {
+    return this.noteService.delete(args.lessonId, args.id, context.userId);
+  }
+}

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

@@ -0,0 +1,13 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { CourseLessonNoteController } from './course-lesson-note.controller';
+import { LmsCourseLessonNoteMcpTools } from './course-lesson-note.mcp-tools';
+import { CourseLessonNoteService } from './course-lesson-note.service';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule)],
+  controllers: [CourseLessonNoteController],
+  providers: [CourseLessonNoteService, LmsCourseLessonNoteMcpTools],
+  exports: [CourseLessonNoteService],
+})
+export class CourseLessonNoteModule {}