@hed-hog/lms 0.0.304 → 0.0.306

package/src/instructor/instructor.service.ts

@@ -0,0 +1,646 @@
+import { Prisma, PrismaService } from '@hed-hog/api-prisma';
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { CreateInstructorDto } from './dto/create-instructor.dto';
+import { UpdateInstructorDto } from './dto/update-instructor.dto';
+
+type DbClient = PrismaService | Prisma.TransactionClient;
+
+const DEFAULT_QUALIFICATION_SLUGS = ['course-lessons', 'class-sessions'] as const;
+
+@Injectable()
+export class InstructorService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async list(params: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    status?: string;
+    qualificationSlugs?: string[];
+  }) {
+    await this.ensureQualificationCatalog();
+    await this.backfillLegacyCourseLessonQualifications();
+
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 20, 1);
+    const skip = (page - 1) * pageSize;
+    const qualificationSlugs = this.normalizeQualificationSlugs(
+      params.qualificationSlugs,
+    );
+    const search = params.search?.trim();
+
+    const where: Prisma.instructorWhereInput = {};
+
+    if (params.status && params.status !== 'all') {
+      where.status =
+        params.status === 'inactive' ? 'inactive' : ('active' as any);
+    }
+
+    if (search) {
+      where.person = {
+        is: {
+          OR: [
+            {
+              name: {
+                contains: search,
+                mode: 'insensitive',
+              },
+            },
+            {
+              contact: {
+                some: {
+                  value: {
+                    contains: search,
+                    mode: 'insensitive',
+                  },
+                },
+              },
+            },
+          ],
+        },
+      };
+    }
+
+    if (qualificationSlugs.length > 0) {
+      where.instructor_qualification_assignment = {
+        some: {
+          instructor_qualification: {
+            slug: {
+              in: qualificationSlugs,
+            },
+            status: 'active',
+          },
+        },
+      };
+    }
+
+    const [rows, total] = await Promise.all([
+      this.prisma.instructor.findMany({
+        where,
+        skip,
+        take: pageSize,
+        include: {
+          person: {
+            select: {
+              id: true,
+              name: true,
+              avatar_id: true,
+            },
+          },
+          instructor_qualification_assignment: {
+            include: {
+              instructor_qualification: {
+                select: {
+                  slug: true,
+                },
+              },
+            },
+          },
+        },
+        orderBy: {
+          id: 'asc',
+        },
+      }),
+      this.prisma.instructor.count({ where }),
+    ]);
+
+    return {
+      data: rows
+        .map((row) => ({
+          id: row.id,
+          personId: row.person_id,
+          name: row.person?.name?.trim() || `Instructor #${row.id}`,
+          avatarId: row.person?.avatar_id ?? null,
+          status: row.status,
+          qualificationSlugs: row.instructor_qualification_assignment
+            .map((assignment) => assignment.instructor_qualification.slug)
+            .sort(),
+        }))
+        .sort((left, right) => left.name.localeCompare(right.name)),
+      total,
+      page,
+      pageSize,
+    };
+  }
+
+  async create(dto: CreateInstructorDto) {
+    return this.prisma.$transaction(async (tx) => {
+      await this.ensureQualificationCatalog(tx);
+      await this.backfillLegacyCourseLessonQualifications(tx);
+
+      const normalizedEmail = this.normalizeEmail(dto.email);
+      const name = dto.name.trim();
+      const phone = this.normalizePhone(dto.phone);
+      const requestedPersonId =
+        typeof dto.personId === 'number' && dto.personId > 0 ? dto.personId : null;
+
+      const existingPersonId =
+        requestedPersonId ??
+        (normalizedEmail
+          ? await this.findPersonIdByEmail(tx, normalizedEmail)
+          : null);
+
+      const person = existingPersonId
+        ? await tx.person.findUnique({
+            where: { id: existingPersonId },
+            select: { id: true, name: true, avatar_id: true },
+          })
+        : await tx.person.create({
+            data: {
+              name,
+              type: 'individual',
+              status: 'active',
+              avatar_id: dto.avatarId ?? null,
+            },
+            select: { id: true, name: true, avatar_id: true },
+          });
+
+      if (!person) {
+        throw new BadRequestException('Unable to resolve instructor person');
+      }
+
+      if (existingPersonId && dto.avatarId !== undefined) {
+        await tx.person.update({
+          where: { id: person.id },
+          data: {
+            avatar_id: dto.avatarId,
+          },
+        });
+      }
+
+      await this.syncPersonContacts(tx, person.id, normalizedEmail, phone);
+
+      const instructor =
+        (await tx.instructor.findFirst({
+          where: { person_id: person.id },
+          select: { id: true, person_id: true, status: true },
+        })) ??
+        (await tx.instructor.create({
+          data: {
+            person_id: person.id,
+            status: dto.status ?? 'active',
+          },
+          select: { id: true, person_id: true, status: true },
+        }));
+
+      if (instructor.status !== (dto.status ?? instructor.status)) {
+        await tx.instructor.update({
+          where: { id: instructor.id },
+          data: {
+            status: dto.status ?? instructor.status,
+          },
+        });
+      }
+
+      await this.syncInstructorQualifications(
+        tx,
+        instructor.id,
+        dto.qualificationSlugs,
+      );
+
+      return this.getById(instructor.id, tx);
+    });
+  }
+
+  async update(id: number, dto: UpdateInstructorDto) {
+    return this.prisma.$transaction(async (tx) => {
+      await this.ensureQualificationCatalog(tx);
+      await this.backfillLegacyCourseLessonQualifications(tx);
+
+      const instructor = await tx.instructor.findUnique({
+        where: { id },
+        include: {
+          person: {
+            select: {
+              id: true,
+              avatar_id: true,
+            },
+          },
+        },
+      });
+
+      if (!instructor?.person) {
+        throw new NotFoundException('Instructor not found');
+      }
+
+      if (dto.name?.trim()) {
+        await tx.person.update({
+          where: { id: instructor.person.id },
+          data: {
+            name: dto.name.trim(),
+          },
+        });
+      }
+
+      await this.syncPersonContacts(
+        tx,
+        instructor.person.id,
+        this.normalizeEmail(dto.email),
+        this.normalizePhone(dto.phone),
+      );
+
+      if (dto.avatarId !== undefined) {
+        await tx.person.update({
+          where: { id: instructor.person.id },
+          data: {
+            avatar_id: dto.avatarId,
+          },
+        });
+      }
+
+      if (dto.status) {
+        await tx.instructor.update({
+          where: { id },
+          data: {
+            status: dto.status,
+          },
+        });
+      }
+
+      if (dto.qualificationSlugs) {
+        await this.syncInstructorQualifications(
+          tx,
+          id,
+          dto.qualificationSlugs,
+        );
+      }
+
+      return this.getById(id, tx);
+    });
+  }
+
+  async getById(id: number, db: DbClient = this.prisma) {
+    await this.ensureQualificationCatalog(db);
+    await this.backfillLegacyCourseLessonQualifications(db);
+
+    const instructor = await db.instructor.findUnique({
+      where: { id },
+      include: {
+        person: {
+          include: {
+            contact: {
+              where: {
+                contact_type: {
+                  code: {
+                    in: ['EMAIL', 'PHONE', 'MOBILE', 'WHATSAPP'],
+                  },
+                },
+              },
+              include: {
+                contact_type: {
+                  select: {
+                    code: true,
+                  },
+                },
+              },
+              orderBy: [{ is_primary: 'desc' }, { id: 'asc' }],
+            },
+          },
+        },
+        instructor_qualification_assignment: {
+          include: {
+            instructor_qualification: {
+              select: {
+                slug: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!instructor?.person) {
+      throw new NotFoundException('Instructor not found');
+    }
+
+    return {
+      id: instructor.id,
+      personId: instructor.person.id,
+      name: instructor.person.name?.trim() || `Instructor #${instructor.id}`,
+      avatarId: instructor.person.avatar_id ?? null,
+      email: this.getPrimaryContactValue(instructor.person.contact, ['EMAIL']),
+      phone: this.getPrimaryContactValue(instructor.person.contact, [
+        'PHONE',
+        'MOBILE',
+        'WHATSAPP',
+      ]),
+      status: instructor.status,
+      qualificationSlugs: instructor.instructor_qualification_assignment
+        .map((assignment) => assignment.instructor_qualification.slug)
+        .sort(),
+    };
+  }
+
+  async listQualifiedInstructorOptions(qualificationSlugs: string[]) {
+    const result = await this.list({
+      page: 1,
+      pageSize: 500,
+      status: 'active',
+      qualificationSlugs,
+    });
+
+    return result.data;
+  }
+
+  async assertQualifiedInstructorIds(
+    instructorIds: number[],
+    qualificationSlugs: string[],
+  ) {
+    const uniqueIds = [...new Set(instructorIds.filter((id) => Number(id) > 0))];
+    if (uniqueIds.length === 0) return;
+
+    const qualifiedSet = new Set(
+      (
+        await this.prisma.instructor.findMany({
+          where: {
+            id: { in: uniqueIds },
+            status: 'active',
+            instructor_qualification_assignment: {
+              some: {
+                instructor_qualification: {
+                  slug: {
+                    in: this.normalizeQualificationSlugs(qualificationSlugs),
+                  },
+                  status: 'active',
+                },
+              },
+            },
+          },
+          select: { id: true },
+        })
+      ).map((item) => item.id),
+    );
+
+    if (uniqueIds.some((id) => !qualifiedSet.has(id))) {
+      throw new BadRequestException('One or more instructors are invalid');
+    }
+  }
+
+  private normalizeQualificationSlugs(value?: string[]) {
+    return [...new Set((value ?? []).map((item) => item?.trim()).filter(Boolean))];
+  }
+
+  private normalizeEmail(value?: string) {
+    const normalized = value?.trim().toLowerCase();
+    return normalized ? normalized : null;
+  }
+
+  private normalizePhone(value?: string) {
+    const normalized = value?.trim();
+    return normalized ? normalized : null;
+  }
+
+  private getPrimaryContactValue(
+    contacts: Array<{
+      value?: string | null;
+      is_primary?: boolean | null;
+      contact_type?: { code?: string | null } | null;
+    }>,
+    acceptedCodes: string[],
+  ) {
+    const normalizedCodes = acceptedCodes.map((code) => code.toUpperCase());
+
+    const primaryMatch = contacts.find(
+      (contact) =>
+        normalizedCodes.includes(
+          String(contact.contact_type?.code || '').toUpperCase(),
+        ) && contact.is_primary,
+    );
+
+    if (primaryMatch?.value) {
+      return primaryMatch.value;
+    }
+
+    const fallbackMatch = contacts.find((contact) =>
+      normalizedCodes.includes(
+        String(contact.contact_type?.code || '').toUpperCase(),
+      ),
+    );
+
+    return fallbackMatch?.value ?? null;
+  }
+
+  private async ensureQualificationCatalog(db: DbClient = this.prisma) {
+    for (const slug of DEFAULT_QUALIFICATION_SLUGS) {
+      await db.instructor_qualification.upsert({
+        where: { slug },
+        update: {
+          status: 'active',
+        },
+        create: {
+          slug,
+          status: 'active',
+        },
+      });
+    }
+  }
+
+  private async backfillLegacyCourseLessonQualifications(
+    db: DbClient = this.prisma,
+  ) {
+    await this.ensureQualificationCatalog(db);
+
+    const courseLessonQualification = await db.instructor_qualification.findUnique({
+      where: { slug: 'course-lessons' },
+      select: { id: true },
+    });
+
+    if (!courseLessonQualification) {
+      return;
+    }
+
+    const legacyInstructors = await db.instructor.findMany({
+      where: {
+        status: 'active',
+        can_teach_courses: true,
+        instructor_qualification_assignment: {
+          none: {
+            qualification_id: courseLessonQualification.id,
+          },
+        },
+      },
+      select: { id: true },
+    });
+
+    if (legacyInstructors.length > 0) {
+      await db.instructor_qualification_assignment.createMany({
+        data: legacyInstructors.map((item) => ({
+          instructor_id: item.id,
+          qualification_id: courseLessonQualification.id,
+        })),
+        skipDuplicates: true,
+      });
+    }
+  }
+
+  private async syncInstructorQualifications(
+    db: DbClient,
+    instructorId: number,
+    qualificationSlugs: string[],
+  ) {
+    const normalizedQualificationSlugs =
+      this.normalizeQualificationSlugs(qualificationSlugs);
+
+    if (normalizedQualificationSlugs.length === 0) {
+      throw new BadRequestException(
+        'At least one instructor qualification is required',
+      );
+    }
+
+    const rows = await db.instructor_qualification.findMany({
+      where: {
+        slug: {
+          in: normalizedQualificationSlugs,
+        },
+      },
+      select: {
+        id: true,
+        slug: true,
+      },
+    });
+
+    if (rows.length !== normalizedQualificationSlugs.length) {
+      throw new BadRequestException('One or more instructor qualifications are invalid');
+    }
+
+    const qualificationIds = rows.map((row) => row.id);
+
+    await db.instructor_qualification_assignment.deleteMany({
+      where: {
+        instructor_id: instructorId,
+        qualification_id: {
+          notIn: qualificationIds,
+        },
+      },
+    });
+
+    await db.instructor_qualification_assignment.createMany({
+      data: qualificationIds.map((qualificationId) => ({
+        instructor_id: instructorId,
+        qualification_id: qualificationId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+
+  private async findPersonIdByEmail(db: DbClient, email: string) {
+    const contact = await db.contact.findFirst({
+      where: {
+        value: {
+          equals: email,
+          mode: 'insensitive',
+        },
+        contact_type: {
+          code: {
+            equals: 'EMAIL',
+            mode: 'insensitive',
+          },
+        },
+      },
+      select: {
+        person_id: true,
+      },
+    });
+
+    return contact?.person_id ?? null;
+  }
+
+  private async syncPersonContacts(
+    db: DbClient,
+    personId: number,
+    email: string | null,
+    phone: string | null,
+  ) {
+    const contactTypeIds = await this.resolveContactTypeIds(db);
+
+    if (email && contactTypeIds.email) {
+      await this.upsertPrimaryContact(
+        db,
+        personId,
+        contactTypeIds.email,
+        email,
+      );
+    }
+
+    if (phone && contactTypeIds.phone) {
+      await this.upsertPrimaryContact(
+        db,
+        personId,
+        contactTypeIds.phone,
+        phone,
+      );
+    }
+  }
+
+  private async resolveContactTypeIds(db: DbClient) {
+    const types = await db.contact_type.findMany({
+      where: {
+        code: {
+          in: ['EMAIL', 'PHONE'],
+        },
+      },
+      select: {
+        id: true,
+        code: true,
+      },
+    });
+
+    const byCode = new Map(types.map((item) => [item.code.toUpperCase(), item.id]));
+
+    return {
+      email: byCode.get('EMAIL') ?? null,
+      phone: byCode.get('PHONE') ?? null,
+    };
+  }
+
+  private async upsertPrimaryContact(
+    db: DbClient,
+    personId: number,
+    contactTypeId: number,
+    value: string,
+  ) {
+    await db.contact.updateMany({
+      where: {
+        person_id: personId,
+        contact_type_id: contactTypeId,
+      },
+      data: {
+        is_primary: false,
+      },
+    });
+
+    const existing = await db.contact.findFirst({
+      where: {
+        person_id: personId,
+        contact_type_id: contactTypeId,
+        value: {
+          equals: value,
+          mode: 'insensitive',
+        },
+      },
+      select: {
+        id: true,
+      },
+    });
+
+    if (existing) {
+      await db.contact.update({
+        where: { id: existing.id },
+        data: {
+          value,
+          is_primary: true,
+        },
+      });
+      return;
+    }
+
+    await db.contact.create({
+      data: {
+        person_id: personId,
+        contact_type_id: contactTypeId,
+        value,
+        is_primary: true,
+      },
+    });
+  }
+}

package/src/lms.module.ts

@@ -1,15 +1,47 @@
-import { forwardRef, Module } from '@nestjs/common';
-import { ConfigModule } from '@nestjs/config';
 import { LocaleModule } from '@hed-hog/api-locale';
 import { PaginationModule } from '@hed-hog/api-pagination';
 import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { LmsCertificateModule } from './certificate/certificate.module';
+import { ClassGroupModule } from './class-group/class-group.module';
+import { CourseModule } from './course/course.module';
+import { LmsDashboardModule } from './dashboard/dashboard.module';
+import { EnterpriseModule } from './enterprise/enterprise.module';
+import { EvaluationModule } from './evaluation/evaluation.module';
+import { ExamModule } from './exam/exam.module';
+import { InstructorModule } from './instructor/instructor.module';
+import { LmsReportsModule } from './reports/reports.module';
+import { TrainingModule } from './training/training.module';
 
 @Module({
   imports: [
     ConfigModule.forRoot(),
     forwardRef(() => PaginationModule),
     forwardRef(() => PrismaModule),
-    forwardRef(() => LocaleModule)
-  ]
+    forwardRef(() => LocaleModule),
+    forwardRef(() => LmsCertificateModule),
+    forwardRef(() => ClassGroupModule),
+    forwardRef(() => CourseModule),
+    forwardRef(() => LmsDashboardModule),
+    forwardRef(() => EnterpriseModule),
+    forwardRef(() => EvaluationModule),
+    forwardRef(() => ExamModule),
+    forwardRef(() => InstructorModule),
+    forwardRef(() => LmsReportsModule),
+    forwardRef(() => TrainingModule),
+  ],
+  exports: [
+    forwardRef(() => ClassGroupModule),
+    forwardRef(() => LmsCertificateModule),
+    forwardRef(() => CourseModule),
+    forwardRef(() => LmsDashboardModule),
+    forwardRef(() => EnterpriseModule),
+    forwardRef(() => EvaluationModule),
+    forwardRef(() => ExamModule),
+    forwardRef(() => InstructorModule),
+    forwardRef(() => LmsReportsModule),
+    forwardRef(() => TrainingModule),
+  ],
 })
 export class LmsModule {}

package/src/reports/reports.controller.ts

@@ -0,0 +1,14 @@
+import { Role } from '@hed-hog/api';
+import { Controller, Get, Query } from '@nestjs/common';
+import { LmsReportsService } from './reports.service';
+
+@Role()
+@Controller('lms/reports')
+export class LmsReportsController {
+  constructor(private readonly reportsService: LmsReportsService) {}
+
+  @Get()
+  getReports(@Query('period') period?: string) {
+    return this.reportsService.getReports(period ?? '12m');
+  }
+}

package/src/reports/reports.module.ts

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