@hed-hog/lms 0.0.349 → 0.0.350

package/src/class-group/class-group.mcp-tools.ts

@@ -0,0 +1,435 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { ClassGroupService } from './class-group.service';
+
+@Injectable()
+export class LmsClassGroupMcpTools {
+  constructor(private readonly classGroupService: ClassGroupService) {}
+
+  @McpTool({
+    name: 'lms.classes.list',
+    description: 'Lists class groups with optional pagination and filters.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        search: { type: 'string', description: 'Search term' },
+        status: { type: 'string', description: 'Filter by status (open|ongoing|completed|cancelled)' },
+        deliveryMode: { type: 'string', description: 'Filter by delivery mode (presential|online|hybrid)' },
+        courseId: { type: 'number', description: 'Filter by course ID' },
+      },
+    },
+    readOnly: true,
+  })
+  async listClasses(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.classGroupService.list(args);
+  }
+
+  @McpTool({
+    name: 'lms.classes.stats',
+    description: 'Returns summary statistics for class groups.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getStats(_args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.classGroupService.stats();
+  }
+
+  @McpTool({
+    name: 'lms.classes.get',
+    description: 'Returns a single class group by ID with full details.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getClass(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.classGroupService.getById(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.classes.create',
+    description: 'Creates a new class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'Class code (required, max 50 chars)' },
+        courseId: { type: 'number', description: 'Course ID (required)' },
+        instructorId: { type: 'number', description: 'Instructor ID' },
+        title: { type: 'string', description: 'Class title (required, max 255 chars)' },
+        description: { type: 'string', description: 'Description' },
+        deliveryMode: { type: 'string', description: 'Delivery mode (required): presential|online|hybrid' },
+        status: { type: 'string', description: 'Status (open|ongoing|completed|cancelled)' },
+        startDate: { type: 'string', description: 'Start date (ISO8601)' },
+        endDate: { type: 'string', description: 'End date (ISO8601)' },
+        startTime: { type: 'string', description: 'Start time (HH:MM)' },
+        endTime: { type: 'string', description: 'End time (HH:MM)' },
+        weekDays: { type: 'string', description: 'Week days string' },
+        capacity: { type: 'number', description: 'Maximum capacity' },
+        location: { type: 'string', description: 'Physical location' },
+        virtualRoomUrl: { type: 'string', description: 'Virtual room URL (max 500 chars)' },
+      },
+      required: ['code', 'courseId', 'title', 'deliveryMode', 'startDate'],
+    },
+  })
+  async createClass(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.classGroupService.create(args as any);
+  }
+
+  @McpTool({
+    name: 'lms.classes.update',
+    description: 'Updates an existing class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        title: { type: 'string', description: 'Class title' },
+        description: { type: 'string', description: 'Description' },
+        instructorId: { type: 'number', description: 'Instructor ID' },
+        status: { type: 'string', description: 'Status (open|ongoing|completed|cancelled)' },
+        startDate: { type: 'string', description: 'Start date (ISO8601)' },
+        endDate: { type: 'string', description: 'End date (ISO8601)' },
+        startTime: { type: 'string', description: 'Start time (HH:MM)' },
+        endTime: { type: 'string', description: 'End time (HH:MM)' },
+        capacity: { type: 'number', description: 'Maximum capacity' },
+        location: { type: 'string', description: 'Physical location' },
+        virtualRoomUrl: { type: 'string', description: 'Virtual room URL' },
+      },
+      required: ['id'],
+    },
+  })
+  async updateClass(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.classGroupService.update(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.classes.delete',
+    description: 'Removes a class group by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteClass(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.classGroupService.remove(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.classes.people-search',
+    description: 'Searches for people that can be added to a class group as students.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        q: { type: 'string', description: 'Search query (name, email)' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async searchPeople(args: { id: number; q?: string }, _context: McpContext): Promise<any> {
+    return this.classGroupService.searchPeople(args.q ?? '', args.id);
+  }
+
+  @McpTool({
+    name: 'lms.classes.students.list',
+    description: 'Lists students enrolled in a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        search: { type: 'string', description: 'Search term (name, email)' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async listStudents(args: { id: number; search?: string }, _context: McpContext): Promise<any> {
+    return this.classGroupService.listStudents(args.id, args.search);
+  }
+
+  @McpTool({
+    name: 'lms.classes.students.enroll',
+    description: 'Enrolls an existing person as a student in a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        personId: { type: 'number', description: 'Person ID to enroll' },
+      },
+      required: ['id', 'personId'],
+    },
+  })
+  async enrollStudent(args: { id: number; personId: number }, _context: McpContext): Promise<any> {
+    return this.classGroupService.enrollStudent(args.id, args.personId);
+  }
+
+  @McpTool({
+    name: 'lms.classes.students.enroll-new',
+    description: 'Creates a new person and immediately enrolls them in a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        name: { type: 'string', description: 'Student name (required)' },
+        email: { type: 'string', description: 'Student email' },
+        phone: { type: 'string', description: 'Student phone' },
+        department: { type: 'string', description: 'Student department' },
+      },
+      required: ['id', 'name'],
+    },
+  })
+  async enrollNewStudent(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.classGroupService.createAndEnrollStudent(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.classes.students.get',
+    description: 'Returns the profile and progress of a specific student in a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        personId: { type: 'number', description: 'Person ID' },
+      },
+      required: ['id', 'personId'],
+    },
+    readOnly: true,
+  })
+  async getStudentProfile(args: { id: number; personId: number }, _context: McpContext): Promise<any> {
+    return this.classGroupService.getStudentProfile(args.id, args.personId);
+  }
+
+  @McpTool({
+    name: 'lms.classes.students.update',
+    description: "Updates a student's profile data within a class group.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        personId: { type: 'number', description: 'Person ID' },
+        name: { type: 'string', description: 'Student name' },
+        email: { type: 'string', description: 'Student email' },
+        phone: { type: 'string', description: 'Student phone' },
+        department: { type: 'string', description: 'Department' },
+      },
+      required: ['id', 'personId'],
+    },
+  })
+  async updateStudentProfile(args: { id: number; personId: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, personId, ...dto } = args;
+    return this.classGroupService.updateStudentProfile(id, personId, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.classes.students.remove',
+    description: 'Removes a student from a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        personId: { type: 'number', description: 'Person ID to remove' },
+      },
+      required: ['id', 'personId'],
+    },
+  })
+  async removeStudent(args: { id: number; personId: number }, _context: McpContext): Promise<any> {
+    return this.classGroupService.removeStudent(args.id, args.personId);
+  }
+
+  @McpTool({
+    name: 'lms.classes.sessions.list',
+    description: 'Lists all sessions (classes) scheduled for a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async listSessions(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.classGroupService.listSessions(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.classes.sessions.create',
+    description: 'Creates a new session for a class group. Supports optional recurrence.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        title: { type: 'string', description: 'Session title (required)' },
+        description: { type: 'string', description: 'Session description' },
+        sessionDate: { type: 'string', description: 'Session date (ISO8601, required)' },
+        startTime: { type: 'string', description: 'Start time HH:MM (required)' },
+        endTime: { type: 'string', description: 'End time HH:MM (required)' },
+        location: { type: 'string', description: 'Physical location' },
+        meetingUrl: { type: 'string', description: 'Virtual meeting URL' },
+        color: { type: 'string', description: 'Session color hex code' },
+        status: { type: 'string', description: 'Status (scheduled|completed|cancelled)' },
+        instructorId: { type: 'number', description: 'Instructor ID' },
+      },
+      required: ['id', 'title', 'sessionDate', 'startTime', 'endTime'],
+    },
+  })
+  async createSession(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.classGroupService.createSession(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.classes.sessions.update',
+    description: 'Updates a session in a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+        title: { type: 'string', description: 'Session title' },
+        description: { type: 'string', description: 'Session description' },
+        sessionDate: { type: 'string', description: 'Session date (ISO8601)' },
+        startTime: { type: 'string', description: 'Start time HH:MM' },
+        endTime: { type: 'string', description: 'End time HH:MM' },
+        location: { type: 'string', description: 'Physical location' },
+        meetingUrl: { type: 'string', description: 'Virtual meeting URL' },
+        color: { type: 'string', description: 'Session color hex code' },
+        status: { type: 'string', description: 'Status (scheduled|completed|cancelled)' },
+        instructorId: { type: 'number', description: 'Instructor ID' },
+        scope: { type: 'string', description: 'Update scope for recurring sessions (single|series)' },
+      },
+      required: ['id', 'sessionId'],
+    },
+  })
+  async updateSession(args: { id: number; sessionId: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, sessionId, ...dto } = args;
+    return this.classGroupService.updateSession(id, sessionId, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.classes.sessions.delete',
+    description: 'Deletes a session from a class group. For recurring sessions, use scope=series to delete all.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+        scope: { type: 'string', description: 'Delete scope for recurring sessions (single|series, default: single)' },
+      },
+      required: ['id', 'sessionId'],
+    },
+  })
+  async deleteSession(args: { id: number; sessionId: number; scope?: string }, _context: McpContext): Promise<any> {
+    return this.classGroupService.deleteSession(args.id, args.sessionId, args.scope as any);
+  }
+
+  @McpTool({
+    name: 'lms.classes.sessions.attendance.get',
+    description: 'Returns the attendance list for a specific session in a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+      },
+      required: ['id', 'sessionId'],
+    },
+    readOnly: true,
+  })
+  async getAttendance(args: { id: number; sessionId: number }, _context: McpContext): Promise<any> {
+    return this.classGroupService.getAttendance(args.id, args.sessionId);
+  }
+
+  @McpTool({
+    name: 'lms.classes.sessions.attendance.save',
+    description: 'Saves attendance records for a session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+        attendance: {
+          type: 'array',
+          description: 'Attendance records',
+          items: {
+            type: 'object',
+            properties: {
+              personId: { type: 'number', description: 'Person ID' },
+              present: { type: 'boolean', description: 'Whether the person was present' },
+            },
+          },
+        },
+      },
+      required: ['id', 'sessionId', 'attendance'],
+    },
+  })
+  async saveAttendance(args: { id: number; sessionId: number; attendance: any[] }, _context: McpContext): Promise<any> {
+    return this.classGroupService.saveAttendance(args.id, args.sessionId, args.attendance);
+  }
+
+  @McpTool({
+    name: 'lms.classes.materials.list',
+    description: 'Lists materials for a class group, optionally filtered by session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        sessionId: { type: 'number', description: 'Filter by session ID (optional)' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async listMaterials(args: { id: number; sessionId?: number }, _context: McpContext): Promise<any> {
+    return this.classGroupService.listMaterials(args.id, args.sessionId);
+  }
+
+  @McpTool({
+    name: 'lms.classes.materials.create',
+    description: 'Creates a new material (link) for a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        title: { type: 'string', description: 'Material title (required)' },
+        description: { type: 'string', description: 'Material description' },
+        type: { type: 'string', description: 'Material type (required)' },
+        url: { type: 'string', description: 'Material URL' },
+        fileId: { type: 'number', description: 'File ID for uploaded materials' },
+        sessionId: { type: 'number', description: 'Associate with a specific session' },
+      },
+      required: ['id', 'title', 'type'],
+    },
+  })
+  async createMaterial(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.classGroupService.createMaterial(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.classes.materials.delete',
+    description: 'Deletes a material from a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        materialId: { type: 'number', description: 'Material ID' },
+      },
+      required: ['id', 'materialId'],
+    },
+  })
+  async deleteMaterial(args: { id: number; materialId: number }, _context: McpContext): Promise<any> {
+    return this.classGroupService.deleteMaterial(args.id, args.materialId);
+  }
+}

package/src/class-group/class-group.module.ts

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

package/src/class-group/class-group.service.ts

@@ -1,9 +1,12 @@
 import { PrismaService } from '@hed-hog/api-prisma';
+import { IntegrationDeveloperApiService } from '@hed-hog/core';
 import {
     BadRequestException,
     ConflictException,
+    Inject,
     Injectable,
     NotFoundException,
+    forwardRef,
 } from '@nestjs/common';
 import { Prisma } from '@prisma/client';
 import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
@@ -55,7 +58,11 @@ export class ClassGroupService {
     'SA',
   ];
 
-  constructor(private readonly prisma: PrismaService) {}
+  constructor(
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => IntegrationDeveloperApiService))
+    private readonly integrationApi: IntegrationDeveloperApiService,
+  ) {}
 
   private isEmailCode(code?: string | null) {
     return (code ?? '').toLowerCase() === 'email';
@@ -316,6 +323,14 @@ export class ClassGroupService {
         return createdClass;
       });
 
+      await this.integrationApi.publishEvent({
+        eventName: 'lms.class_group.created',
+        sourceModule: 'lms',
+        aggregateType: 'class_group',
+        aggregateId: String(created.id),
+        payload: { id: created.id, name: created.title ?? created.code, courseId: created.course_id, status: created.status },
+      }).catch(() => null);
+
       return this.mapClassGroup(created);
     } catch (error) {
       this.handlePrismaError(error);
@@ -414,6 +429,14 @@ export class ClassGroupService {
         return updatedClass;
       });
 
+      await this.integrationApi.publishEvent({
+        eventName: 'lms.class_group.updated',
+        sourceModule: 'lms',
+        aggregateType: 'class_group',
+        aggregateId: String(id),
+        payload: { id, name: dto.title, status: dto.status },
+      }).catch(() => null);
+
       return this.mapClassGroup(updated);
     } catch (error) {
       this.handlePrismaError(error);
@@ -422,6 +445,15 @@ export class ClassGroupService {
 
   async remove(id: number) {
     await this.prisma.course_class_group.delete({ where: { id } });
+
+    await this.integrationApi.publishEvent({
+      eventName: 'lms.class_group.deleted',
+      sourceModule: 'lms',
+      aggregateType: 'class_group',
+      aggregateId: String(id),
+      payload: { id },
+    }).catch(() => null);
+
     return { success: true };
   }
 
@@ -780,6 +812,15 @@ export class ClassGroupService {
       },
     });
     await this.ensureEnterpriseStudent(classGroupId, personId);
+
+    await this.integrationApi.publishEvent({
+      eventName: 'lms.class_group.student.enrolled',
+      sourceModule: 'lms',
+      aggregateType: 'class_group',
+      aggregateId: String(classGroupId),
+      payload: { classGroupId, courseId: group.course_id, personId, enrollmentId: enrollment.id },
+    }).catch(() => null);
+
     return enrollment;
   }
 
@@ -935,6 +976,15 @@ export class ClassGroupService {
       where: { id: enrollment.id },
       data: { status: 'cancelled' },
     });
+
+    await this.integrationApi.publishEvent({
+      eventName: 'lms.class_group.student.removed',
+      sourceModule: 'lms',
+      aggregateType: 'class_group',
+      aggregateId: String(classGroupId),
+      payload: { classGroupId, personId, enrollmentId: enrollment.id },
+    }).catch(() => null);
+
     return { success: true };
   }