@hed-hog/lms 0.0.349 → 0.0.351

package/src/achievement/achievement.service.ts

@@ -0,0 +1,252 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { CreateAchievementDto } from './dto/create-achievement.dto';
+import { UpdateAchievementDto } from './dto/update-achievement.dto';
+
+type AchievementRow = {
+  id: number;
+  name: string;
+  description: string | null;
+  iconFileId: number | null;
+  mainImageFileId: number | null;
+  type: string;
+  bitCodesValue: number;
+  canReceiveMultipleTimes: boolean;
+  createdAt: string | null;
+  updatedAt: string | null;
+};
+
+@Injectable()
+export class AchievementService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  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 offset = (page - 1) * pageSize;
+    const search = params.search?.trim();
+
+    const values: unknown[] = [];
+    const where = ['1 = 1'];
+
+    if (search) {
+      const placeholder = this.param(values, `%${search}%`);
+      where.push(`(
+        a.name ILIKE ${placeholder}
+        OR COALESCE(a.description, '') ILIKE ${placeholder}
+        OR a.type::text ILIKE ${placeholder}
+      )`);
+    }
+
+    const whereClause = where.join(' AND ');
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM achievement a
+        WHERE ${whereClause}`,
+      values
+    );
+
+    const queryValues = [...values];
+    const limitPlaceholder = this.param(queryValues, pageSize);
+    const offsetPlaceholder = this.param(queryValues, offset);
+
+    const rows = await this.queryRows<AchievementRow>(
+      `SELECT
+          a.id,
+          a.name,
+          a.description,
+          a.icon_file_id AS "iconFileId",
+          a.main_image_file_id AS "mainImageFileId",
+          a.type::text AS type,
+          a.bitcodes_value AS "bitCodesValue",
+          a.can_receive_multiple_times AS "canReceiveMultipleTimes",
+          a.created_at::text AS "createdAt",
+          a.updated_at::text AS "updatedAt"
+        FROM achievement a
+       WHERE ${whereClause}
+       ORDER BY a.name ASC, a.id ASC
+       LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}`,
+      queryValues
+    );
+
+    return {
+      data: rows.map((row) => this.mapRow(row)),
+      total: Number(totalRow?.total ?? 0),
+      page,
+      pageSize,
+    };
+  }
+
+  async create(dto: CreateAchievementDto) {
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO achievement (
+          name,
+          description,
+          icon_file_id,
+          main_image_file_id,
+          type,
+          bitcodes_value,
+          can_receive_multiple_times,
+          created_at,
+          updated_at
+        ) VALUES (
+          $1,
+          $2,
+          $3,
+          $4,
+          $5::achievement_type_6ee0f922f6_enum,
+          $6,
+          $7,
+          NOW(),
+          NOW()
+        )
+        RETURNING id`,
+      [
+        dto.name.trim(),
+        this.normalizeOptionalText(dto.description),
+        dto.iconFileId ?? null,
+        dto.mainImageFileId ?? null,
+        dto.type,
+        Number(dto.bitCodesValue ?? 0),
+        Boolean(dto.canReceiveMultipleTimes),
+      ]
+    );
+
+    return this.getById(created.id);
+  }
+
+  async update(id: number, dto: UpdateAchievementDto) {
+    await this.ensureExists(id);
+
+    const updates: string[] = [];
+    const values: unknown[] = [];
+
+    if (dto.name !== undefined) {
+      updates.push(`name = ${this.param(values, dto.name.trim())}`);
+    }
+
+    if (dto.description !== undefined) {
+      updates.push(
+        `description = ${this.param(values, this.normalizeOptionalText(dto.description))}`
+      );
+    }
+
+    if (dto.iconFileId !== undefined) {
+      updates.push(`icon_file_id = ${this.param(values, dto.iconFileId ?? null)}`);
+    }
+
+    if (dto.mainImageFileId !== undefined) {
+      updates.push(
+        `main_image_file_id = ${this.param(values, dto.mainImageFileId ?? null)}`
+      );
+    }
+
+    if (dto.type !== undefined) {
+      updates.push(
+        `type = ${this.param(values, dto.type)}::achievement_type_6ee0f922f6_enum`
+      );
+    }
+
+    if (dto.bitCodesValue !== undefined) {
+      updates.push(`bitcodes_value = ${this.param(values, Number(dto.bitCodesValue))}`);
+    }
+
+    if (dto.canReceiveMultipleTimes !== undefined) {
+      updates.push(
+        `can_receive_multiple_times = ${this.param(
+          values,
+          Boolean(dto.canReceiveMultipleTimes)
+        )}`
+      );
+    }
+
+    if (updates.length > 0) {
+      values.push(id);
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE achievement
+            SET ${updates.join(', ')},
+                updated_at = NOW()
+          WHERE id = $${values.length}`,
+        ...values
+      );
+    }
+
+    return this.getById(id);
+  }
+
+  async delete(id: number) {
+    await this.ensureExists(id);
+    await this.prisma.$executeRawUnsafe(`DELETE FROM achievement WHERE id = $1`, id);
+  }
+
+  async getById(id: number) {
+    const row = await this.querySingle<AchievementRow>(
+      `SELECT
+          a.id,
+          a.name,
+          a.description,
+          a.icon_file_id AS "iconFileId",
+          a.main_image_file_id AS "mainImageFileId",
+          a.type::text AS type,
+          a.bitcodes_value AS "bitCodesValue",
+          a.can_receive_multiple_times AS "canReceiveMultipleTimes",
+          a.created_at::text AS "createdAt",
+          a.updated_at::text AS "updatedAt"
+        FROM achievement a
+       WHERE a.id = $1`,
+      [id]
+    );
+
+    if (!row) {
+      throw new NotFoundException('Achievement not found');
+    }
+
+    return this.mapRow(row);
+  }
+
+  private async ensureExists(id: number) {
+    const row = await this.querySingle<{ id: number }>(
+      `SELECT id FROM achievement WHERE id = $1`,
+      [id]
+    );
+
+    if (!row) {
+      throw new NotFoundException('Achievement not found');
+    }
+  }
+
+  private mapRow(row: AchievementRow) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      iconFileId: row.iconFileId,
+      mainImageFileId: row.mainImageFileId,
+      type: row.type,
+      bitCodesValue: Number(row.bitCodesValue ?? 0),
+      canReceiveMultipleTimes: Boolean(row.canReceiveMultipleTimes),
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  private normalizeOptionalText(value?: string | null) {
+    const normalized = value?.trim();
+    return normalized ? normalized : null;
+  }
+
+  private param(values: unknown[], value: unknown) {
+    values.push(value);
+    return `$${values.length}`;
+  }
+
+  private async queryRows<T>(query: string, values: unknown[] = []) {
+    return this.prisma.$queryRawUnsafe<T[]>(query, ...values);
+  }
+
+  private async querySingle<T>(query: string, values: unknown[] = []) {
+    const rows = await this.prisma.$queryRawUnsafe<T[]>(query, ...values);
+    return rows[0] ?? null;
+  }
+}

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

@@ -0,0 +1,50 @@
+import {
+  IsBoolean,
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+  MaxLength,
+  Min,
+} from 'class-validator';
+
+export const ACHIEVEMENT_TYPE_VALUES = [
+  'course_completion',
+  'learning_path_completion',
+  'exam_approval',
+  'attendance',
+  'engagement',
+  'custom',
+] as const;
+
+export type AchievementType = (typeof ACHIEVEMENT_TYPE_VALUES)[number];
+
+export class CreateAchievementDto {
+  @IsString()
+  @MaxLength(255)
+  name: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  iconFileId?: number | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  mainImageFileId?: number | null;
+
+  @IsEnum(ACHIEVEMENT_TYPE_VALUES)
+  type: AchievementType;
+
+  @IsInt()
+  @Min(0)
+  bitCodesValue: number;
+
+  @IsBoolean()
+  canReceiveMultipleTimes: boolean;
+}

package/src/achievement/dto/update-achievement.dto.ts

@@ -0,0 +1,47 @@
+import {
+  IsBoolean,
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+  MaxLength,
+  Min,
+} from 'class-validator';
+import {
+  ACHIEVEMENT_TYPE_VALUES,
+  type AchievementType,
+} from './create-achievement.dto';
+
+export class UpdateAchievementDto {
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  name?: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  iconFileId?: number | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  mainImageFileId?: number | null;
+
+  @IsOptional()
+  @IsEnum(ACHIEVEMENT_TYPE_VALUES)
+  type?: AchievementType;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  bitCodesValue?: number;
+
+  @IsOptional()
+  @IsBoolean()
+  canReceiveMultipleTimes?: boolean;
+}

package/src/bitcode-wallet/bitcode-wallet.controller.ts

@@ -0,0 +1,69 @@
+import { Role } from '@hed-hog/api';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    HttpCode,
+    HttpStatus,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Query,
+} from '@nestjs/common';
+import { BitcodeWalletService } from './bitcode-wallet.service';
+import { CreateBitcodeWalletTransactionDto } from './dto/create-bitcode-wallet-transaction.dto';
+import { CreateBitcodeWalletDto } from './dto/create-bitcode-wallet.dto';
+import { UpdateBitcodeWalletDto } from './dto/update-bitcode-wallet.dto';
+
+@Role()
+@Controller('lms/bitcode-wallets')
+export class BitcodeWalletController {
+  constructor(private readonly bitcodeWalletService: BitcodeWalletService) {}
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string
+  ) {
+    return this.bitcodeWalletService.list({
+      page: page ? Number(page) : 1,
+      pageSize: pageSize ? Number(pageSize) : 12,
+      search,
+    });
+  }
+
+  @Get(':id')
+  getById(@Param('id', ParseIntPipe) id: number) {
+    return this.bitcodeWalletService.getById(id);
+  }
+
+  @Post()
+  create(@Body() dto: CreateBitcodeWalletDto) {
+    return this.bitcodeWalletService.create(dto);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateBitcodeWalletDto
+  ) {
+    return this.bitcodeWalletService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.bitcodeWalletService.delete(id);
+  }
+
+  @Post(':id/transactions')
+  createTransaction(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: CreateBitcodeWalletTransactionDto
+  ) {
+    return this.bitcodeWalletService.createTransaction(id, dto);
+  }
+}

package/src/bitcode-wallet/bitcode-wallet.mcp-tools.ts

@@ -0,0 +1,107 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { BitcodeWalletService } from './bitcode-wallet.service';
+
+@Injectable()
+export class LmsBitcodeWalletMcpTools {
+  constructor(private readonly bitcodeWalletService: BitcodeWalletService) {}
+
+  @McpTool({
+    name: 'lms.bitcode-wallet.list',
+    description: 'Lists LMS BitCode wallets with optional pagination and search by person name.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 12)' },
+        search: { type: 'string', description: 'Search term (person name)' },
+      },
+    },
+    readOnly: true,
+  })
+  async listWallets(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.bitcodeWalletService.list(args);
+  }
+
+  @McpTool({
+    name: 'lms.bitcode-wallet.get',
+    description: 'Returns a single BitCode wallet by ID including its transaction history.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Wallet ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getWallet(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.bitcodeWalletService.getById(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.bitcode-wallet.create',
+    description: 'Creates a new BitCode wallet for a person.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        personId: { type: 'number', description: 'Person ID to create the wallet for (required)' },
+      },
+      required: ['personId'],
+    },
+  })
+  async createWallet(args: { personId: number }, _context: McpContext): Promise<any> {
+    return this.bitcodeWalletService.create(args as any);
+  }
+
+  @McpTool({
+    name: 'lms.bitcode-wallet.update',
+    description: 'Updates the person linked to a BitCode wallet.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Wallet ID' },
+        personId: { type: 'number', description: 'New person ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async updateWallet(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.bitcodeWalletService.update(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.bitcode-wallet.delete',
+    description: 'Deletes a BitCode wallet by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Wallet ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteWallet(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.bitcodeWalletService.delete(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.bitcode-wallet.create-transaction',
+    description: 'Creates a credit or debit transaction on a BitCode wallet.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Wallet ID' },
+        type: { type: 'string', description: 'Transaction type', enum: ['credit', 'debit'] },
+        amount: { type: 'number', description: 'Transaction amount' },
+        description: { type: 'string', description: 'Transaction description' },
+      },
+      required: ['id', 'type', 'amount'],
+    },
+  })
+  async createTransaction(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.bitcodeWalletService.createTransaction(id, dto as any);
+  }
+}

package/src/bitcode-wallet/bitcode-wallet.module.ts

@@ -0,0 +1,13 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { BitcodeWalletController } from './bitcode-wallet.controller';
+import { LmsBitcodeWalletMcpTools } from './bitcode-wallet.mcp-tools';
+import { BitcodeWalletService } from './bitcode-wallet.service';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule)],
+  controllers: [BitcodeWalletController],
+  providers: [BitcodeWalletService, LmsBitcodeWalletMcpTools],
+  exports: [BitcodeWalletService],
+})
+export class BitcodeWalletModule {}