@hed-hog/lms 0.0.319 → 0.0.321

package/src/class-group/dto/create-class-group.dto.ts

@@ -6,7 +6,6 @@ import {
     IsNotEmpty,
     IsOptional,
     IsString,
-    IsUrl,
     Matches,
     MaxLength,
     Min,
@@ -128,7 +127,8 @@ export class CreateClassGroupDto {
   @IsOptional()
   location?: string;
 
-  @IsUrl({ require_tld: false })
+  @IsString()
+  @MaxLength(500)
   @IsOptional()
   virtualRoomUrl?: string;
 

package/src/class-group/dto/material.dto.ts

@@ -0,0 +1,69 @@
+import {
+    IsEnum,
+    IsInt,
+    IsNotEmpty,
+    IsOptional,
+    IsString,
+    MaxLength,
+    Min
+} from 'class-validator';
+
+export type MaterialType = 'file' | 'link';
+
+export class CreateMaterialDto {
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  title: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+
+  @IsEnum(['file', 'link'])
+  materialType: MaterialType;
+
+  @IsInt()
+  @Min(1)
+  @IsOptional()
+  fileId?: number;
+
+  @IsString()
+  @MaxLength(500)
+  @IsOptional()
+  url?: string;
+
+  @IsInt()
+  @IsOptional()
+  sessionId?: number;
+
+  @IsInt()
+  @IsOptional()
+  sortOrder?: number;
+}
+
+export class UpdateMaterialDto {
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  @IsOptional()
+  title?: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+
+  @IsInt()
+  @Min(1)
+  @IsOptional()
+  fileId?: number;
+
+  @IsString()
+  @MaxLength(500)
+  @IsOptional()
+  url?: string;
+
+  @IsInt()
+  @IsOptional()
+  sortOrder?: number;
+}

package/src/course/course.service.ts

@@ -825,21 +825,54 @@ export class CourseService {
   private async syncCourseImages(
     courseId: number,
     data: {
-      logoFileId?: number;
-      bannerFileId?: number;
+      logoFileId?: number | null;
+      bannerFileId?: number | null;
     },
   ) {
     if (data.logoFileId !== undefined) {
-      await this.upsertCourseImage(courseId, data.logoFileId, 'course-logo');
+      await this.syncCourseImage(courseId, data.logoFileId, 'course-logo');
     }
 
     if (data.bannerFileId !== undefined) {
-      await this.upsertCourseImage(
-        courseId,
-        data.bannerFileId,
-        'course-banner',
-      );
+      await this.syncCourseImage(courseId, data.bannerFileId, 'course-banner');
+    }
+  }
+
+  private async syncCourseImage(
+    courseId: number,
+    fileId: number | null,
+    imageTypeSlug: CourseImageTypeSlug,
+  ) {
+    if (fileId === null) {
+      await this.removeCourseImage(courseId, imageTypeSlug);
+      return;
     }
+
+    await this.upsertCourseImage(courseId, fileId, imageTypeSlug);
+  }
+
+  private async removeCourseImage(
+    courseId: number,
+    imageTypeSlug: CourseImageTypeSlug,
+  ) {
+    const imageType = await this.prisma.image_type.findFirst({
+      where: {
+        slug: imageTypeSlug,
+        applies_to_course: true,
+      },
+      select: { id: true },
+    });
+
+    if (!imageType) {
+      return;
+    }
+
+    await this.prisma.course_image.deleteMany({
+      where: {
+        course_id: courseId,
+        image_type_id: imageType.id,
+      },
+    });
   }
 
   private async upsertCourseImage(

package/src/course/dto/create-course.dto.ts

@@ -106,9 +106,9 @@ export class CreateCourseDto {
 
   @IsInt()
   @IsOptional()
-  logoFileId?: number;
+  logoFileId?: number | null;
 
   @IsInt()
   @IsOptional()
-  bannerFileId?: number;
+  bannerFileId?: number | null;
 }

package/src/enterprise/enterprise.controller.ts

@@ -1,15 +1,21 @@
 import { Public, Role, UserOptional } from '@hed-hog/api';
+import { Locale } from '@hed-hog/api-locale';
+import { FileService } from '@hed-hog/core';
 import {
     Body,
     Controller,
     Delete,
+    forwardRef,
     Get,
+    Inject,
     Param,
     ParseIntPipe,
     Patch,
     Post,
     Query,
+    Res,
 } from '@nestjs/common';
+import { Response } from 'express';
 import { AddEnterpriseClassGroupDto } from './dto/add-enterprise-class-group.dto';
 import { AddEnterpriseCourseDto } from './dto/add-enterprise-course.dto';
 import { AddEnterpriseStudentDto } from './dto/add-enterprise-student.dto';
@@ -23,7 +29,62 @@ import { EnterpriseService } from './enterprise.service';
 @Role()
 @Controller('lms/enterprise')
 export class EnterpriseController {
-  constructor(private readonly enterpriseService: EnterpriseService) {}
+  constructor(
+    private readonly enterpriseService: EnterpriseService,
+    @Inject(forwardRef(() => FileService))
+    private readonly fileService: FileService,
+  ) {}
+
+  @Public()
+  @Get('course/:courseId/logo')
+  async courseLogo(
+    @Param('courseId', ParseIntPipe) courseId: number,
+    @Res() res: Response,
+    @Locale() locale: string,
+  ) {
+    const fileId = await this.enterpriseService.getCourseLogoFileId(courseId);
+    const { stream, filename, mimetype, size } = await this.fileService.openById(locale, fileId);
+    res.set({
+      'Content-Type': mimetype || 'image/octet-stream',
+      'Content-Disposition': `inline; filename="${filename}"`,
+    });
+    if (typeof size === 'number') res.set('Content-Length', `${size}`);
+    stream.pipe(res);
+  }
+
+  @Public()
+  @Get('class/:classId/logo')
+  async classLogo(
+    @Param('classId', ParseIntPipe) classId: number,
+    @Res() res: Response,
+    @Locale() locale: string,
+  ) {
+    const fileId = await this.enterpriseService.getClassLogoFileId(classId);
+    const { stream, filename, mimetype, size } = await this.fileService.openById(locale, fileId);
+    res.set({
+      'Content-Type': mimetype || 'image/octet-stream',
+      'Content-Disposition': `inline; filename="${filename}"`,
+    });
+    if (typeof size === 'number') res.set('Content-Length', `${size}`);
+    stream.pipe(res);
+  }
+
+  @Public()
+  @Get('class/:classId/banner')
+  async classBanner(
+    @Param('classId', ParseIntPipe) classId: number,
+    @Res() res: Response,
+    @Locale() locale: string,
+  ) {
+    const fileId = await this.enterpriseService.getClassBannerFileId(classId);
+    const { stream, filename, mimetype, size } = await this.fileService.openById(locale, fileId);
+    res.set({
+      'Content-Type': mimetype || 'image/octet-stream',
+      'Content-Disposition': `inline; filename="${filename}"`,
+    });
+    if (typeof size === 'number') res.set('Content-Length', `${size}`);
+    stream.pipe(res);
+  }
 
   @Get()
   list(

package/src/enterprise/enterprise.module.ts

@@ -1,10 +1,11 @@
+import { FileModule } from '@hed-hog/core';
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
 import { EnterpriseController } from './enterprise.controller';
 import { EnterpriseService } from './enterprise.service';
 
 @Module({
-  imports: [forwardRef(() => PrismaModule)],
+  imports: [forwardRef(() => PrismaModule), forwardRef(() => FileModule)],
   controllers: [EnterpriseController],
   providers: [EnterpriseService],
   exports: [forwardRef(() => EnterpriseService)],

package/src/enterprise/enterprise.service.ts

@@ -531,9 +531,33 @@ export class EnterpriseService {
         `Class group #${dto.course_class_group_id} is already linked to this enterprise`,
       );
 
-    return this.prisma.enterprise_class_group.create({
+    const link = await this.prisma.enterprise_class_group.create({
       data: { enterprise_id: enterpriseId, ...(dto as any) },
     });
+
+    // Backfill existing enrolled students into enterprise_student
+    const enrolledPersons = await this.prisma.course_enrollment.findMany({
+      where: {
+        course_class_group_id: dto.course_class_group_id,
+        status: { not: 'cancelled' },
+      },
+      select: { person_id: true },
+      distinct: ['person_id'],
+    });
+
+    for (const { person_id } of enrolledPersons) {
+      const exists = await this.prisma.enterprise_student.findFirst({
+        where: { enterprise_id: enterpriseId, person_id },
+        select: { id: true },
+      });
+      if (!exists) {
+        await this.prisma.enterprise_student.create({
+          data: { enterprise_id: enterpriseId, person_id, status: 'active' },
+        });
+      }
+    }
+
+    return link;
   }
 
   async removeClassGroup(enterpriseId: number, classGroupId: number) {
@@ -691,6 +715,65 @@ export class EnterpriseService {
 
   // ─── Training Auth Profiles ──────────────────────────────────────────────────
 
+  async getCourseLogoFileId(courseId: number): Promise<number> {
+    const row = await this.prisma.course.findFirst({
+      where: { id: courseId },
+      select: {
+        course_image: {
+          where: { image_type: { slug: 'course-logo' } },
+          orderBy: { is_primary: 'desc' as const },
+          take: 1,
+          select: { file: { select: { id: true } } },
+        },
+      },
+    });
+    const fileId = row?.course_image?.[0]?.file?.id;
+    if (!fileId) throw new NotFoundException(`Logo not found for course #${courseId}`);
+    return fileId;
+  }
+
+  async getClassLogoFileId(classId: number): Promise<number> {
+    const row = await this.prisma.course_class_group.findFirst({
+      where: { id: classId },
+      select: {
+        course: {
+          select: {
+            course_image: {
+              where: { image_type: { slug: 'course-logo' } },
+              orderBy: { is_primary: 'desc' as const },
+              take: 1,
+              select: { file: { select: { id: true } } },
+            },
+          },
+        },
+      },
+    });
+    const fileId = row?.course?.course_image?.[0]?.file?.id;
+    if (!fileId) throw new NotFoundException(`Logo not found for class #${classId}`);
+    return fileId;
+  }
+
+  async getClassBannerFileId(classId: number): Promise<number> {
+    const row = await this.prisma.course_class_group.findFirst({
+      where: { id: classId },
+      select: {
+        course: {
+          select: {
+            course_image: {
+              where: { image_type: { slug: 'course-banner' } },
+              orderBy: { is_primary: 'desc' as const },
+              take: 1,
+              select: { file: { select: { id: true } } },
+            },
+          },
+        },
+      },
+    });
+    const fileId = row?.course?.course_image?.[0]?.file?.id;
+    if (!fileId) throw new NotFoundException(`Banner not found for class #${classId}`);
+    return fileId;
+  }
+
   async getProfilesForUser(userId: number): Promise<EnterpriseProfile[]> {
     const ROLE_TO_SLUG: Record<string, string> = {
       hr_manager: 'lms-enterprise-admin',

package/src/enterprise/training/enterprise-training.module.ts

@@ -0,0 +1,27 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { FileModule } from '@hed-hog/core';
+import { forwardRef, Module } from '@nestjs/common';
+import { TrainingAdminController } from './training-admin.controller';
+import { TrainingAdminService } from './training-admin.service';
+import { TrainingInstructorController } from './training-instructor.controller';
+import { TrainingInstructorService } from './training-instructor.service';
+import { TrainingStudentController } from './training-student.controller';
+import { TrainingStudentService } from './training-student.service';
+import { TrainingViewerController } from './training-viewer.controller';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule), forwardRef(() => FileModule)],
+  controllers: [
+    TrainingAdminController,
+    TrainingViewerController,
+    TrainingInstructorController,
+    TrainingStudentController,
+  ],
+  providers: [TrainingAdminService, TrainingInstructorService, TrainingStudentService],
+  exports: [
+    forwardRef(() => TrainingAdminService),
+    forwardRef(() => TrainingInstructorService),
+    forwardRef(() => TrainingStudentService),
+  ],
+})
+export class EnterpriseTrainingModule {}

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

@@ -0,0 +1,278 @@
+import { Role, User } from '@hed-hog/api';
+import { Body, Controller, Delete, Get, Param, ParseIntPipe, Patch, Post, Query } from '@nestjs/common';
+import { TrainingAdminService } from './training-admin.service';
+
+@Role()
+@Controller('lms/enterprise/training/admin')
+export class TrainingAdminController {
+  constructor(private readonly trainingAdminService: TrainingAdminService) {}
+
+  @Get()
+  getDashboard(
+    @User('id') userId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+  ) {
+    return this.trainingAdminService.getDashboard(userId, enterpriseId);
+  }
+
+  @Get('courses/stats')
+  getCourseStats(
+    @User('id') userId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+  ) {
+    return this.trainingAdminService.getCourseStats(userId, enterpriseId);
+  }
+
+  @Get('courses/:courseId')
+  getCourseDetail(
+    @User('id') userId: number,
+    @Param('courseId', ParseIntPipe) courseId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+  ) {
+    return this.trainingAdminService.getCourseDetail(userId, courseId, enterpriseId);
+  }
+
+  @Get('courses')
+  getCourses(
+    @User('id') userId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: 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, { enterpriseId, 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,
+    @Query('instructorId', new ParseIntPipe({ optional: true })) instructorId?: number,
+  ) {
+    return this.trainingAdminService.getClassGroups(userId, {
+      enterpriseId,
+      search,
+      status,
+      deliveryMode,
+      instructorId,
+    });
+  }
+
+  @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('license-info')
+  getLicenseAvailability(@User('id') userId: number) {
+    return this.trainingAdminService.getLicenseAvailability(userId);
+  }
+
+  @Get('licenses')
+  listLicenses(
+    @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,
+    @Query('department') department?: string,
+  ) {
+    return this.trainingAdminService.listLicenses(userId, { page, pageSize, search, status, department });
+  }
+
+  @Post('licenses')
+  assignLicense(
+    @User('id') userId: number,
+    @Body() dto: { name: string; email?: string; department?: string },
+  ) {
+    return this.trainingAdminService.assignLicense(userId, dto);
+  }
+
+  @Delete('licenses/:personId')
+  revokeLicense(
+    @User('id') userId: number,
+    @Param('personId', ParseIntPipe) personId: number,
+  ) {
+    return this.trainingAdminService.revokeLicense(userId, personId);
+  }
+
+  @Get('class-groups/:id/enrollable-students')
+  getEnrollableStudents(
+    @User('id') userId: number,
+    @Param('id', ParseIntPipe) classGroupId: number,
+    @Query('search') search?: string,
+  ) {
+    return this.trainingAdminService.getEnrollableStudents(userId, classGroupId, search);
+  }
+
+  @Post('class-groups/:id/enroll')
+  enrollExistingStudent(
+    @User('id') userId: number,
+    @Param('id', ParseIntPipe) classGroupId: number,
+    @Body() dto: { personId: number },
+  ) {
+    return this.trainingAdminService.enrollExistingStudent(userId, classGroupId, dto.personId);
+  }
+
+  @Post('class-groups/:id/enroll/create')
+  createAndEnrollNewStudent(
+    @User('id') userId: number,
+    @Param('id', ParseIntPipe) classGroupId: number,
+    @Body() dto: { name: string; email?: string; department?: string },
+  ) {
+    return this.trainingAdminService.createAndEnrollNewStudent(userId, classGroupId, dto);
+  }
+
+  @Get('students/stats')
+  getStudentStats(
+    @User('id') userId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+  ) {
+    return this.trainingAdminService.getStudentStats(userId, enterpriseId);
+  }
+
+  @Get('students/:personId')
+  getStudentDetail(
+    @User('id') userId: number,
+    @Param('personId', ParseIntPipe) personId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+  ) {
+    return this.trainingAdminService.getStudentDetail(userId, personId, enterpriseId);
+  }
+
+  @Get('students')
+  getStudents(
+    @User('id') userId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: 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, { enterpriseId, page, pageSize, search, status });
+  }
+
+  @Get('admins/stats')
+  getAdminStats(
+    @User('id') userId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+  ) {
+    return this.trainingAdminService.getAdminStats(userId, enterpriseId);
+  }
+
+  @Get('admins')
+  getAdmins(
+    @User('id') userId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+    @Query('page', new ParseIntPipe({ optional: true })) page?: number,
+    @Query('pageSize', new ParseIntPipe({ optional: true })) pageSize?: number,
+    @Query('search') search?: string,
+    @Query('role') role?: string,
+  ) {
+    return this.trainingAdminService.getAdmins(userId, { enterpriseId, page, pageSize, search, role });
+  }
+
+  @Post('admins')
+  addAdmin(
+    @User('id') userId: number,
+    @Body() dto: { name: string; email?: string; department?: string; role?: string },
+  ) {
+    return this.trainingAdminService.addAdmin(userId, dto);
+  }
+
+  @Patch('admins/:id')
+  updateAdminRole(
+    @User('id') userId: number,
+    @Param('id', ParseIntPipe) enterpriseUserId: number,
+    @Body('role') role: string,
+  ) {
+    return this.trainingAdminService.updateAdminRole(userId, enterpriseUserId, role);
+  }
+
+  @Delete('admins/:id')
+  removeAdmin(
+    @User('id') userId: number,
+    @Param('id', ParseIntPipe) enterpriseUserId: number,
+  ) {
+    return this.trainingAdminService.removeAdmin(userId, enterpriseUserId);
+  }
+
+  @Get('relatorios')
+  getAdminReports(
+    @User('id') userId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+    @Query('dateFrom') dateFrom?: string,
+    @Query('dateTo') dateTo?: string,
+  ) {
+    return this.trainingAdminService.getAdminReports(userId, { enterpriseId, dateFrom, dateTo });
+  }
+
+  @Get('avaliacoes/stats')
+  getEvaluationStats(
+    @User('id') userId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+  ) {
+    return this.trainingAdminService.getEvaluationStats(userId, enterpriseId);
+  }
+
+  @Get('avaliacoes')
+  getEvaluationClassGroups(
+    @User('id') userId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+    @Query('page', new ParseIntPipe({ optional: true })) page?: number,
+    @Query('pageSize', new ParseIntPipe({ optional: true })) pageSize?: number,
+    @Query('search') search?: string,
+  ) {
+    return this.trainingAdminService.getEvaluationClassGroups(userId, { enterpriseId, page, pageSize, search });
+  }
+
+  @Get('avaliacoes/:classGroupId')
+  getEvaluationClassGroupDetail(
+    @User('id') userId: number,
+    @Param('classGroupId', ParseIntPipe) classGroupId: number,
+    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+  ) {
+    return this.trainingAdminService.getEvaluationClassGroupDetail(userId, classGroupId, enterpriseId);
+  }
+}