@hed-hog/lms 0.0.350 → 0.0.353

package/src/course/course.service.ts

@@ -201,7 +201,17 @@ export class CourseService {
             orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
           },
           _count: {
-            select: { course_enrollment: true, course_class_group: true },
+            select: {
+              course_enrollment: true,
+              course_class_group: true,
+              course_module: true,
+              course_file: true,
+            },
+          },
+          course_module: {
+            select: {
+              _count: { select: { course_lesson: true } },
+            },
           },
         },
       }),
@@ -425,6 +435,7 @@ export class CourseService {
         }),
         level: this.normalizeLevel(data.level) ?? 'beginner',
         status: this.normalizeStatus(data.status) ?? 'draft',
+        offering_type: (this.normalizeOfferingType(data.offeringType) ?? 'on_demand') as any,
         ...(data.requirements !== undefined && {
           requirements: data.requirements,
         }),
@@ -455,6 +466,7 @@ export class CourseService {
         ...(data.secondaryContrastColor !== undefined && {
           secondary_contrast_color: data.secondaryContrastColor,
         }),
+        ...(data.code !== undefined && { code: data.code }),
         ...(categories.length > 0 && {
           course_category: {
             create: categories.map((item) => ({ category_id: item.id })),
@@ -627,6 +639,10 @@ export class CourseService {
         ...(data.status !== undefined && {
           status: this.normalizeStatus(data.status),
         }),
+        ...(data.offeringType !== undefined &&
+          this.normalizeOfferingType(data.offeringType) !== undefined && {
+            offering_type: this.normalizeOfferingType(data.offeringType) as any,
+          }),
         ...(data.requirements !== undefined && {
           requirements: data.requirements,
         }),
@@ -657,6 +673,7 @@ export class CourseService {
         ...(data.secondaryContrastColor !== undefined && {
           secondary_contrast_color: data.secondaryContrastColor,
         }),
+        ...(data.code !== undefined && { code: data.code }),
         ...(categories.length > 0 && {
           course_category: {
             create: categories.map((item) => ({ category_id: item.id })),
@@ -811,6 +828,7 @@ export class CourseService {
       id: c.id,
       name: resolvedName ?? '',
       slug: c.slug,
+      code: c.code ?? null,
       title: resolvedTitle,
       description: c.description ?? '',
       level: c.level,
@@ -860,7 +878,12 @@ export class CourseService {
       enrollmentCount: c._count?.course_enrollment ?? 0,
       moduleCount: c._count?.course_module ?? 0,
       classCount,
-      lessonCount: metrics?.lessonCount ?? 0,
+      lessonCount:
+        (c.course_module as { _count: { course_lesson: number } }[] | undefined)
+          ?.reduce((sum: number, m: any) => sum + (m._count?.course_lesson ?? 0), 0) ??
+        metrics?.lessonCount ??
+        0,
+      resourceCount: c._count?.course_file ?? 0,
       sessionCount: metrics?.sessionCount ?? 0,
       averageCompletion: Math.round(metrics?.averageCompletion ?? 0),
       certificatesIssued:
@@ -1154,4 +1177,51 @@ export class CourseService {
       select: { id: true },
     });
   }
+
+  async getCourseVideoProfiles(courseId: number) {
+    const rows = await (this.prisma as any).course_video_resolution_profile.findMany({
+      where: { course_id: courseId },
+      include: { video_resolution_profile: true },
+      orderBy: { video_resolution_profile: { name: 'asc' } },
+    });
+
+    return (rows as any[]).map((row) => ({
+      id: row.video_resolution_profile.id,
+      name: row.video_resolution_profile.name,
+      ffmpeg_params: row.video_resolution_profile.ffmpeg_params,
+      status: row.video_resolution_profile.status,
+    }));
+  }
+
+  async syncCourseVideoProfiles(courseId: number, profileIds: number[]) {
+    const linkClient = (this.prisma as any).course_video_resolution_profile;
+
+    await this.prisma.$transaction(async (tx: any) => {
+      await tx.course_video_resolution_profile.deleteMany({
+        where: { course_id: courseId },
+      });
+
+      if (profileIds.length > 0) {
+        await tx.course_video_resolution_profile.createMany({
+          data: profileIds.map((id) => ({
+            course_id: courseId,
+            video_resolution_profile_id: id,
+          })),
+        });
+      }
+    });
+
+    return linkClient.findMany({
+      where: { course_id: courseId },
+      include: { video_resolution_profile: true },
+      orderBy: { video_resolution_profile: { name: 'asc' } },
+    }).then((rows: any[]) =>
+      rows.map((row: any) => ({
+        id: row.video_resolution_profile.id,
+        name: row.video_resolution_profile.name,
+        ffmpeg_params: row.video_resolution_profile.ffmpeg_params,
+        status: row.video_resolution_profile.status,
+      })),
+    );
+  }
 }

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

@@ -32,6 +32,12 @@ class CourseLessonResourceDto {
   publico?: boolean;
 }
 
+export class CreateLessonVideoConversionDto {
+  @IsInt()
+  @Min(1)
+  originalFileId: number;
+}
+
 export class CreateCourseStructureLessonDto {
   @IsString()
   @IsNotEmpty()
@@ -60,9 +66,9 @@ export class CreateCourseStructureLessonDto {
   @IsOptional()
   duracao: number = 0;
 
-  @IsEnum(['youtube', 'vimeo', 'bunny', 'custom'])
+  @IsEnum(['youtube', 'vimeo', 'file_storage', 'bunny', 'custom'])
   @IsOptional()
-  videoProvedor?: 'youtube' | 'vimeo' | 'bunny' | 'custom';
+  videoProvedor?: 'youtube' | 'vimeo' | 'file_storage' | 'bunny' | 'custom';
 
   @IsString()
   @IsOptional()
@@ -76,6 +82,11 @@ export class CreateCourseStructureLessonDto {
   @IsOptional()
   transcricao?: string;
 
+  @IsInt()
+  @Min(1)
+  @IsOptional()
+  videoConversionJobId?: number;
+
   @IsInt()
   @Min(1)
   @IsOptional()

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

@@ -123,4 +123,12 @@ export class CreateCourseDto {
   @IsInt()
   @IsOptional()
   operationsProjectId?: number | null;
+
+  @IsString()
+  @MaxLength(32)
+  @Matches(/^[A-Z0-9]{2,}$/, {
+    message: 'code deve conter apenas letras maiúsculas e números, mínimo 2 caracteres',
+  })
+  @IsOptional()
+  code?: string;
 }

package/src/enterprise/enterprise.controller.ts

@@ -118,7 +118,6 @@ export class EnterpriseController {
     return this.enterpriseService.getCrmOptions();
   }
 
-  @Public()
   @Get('auth/profiles')
   async getAuthProfiles(@UserOptional() user: any) {
     if (!user?.id) return { profiles: [] };

package/src/evaluation/evaluation.service.ts

@@ -114,7 +114,14 @@ export class EvaluationService {
       sessionWhere.course_class_group_id = params.classId;
     }
     if (params.instructorId) {
-      sessionWhere.course_class_group = { instructor_id: params.instructorId };
+      sessionWhere.OR = [
+        { course_class_group: { instructor_id: params.instructorId } },
+        {
+          course_class_session_instructor: {
+            some: { instructor_id: params.instructorId },
+          },
+        },
+      ];
     }
     if (Object.keys(sessionWhere).length > 0) {
       topicWhere.course_class_session = sessionWhere;
@@ -252,7 +259,7 @@ export class EvaluationService {
         }
         if (group.instructor?.person) {
           instructorName = group.instructor.person.name;
-          instructorId = group.instructor.person.id;
+          instructorId = group.instructor.id;
         }
       }
     } else if (targetType === 'question' && topic.question) {

package/src/index.ts

@@ -12,6 +12,7 @@ export * from './course-lesson-note/course-lesson-note.module';
 export * from './course-lesson-note/course-lesson-note.service';
 export * from './course/course-structure.controller';
 export * from './course/course-structure.service';
+export * from './course/course-video-conversion.service';
 export * from './course/course.controller';
 export * from './course/course.module';
 export * from './course/course.service';

package/src/lms.module.ts

@@ -19,6 +19,7 @@ import { InstructorModule } from './instructor/instructor.module';
 import { LmsRealtimeModule } from './realtime/lms-realtime.module';
 import { LmsReportsModule } from './reports/reports.module';
 import { TrainingModule } from './training/training.module';
+import { VideoResolutionProfileModule } from './video-resolution-profile/video-resolution-profile.module';
 
 @Module({
   imports: [
@@ -42,6 +43,7 @@ import { TrainingModule } from './training/training.module';
     forwardRef(() => LmsRealtimeModule),
     forwardRef(() => LmsReportsModule),
     forwardRef(() => TrainingModule),
+    forwardRef(() => VideoResolutionProfileModule),
   ],
   exports: [
     forwardRef(() => AchievementModule),
@@ -60,6 +62,7 @@ import { TrainingModule } from './training/training.module';
     forwardRef(() => LmsRealtimeModule),
     forwardRef(() => LmsReportsModule),
     forwardRef(() => TrainingModule),
+    forwardRef(() => VideoResolutionProfileModule),
   ],
 })
 export class LmsModule {}

package/src/video-resolution-profile/dto/create-video-resolution-profile.dto.ts

@@ -0,0 +1,16 @@
+import { IsEnum, IsNotEmpty, IsOptional, IsString, MaxLength } from 'class-validator';
+
+export class CreateVideoResolutionProfileDto {
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(100)
+  name: string;
+
+  @IsString()
+  @IsNotEmpty()
+  ffmpeg_params: string;
+
+  @IsOptional()
+  @IsEnum(['active', 'inactive'])
+  status?: 'active' | 'inactive';
+}

package/src/video-resolution-profile/dto/update-video-resolution-profile.dto.ts

@@ -0,0 +1,16 @@
+import { IsEnum, IsOptional, IsString, MaxLength } from 'class-validator';
+
+export class UpdateVideoResolutionProfileDto {
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  name?: string;
+
+  @IsOptional()
+  @IsString()
+  ffmpeg_params?: string;
+
+  @IsOptional()
+  @IsEnum(['active', 'inactive'])
+  status?: 'active' | 'inactive';
+}

package/src/video-resolution-profile/video-resolution-profile.controller.ts

@@ -0,0 +1,62 @@
+import { Role } from '@hed-hog/api';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { CreateVideoResolutionProfileDto } from './dto/create-video-resolution-profile.dto';
+import { UpdateVideoResolutionProfileDto } from './dto/update-video-resolution-profile.dto';
+import { VideoResolutionProfileService } from './video-resolution-profile.service';
+
+@Role()
+@Controller('lms/video-resolution-profiles')
+export class VideoResolutionProfileController {
+  constructor(
+    private readonly videoResolutionProfileService: VideoResolutionProfileService,
+  ) {}
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+  ) {
+    return this.videoResolutionProfileService.list({
+      page: page ? Number(page) : 1,
+      pageSize: pageSize ? Number(pageSize) : 20,
+      search,
+    });
+  }
+
+  @Get('all')
+  getAll() {
+    return this.videoResolutionProfileService.getAll();
+  }
+
+  @Post()
+  create(@Body() dto: CreateVideoResolutionProfileDto) {
+    return this.videoResolutionProfileService.create(dto);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateVideoResolutionProfileDto,
+  ) {
+    return this.videoResolutionProfileService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.videoResolutionProfileService.delete(id);
+  }
+}

package/src/video-resolution-profile/video-resolution-profile.mcp-tools.ts

@@ -0,0 +1,128 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { CreateVideoResolutionProfileDto } from './dto/create-video-resolution-profile.dto';
+import { UpdateVideoResolutionProfileDto } from './dto/update-video-resolution-profile.dto';
+import { VideoResolutionProfileService } from './video-resolution-profile.service';
+
+@Injectable()
+export class VideoResolutionProfileMcpTools {
+  constructor(
+    private readonly videoResolutionProfileService: VideoResolutionProfileService,
+  ) {}
+
+  @McpTool({
+    name: 'lms.video-resolution-profiles.list',
+    description: 'Lists video resolution profiles with optional pagination and search.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        search: { type: 'string', description: 'Search term by profile name' },
+      },
+    },
+    readOnly: true,
+  })
+  async listProfiles(
+    args: { page?: number; pageSize?: number; search?: string },
+    _context: McpContext,
+  ): Promise<any> {
+    return this.videoResolutionProfileService.list(args);
+  }
+
+  @McpTool({
+    name: 'lms.video-resolution-profiles.list-active',
+    description: 'Lists all active video resolution profiles.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+    readOnly: true,
+  })
+  async listActiveProfiles(
+    _args: Record<string, never>,
+    _context: McpContext,
+  ): Promise<any> {
+    return this.videoResolutionProfileService.getAll();
+  }
+
+  @McpTool({
+    name: 'lms.video-resolution-profiles.create',
+    description: 'Creates a new video resolution profile.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Profile name (required, max 100 chars)' },
+        ffmpeg_params: { type: 'string', description: 'FFmpeg params string (required)' },
+        status: { type: 'string', description: 'Status (active|inactive)' },
+      },
+      required: ['name', 'ffmpeg_params'],
+    },
+  })
+  async createProfile(
+    args: CreateVideoResolutionProfileDto,
+    _context: McpContext,
+  ): Promise<any> {
+    return this.videoResolutionProfileService.create(args);
+  }
+
+  @McpTool({
+    name: 'lms.video-resolution-profiles.update',
+    description: 'Updates an existing video resolution profile.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Profile ID' },
+        name: { type: 'string', description: 'Profile name (max 100 chars)' },
+        ffmpeg_params: { type: 'string', description: 'FFmpeg params string' },
+        status: { type: 'string', description: 'Status (active|inactive)' },
+      },
+      required: ['id'],
+    },
+  })
+  async updateProfile(
+    args: { id: number } & UpdateVideoResolutionProfileDto,
+    _context: McpContext,
+  ): Promise<any> {
+    const { id, ...dto } = args;
+    return this.videoResolutionProfileService.update(id, dto);
+  }
+
+  @McpTool({
+    name: 'lms.video-resolution-profiles.delete',
+    description: 'Removes a video resolution profile by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Profile ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteProfile(
+    args: { id: number },
+    _context: McpContext,
+  ): Promise<any> {
+    return this.videoResolutionProfileService.delete(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.video-resolution-profiles.toggle-status',
+    description: 'Toggles profile status between active and inactive.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Profile ID' },
+        status: { type: 'string', description: 'Target status (active|inactive)' },
+      },
+      required: ['id', 'status'],
+    },
+  })
+  async toggleProfileStatus(
+    args: { id: number; status: 'active' | 'inactive' },
+    _context: McpContext,
+  ): Promise<any> {
+    const { id, status } = args;
+    return this.videoResolutionProfileService.update(id, { status });
+  }
+}

package/src/video-resolution-profile/video-resolution-profile.module.ts

@@ -0,0 +1,13 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { VideoResolutionProfileController } from './video-resolution-profile.controller';
+import { VideoResolutionProfileMcpTools } from './video-resolution-profile.mcp-tools';
+import { VideoResolutionProfileService } from './video-resolution-profile.service';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule)],
+  controllers: [VideoResolutionProfileController],
+  providers: [VideoResolutionProfileService, VideoResolutionProfileMcpTools],
+  exports: [forwardRef(() => VideoResolutionProfileService)],
+})
+export class VideoResolutionProfileModule {}

package/src/video-resolution-profile/video-resolution-profile.service.ts

@@ -0,0 +1,117 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { CreateVideoResolutionProfileDto } from './dto/create-video-resolution-profile.dto';
+import { UpdateVideoResolutionProfileDto } from './dto/update-video-resolution-profile.dto';
+
+@Injectable()
+export class VideoResolutionProfileService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  private get profileClient() {
+    return (this.prisma as any).video_resolution_profile;
+  }
+
+  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.name = { contains: search, mode: 'insensitive' };
+    }
+
+    const [rows, total] = await Promise.all([
+      this.profileClient.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy: { name: 'asc' },
+      }),
+      this.profileClient.count({ where }),
+    ]);
+
+    return {
+      data: (rows as any[]).map((row) => this.mapRow(row)),
+      total,
+      page,
+      pageSize,
+    };
+  }
+
+  async getAll() {
+    const rows = await this.profileClient.findMany({
+      where: { status: 'active' },
+      orderBy: { name: 'asc' },
+    });
+
+    return (rows as any[]).map((row) => this.mapRow(row));
+  }
+
+  async create(dto: CreateVideoResolutionProfileDto) {
+    const profile = await this.profileClient.create({
+      data: {
+        name: dto.name,
+        ffmpeg_params: dto.ffmpeg_params,
+        status: dto.status ?? 'active',
+      },
+    });
+
+    return this.getProfileById(profile.id);
+  }
+
+  async update(id: number, dto: UpdateVideoResolutionProfileDto) {
+    const profile = await this.profileClient.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!profile) {
+      throw new NotFoundException('Video resolution profile not found');
+    }
+
+    const data: any = {};
+    if (dto.name !== undefined) data.name = dto.name;
+    if (dto.ffmpeg_params !== undefined) data.ffmpeg_params = dto.ffmpeg_params;
+    if (dto.status !== undefined) data.status = dto.status;
+
+    if (Object.keys(data).length > 0) {
+      await this.profileClient.update({ where: { id }, data });
+    }
+
+    return this.getProfileById(id);
+  }
+
+  async delete(id: number) {
+    const profile = await this.profileClient.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!profile) {
+      throw new NotFoundException('Video resolution profile not found');
+    }
+
+    await this.profileClient.delete({ where: { id } });
+  }
+
+  private async getProfileById(id: number) {
+    const row = await this.profileClient.findUnique({ where: { id } });
+
+    if (!row) {
+      throw new NotFoundException('Video resolution profile not found');
+    }
+
+    return this.mapRow(row);
+  }
+
+  private mapRow(row: any) {
+    return {
+      id: row.id,
+      name: row.name,
+      ffmpeg_params: row.ffmpeg_params,
+      status: row.status,
+    };
+  }
+}