@hed-hog/lms 0.0.325 → 0.0.327

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

@@ -0,0 +1,214 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { CreateInstructorSkillDto } from './dto/create-instructor-skill.dto';
+import { UpdateInstructorSkillDto } from './dto/update-instructor-skill.dto';
+
+@Injectable()
+export class InstructorSkillService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  private get skillClient() {
+    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);
+    const skip = (page - 1) * pageSize;
+    const search = params.search?.trim();
+
+    const where: any = {};
+
+    if (search) {
+      where.OR = [
+        { slug: { contains: search, mode: 'insensitive' } },
+        {
+          instructor_skill_locale: {
+            some: { name: { contains: search, mode: 'insensitive' } },
+          },
+        },
+      ];
+    }
+
+    const [rows, total] = await Promise.all([
+      this.skillClient.findMany({
+        where,
+        skip,
+        take: pageSize,
+        include: {
+          instructor_skill_locale: {
+            select: { locale_id: true, name: true, description: true },
+          },
+        },
+        orderBy: { slug: 'asc' },
+      }),
+      this.skillClient.count({ where }),
+    ]);
+
+    return {
+      data: (rows as any[]).map((row) => this.mapRow(row)),
+      total,
+      page,
+      pageSize,
+    };
+  }
+
+  async getAll() {
+    const rows = await this.skillClient.findMany({
+      where: { status: 'active' },
+      include: {
+        instructor_skill_locale: {
+          select: { locale_id: true, name: true },
+        },
+      },
+      orderBy: { slug: 'asc' },
+    });
+
+    return (rows as any[]).map((row) => this.mapRow(row));
+  }
+
+  async create(dto: CreateInstructorSkillDto) {
+    const skill = await this.skillClient.create({
+      data: {
+        slug: dto.slug,
+        status: dto.status ?? 'active',
+      },
+    });
+
+    await this.syncLocales(skill.id, dto);
+
+    return this.getSkillById(skill.id);
+  }
+
+  async update(id: number, dto: UpdateInstructorSkillDto) {
+    const skill = await this.skillClient.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!skill) {
+      throw new NotFoundException('Instructor skill not found');
+    }
+
+    const data: any = {};
+
+    if (dto.slug !== undefined) data.slug = dto.slug;
+    if (dto.status !== undefined) data.status = dto.status;
+
+    if (Object.keys(data).length > 0) {
+      await this.skillClient.update({ where: { id }, data });
+    }
+
+    await this.syncLocales(id, dto);
+
+    return this.getSkillById(id);
+  }
+
+  async delete(id: number) {
+    const skill = await this.skillClient.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!skill) {
+      throw new NotFoundException('Instructor skill not found');
+    }
+
+    await this.skillClient.delete({ where: { id } });
+  }
+
+  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) {
+      throw new NotFoundException('Instructor skill not found');
+    }
+
+    return this.mapRow(row);
+  }
+
+  private mapRow(row: any) {
+    return {
+      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,
+    };
+  }
+}

package/src/instructor/instructor.module.ts

@@ -1,12 +1,14 @@
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
+import { InstructorSkillController } from './instructor-skill.controller';
+import { InstructorSkillService } from './instructor-skill.service';
 import { InstructorController } from './instructor.controller';
 import { InstructorService } from './instructor.service';
 
 @Module({
   imports: [forwardRef(() => PrismaModule)],
-  controllers: [InstructorController],
-  providers: [InstructorService],
+  controllers: [InstructorController, InstructorSkillController],
+  providers: [InstructorService, InstructorSkillService],
   exports: [forwardRef(() => InstructorService)],
 })
 export class InstructorModule {}

package/src/instructor/instructor.service.ts

@@ -85,6 +85,17 @@ export class InstructorService {
               id: true,
               name: true,
               avatar_id: true,
+              contact: {
+                where: {
+                  contact_type: {
+                    code: { in: ['EMAIL', 'PHONE', 'MOBILE', 'WHATSAPP'] },
+                  },
+                },
+                include: {
+                  contact_type: { select: { code: true } },
+                },
+                orderBy: [{ is_primary: 'desc' as const }, { id: 'asc' as const }],
+              },
               person_user: {
                 take: 1,
                 select: {
@@ -118,6 +129,48 @@ export class InstructorService {
       this.prisma.instructor.count({ where }),
     ]);
 
+    const instructorIds = rows.map((r) => r.id);
+    let hourlyRateMap = new Map<number, number | null>();
+    let skillsMap = new Map<number, Array<{ id: number; slug: string; name: string }>>();
+
+    if (instructorIds.length > 0) {
+      const [rateRows, assignmentRows] = (await Promise.all([
+        this.prisma.$queryRaw(
+          Prisma.sql`SELECT id, hourly_rate FROM instructor WHERE id IN (${Prisma.join(instructorIds)})`,
+        ),
+        (this.prisma as any).instructor_skill_assignment.findMany({
+          where: { instructor_id: { in: instructorIds } },
+          select: {
+            instructor_id: true,
+            instructor_skill: {
+              select: {
+                id: true,
+                slug: true,
+                instructor_skill_locale: {
+                  take: 1,
+                  select: { name: true },
+                },
+              },
+            },
+          },
+        }),
+      ])) as [Array<{ id: number; hourly_rate: number | null }>, any[]];
+
+      for (const r of rateRows) {
+        hourlyRateMap.set(Number(r.id), r.hourly_rate !== null ? Number(r.hourly_rate) : null);
+      }
+
+      for (const a of assignmentRows) {
+        const existing = skillsMap.get(a.instructor_id) ?? [];
+        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,
+        });
+        skillsMap.set(a.instructor_id, existing);
+      }
+    }
+
     return {
       data: rows
         .map((row) => {
@@ -127,12 +180,22 @@ export class InstructorService {
             personId: row.person_id,
             name: row.person?.name?.trim() || `Instructor #${row.id}`,
             avatarId: row.person?.avatar_id ?? null,
+            email: this.getPrimaryContactValue(
+              row.person?.contact ?? [],
+              ['EMAIL'],
+            ),
+            phone: this.getPrimaryContactValue(
+              row.person?.contact ?? [],
+              ['PHONE', 'MOBILE', 'WHATSAPP'],
+            ),
             userId: personUser?.user_id ?? null,
             hasTrainingAccess: (personUser?.user?.role_user?.length ?? 0) > 0,
             status: row.status,
+            hourlyRate: hourlyRateMap.get(row.id) ?? null,
             qualificationSlugs: [...new Set(row.instructor_qualification_assignment
               .map((assignment) => assignment.instructor_qualification.slug)
               .sort())],
+            skills: skillsMap.get(row.id) ?? [],
           };
         })
         .sort((left, right) => left.name.localeCompare(right.name)),
@@ -217,6 +280,12 @@ export class InstructorService {
         dto.qualificationSlugs,
       );
 
+      if (dto.hourlyRate !== undefined) {
+        await tx.$executeRaw`UPDATE instructor SET hourly_rate = ${dto.hourlyRate ?? null} WHERE id = ${instructor.id}`;
+      }
+
+      await this.syncInstructorSkills(tx, instructor.id, dto.skillSlugs ?? []);
+
       return this.getById(instructor.id, tx);
     });
   }
@@ -284,6 +353,14 @@ export class InstructorService {
         );
       }
 
+      if (dto.hourlyRate !== undefined) {
+        await tx.$executeRaw`UPDATE instructor SET hourly_rate = ${dto.hourlyRate ?? null} WHERE id = ${id}`;
+      }
+
+      if (dto.skillSlugs !== undefined) {
+        await this.syncInstructorSkills(tx, id, dto.skillSlugs);
+      }
+
       return this.getById(id, tx);
     });
   }
@@ -379,6 +456,36 @@ export class InstructorService {
 
     const personUser = instructor.person.person_user?.[0] ?? null;
 
+    const [rateRows, skillAssignments] = (await Promise.all([
+      (db as any).$queryRaw`SELECT id, hourly_rate FROM instructor WHERE id = ${id}`,
+      (db as any).instructor_skill_assignment.findMany({
+        where: { instructor_id: id },
+        select: {
+          instructor_skill: {
+            select: {
+              id: true,
+              slug: true,
+              instructor_skill_locale: {
+                take: 1,
+                select: { name: true },
+              },
+            },
+          },
+        },
+      }),
+    ])) as [Array<{ id: number; hourly_rate: number | null }>, any[]];
+
+    const hourlyRate =
+      rateRows[0]?.hourly_rate !== null && rateRows[0]?.hourly_rate !== undefined
+        ? Number(rateRows[0].hourly_rate)
+        : null;
+
+    const skills = skillAssignments.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,
+    }));
+
     return {
       id: instructor.id,
       personId: instructor.person.id,
@@ -393,9 +500,11 @@ export class InstructorService {
         'WHATSAPP',
       ]),
       status: instructor.status,
+      hourlyRate,
       qualificationSlugs: [...new Set(instructor.instructor_qualification_assignment
         .map((assignment) => assignment.instructor_qualification.slug)
         .sort())],
+      skills,
     };
   }
 
@@ -773,4 +882,43 @@ export class InstructorService {
       },
     });
   }
+
+  private async syncInstructorSkills(
+    db: DbClient,
+    instructorId: number,
+    slugs: string[],
+  ) {
+    const normalizedSlugs = [...new Set((slugs ?? []).map((s) => s?.trim()).filter(Boolean))];
+
+    if (normalizedSlugs.length === 0) {
+      await (db as any).instructor_skill_assignment.deleteMany({
+        where: { instructor_id: instructorId },
+      });
+      return;
+    }
+
+    const skillRows = await (db as any).instructor_skill.findMany({
+      where: { slug: { in: normalizedSlugs } },
+      select: { id: true },
+    });
+
+    const skillIds = (skillRows as any[]).map((r) => r.id);
+
+    await (db as any).instructor_skill_assignment.deleteMany({
+      where: {
+        instructor_id: instructorId,
+        skill_id: { notIn: skillIds },
+      },
+    });
+
+    if (skillIds.length > 0) {
+      await (db as any).instructor_skill_assignment.createMany({
+        data: skillIds.map((skillId: number) => ({
+          instructor_id: instructorId,
+          skill_id: skillId,
+        })),
+        skipDuplicates: true,
+      });
+    }
+  }
 }

package/src/training/training.service.ts

@@ -1,11 +1,16 @@
 import { PrismaService } from '@hed-hog/api-prisma';
-import { Injectable } from '@nestjs/common';
+import { IntegrationDeveloperApiService } from '@hed-hog/core';
+import { Inject, Injectable, forwardRef } from '@nestjs/common';
 import { CreateTrainingDto, LearningPathItemDto } from './dto/create-training.dto';
 import { UpdateTrainingDto } from './dto/update-training.dto';
 
 @Injectable()
 export class TrainingService {
-  constructor(private readonly prisma: PrismaService) {}
+  constructor(
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => IntegrationDeveloperApiService))
+    private readonly integrationApi: IntegrationDeveloperApiService,
+  ) {}
 
   async list(params: {
     page?: number;
@@ -237,7 +242,17 @@ export class TrainingService {
       },
     });
 
-    return this.mapTraining(created);
+    const trainingResult = this.mapTraining(created);
+
+    await this.integrationApi.publishEvent({
+      eventName: 'lms.training.created',
+      sourceModule: 'lms',
+      aggregateType: 'training',
+      aggregateId: String(created.id),
+      payload: { id: created.id, title: dto.title, slug, status: normalizedStatus },
+    }).catch(() => null);
+
+    return trainingResult;
   }
 
   async update(id: number, dto: UpdateTrainingDto) {
@@ -314,11 +329,30 @@ export class TrainingService {
       },
     });
 
-    return this.mapTraining(updated);
+    const updateTrainingResult = this.mapTraining(updated);
+
+    await this.integrationApi.publishEvent({
+      eventName: 'lms.training.updated',
+      sourceModule: 'lms',
+      aggregateType: 'training',
+      aggregateId: String(id),
+      payload: { id, title: dto.title, status: dto.status },
+    }).catch(() => null);
+
+    return updateTrainingResult;
   }
 
   async remove(id: number) {
     await this.prisma.learning_path.delete({ where: { id } });
+
+    await this.integrationApi.publishEvent({
+      eventName: 'lms.training.deleted',
+      sourceModule: 'lms',
+      aggregateType: 'training',
+      aggregateId: String(id),
+      payload: { id },
+    }).catch(() => null);
+
     return { success: true };
   }