@hed-hog/lms 0.0.347 → 0.0.350

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 {}

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

@@ -0,0 +1,361 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+    ConflictException,
+    Injectable,
+    NotFoundException,
+} from '@nestjs/common';
+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';
+
+type BitcodeWalletListRow = {
+  id: number;
+  personId: number;
+  personName: string | null;
+  currentBalance: number;
+  transactionCount: number;
+  totalCredits: number;
+  totalDebits: number;
+  createdAt: string | null;
+  updatedAt: string | null;
+};
+
+type BitcodeWalletSummaryRow = {
+  walletCount: number;
+  totalBalance: number;
+  transactionCount: number;
+  totalCredits: number;
+  totalDebits: number;
+};
+
+type BitcodeWalletTransactionRow = {
+  id: number;
+  walletId: number;
+  type: string;
+  amount: number;
+  description: string | null;
+  createdAt: string | null;
+  updatedAt: string | null;
+};
+
+@Injectable()
+export class BitcodeWalletService {
+  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) || 12, 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(`p.name ILIKE ${placeholder}`);
+    }
+
+    const whereClause = where.join(' AND ');
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM bitcode_wallet bw
+         JOIN person p ON p.id = bw.person_id
+        WHERE ${whereClause}`,
+      values
+    );
+
+    const summaryRow =
+      (await this.querySingle<BitcodeWalletSummaryRow>(
+        `SELECT
+            COUNT(*)::int AS "walletCount",
+            COALESCE(SUM(bw.current_balance), 0)::int AS "totalBalance",
+            COALESCE(SUM(stats.transaction_count), 0)::int AS "transactionCount",
+            COALESCE(SUM(stats.total_credits), 0)::int AS "totalCredits",
+            COALESCE(SUM(stats.total_debits), 0)::int AS "totalDebits"
+          FROM bitcode_wallet bw
+          JOIN person p ON p.id = bw.person_id
+          LEFT JOIN LATERAL (
+            SELECT
+              COUNT(*)::int AS transaction_count,
+              COALESCE(SUM(CASE WHEN type = 'credit' THEN amount ELSE 0 END), 0)::int AS total_credits,
+              COALESCE(SUM(CASE WHEN type = 'debit' THEN amount ELSE 0 END), 0)::int AS total_debits
+            FROM bitcode_wallet_transaction bt
+            WHERE bt.wallet_id = bw.id
+          ) stats ON TRUE
+         WHERE ${whereClause}`,
+        values
+      )) ?? {
+        walletCount: 0,
+        totalBalance: 0,
+        transactionCount: 0,
+        totalCredits: 0,
+        totalDebits: 0,
+      };
+
+    const queryValues = [...values];
+    const limitPlaceholder = this.param(queryValues, pageSize);
+    const offsetPlaceholder = this.param(queryValues, offset);
+
+    const rows = await this.queryRows<BitcodeWalletListRow>(
+      `SELECT
+          bw.id,
+          bw.person_id AS "personId",
+          p.name AS "personName",
+          bw.current_balance AS "currentBalance",
+          COALESCE(stats.transaction_count, 0)::int AS "transactionCount",
+          COALESCE(stats.total_credits, 0)::int AS "totalCredits",
+          COALESCE(stats.total_debits, 0)::int AS "totalDebits",
+          bw.created_at::text AS "createdAt",
+          bw.updated_at::text AS "updatedAt"
+        FROM bitcode_wallet bw
+        JOIN person p ON p.id = bw.person_id
+        LEFT JOIN LATERAL (
+          SELECT
+            COUNT(*)::int AS transaction_count,
+            COALESCE(SUM(CASE WHEN type = 'credit' THEN amount ELSE 0 END), 0)::int AS total_credits,
+            COALESCE(SUM(CASE WHEN type = 'debit' THEN amount ELSE 0 END), 0)::int AS total_debits
+          FROM bitcode_wallet_transaction bt
+          WHERE bt.wallet_id = bw.id
+        ) stats ON TRUE
+       WHERE ${whereClause}
+       ORDER BY p.name ASC, bw.id ASC
+       LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}`,
+      queryValues
+    );
+
+    const total = Number(totalRow?.total ?? 0);
+
+    return {
+      data: rows.map((row) => this.mapWalletRow(row)),
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      summary: {
+        walletCount: Number(summaryRow.walletCount ?? 0),
+        totalBalance: Number(summaryRow.totalBalance ?? 0),
+        transactionCount: Number(summaryRow.transactionCount ?? 0),
+        totalCredits: Number(summaryRow.totalCredits ?? 0),
+        totalDebits: Number(summaryRow.totalDebits ?? 0),
+      },
+    };
+  }
+
+  async getById(id: number) {
+    const row = await this.querySingle<BitcodeWalletListRow>(
+      `SELECT
+          bw.id,
+          bw.person_id AS "personId",
+          p.name AS "personName",
+          bw.current_balance AS "currentBalance",
+          COALESCE(stats.transaction_count, 0)::int AS "transactionCount",
+          COALESCE(stats.total_credits, 0)::int AS "totalCredits",
+          COALESCE(stats.total_debits, 0)::int AS "totalDebits",
+          bw.created_at::text AS "createdAt",
+          bw.updated_at::text AS "updatedAt"
+        FROM bitcode_wallet bw
+        JOIN person p ON p.id = bw.person_id
+        LEFT JOIN LATERAL (
+          SELECT
+            COUNT(*)::int AS transaction_count,
+            COALESCE(SUM(CASE WHEN type = 'credit' THEN amount ELSE 0 END), 0)::int AS total_credits,
+            COALESCE(SUM(CASE WHEN type = 'debit' THEN amount ELSE 0 END), 0)::int AS total_debits
+          FROM bitcode_wallet_transaction bt
+          WHERE bt.wallet_id = bw.id
+        ) stats ON TRUE
+       WHERE bw.id = $1`,
+      [id]
+    );
+
+    if (!row) {
+      throw new NotFoundException('BitCode wallet not found');
+    }
+
+    const transactions = await this.queryRows<BitcodeWalletTransactionRow>(
+      `SELECT
+          bt.id,
+          bt.wallet_id AS "walletId",
+          bt.type::text AS type,
+          bt.amount,
+          bt.description,
+          bt.created_at::text AS "createdAt",
+          bt.updated_at::text AS "updatedAt"
+        FROM bitcode_wallet_transaction bt
+       WHERE bt.wallet_id = $1
+       ORDER BY bt.created_at DESC, bt.id DESC`,
+      [id]
+    );
+
+    return {
+      ...this.mapWalletRow(row),
+      transactions: transactions.map((transaction) =>
+        this.mapTransactionRow(transaction)
+      ),
+    };
+  }
+
+  async create(dto: CreateBitcodeWalletDto) {
+    await this.ensurePersonExists(dto.personId);
+    await this.ensurePersonHasNoWallet(dto.personId);
+
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO bitcode_wallet (
+          person_id,
+          current_balance,
+          created_at,
+          updated_at
+        ) VALUES (
+          $1,
+          0,
+          NOW(),
+          NOW()
+        )
+        RETURNING id`,
+      [dto.personId]
+    );
+
+    return this.getById(created.id);
+  }
+
+  async update(id: number, dto: UpdateBitcodeWalletDto) {
+    await this.ensureWalletExists(id);
+
+    if (dto.personId !== undefined) {
+      await this.ensurePersonExists(dto.personId);
+      await this.ensurePersonHasNoWallet(dto.personId, id);
+
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE bitcode_wallet
+            SET person_id = $1,
+                updated_at = NOW()
+          WHERE id = $2`,
+        dto.personId,
+        id
+      );
+    }
+
+    return this.getById(id);
+  }
+
+  async delete(id: number) {
+    await this.ensureWalletExists(id);
+    await this.prisma.$executeRawUnsafe(`DELETE FROM bitcode_wallet WHERE id = $1`, id);
+  }
+
+  async createTransaction(
+    walletId: number,
+    dto: CreateBitcodeWalletTransactionDto
+  ) {
+    await this.ensureWalletExists(walletId);
+
+    await this.prisma.$executeRawUnsafe(
+      `INSERT INTO bitcode_wallet_transaction (
+          wallet_id,
+          type,
+          amount,
+          description,
+          created_at,
+          updated_at
+        ) VALUES (
+          $1,
+          $2::bitcode_wallet_transaction_type_7b37a2f43e_enum,
+          $3,
+          $4,
+          NOW(),
+          NOW()
+        )`,
+      walletId,
+      dto.type,
+      Number(dto.amount),
+      this.normalizeOptionalText(dto.description)
+    );
+
+    return this.getById(walletId);
+  }
+
+  private async ensurePersonExists(personId: number) {
+    const row = await this.querySingle<{ id: number }>(
+      `SELECT id FROM person WHERE id = $1`,
+      [personId]
+    );
+
+    if (!row) {
+      throw new NotFoundException('Person not found');
+    }
+  }
+
+  private async ensureWalletExists(id: number) {
+    const row = await this.querySingle<{ id: number }>(
+      `SELECT id FROM bitcode_wallet WHERE id = $1`,
+      [id]
+    );
+
+    if (!row) {
+      throw new NotFoundException('BitCode wallet not found');
+    }
+  }
+
+  private async ensurePersonHasNoWallet(personId: number, walletIdToIgnore?: number) {
+    const values: unknown[] = [personId];
+    let query = `SELECT id FROM bitcode_wallet WHERE person_id = $1`;
+
+    if (walletIdToIgnore) {
+      values.push(walletIdToIgnore);
+      query += ` AND id <> $2`;
+    }
+
+    const existing = await this.querySingle<{ id: number }>(query, values);
+
+    if (existing) {
+      throw new ConflictException('This person already has a BitCode wallet');
+    }
+  }
+
+  private mapWalletRow(row: BitcodeWalletListRow) {
+    return {
+      id: row.id,
+      personId: row.personId,
+      personName: row.personName ?? `Pessoa #${row.personId}`,
+      currentBalance: Number(row.currentBalance ?? 0),
+      transactionCount: Number(row.transactionCount ?? 0),
+      totalCredits: Number(row.totalCredits ?? 0),
+      totalDebits: Number(row.totalDebits ?? 0),
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  private mapTransactionRow(row: BitcodeWalletTransactionRow) {
+    return {
+      id: row.id,
+      walletId: row.walletId,
+      type: row.type,
+      amount: Number(row.amount ?? 0),
+      description: row.description,
+      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/bitcode-wallet/dto/create-bitcode-wallet-transaction.dto.ts

@@ -0,0 +1,27 @@
+import {
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+  MaxLength,
+  Min,
+} from 'class-validator';
+
+export const BITCODE_TRANSACTION_TYPE_VALUES = ['credit', 'debit'] as const;
+
+export type BitcodeTransactionType =
+  (typeof BITCODE_TRANSACTION_TYPE_VALUES)[number];
+
+export class CreateBitcodeWalletTransactionDto {
+  @IsEnum(BITCODE_TRANSACTION_TYPE_VALUES)
+  type: BitcodeTransactionType;
+
+  @IsInt()
+  @Min(1)
+  amount: number;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(2000)
+  description?: string | null;
+}

package/src/bitcode-wallet/dto/create-bitcode-wallet.dto.ts

@@ -0,0 +1,7 @@
+import { IsInt, Min } from 'class-validator';
+
+export class CreateBitcodeWalletDto {
+  @IsInt()
+  @Min(1)
+  personId: number;
+}

package/src/bitcode-wallet/dto/update-bitcode-wallet-transaction.dto.ts

@@ -0,0 +1,28 @@
+import {
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+  MaxLength,
+  Min,
+} from 'class-validator';
+import {
+  BITCODE_TRANSACTION_TYPE_VALUES,
+  type BitcodeTransactionType,
+} from './create-bitcode-wallet-transaction.dto';
+
+export class UpdateBitcodeWalletTransactionDto {
+  @IsOptional()
+  @IsEnum(BITCODE_TRANSACTION_TYPE_VALUES)
+  type?: BitcodeTransactionType;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  amount?: number;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(2000)
+  description?: string | null;
+}

package/src/bitcode-wallet/dto/update-bitcode-wallet.dto.ts

@@ -0,0 +1,8 @@
+import { IsInt, IsOptional, Min } from 'class-validator';
+
+export class UpdateBitcodeWalletDto {
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  personId?: number;
+}