@hed-hog/lms 0.0.319 → 0.0.320

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

@@ -4,11 +4,10 @@ import {
     IsInt,
     IsISO8601,
     IsNotEmpty,
-    IsOptional,
-    IsString,
-    IsUrl,
-    Matches,
-    MaxLength,
+    IsOptional,
+    IsString,
+    Matches,
+    MaxLength,
     Min,
     ValidateNested,
 } from 'class-validator';
@@ -128,9 +127,10 @@ export class CreateClassGroupDto {
   @IsOptional()
   location?: string;
 
-  @IsUrl({ require_tld: false })
-  @IsOptional()
-  virtualRoomUrl?: string;
+  @IsString()
+  @MaxLength(500)
+  @IsOptional()
+  virtualRoomUrl?: string;
 
   @ValidateNested()
   @Type(() => ClassGroupSessionTemplateDto)

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

@@ -822,27 +822,60 @@ export class CourseService {
     }
   }
 
-  private async syncCourseImages(
-    courseId: number,
-    data: {
-      logoFileId?: number;
-      bannerFileId?: number;
-    },
-  ) {
-    if (data.logoFileId !== undefined) {
-      await this.upsertCourseImage(courseId, data.logoFileId, 'course-logo');
-    }
-
-    if (data.bannerFileId !== undefined) {
-      await this.upsertCourseImage(
-        courseId,
-        data.bannerFileId,
-        'course-banner',
-      );
-    }
-  }
-
-  private async upsertCourseImage(
+  private async syncCourseImages(
+    courseId: number,
+    data: {
+      logoFileId?: number | null;
+      bannerFileId?: number | null;
+    },
+  ) {
+    if (data.logoFileId !== undefined) {
+      await this.syncCourseImage(courseId, data.logoFileId, 'course-logo');
+    }
+
+    if (data.bannerFileId !== undefined) {
+      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(
     courseId: number,
     fileId: number,
     imageTypeSlug: CourseImageTypeSlug,

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

@@ -104,11 +104,11 @@ export class CreateCourseDto {
   @IsOptional()
   instructorIds?: number[];
 
-  @IsInt()
-  @IsOptional()
-  logoFileId?: number;
-
-  @IsInt()
-  @IsOptional()
-  bannerFileId?: number;
-}
+  @IsInt()
+  @IsOptional()
+  logoFileId?: number | null;
+
+  @IsInt()
+  @IsOptional()
+  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 {}