@hed-hog/lms 0.0.304 → 0.0.306

package/src/certificate/certificate.service.ts

@@ -0,0 +1,413 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { FileService } from '@hed-hog/core';
+import {
+    BadRequestException,
+    Injectable,
+    NotFoundException,
+} from '@nestjs/common';
+import { CreateCertificateTemplateDto } from './dto/create-certificate-template.dto';
+import { UpdateCertificateTemplateDto } from './dto/update-certificate-template.dto';
+
+type CertificateTemplateStatus = 'draft' | 'active' | 'inactive';
+type CertificateType = 'course' | 'exam' | 'course_class_group' | 'learning_path';
+
+type ListIssuedCertificatesParams = {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  type?: string;
+};
+
+type ListCertificateTemplatesParams = {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  status?: string;
+};
+
+@Injectable()
+export class LmsCertificateService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly fileService: FileService,
+  ) {}
+
+  async uploadTemplateBackgroundImage(file: any) {
+    if (!file) {
+      throw new BadRequestException('Background image file is required');
+    }
+
+    if (!String(file.mimetype || '').startsWith('image/')) {
+      throw new BadRequestException('Only image files are allowed');
+    }
+
+    const uploaded = await this.fileService.upload(
+      'lms/certificates/templates/backgrounds',
+      file,
+    );
+
+    return {
+      id: uploaded.id,
+      filename: uploaded.filename,
+      // Expose an HTTP-openable URL so admin can render immediately.
+      url: `/file/open/${uploaded.id}`,
+      storagePath: uploaded.path,
+      size: uploaded.size,
+      mimetypeId: uploaded.mimetype_id,
+    };
+  }
+
+  async listTemplates(params: ListCertificateTemplatesParams) {
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 12, 1);
+    const skip = (page - 1) * pageSize;
+
+    const where: Record<string, any> = {};
+
+    if (params.search?.trim()) {
+      const search = params.search.trim();
+      where.OR = [
+        { name: { contains: search, mode: 'insensitive' } },
+        { slug: { contains: search, mode: 'insensitive' } },
+        { description: { contains: search, mode: 'insensitive' } },
+      ];
+    }
+
+    const status = this.normalizeTemplateStatus(params.status);
+    if (status) {
+      where.status = status;
+    }
+
+    const [templates, total] = await Promise.all([
+      this.prisma.certificate_template.findMany({
+        skip,
+        take: pageSize,
+        where,
+        orderBy: [{ updated_at: 'desc' }, { id: 'desc' }],
+      }),
+      this.prisma.certificate_template.count({ where }),
+    ]);
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: templates.map((template) => this.mapTemplate(template)),
+    };
+  }
+
+  async getTemplateById(id: number) {
+    const template = await this.prisma.certificate_template.findUnique({
+      where: { id },
+    });
+
+    if (!template) {
+      throw new NotFoundException('Certificate template not found');
+    }
+
+    return this.mapTemplate(template);
+  }
+
+  async createTemplate(dto: CreateCertificateTemplateDto) {
+    const payload = this.prepareTemplatePayload(
+      dto
+    ) as Record<string, any>;
+    payload.slug = await this.resolveUniqueTemplateSlug(payload.slug || payload.name);
+
+    const template = await this.prisma.certificate_template.create({
+      data: payload as any,
+    });
+
+    return this.mapTemplate(template);
+  }
+
+  async updateTemplate(id: number, dto: UpdateCertificateTemplateDto) {
+    await this.ensureTemplateExists(id);
+
+    const payload = this.prepareTemplatePayload(dto, true);
+
+    const template = await this.prisma.certificate_template.update({
+      where: { id },
+      data: payload,
+    });
+
+    return this.mapTemplate(template);
+  }
+
+  async deleteTemplate(id: number) {
+    await this.ensureTemplateExists(id);
+
+    try {
+      await this.prisma.certificate_template.delete({
+        where: { id },
+      });
+    } catch {
+      throw new BadRequestException('Certificate template cannot be removed');
+    }
+
+    return { success: true };
+  }
+
+  async listIssued(params: ListIssuedCertificatesParams) {
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 12, 1);
+    const skip = (page - 1) * pageSize;
+
+    const where: Record<string, any> = {};
+    const type = this.normalizeType(params.type);
+
+    if (type) {
+      where.certificate_type = type;
+    }
+
+    if (params.search?.trim()) {
+      const search = params.search.trim();
+      where.OR = [
+        { student_name: { contains: search, mode: 'insensitive' } },
+        { course_name: { contains: search, mode: 'insensitive' } },
+        { verification_code: { contains: search, mode: 'insensitive' } },
+        {
+          certificate_template: {
+            name: { contains: search, mode: 'insensitive' },
+          },
+        },
+      ];
+    }
+
+    const [certificates, total] = await Promise.all([
+      this.prisma.certificate.findMany({
+        skip,
+        take: pageSize,
+        where,
+        orderBy: [{ issued_at: 'desc' }, { id: 'desc' }],
+        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,
+            },
+          },
+        },
+      }),
+      this.prisma.certificate.count({ where }),
+    ]);
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: certificates.map((certificate) => this.mapIssuedCertificate(certificate)),
+    };
+  }
+
+  private mapIssuedCertificate(certificate: any) {
+    return {
+      id: certificate.id,
+      studentId: certificate.student_id,
+      studentName: certificate.person?.name ?? certificate.student_name,
+      courseName: certificate.course?.title ?? certificate.course_name,
+      templateId: certificate.certificate_template_id,
+      templateName: certificate.certificate_template?.name ?? '',
+      templateStatus: certificate.certificate_template?.status ?? null,
+      certificateType: certificate.certificate_type,
+      workloadHours: certificate.workload_hours ?? 0,
+      issuedAt: certificate.issued_at,
+      completedAt: certificate.completed_at,
+      finalScore: certificate.final_score,
+      verificationCode: certificate.verification_code,
+      verificationUrl: certificate.verification_url,
+      pdfUrl: certificate.pdf_url,
+      sourceTitle:
+        certificate.course_class_group?.title ??
+        certificate.learning_path?.title ??
+        certificate.exam?.title ??
+        certificate.course?.title ??
+        certificate.course_name,
+      primaryColor:
+        certificate.course?.primary_color ??
+        certificate.learning_path?.primary_color ??
+        null,
+    };
+  }
+
+  private mapTemplate(template: any) {
+    return {
+      id: template.id,
+      name: template.name,
+      slug: template.slug,
+      description: template.description,
+      templateContent: template.template_content,
+      status: template.status,
+      createdAt: template.created_at,
+      updatedAt: template.updated_at,
+    };
+  }
+
+  private normalizeTemplateStatus(value?: string) {
+    if (!value || value === 'all') {
+      return undefined;
+    }
+
+    const normalized = value.trim().toLowerCase();
+    const allowed: CertificateTemplateStatus[] = [
+      'draft',
+      'active',
+      'inactive',
+    ];
+
+    if (!allowed.includes(normalized as CertificateTemplateStatus)) {
+      throw new BadRequestException('Invalid template status');
+    }
+
+    return normalized as CertificateTemplateStatus;
+  }
+
+  private prepareTemplatePayload(
+    dto: CreateCertificateTemplateDto | UpdateCertificateTemplateDto,
+    partial = false,
+  ) {
+    const payload: Record<string, any> = {
+      name: dto.name?.trim() ?? '',
+      slug: dto.slug?.trim() ?? '',
+      description: dto.description?.trim() || null,
+      template_content: dto.templateContent ?? '',
+      status: (dto.status as CertificateTemplateStatus) ?? 'draft',
+    };
+
+    if (!partial) {
+      this.validateTemplateContent(payload.template_content);
+      return payload;
+    }
+
+    const partialPayload: Record<string, any> = {};
+
+    if (dto.name !== undefined) {
+      partialPayload.name = dto.name.trim();
+    }
+    if (dto.slug !== undefined) {
+      partialPayload.slug = dto.slug.trim();
+    }
+    if (dto.description !== undefined) {
+      partialPayload.description = dto.description.trim() || null;
+    }
+    if (dto.templateContent !== undefined) {
+      this.validateTemplateContent(dto.templateContent);
+      partialPayload.template_content = dto.templateContent;
+    }
+    if (dto.status !== undefined) {
+      partialPayload.status = dto.status as CertificateTemplateStatus;
+    }
+
+    return partialPayload;
+  }
+
+  private validateTemplateContent(value: string) {
+    try {
+      JSON.parse(value);
+    } catch {
+      throw new BadRequestException('templateContent must be valid JSON');
+    }
+  }
+
+  private async resolveUniqueTemplateSlug(value: string) {
+    const normalizedBase = this.slugify(value) || 'template';
+    let candidate = normalizedBase;
+    let counter = 2;
+
+    while (await this.hasTemplateSlug(candidate)) {
+      const suffix = `-${counter}`;
+      const maxBaseLength = Math.max(1, 255 - suffix.length);
+      candidate = `${normalizedBase.slice(0, maxBaseLength)}${suffix}`;
+      counter += 1;
+    }
+
+    return candidate;
+  }
+
+  private async hasTemplateSlug(slug: string) {
+    const count = await this.prisma.certificate_template.count({
+      where: { slug },
+    });
+
+    return count > 0;
+  }
+
+  private slugify(value: string) {
+    const normalized = value
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, '')
+      .trim()
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-+|-+$/g, '');
+
+    return normalized.slice(0, 255);
+  }
+
+  private async ensureTemplateExists(id: number) {
+    const count = await this.prisma.certificate_template.count({
+      where: { id },
+    });
+
+    if (!count) {
+      throw new NotFoundException('Certificate template not found');
+    }
+  }
+
+  private normalizeType(value?: string) {
+    if (!value || value === 'all') {
+      return undefined;
+    }
+
+    const normalized = value.trim().toLowerCase();
+    const allowed: CertificateType[] = [
+      'course',
+      'exam',
+      'course_class_group',
+      'learning_path',
+    ];
+
+    if (!allowed.includes(normalized as CertificateType)) {
+      throw new BadRequestException('Invalid certificate type');
+    }
+
+    return normalized as CertificateType;
+  }
+}

package/src/certificate/dto/create-certificate-template.dto.ts

@@ -0,0 +1,25 @@
+import { IsEnum, IsNotEmpty, IsOptional, IsString, MaxLength } from 'class-validator';
+
+export class CreateCertificateTemplateDto {
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  name: string;
+
+  @IsString()
+  @IsOptional()
+  @MaxLength(255)
+  slug?: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  templateContent: string;
+
+  @IsEnum(['draft', 'active', 'inactive'])
+  @IsOptional()
+  status?: 'draft' | 'active' | 'inactive';
+}

package/src/certificate/dto/update-certificate-template.dto.ts

@@ -0,0 +1,6 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateCertificateTemplateDto } from './create-certificate-template.dto';
+
+export class UpdateCertificateTemplateDto extends PartialType(
+  CreateCertificateTemplateDto,
+) {}

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

@@ -0,0 +1,189 @@
+import { Role } from '@hed-hog/api';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Query,
+} from '@nestjs/common';
+import { ClassGroupService } from './class-group.service';
+import { CreateClassGroupDto } from './dto/create-class-group.dto';
+import { CreateSessionDto } from './dto/create-session.dto';
+import {
+    CreateStudentAndEnrollDto,
+    EnrollStudentDto,
+    SaveAttendanceDto,
+    UpdateStudentProfileDto,
+} from './dto/enrollment.dto';
+import { UpdateClassGroupDto } from './dto/update-class-group.dto';
+import { UpdateSessionDto } from './dto/update-session.dto';
+
+@Role()
+@Controller('lms/classes')
+export class ClassGroupController {
+  constructor(private readonly classGroupService: ClassGroupService) {}
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+    @Query('deliveryMode') deliveryMode?: string,
+    @Query('courseId') courseId?: string,
+  ) {
+    return this.classGroupService.list({
+      page: page ? Number(page) : 1,
+      pageSize: pageSize ? Number(pageSize) : 12,
+      search,
+      status,
+      deliveryMode,
+      courseId: courseId ? Number(courseId) : undefined,
+    });
+  }
+
+  @Get('stats')
+  stats() {
+    return this.classGroupService.stats();
+  }
+
+  @Get(':id')
+  getById(@Param('id', ParseIntPipe) id: number) {
+    return this.classGroupService.getById(id);
+  }
+
+  @Post()
+  create(@Body() dto: CreateClassGroupDto) {
+    return this.classGroupService.create(dto);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateClassGroupDto,
+  ) {
+    return this.classGroupService.update(id, dto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.classGroupService.remove(id);
+  }
+
+  // ── People search ───────────────────────────────────────────────────────────
+
+  @Get(':id/people/search')
+  searchPeople(
+    @Param('id', ParseIntPipe) id: number,
+    @Query('q') q?: string,
+  ) {
+    return this.classGroupService.searchPeople(q ?? '', id);
+  }
+
+  // ── Students (enrollments) ──────────────────────────────────────────────────
+
+  @Get(':id/students')
+  listStudents(
+    @Param('id', ParseIntPipe) id: number,
+    @Query('search') search?: string,
+  ) {
+    return this.classGroupService.listStudents(id, search);
+  }
+
+  @Post(':id/students')
+  enrollStudent(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: EnrollStudentDto,
+  ) {
+    return this.classGroupService.enrollStudent(id, dto.personId);
+  }
+
+  @Post(':id/students/create')
+  createAndEnrollStudent(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: CreateStudentAndEnrollDto,
+  ) {
+    return this.classGroupService.createAndEnrollStudent(id, dto);
+  }
+
+  @Get(':id/students/:personId')
+  getStudentProfile(
+    @Param('id', ParseIntPipe) id: number,
+    @Param('personId', ParseIntPipe) personId: number,
+  ) {
+    return this.classGroupService.getStudentProfile(id, personId);
+  }
+
+  @Patch(':id/students/:personId')
+  updateStudentProfile(
+    @Param('id', ParseIntPipe) id: number,
+    @Param('personId', ParseIntPipe) personId: number,
+    @Body() dto: UpdateStudentProfileDto,
+  ) {
+    return this.classGroupService.updateStudentProfile(id, personId, dto);
+  }
+
+  @Delete(':id/students/:personId')
+  removeStudent(
+    @Param('id', ParseIntPipe) id: number,
+    @Param('personId', ParseIntPipe) personId: number,
+  ) {
+    return this.classGroupService.removeStudent(id, personId);
+  }
+
+  // ── Sessions ────────────────────────────────────────────────────────────────
+
+  @Get(':id/sessions')
+  listSessions(@Param('id', ParseIntPipe) id: number) {
+    return this.classGroupService.listSessions(id);
+  }
+
+  @Post(':id/sessions')
+  createSession(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: CreateSessionDto,
+  ) {
+    return this.classGroupService.createSession(id, dto);
+  }
+
+  @Patch(':id/sessions/:sessionId')
+  updateSession(
+    @Param('id', ParseIntPipe) id: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+    @Body() dto: UpdateSessionDto,
+  ) {
+    return this.classGroupService.updateSession(id, sessionId, dto);
+  }
+
+  @Delete(':id/sessions/:sessionId')
+  deleteSession(
+    @Param('id', ParseIntPipe) id: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+    @Query('scope') scope?: 'single' | 'series',
+  ) {
+    return this.classGroupService.deleteSession(id, sessionId, scope);
+  }
+
+  // ── Attendance ──────────────────────────────────────────────────────────────
+
+  @Get(':id/sessions/:sessionId/attendance')
+  getAttendance(
+    @Param('id', ParseIntPipe) id: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+  ) {
+    return this.classGroupService.getAttendance(id, sessionId);
+  }
+
+  @Post(':id/sessions/:sessionId/attendance')
+  saveAttendance(
+    @Param('id', ParseIntPipe) id: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+    @Body() dto: SaveAttendanceDto,
+  ) {
+    return this.classGroupService.saveAttendance(id, sessionId, dto.attendance);
+  }
+}

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

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