@hed-hog/lms 0.0.349 → 0.0.351

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

@@ -0,0 +1,409 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { CourseStructureService } from './course-structure.service';
+import { CourseService } from './course.service';
+
+@Injectable()
+export class LmsCoursesMcpTools {
+  constructor(
+    private readonly courseService: CourseService,
+    private readonly courseStructureService: CourseStructureService,
+  ) {}
+
+  @McpTool({
+    name: 'lms.courses.list',
+    description: 'Lists courses 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 (draft|published|archived)' },
+        level: { type: 'string', description: 'Filter by level (beginner|intermediate|advanced)' },
+        category: { type: 'string', description: 'Filter by category slug' },
+        offeringTypes: { type: 'string', description: 'Filter by offering type(s), comma-separated (scheduled|on_demand|blended)' },
+      },
+    },
+    readOnly: true,
+  })
+  async listCourses(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.courseService.list(args);
+  }
+
+  @McpTool({
+    name: 'lms.courses.stats',
+    description: 'Returns summary statistics for courses (total, by status, enrollments, etc.).',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getCourseStats(_args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.courseService.stats();
+  }
+
+  @McpTool({
+    name: 'lms.courses.get',
+    description: 'Returns a single course by ID with full details.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Course ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getCourse(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.courseService.getById(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.courses.create',
+    description: 'Creates a new course.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        slug: { type: 'string', description: 'Course slug (required, kebab-case, max 255)' },
+        title: { type: 'string', description: 'Course title' },
+        description: { type: 'string', description: 'Full description' },
+        requirements: { type: 'string', description: 'Prerequisites' },
+        objectives: { type: 'string', description: 'Learning objectives' },
+        targetAudience: { type: 'string', description: 'Target audience description' },
+        durationHours: { type: 'number', description: 'Total duration in hours' },
+        level: { type: 'string', description: 'Level (beginner|intermediate|advanced)' },
+        status: { type: 'string', description: 'Status (draft|published|archived)' },
+        offeringType: { type: 'string', description: 'Offering type (scheduled|on_demand|blended)' },
+        isFeatured: { type: 'boolean', description: 'Whether to feature the course' },
+        hasCertificate: { type: 'boolean', description: 'Whether to issue certificates' },
+        isListed: { type: 'boolean', description: 'Whether the course is publicly listed' },
+        instructorIds: { type: 'array', description: 'Instructor IDs', items: { type: 'number' } },
+        categorySlugs: { type: 'array', description: 'Category slugs', items: { type: 'string' } },
+      },
+      required: ['slug'],
+    },
+  })
+  async createCourse(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.courseService.create(args as any);
+  }
+
+  @McpTool({
+    name: 'lms.courses.update',
+    description: 'Updates an existing course.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Course ID' },
+        title: { type: 'string', description: 'Course title' },
+        description: { type: 'string', description: 'Full description' },
+        requirements: { type: 'string', description: 'Prerequisites' },
+        objectives: { type: 'string', description: 'Learning objectives' },
+        targetAudience: { type: 'string', description: 'Target audience description' },
+        durationHours: { type: 'number', description: 'Total duration in hours' },
+        level: { type: 'string', description: 'Level (beginner|intermediate|advanced)' },
+        status: { type: 'string', description: 'Status (draft|published|archived)' },
+        offeringType: { type: 'string', description: 'Offering type (scheduled|on_demand|blended)' },
+        isFeatured: { type: 'boolean', description: 'Whether to feature the course' },
+        hasCertificate: { type: 'boolean', description: 'Whether to issue certificates' },
+        isListed: { type: 'boolean', description: 'Whether the course is publicly listed' },
+        instructorIds: { type: 'array', description: 'Instructor IDs', items: { type: 'number' } },
+        categorySlugs: { type: 'array', description: 'Category slugs', items: { type: 'string' } },
+      },
+      required: ['id'],
+    },
+  })
+  async updateCourse(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.courseService.update(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.courses.delete',
+    description: 'Removes a course by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Course ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteCourse(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.courseService.remove(args.id);
+  }
+
+  // ── Course Structure ────────────────────────────────────────────────────────
+
+  @McpTool({
+    name: 'lms.courses.structure.get',
+    description: 'Returns the full content structure of a course (modules/sessions and their lessons).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+      },
+      required: ['courseId'],
+    },
+    readOnly: true,
+  })
+  async getCourseStructure(args: { courseId: number }, _context: McpContext): Promise<any> {
+    return this.courseStructureService.getStructure(args.courseId);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.sessions.create',
+    description: 'Creates a new module/session in a course structure.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        title: { type: 'string', description: 'Session title (required)' },
+        description: { type: 'string', description: 'Session description' },
+        order: { type: 'number', description: 'Display order' },
+      },
+      required: ['courseId', 'title'],
+    },
+  })
+  async createStructureSession(args: { courseId: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { courseId, ...dto } = args;
+    return this.courseStructureService.createSession(courseId, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.sessions.reorder',
+    description: 'Reorders modules/sessions within a course structure.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        ids: { type: 'array', description: 'Session IDs in the desired order', items: { type: 'number' } },
+      },
+      required: ['courseId', 'ids'],
+    },
+  })
+  async reorderStructureSessions(args: { courseId: number; ids: number[] }, _context: McpContext): Promise<any> {
+    return this.courseStructureService.reorderSessions(args.courseId, { ids: args.ids } as any);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.sessions.update',
+    description: 'Updates a module/session in a course structure.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+        title: { type: 'string', description: 'Session title' },
+        description: { type: 'string', description: 'Session description' },
+      },
+      required: ['courseId', 'sessionId'],
+    },
+  })
+  async updateStructureSession(args: { courseId: number; sessionId: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { courseId, sessionId, ...dto } = args;
+    return this.courseStructureService.updateSession(courseId, sessionId, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.sessions.delete',
+    description: 'Deletes a module/session from a course structure.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+      },
+      required: ['courseId', 'sessionId'],
+    },
+  })
+  async deleteStructureSession(args: { courseId: number; sessionId: number }, _context: McpContext): Promise<any> {
+    return this.courseStructureService.deleteSession(args.courseId, args.sessionId);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.sessions.duplicate',
+    description: 'Duplicates a module/session with all its lessons.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        sessionId: { type: 'number', description: 'Session ID to duplicate' },
+      },
+      required: ['courseId', 'sessionId'],
+    },
+  })
+  async duplicateStructureSession(args: { courseId: number; sessionId: number }, _context: McpContext): Promise<any> {
+    return this.courseStructureService.duplicateSession(args.courseId, args.sessionId);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.lessons.create',
+    description: 'Creates a new lesson inside a module/session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+        titulo: { type: 'string', description: 'Lesson title (required, max 255)' },
+        tipo: { type: 'string', description: 'Lesson type (required): video|questao|post|exercicio' },
+        descricaoPublica: { type: 'string', description: 'Public description' },
+        descricaoPrivada: { type: 'string', description: 'Private description' },
+        duracao: { type: 'number', description: 'Duration in seconds' },
+        videoProvedor: { type: 'string', description: 'Video provider (youtube|vimeo|bunny|custom)' },
+        videoUrl: { type: 'string', description: 'Video URL' },
+        exameVinculado: { type: 'number', description: 'Linked exam ID (for questao type)' },
+        conteudoPost: { type: 'string', description: 'Post content (for post type)' },
+        instructorIds: { type: 'array', description: 'Instructor IDs', items: { type: 'number' } },
+      },
+      required: ['courseId', 'sessionId', 'titulo', 'tipo'],
+    },
+  })
+  async createStructureLesson(args: { courseId: number; sessionId: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { courseId, sessionId, ...dto } = args;
+    return this.courseStructureService.createLesson(courseId, sessionId, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.lessons.paste',
+    description: 'Pastes (copies) lessons from another session into a session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        sessionId: { type: 'number', description: 'Target session ID' },
+        lessonIds: { type: 'array', description: 'Lesson IDs to paste', items: { type: 'number' } },
+      },
+      required: ['courseId', 'sessionId', 'lessonIds'],
+    },
+  })
+  async pasteStructureLessons(args: { courseId: number; sessionId: number; lessonIds: number[] }, _context: McpContext): Promise<any> {
+    return this.courseStructureService.pasteLessons(args.courseId, args.sessionId, { lessonIds: args.lessonIds } as any);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.lessons.reorder',
+    description: 'Reorders lessons within a session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+        ids: { type: 'array', description: 'Lesson IDs in the desired order', items: { type: 'number' } },
+      },
+      required: ['courseId', 'sessionId', 'ids'],
+    },
+  })
+  async reorderStructureLessons(args: { courseId: number; sessionId: number; ids: number[] }, _context: McpContext): Promise<any> {
+    return this.courseStructureService.reorderLessons(args.courseId, args.sessionId, { ids: args.ids } as any);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.lessons.update',
+    description: 'Updates a lesson in the course structure.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+        lessonId: { type: 'number', description: 'Lesson ID' },
+        titulo: { type: 'string', description: 'Lesson title' },
+        descricaoPublica: { type: 'string', description: 'Public description' },
+        duracao: { type: 'number', description: 'Duration in seconds' },
+        videoUrl: { type: 'string', description: 'Video URL' },
+        conteudoPost: { type: 'string', description: 'Post content' },
+        instructorIds: { type: 'array', description: 'Instructor IDs', items: { type: 'number' } },
+      },
+      required: ['courseId', 'sessionId', 'lessonId'],
+    },
+  })
+  async updateStructureLesson(args: { courseId: number; sessionId: number; lessonId: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { courseId, sessionId, lessonId, ...dto } = args;
+    return this.courseStructureService.updateLesson(courseId, sessionId, lessonId, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.lessons.move',
+    description: 'Moves a lesson to a different session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        sessionId: { type: 'number', description: 'Current session ID' },
+        lessonId: { type: 'number', description: 'Lesson ID' },
+        targetSessionId: { type: 'number', description: 'Target session ID' },
+        targetOrder: { type: 'number', description: 'Target position order' },
+      },
+      required: ['courseId', 'sessionId', 'lessonId', 'targetSessionId'],
+    },
+  })
+  async moveStructureLesson(args: { courseId: number; sessionId: number; lessonId: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { courseId, sessionId, lessonId, ...dto } = args;
+    return this.courseStructureService.moveLesson(courseId, sessionId, lessonId, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.lessons.delete',
+    description: 'Deletes a lesson from the course structure.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+        lessonId: { type: 'number', description: 'Lesson ID' },
+      },
+      required: ['courseId', 'sessionId', 'lessonId'],
+    },
+  })
+  async deleteStructureLesson(args: { courseId: number; sessionId: number; lessonId: number }, _context: McpContext): Promise<any> {
+    return this.courseStructureService.deleteLesson(args.courseId, args.sessionId, args.lessonId);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.lessons.duplicate',
+    description: 'Duplicates a lesson within its session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+        lessonId: { type: 'number', description: 'Lesson ID to duplicate' },
+      },
+      required: ['courseId', 'sessionId', 'lessonId'],
+    },
+  })
+  async duplicateStructureLesson(args: { courseId: number; sessionId: number; lessonId: number }, _context: McpContext): Promise<any> {
+    return this.courseStructureService.duplicateLesson(args.courseId, args.sessionId, args.lessonId);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.resources.get',
+    description: 'Returns the resource list (file attachments, links) for a course.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+      },
+      required: ['courseId'],
+    },
+    readOnly: true,
+  })
+  async getCourseResources(args: { courseId: number }, _context: McpContext): Promise<any> {
+    return this.courseStructureService.getCourseResources(args.courseId);
+  }
+
+  @McpTool({
+    name: 'lms.courses.structure.resources.update',
+    description: 'Updates the resource list for a course.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        resources: { type: 'array', description: 'Resource list', items: { type: 'object' } },
+      },
+      required: ['courseId'],
+    },
+  })
+  async updateCourseResources(args: { courseId: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { courseId, ...dto } = args;
+    return this.courseStructureService.updateCourseResources(courseId, dto as any);
+  }
+}

package/src/course/course.module.ts

@@ -1,15 +1,35 @@
 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 { CourseOperationsIntegrationService } from './course-operations-integration.service';
 import { CourseStructureController } from './course-structure.controller';
 import { CourseStructureService } from './course-structure.service';
+import { CourseVideoConversionService } from './course-video-conversion.service';
+import { LmsCoursesMcpTools } from './course.mcp-tools';
 import { CourseController } from './course.controller';
 import { CourseService } from './course.service';
 import { InstructorModule } from '../instructor/instructor.module';
 
 @Module({
-  imports: [forwardRef(() => PrismaModule), forwardRef(() => InstructorModule)],
+  imports: [
+    forwardRef(() => PrismaModule),
+    forwardRef(() => InstructorModule),
+    forwardRef(() => CoreModule),
+    forwardRef(() => QueueModule),
+  ],
   controllers: [CourseController, CourseStructureController],
-  providers: [CourseService, CourseStructureService],
-  exports: [forwardRef(() => CourseService), forwardRef(() => CourseStructureService)],
+  providers: [
+    CourseOperationsIntegrationService,
+    CourseService,
+    CourseStructureService,
+    CourseVideoConversionService,
+    LmsCoursesMcpTools,
+  ],
+  exports: [
+    forwardRef(() => CourseService),
+    forwardRef(() => CourseStructureService),
+    forwardRef(() => CourseVideoConversionService),
+  ],
 })
 export class CourseModule {}