@hed-hog/lms 0.0.349 → 0.0.351

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,
+    Inject,
     Injectable,
     NotFoundException,
+    forwardRef,
 } from '@nestjs/common';
 import { CreateCertificateTemplateDto } from './dto/create-certificate-template.dto';
 import { UpdateCertificateTemplateDto } from './dto/update-certificate-template.dto';
@@ -25,11 +27,20 @@ type ListCertificateTemplatesParams = {
   status?: string;
 };
 
+type TemplateLike = {
+  objects?: Array<{
+    type?: string;
+    image?: { file_id?: number | null };
+  }>;
+};
+
 @Injectable()
 export class LmsCertificateService {
   constructor(
     private readonly prisma: PrismaService,
     private readonly fileService: FileService,
+    @Inject(forwardRef(() => IntegrationDeveloperApiService))
+    private readonly integrationApi: IntegrationDeveloperApiService,
   ) {}
 
   async uploadTemplateBackgroundImage(file: any) {
@@ -119,24 +130,60 @@ 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);
   }
 
-  async updateTemplate(id: number, dto: UpdateCertificateTemplateDto) {
-    await this.ensureTemplateExists(id);
+  async updateTemplate(
+    id: number,
+    dto: UpdateCertificateTemplateDto,
+    locale?: string,
+  ) {
+    const existingTemplate = await this.ensureTemplateExists(id);
 
     const payload = this.prepareTemplatePayload(dto, true);
 
+    const previousFileIds = this.extractTemplateImageFileIds(
+      existingTemplate.template_content,
+    );
+    const nextFileIds =
+      payload.template_content !== undefined
+        ? this.extractTemplateImageFileIds(payload.template_content)
+        : previousFileIds;
+    const removedFileIds = previousFileIds.filter(
+      (fileId) => !nextFileIds.includes(fileId),
+    );
+
     const template = await this.prisma.certificate_template.update({
       where: { id },
       data: payload,
     });
 
+    await this.deleteFilesIfExist(removedFileIds, locale);
+
+    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);
   }
 
-  async deleteTemplate(id: number) {
-    await this.ensureTemplateExists(id);
+  async deleteTemplate(id: number, locale?: string) {
+    const existingTemplate = await this.ensureTemplateExists(id);
+    const fileIdsToDelete = this.extractTemplateImageFileIds(
+      existingTemplate.template_content,
+    );
 
     try {
       await this.prisma.certificate_template.delete({
@@ -146,6 +193,16 @@ export class LmsCertificateService {
       throw new BadRequestException('Certificate template cannot be removed');
     }
 
+    await this.deleteFilesIfExist(fileIdsToDelete, locale);
+
+    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 +308,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 +323,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,
@@ -381,14 +491,90 @@ export class LmsCertificateService {
     return normalized.slice(0, 255);
   }
 
+  private extractTemplateImageFileIds(templateContent: string): number[] {
+    try {
+      const parsed = JSON.parse(templateContent) as TemplateLike;
+      if (!Array.isArray(parsed?.objects)) {
+        return [];
+      }
+
+      const unique = new Set<number>();
+      for (const obj of parsed.objects) {
+        if (!obj || obj.type !== 'image') {
+          continue;
+        }
+
+        const fileId = obj.image?.file_id;
+        if (
+          typeof fileId === 'number' &&
+          Number.isInteger(fileId) &&
+          fileId > 0
+        ) {
+          unique.add(fileId);
+        }
+      }
+
+      return [...unique];
+    } catch {
+      return [];
+    }
+  }
+
+  private normalizeLocale(locale?: string) {
+    const value = String(locale || '').trim();
+    if (!value) {
+      return 'en';
+    }
+
+    return value.split(',')[0]?.trim() || 'en';
+  }
+
+  private async deleteFilesIfExist(fileIds: number[], locale?: string) {
+    if (!Array.isArray(fileIds) || fileIds.length === 0) {
+      return;
+    }
+
+    const existingFiles = await this.prisma.file.findMany({
+      where: {
+        id: { in: fileIds },
+      },
+      select: { id: true },
+    });
+
+    const existingIds = existingFiles.map((file) => file.id);
+    if (existingIds.length === 0) {
+      return;
+    }
+
+    await this.fileService.delete(this.normalizeLocale(locale), {
+      ids: existingIds,
+    });
+  }
+
   private async ensureTemplateExists(id: number) {
-    const count = await this.prisma.certificate_template.count({
+    const template = await this.prisma.certificate_template.findUnique({
       where: { id },
+      select: {
+        id: true,
+        template_content: true,
+      },
     });
 
-    if (!count) {
+    if (!template) {
       throw new NotFoundException('Certificate template not found');
     }
+
+    return template;
+  }
+
+  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) {

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;
+}