@hed-hog/lms 0.0.349 → 0.0.351

package/src/training/training.module.ts

@@ -1,12 +1,13 @@
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
+import { LmsTrainingPathsMcpTools } from './training.mcp-tools';
 import { TrainingController } from './training.controller';
 import { TrainingService } from './training.service';
 
 @Module({
   imports: [forwardRef(() => PrismaModule)],
   controllers: [TrainingController],
-  providers: [TrainingService],
+  providers: [TrainingService, LmsTrainingPathsMcpTools],
   exports: [forwardRef(() => TrainingService)],
 })
 export class TrainingModule {}

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,
+    };
+  }
+}