@hed-hog/lms 0.0.347 → 0.0.350

package/src/certificate/certificate.controller.ts

@@ -1,20 +1,21 @@
 import { Role } from '@hed-hog/api';
 import {
-    Body,
-    Controller,
-    Delete,
-    Get,
-    Param,
-    ParseIntPipe,
-    Patch,
-    Post,
-    Query,
-    UploadedFile,
-    UseInterceptors,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Query,
+  UploadedFile,
+  UseInterceptors,
 } from '@nestjs/common';
 import { FileInterceptor } from '@nestjs/platform-express';
 import { LmsCertificateService } from './certificate.service';
 import { CreateCertificateTemplateDto } from './dto/create-certificate-template.dto';
+import { UpdateCertificatePublicAccessDto } from './dto/update-certificate-public-access.dto';
 import { UpdateCertificateTemplateDto } from './dto/update-certificate-template.dto';
 
 @Role()
@@ -80,4 +81,12 @@ export class LmsCertificateController {
       type,
     });
   }
+
+  @Patch('issued/:id/public-access')
+  updateIssuedPublicAccess(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateCertificatePublicAccessDto,
+  ) {
+    return this.certificateService.updatePublicAccess(id, dto.publicAccess);
+  }
 }

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

@@ -0,0 +1,131 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { LmsCertificateService } from './certificate.service';
+
+@Injectable()
+export class LmsCertificateMcpTools {
+  constructor(private readonly certificateService: LmsCertificateService) {}
+
+  @McpTool({
+    name: 'lms.certificates.templates.list',
+    description: 'Lists certificate templates with optional pagination, search and status filter.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 12)' },
+        search: { type: 'string', description: 'Search term (name, slug, description)' },
+        status: { type: 'string', description: 'Filter by status (draft|active|inactive)' },
+      },
+    },
+    readOnly: true,
+  })
+  async listTemplates(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.certificateService.listTemplates(args);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.templates.get',
+    description: 'Returns a single certificate template by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Template ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getTemplate(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.certificateService.getTemplateById(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.templates.create',
+    description: 'Creates a new certificate template.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Template name (required)' },
+        slug: { type: 'string', description: 'Unique slug (auto-generated if omitted)' },
+        description: { type: 'string', description: 'Description' },
+        templateContent: { type: 'string', description: 'Template content as JSON string (required)' },
+        status: { type: 'string', description: 'Status (draft|active|inactive, default: draft)' },
+      },
+      required: ['name', 'templateContent'],
+    },
+  })
+  async createTemplate(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.certificateService.createTemplate(args as any);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.templates.update',
+    description: 'Updates an existing certificate template.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Template ID' },
+        name: { type: 'string', description: 'Template name' },
+        slug: { type: 'string', description: 'Unique slug' },
+        description: { type: 'string', description: 'Description' },
+        templateContent: { type: 'string', description: 'Template content as JSON string' },
+        status: { type: 'string', description: 'Status (draft|active|inactive)' },
+      },
+      required: ['id'],
+    },
+  })
+  async updateTemplate(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.certificateService.updateTemplate(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.templates.delete',
+    description: 'Deletes a certificate template by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Template ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteTemplate(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.certificateService.deleteTemplate(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.issued.list',
+    description: 'Lists issued certificates with optional pagination, search and type filter.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 12)' },
+        search: { type: 'string', description: 'Search term (student name, course name, verification code)' },
+        type: { type: 'string', description: 'Filter by certificate type (course|exam|course_class_group|learning_path)' },
+      },
+    },
+    readOnly: true,
+  })
+  async listIssued(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.certificateService.listIssued(args);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.issued.update-public-access',
+    description: 'Enables or disables public access for an issued certificate.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Certificate ID' },
+        publicAccess: { type: 'boolean', description: 'Whether to allow public access to the certificate' },
+      },
+      required: ['id', 'publicAccess'],
+    },
+  })
+  async updatePublicAccess(args: { id: number; publicAccess: boolean }, _context: McpContext): Promise<any> {
+    return this.certificateService.updatePublicAccess(args.id, args.publicAccess);
+  }
+}

package/src/certificate/certificate.module.ts

@@ -2,12 +2,13 @@ import { PrismaModule } from '@hed-hog/api-prisma';
 import { FileModule } from '@hed-hog/core';
 import { forwardRef, Module } from '@nestjs/common';
 import { LmsCertificateController } from './certificate.controller';
+import { LmsCertificateMcpTools } from './certificate.mcp-tools';
 import { LmsCertificateService } from './certificate.service';
 
 @Module({
   imports: [forwardRef(() => PrismaModule), forwardRef(() => FileModule)],
   controllers: [LmsCertificateController],
-  providers: [LmsCertificateService],
+  providers: [LmsCertificateService, LmsCertificateMcpTools],
   exports: [forwardRef(() => LmsCertificateService)],
 })
 export class LmsCertificateModule {}

package/src/certificate/certificate.service.ts

@@ -1,9 +1,11 @@
 import { PrismaService } from '@hed-hog/api-prisma';
-import { FileService } from '@hed-hog/core';
+import { FileService, IntegrationDeveloperApiService } from '@hed-hog/core';
 import {
-    BadRequestException,
-    Injectable,
-    NotFoundException,
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+  forwardRef,
 } from '@nestjs/common';
 import { CreateCertificateTemplateDto } from './dto/create-certificate-template.dto';
 import { UpdateCertificateTemplateDto } from './dto/update-certificate-template.dto';
@@ -30,6 +32,8 @@ export class LmsCertificateService {
   constructor(
     private readonly prisma: PrismaService,
     private readonly fileService: FileService,
+    @Inject(forwardRef(() => IntegrationDeveloperApiService))
+    private readonly integrationApi: IntegrationDeveloperApiService,
   ) {}
 
   async uploadTemplateBackgroundImage(file: any) {
@@ -119,6 +123,14 @@ export class LmsCertificateService {
       data: payload as any,
     });
 
+    await this.integrationApi.publishEvent({
+      eventName: 'lms.certificate_template.created',
+      sourceModule: 'lms',
+      aggregateType: 'certificate_template',
+      aggregateId: String(template.id),
+      payload: { id: template.id, name: template.name, status: template.status },
+    }).catch(() => null);
+
     return this.mapTemplate(template);
   }
 
@@ -132,6 +144,14 @@ export class LmsCertificateService {
       data: payload,
     });
 
+    await this.integrationApi.publishEvent({
+      eventName: 'lms.certificate_template.updated',
+      sourceModule: 'lms',
+      aggregateType: 'certificate_template',
+      aggregateId: String(id),
+      payload: { id, name: (dto as any).name, status: (dto as any).status },
+    }).catch(() => null);
+
     return this.mapTemplate(template);
   }
 
@@ -146,6 +166,14 @@ export class LmsCertificateService {
       throw new BadRequestException('Certificate template cannot be removed');
     }
 
+    await this.integrationApi.publishEvent({
+      eventName: 'lms.certificate_template.deleted',
+      sourceModule: 'lms',
+      aggregateType: 'certificate_template',
+      aggregateId: String(id),
+      payload: { id },
+    }).catch(() => null);
+
     return { success: true };
   }
 
@@ -251,6 +279,7 @@ export class LmsCertificateService {
       finalScore: certificate.final_score,
       verificationCode: certificate.verification_code,
       verificationUrl: certificate.verification_url,
+      publicAccess: Boolean(certificate.public_access),
       pdfUrl: certificate.pdf_url,
       sourceTitle:
         certificate.course_class_group?.title ??
@@ -265,6 +294,58 @@ export class LmsCertificateService {
     };
   }
 
+    async updatePublicAccess(certificateId: number, publicAccess: boolean) {
+      await this.ensureCertificateExists(certificateId);
+
+      const certificate = await this.prisma.certificate.update({
+        where: { id: certificateId },
+        data: { public_access: publicAccess },
+        include: {
+          certificate_template: {
+            select: {
+              id: true,
+              name: true,
+              status: 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,
+            },
+          },
+        },
+      });
+
+      return this.mapIssuedCertificate(certificate);
+    }
+
   private mapTemplate(template: any) {
     return {
       id: template.id,
@@ -391,6 +472,16 @@ export class LmsCertificateService {
     }
   }
 
+  private async ensureCertificateExists(id: number) {
+    const count = await this.prisma.certificate.count({
+      where: { id },
+    });
+
+    if (!count) {
+      throw new NotFoundException('Issued certificate not found');
+    }
+  }
+
   private normalizeType(value?: string) {
     if (!value || value === 'all') {
       return undefined;

package/src/certificate/dto/update-certificate-public-access.dto.ts

@@ -0,0 +1,6 @@
+import { IsBoolean } from 'class-validator';
+
+export class UpdateCertificatePublicAccessDto {
+  @IsBoolean()
+  publicAccess: boolean;
+}