@hed-hog/lms 0.0.331 → 0.0.338

package/src/enterprise/training/training-admin.service.ts

@@ -1,4 +1,4 @@
-import { PrismaService } from '@hed-hog/api-prisma';
+import { Prisma, PrismaService } from '@hed-hog/api-prisma';
 import {
     BadRequestException,
     ConflictException,
@@ -11,6 +11,30 @@ import {
 export class TrainingAdminService {
   constructor(private readonly prisma: PrismaService) {}
 
+  private async recordLicenseEvent(params: {
+    enterpriseId: number;
+    personId: number;
+    eventType: 'assigned' | 'revoked' | 'status_changed';
+    previousStatus?: string | null;
+    nextStatus?: string | null;
+  }) {
+    const eventModel = (this.prisma as any).enterprise_student_license_event;
+    if (!eventModel) return;
+    try {
+      await eventModel.create({
+        data: {
+          enterprise_id: params.enterpriseId,
+          person_id: params.personId,
+          event_type: params.eventType,
+          previous_status: params.previousStatus ?? null,
+          next_status: params.nextStatus ?? null,
+        },
+      });
+    } catch {
+      // Keep license operations working until the YAML table is applied.
+    }
+  }
+
   async getDashboard(userId: number, requestedEnterpriseId?: number) {
     if (requestedEnterpriseId !== undefined) {
       const allowed = await this.prisma.enterprise_user.findFirst({
@@ -311,6 +335,8 @@ export class TrainingAdminService {
     userId: number,
     options: {
       enterpriseId?: number;
+      page?: number;
+      pageSize?: number;
       search?: string;
       status?: string;
       deliveryMode?: string;
@@ -340,62 +366,71 @@ export class TrainingAdminService {
     }
 
     const enterpriseId = enterpriseUser.enterprise_id;
-    const { search, status, deliveryMode, instructorId } = options;
+    const { page = 1, pageSize = 10, search, status, deliveryMode, instructorId } = options;
     const now = new Date();
 
-    const classGroups = await this.prisma.course_class_group.findMany({
-      where: {
-        AND: [
-          { enterprise_class_group: { some: { enterprise_id: enterpriseId } } },
-          ...(status ? [{ status: status as any }] : []),
-          ...(deliveryMode ? [{ delivery_mode: deliveryMode as any }] : []),
-          ...(instructorId !== undefined ? [{ instructor_id: instructorId }] : []),
-          ...(search
-            ? [
-                {
-                  OR: [
-                    { title: { contains: search, mode: 'insensitive' as const } },
-                    { code: { contains: search, mode: 'insensitive' as const } },
-                    { course: { title: { contains: search, mode: 'insensitive' as const } } },
-                  ],
-                },
-              ]
-            : []),
-        ],
-      },
-      orderBy: { start_date: 'desc' },
-      include: {
-        course: {
-          select: {
-            id: true,
-            title: true,
-            course_image: {
-              where: { image_type: { slug: { in: ['course-logo', 'course-banner'] } } },
-              orderBy: { is_primary: 'desc' as const },
-              select: {
-                file: { select: { location: true } },
-                image_type: { select: { slug: true } },
+    const where = {
+      AND: [
+        { enterprise_class_group: { some: { enterprise_id: enterpriseId } } },
+        ...(status ? [{ status: status as any }] : []),
+        ...(deliveryMode ? [{ delivery_mode: deliveryMode as any }] : []),
+        ...(instructorId !== undefined ? [{ instructor_id: instructorId }] : []),
+        ...(search
+          ? [
+              {
+                OR: [
+                  { title: { contains: search, mode: 'insensitive' as const } },
+                  { code: { contains: search, mode: 'insensitive' as const } },
+                  { course: { title: { contains: search, mode: 'insensitive' as const } } },
+                ],
               },
+            ]
+          : []),
+      ],
+    };
+
+    const include = Prisma.validator<Prisma.course_class_groupInclude>()({
+      course: {
+        select: {
+          id: true,
+          title: true,
+          course_image: {
+            where: { image_type: { slug: { in: ['course-logo', 'course-banner'] } } },
+            orderBy: { is_primary: 'desc' as const },
+            select: {
+              file: { select: { location: true } },
+              image_type: { select: { slug: true } },
             },
           },
         },
-        instructor: {
-          include: { person: { select: { name: true } } },
-        },
-        _count: {
-          select: {
-            course_enrollment: { where: { status: { not: 'cancelled' } } },
-          },
+      },
+      instructor: {
+        include: { person: { select: { name: true } } },
+      },
+      _count: {
+        select: {
+          course_enrollment: { where: { status: { not: 'cancelled' } } },
         },
-        course_class_session: {
-          where: { session_date: { gte: now } },
-          orderBy: { session_date: 'asc' },
-          take: 1,
+      },
+      course_class_session: {
+        where: { session_date: { gte: now } },
+        orderBy: { session_date: 'asc' as const },
+        take: 1,
           select: { session_date: true, start_time: true, location: true },
-        },
       },
     });
 
+    const [classGroups, total] = await this.prisma.$transaction([
+      this.prisma.course_class_group.findMany({
+        where,
+        orderBy: { start_date: 'desc' },
+        include,
+        skip: (page - 1) * pageSize,
+        take: pageSize,
+      }),
+      this.prisma.course_class_group.count({ where }),
+    ]);
+
     const cgIds = classGroups.map((cg) => cg.id);
 
     const completedCounts =
@@ -453,7 +488,7 @@ export class TrainingAdminService {
       };
     });
 
-    return { data, total: data.length };
+    return { data, total, page, pageSize, lastPage: Math.ceil(total / pageSize) };
   }
 
   // ── Class-group detail endpoints ─────────────────────────────────────────────
@@ -830,17 +865,32 @@ export class TrainingAdminService {
       if (existingStudent.status !== 'inactive') {
         throw new ConflictException('This person already has an active license');
       }
-      return this.prisma.enterprise_student.update({
+      const updated = await this.prisma.enterprise_student.update({
         where: { id: existingStudent.id },
         data: { status: 'active' },
         select: { id: true, person_id: true, status: true, created_at: true },
       });
+      await this.recordLicenseEvent({
+        enterpriseId,
+        personId,
+        eventType: 'status_changed',
+        previousStatus: existingStudent.status,
+        nextStatus: 'active',
+      });
+      return updated;
     }
 
-    return this.prisma.enterprise_student.create({
+    const createdStudent = await this.prisma.enterprise_student.create({
       data: { enterprise_id: enterpriseId, person_id: personId, status: 'pending' },
       select: { id: true, person_id: true, status: true, created_at: true },
     });
+    await this.recordLicenseEvent({
+      enterpriseId,
+      personId,
+      eventType: 'assigned',
+      nextStatus: 'pending',
+    });
+    return createdStudent;
   }
 
   async revokeLicense(userId: number, personId: number) {
@@ -852,15 +902,23 @@ export class TrainingAdminService {
 
     const existing = await this.prisma.enterprise_student.findFirst({
       where: { enterprise_id: enterpriseUser.enterprise_id, person_id: personId },
-      select: { id: true },
+      select: { id: true, status: true },
     });
     if (!existing) throw new NotFoundException('Student not found in your enterprise');
 
-    return this.prisma.enterprise_student.update({
+    const updated = await this.prisma.enterprise_student.update({
       where: { id: existing.id },
       data: { status: 'inactive' },
       select: { id: true },
     });
+    await this.recordLicenseEvent({
+      enterpriseId: enterpriseUser.enterprise_id,
+      personId,
+      eventType: 'revoked',
+      previousStatus: existing.status,
+      nextStatus: 'inactive',
+    });
+    return updated;
   }
 
   // ── Enrollment methods ────────────────────────────────────────────────────────
@@ -1078,6 +1136,12 @@ export class TrainingAdminService {
         },
         select: { id: true },
       });
+      await this.recordLicenseEvent({
+        enterpriseId,
+        personId,
+        eventType: 'assigned',
+        nextStatus: 'active',
+      });
     }
 
     const existingEnrollment = await this.prisma.course_enrollment.findFirst({

package/src/instructor/dto/create-instructor-skill.dto.ts

@@ -5,23 +5,6 @@ export class CreateInstructorSkillDto {
   @MaxLength(255)
   slug: string;
 
-  @IsString()
-  @MaxLength(255)
-  namePt: string;
-
-  @IsOptional()
-  @IsString()
-  @MaxLength(255)
-  nameEn?: string;
-
-  @IsOptional()
-  @IsString()
-  descriptionPt?: string;
-
-  @IsOptional()
-  @IsString()
-  descriptionEn?: string;
-
   @IsOptional()
   @IsEnum(['active', 'inactive'])
   status?: 'active' | 'inactive';

package/src/instructor/dto/update-instructor-skill.dto.ts

@@ -6,24 +6,6 @@ export class UpdateInstructorSkillDto {
   @MaxLength(255)
   slug?: string;
 
-  @IsOptional()
-  @IsString()
-  @MaxLength(255)
-  namePt?: string;
-
-  @IsOptional()
-  @IsString()
-  @MaxLength(255)
-  nameEn?: string;
-
-  @IsOptional()
-  @IsString()
-  descriptionPt?: string;
-
-  @IsOptional()
-  @IsString()
-  descriptionEn?: string;
-
   @IsOptional()
   @IsEnum(['active', 'inactive'])
   status?: 'active' | 'inactive';

package/src/instructor/instructor-skill.service.ts

@@ -11,10 +11,6 @@ export class InstructorSkillService {
     return (this.prisma as any).instructor_skill;
   }
 
-  private get localeClient() {
-    return (this.prisma as any).instructor_skill_locale;
-  }
-
   async list(params: { page?: number; pageSize?: number; search?: string }) {
     const page = Math.max(Number(params.page) || 1, 1);
     const pageSize = Math.max(Number(params.pageSize) || 20, 1);
@@ -24,14 +20,7 @@ export class InstructorSkillService {
     const where: any = {};
 
     if (search) {
-      where.OR = [
-        { slug: { contains: search, mode: 'insensitive' } },
-        {
-          instructor_skill_locale: {
-            some: { name: { contains: search, mode: 'insensitive' } },
-          },
-        },
-      ];
+      where.slug = { contains: search, mode: 'insensitive' };
     }
 
     const [rows, total] = await Promise.all([
@@ -39,11 +28,6 @@ export class InstructorSkillService {
         where,
         skip,
         take: pageSize,
-        include: {
-          instructor_skill_locale: {
-            select: { locale_id: true, name: true, description: true },
-          },
-        },
         orderBy: { slug: 'asc' },
       }),
       this.skillClient.count({ where }),
@@ -60,11 +44,6 @@ export class InstructorSkillService {
   async getAll() {
     const rows = await this.skillClient.findMany({
       where: { status: 'active' },
-      include: {
-        instructor_skill_locale: {
-          select: { locale_id: true, name: true },
-        },
-      },
       orderBy: { slug: 'asc' },
     });
 
@@ -79,8 +58,6 @@ export class InstructorSkillService {
       },
     });
 
-    await this.syncLocales(skill.id, dto);
-
     return this.getSkillById(skill.id);
   }
 
@@ -103,8 +80,6 @@ export class InstructorSkillService {
       await this.skillClient.update({ where: { id }, data });
     }
 
-    await this.syncLocales(id, dto);
-
     return this.getSkillById(id);
   }
 
@@ -124,11 +99,6 @@ export class InstructorSkillService {
   private async getSkillById(id: number) {
     const row = await this.skillClient.findUnique({
       where: { id },
-      include: {
-        instructor_skill_locale: {
-          select: { locale_id: true, name: true, description: true },
-        },
-      },
     });
 
     if (!row) {
@@ -143,72 +113,7 @@ export class InstructorSkillService {
       id: row.id,
       slug: row.slug,
       status: row.status,
-      locales: row.instructor_skill_locale ?? [],
-    };
-  }
-
-  private async syncLocales(
-    skillId: number,
-    dto: CreateInstructorSkillDto | UpdateInstructorSkillDto,
-  ) {
-    const localeIds = await this.resolveLocaleIds();
-
-    if (dto.namePt !== undefined && localeIds.pt !== null) {
-      const existing = await this.localeClient.findFirst({
-        where: { instructor_skill_id: skillId, locale_id: localeIds.pt },
-        select: { id: true },
-      });
-
-      if (existing) {
-        await this.localeClient.update({
-          where: { id: existing.id },
-          data: { name: dto.namePt, description: dto.descriptionPt ?? null },
-        });
-      } else {
-        await this.localeClient.create({
-          data: {
-            instructor_skill_id: skillId,
-            locale_id: localeIds.pt,
-            name: dto.namePt,
-            description: dto.descriptionPt ?? null,
-          },
-        });
-      }
-    }
-
-    if (dto.nameEn !== undefined && localeIds.en !== null) {
-      const existing = await this.localeClient.findFirst({
-        where: { instructor_skill_id: skillId, locale_id: localeIds.en },
-        select: { id: true },
-      });
-
-      if (existing) {
-        await this.localeClient.update({
-          where: { id: existing.id },
-          data: { name: dto.nameEn, description: dto.descriptionEn ?? null },
-        });
-      } else {
-        await this.localeClient.create({
-          data: {
-            instructor_skill_id: skillId,
-            locale_id: localeIds.en,
-            name: dto.nameEn,
-            description: dto.descriptionEn ?? null,
-          },
-        });
-      }
-    }
-  }
-
-  private async resolveLocaleIds() {
-    const locales = await this.prisma.locale.findMany({
-      where: { code: { in: ['pt', 'en'] } },
-      select: { id: true, code: true },
-    });
-
-    return {
-      pt: locales.find((l) => l.code === 'pt')?.id ?? null,
-      en: locales.find((l) => l.code === 'en')?.id ?? null,
+      name: row.slug,
     };
   }
 }

package/src/instructor/instructor.controller.ts

@@ -53,6 +53,22 @@ export class InstructorController {
     return this.instructorService.create(dto);
   }
 
+  @Get(':id/class-groups')
+  getInstructorClassGroups(
+    @Param('id', ParseIntPipe) id: number,
+    @Query('page', new ParseIntPipe({ optional: true })) page?: number,
+    @Query('pageSize', new ParseIntPipe({ optional: true })) pageSize?: number,
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+  ) {
+    return this.instructorService.getInstructorClassGroups(id, {
+      page,
+      pageSize,
+      search,
+      status,
+    });
+  }
+
   @Get(':id')
   getById(@Param('id', ParseIntPipe) id: number) {
     return this.instructorService.getById(id);

package/src/instructor/instructor.service.ts

@@ -146,10 +146,6 @@ export class InstructorService {
               select: {
                 id: true,
                 slug: true,
-                instructor_skill_locale: {
-                  take: 1,
-                  select: { name: true },
-                },
               },
             },
           },
@@ -170,7 +166,7 @@ export class InstructorService {
         existing.push({
           id: a.instructor_skill.id,
           slug: a.instructor_skill.slug,
-          name: a.instructor_skill.instructor_skill_locale?.[0]?.name ?? a.instructor_skill.slug,
+          name: a.instructor_skill.slug,
         });
         skillsMap.set(a.instructor_id, existing);
       }
@@ -470,10 +466,6 @@ export class InstructorService {
             select: {
               id: true,
               slug: true,
-              instructor_skill_locale: {
-                take: 1,
-                select: { name: true },
-              },
             },
           },
         },
@@ -495,7 +487,7 @@ export class InstructorService {
       .map((a) => ({
         id: a.instructor_skill.id,
         slug: a.instructor_skill.slug,
-        name: a.instructor_skill.instructor_skill_locale?.[0]?.name ?? a.instructor_skill.slug,
+        name: a.instructor_skill.slug,
       }));
 
     return {
@@ -924,4 +916,87 @@ export class InstructorService {
       });
     }
   }
+
+  async getInstructorClassGroups(
+    instructorId: number,
+    options: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      status?: string;
+    } = {},
+  ) {
+    const { page = 1, pageSize = 6, search, status } = options;
+
+    const where: Prisma.course_class_groupWhereInput = {
+      instructor_id: instructorId,
+      ...(status ? { status: status as any } : {}),
+      ...(search
+        ? {
+            OR: [
+              { title: { contains: search, mode: 'insensitive' } },
+              { code: { contains: search, mode: 'insensitive' } },
+              { course: { title: { contains: search, mode: 'insensitive' } } },
+            ],
+          }
+        : {}),
+    };
+
+    const [classGroups, total] = await this.prisma.$transaction([
+      this.prisma.course_class_group.findMany({
+        where,
+        orderBy: { start_date: 'desc' },
+        include: {
+          course: {
+            select: {
+              id: true,
+              title: true,
+              course_image: {
+                where: {
+                  image_type: { slug: { in: ['course-logo', 'course-banner'] } },
+                },
+                orderBy: { is_primary: 'desc' },
+                select: {
+                  file: { select: { id: true, location: true } },
+                  image_type: { select: { slug: true } },
+                },
+              },
+            },
+          },
+          _count: {
+            select: {
+              course_enrollment: { where: { status: { not: 'cancelled' } } },
+            },
+          },
+        },
+        skip: (page - 1) * pageSize,
+        take: pageSize,
+      }),
+      this.prisma.course_class_group.count({ where }),
+    ]);
+
+    const data = classGroups.map((cg) => {
+      const preferredImage =
+        cg.course?.course_image.find(
+          (ci) => ci.image_type?.slug === 'course-logo',
+        ) ?? cg.course?.course_image[0];
+
+      return {
+        id: cg.id,
+        name: cg.title,
+        code: cg.code ?? '',
+        courseId: cg.course?.id ?? null,
+        courseName: cg.course?.title ?? null,
+        courseLogoFileId: preferredImage?.file?.id ?? null,
+        courseLogoUrl: preferredImage?.file?.location ?? null,
+        startDate: cg.start_date,
+        endDate: cg.end_date ?? null,
+        slots: cg._count.course_enrollment,
+        totalSlots: cg.capacity ?? null,
+        status: cg.status,
+      };
+    });
+
+    return { data, total, page, pageSize, lastPage: Math.ceil(total / pageSize) };
+  }
 }

package/src/lms.module.ts

@@ -32,6 +32,7 @@ import { TrainingModule } from './training/training.module';
     forwardRef(() => InstructorModule),
     forwardRef(() => LmsReportsModule),
     forwardRef(() => TrainingModule),
+    
   ],
   exports: [
     forwardRef(() => ClassGroupModule),