@hed-hog/lms 0.0.319 → 0.0.320

package/src/enterprise/training/training-viewer.controller.ts

@@ -0,0 +1,115 @@
+import { Role, User } from '@hed-hog/api';
+import { Controller, Get, Param, ParseIntPipe, Query } from '@nestjs/common';
+import { TrainingAdminService } from './training-admin.service';
+
+@Role()
+@Controller('lms/enterprise/training/viewer')
+export class TrainingViewerController {
+  constructor(private readonly trainingAdminService: TrainingAdminService) {}
+
+  @Get()
+  getDashboard(@User('id') userId: number) {
+    return this.trainingAdminService.getDashboard(userId);
+  }
+
+  @Get('courses/stats')
+  getCourseStats(@User('id') userId: number) {
+    return this.trainingAdminService.getCourseStats(userId);
+  }
+
+  @Get('courses/:courseId')
+  getCourseDetail(
+    @User('id') userId: number,
+    @Param('courseId', ParseIntPipe) courseId: number,
+  ) {
+    return this.trainingAdminService.getCourseDetail(userId, courseId);
+  }
+
+  @Get('courses')
+  getCourses(
+    @User('id') userId: number,
+    @Query('page', new ParseIntPipe({ optional: true })) page?: number,
+    @Query('pageSize', new ParseIntPipe({ optional: true })) pageSize?: number,
+    @Query('search') search?: string,
+    @Query('level') level?: string,
+    @Query('category') category?: string,
+  ) {
+    return this.trainingAdminService.getCourses(userId, { page, pageSize, search, level, category });
+  }
+
+  @Get('class-groups')
+  getClassGroups(
+    @User('id') userId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+    @Query('deliveryMode') deliveryMode?: string,
+  ) {
+    return this.trainingAdminService.getClassGroups(userId, {
+      enterpriseId,
+      search,
+      status,
+      deliveryMode,
+    });
+  }
+
+  @Get('class-groups/:id')
+  getClassGroupDetail(
+    @User('id') userId: number,
+    @Param('id', ParseIntPipe) classGroupId: number,
+  ) {
+    return this.trainingAdminService.getClassGroupDetail(userId, classGroupId);
+  }
+
+  @Get('class-groups/:id/students')
+  getClassGroupStudents(
+    @User('id') userId: number,
+    @Param('id', ParseIntPipe) classGroupId: 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.trainingAdminService.getClassGroupStudents(userId, classGroupId, { page, pageSize, search, status });
+  }
+
+  @Get('class-groups/:id/sessions')
+  getClassGroupSessions(
+    @User('id') userId: number,
+    @Param('id', ParseIntPipe) classGroupId: number,
+  ) {
+    return this.trainingAdminService.getClassGroupSessions(userId, classGroupId);
+  }
+
+  @Get('class-groups/:id/materials')
+  getClassGroupMaterials(
+    @User('id') userId: number,
+    @Param('id', ParseIntPipe) classGroupId: number,
+  ) {
+    return this.trainingAdminService.getClassGroupMaterials(userId, classGroupId);
+  }
+
+  @Get('students/stats')
+  getStudentStats(@User('id') userId: number) {
+    return this.trainingAdminService.getStudentStats(userId);
+  }
+
+  @Get('students/:personId')
+  getStudentDetail(
+    @User('id') userId: number,
+    @Param('personId', ParseIntPipe) personId: number,
+  ) {
+    return this.trainingAdminService.getStudentDetail(userId, personId);
+  }
+
+  @Get('students')
+  getStudents(
+    @User('id') userId: 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.trainingAdminService.getStudents(userId, { page, pageSize, search, status });
+  }
+}

package/src/evaluation/dto/create-evaluation-topic.dto.ts

@@ -0,0 +1,48 @@
+import {
+    IsArray,
+    IsBoolean,
+    IsEnum,
+    IsInt,
+    IsNotEmpty,
+    IsOptional,
+    IsString,
+    MaxLength,
+    Min,
+} from 'class-validator';
+
+export enum EvaluationTargetType {
+  COURSE = 'course',
+  COURSE_LESSON = 'course_lesson',
+  COURSE_CLASS_SESSION = 'course_class_session',
+  QUESTION = 'question',
+  EXAM = 'exam',
+}
+
+export class CreateEvaluationTopicDto {
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  name: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+
+  @IsEnum(EvaluationTargetType)
+  targetType: EvaluationTargetType;
+
+  @IsInt()
+  @Min(0)
+  @IsOptional()
+  order?: number;
+
+  @IsBoolean()
+  @IsOptional()
+  isActive?: boolean;
+}
+
+export class ReorderTopicsDto {
+  @IsArray()
+  @IsInt({ each: true })
+  ids: number[];
+}

package/src/evaluation/dto/update-evaluation-topic.dto.ts

@@ -0,0 +1,6 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateEvaluationTopicDto } from './create-evaluation-topic.dto';
+
+export class UpdateEvaluationTopicDto extends PartialType(
+  CreateEvaluationTopicDto,
+) {}

package/src/evaluation/evaluation.controller.ts

@@ -1,5 +1,20 @@
 import { Role } from '@hed-hog/api';
-import { Controller, Get, Query } from '@nestjs/common';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Query,
+} from '@nestjs/common';
+import {
+    CreateEvaluationTopicDto,
+    ReorderTopicsDto,
+} from './dto/create-evaluation-topic.dto';
+import { UpdateEvaluationTopicDto } from './dto/update-evaluation-topic.dto';
 import { EvaluationService } from './evaluation.service';
 
 @Role()
@@ -17,6 +32,53 @@ export class EvaluationController {
     return this.evaluationService.filterOptions();
   }
 
+  // ── Topics ──────────────────────────────────────────────────────────────────
+
+  @Get('topics')
+  listTopics(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('targetType') targetType?: string,
+  ) {
+    return this.evaluationService.listTopics({
+      page: page ? Number(page) : 1,
+      pageSize: pageSize ? Number(pageSize) : 20,
+      search,
+      targetType,
+    });
+  }
+
+  @Post('topics')
+  createTopic(@Body() dto: CreateEvaluationTopicDto) {
+    return this.evaluationService.createTopic(dto);
+  }
+
+  @Get('topics/:id')
+  getTopicById(@Param('id', ParseIntPipe) id: number) {
+    return this.evaluationService.getTopicById(id);
+  }
+
+  @Patch('topics/reorder')
+  reorderTopics(@Body() dto: ReorderTopicsDto) {
+    return this.evaluationService.reorderTopics(dto.ids);
+  }
+
+  @Patch('topics/:id')
+  updateTopic(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateEvaluationTopicDto,
+  ) {
+    return this.evaluationService.updateTopic(id, dto);
+  }
+
+  @Delete('topics/:id')
+  deleteTopic(@Param('id', ParseIntPipe) id: number) {
+    return this.evaluationService.deleteTopic(id);
+  }
+
+  // ── Ratings ─────────────────────────────────────────────────────────────────
+
   @Get()
   list(
     @Query('page') page?: string,

package/src/evaluation/evaluation.service.ts

@@ -1,5 +1,14 @@
 import { PrismaService } from '@hed-hog/api-prisma';
-import { Injectable } from '@nestjs/common';
+import {
+    Injectable,
+    NotFoundException,
+    UnprocessableEntityException,
+} from '@nestjs/common';
+import {
+    CreateEvaluationTopicDto,
+    EvaluationTargetType,
+} from './dto/create-evaluation-topic.dto';
+import { UpdateEvaluationTopicDto } from './dto/update-evaluation-topic.dto';
 
 @Injectable()
 export class EvaluationService {
@@ -391,4 +400,144 @@ export class EvaluationService {
         .map((r) => ({ id: r.person!.id, label: r.person!.name })),
     };
   }
+
+  // ── Topics CRUD ─────────────────────────────────────────────────────────────
+
+  async listTopics(params: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    targetType?: 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 where: any = {};
+
+    if (params.targetType && Object.values(EvaluationTargetType).includes(params.targetType as EvaluationTargetType)) {
+      where.target_type = params.targetType;
+    }
+
+    if (params.search) {
+      where.OR = [
+        { name: { contains: params.search, mode: 'insensitive' } },
+        { description: { contains: params.search, mode: 'insensitive' } },
+      ];
+    }
+
+    const [topics, total] = await Promise.all([
+      this.prisma.evaluation_topic.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy: [{ target_type: 'asc' }, { order: 'asc' }, { name: 'asc' }],
+        include: {
+          _count: { select: { evaluation_rating: true } },
+        },
+      }),
+      this.prisma.evaluation_topic.count({ where }),
+    ]);
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: topics.map((t) => ({
+        id: t.id,
+        name: t.name,
+        description: t.description ?? null,
+        targetType: t.target_type,
+        order: t.order,
+        isActive: t.is_active,
+        ratingCount: t._count.evaluation_rating,
+        createdAt: t.created_at,
+        updatedAt: t.updated_at,
+      })),
+    };
+  }
+
+  async getTopicById(id: number) {
+    const topic = await this.prisma.evaluation_topic.findUnique({
+      where: { id },
+      include: {
+        _count: { select: { evaluation_rating: true } },
+      },
+    });
+
+    if (!topic) {
+      throw new NotFoundException(`Evaluation topic #${id} not found`);
+    }
+
+    return {
+      id: topic.id,
+      name: topic.name,
+      description: topic.description ?? null,
+      targetType: topic.target_type,
+      order: topic.order,
+      isActive: topic.is_active,
+      ratingCount: topic._count.evaluation_rating,
+      createdAt: topic.created_at,
+      updatedAt: topic.updated_at,
+    };
+  }
+
+  async createTopic(dto: CreateEvaluationTopicDto) {
+    const data: any = {
+      name: dto.name,
+      target_type: dto.targetType,
+    };
+
+    if (dto.description !== undefined) data.description = dto.description;
+    if (dto.order !== undefined) data.order = dto.order;
+    if (dto.isActive !== undefined) data.is_active = dto.isActive;
+
+    return this.prisma.evaluation_topic.create({ data });
+  }
+
+  async updateTopic(id: number, dto: UpdateEvaluationTopicDto) {
+    await this.getTopicById(id);
+
+    const data: any = {};
+    if (dto.name !== undefined) data.name = dto.name;
+    if (dto.description !== undefined) data.description = dto.description;
+    if (dto.targetType !== undefined) data.target_type = dto.targetType;
+    if (dto.order !== undefined) data.order = dto.order;
+    if (dto.isActive !== undefined) data.is_active = dto.isActive;
+
+    return this.prisma.evaluation_topic.update({ where: { id }, data });
+  }
+
+  async reorderTopics(ids: number[]) {
+    await this.prisma.$transaction(
+      ids.map((id, index) =>
+        this.prisma.evaluation_topic.update({
+          where: { id },
+          data: { order: index },
+        }),
+      ),
+    );
+    return { reordered: ids.length };
+  }
+
+  async deleteTopic(id: number) {
+    const topic = await this.prisma.evaluation_topic.findUnique({
+      where: { id },
+      include: { _count: { select: { evaluation_rating: true } } },
+    });
+
+    if (!topic) {
+      throw new NotFoundException(`Evaluation topic #${id} not found`);
+    }
+
+    if (topic._count.evaluation_rating > 0) {
+      throw new UnprocessableEntityException(
+        `Cannot delete topic with ${topic._count.evaluation_rating} existing rating(s).`,
+      );
+    }
+
+    await this.prisma.evaluation_topic.delete({ where: { id } });
+    return { deleted: true };
+  }
 }

package/src/instructor/instructor.service.ts

@@ -130,9 +130,9 @@ export class InstructorService {
             userId: personUser?.user_id ?? null,
             hasTrainingAccess: (personUser?.user?.role_user?.length ?? 0) > 0,
             status: row.status,
-            qualificationSlugs: row.instructor_qualification_assignment
+            qualificationSlugs: [...new Set(row.instructor_qualification_assignment
               .map((assignment) => assignment.instructor_qualification.slug)
-              .sort(),
+              .sort())],
           };
         })
         .sort((left, right) => left.name.localeCompare(right.name)),
@@ -393,9 +393,9 @@ export class InstructorService {
         'WHATSAPP',
       ]),
       status: instructor.status,
-      qualificationSlugs: instructor.instructor_qualification_assignment
+      qualificationSlugs: [...new Set(instructor.instructor_qualification_assignment
         .map((assignment) => assignment.instructor_qualification.slug)
-        .sort(),
+        .sort())],
     };
   }
 

package/src/lms.module.ts

@@ -8,6 +8,7 @@ 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 { EnterpriseTrainingModule } from './enterprise/training/enterprise-training.module';
 import { EvaluationModule } from './evaluation/evaluation.module';
 import { ExamModule } from './exam/exam.module';
 import { InstructorModule } from './instructor/instructor.module';
@@ -25,6 +26,7 @@ import { TrainingModule } from './training/training.module';
     forwardRef(() => CourseModule),
     forwardRef(() => LmsDashboardModule),
     forwardRef(() => EnterpriseModule),
+    forwardRef(() => EnterpriseTrainingModule),
     forwardRef(() => EvaluationModule),
     forwardRef(() => ExamModule),
     forwardRef(() => InstructorModule),
@@ -37,6 +39,7 @@ import { TrainingModule } from './training/training.module';
     forwardRef(() => CourseModule),
     forwardRef(() => LmsDashboardModule),
     forwardRef(() => EnterpriseModule),
+    forwardRef(() => EnterpriseTrainingModule),
     forwardRef(() => EvaluationModule),
     forwardRef(() => ExamModule),
     forwardRef(() => InstructorModule),