@hed-hog/lms 0.0.349 → 0.0.351

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

package/src/certificate/certificate.controller.ts

@@ -4,6 +4,7 @@ import {
     Controller,
     Delete,
     Get,
+    Headers,
     Param,
     ParseIntPipe,
     Patch,
@@ -15,6 +16,7 @@ import {
 import { FileInterceptor } from '@nestjs/platform-express';
 import { LmsCertificateService } from './certificate.service';
 import { CreateCertificateTemplateDto } from './dto/create-certificate-template.dto';
+import { UpdateCertificatePublicAccessDto } from './dto/update-certificate-public-access.dto';
 import { UpdateCertificateTemplateDto } from './dto/update-certificate-template.dto';
 
 @Role()
@@ -51,8 +53,9 @@ export class LmsCertificateController {
   updateTemplate(
     @Param('id', ParseIntPipe) id: number,
     @Body() dto: UpdateCertificateTemplateDto,
+    @Headers('accept-language') locale?: string,
   ) {
-    return this.certificateService.updateTemplate(id, dto);
+    return this.certificateService.updateTemplate(id, dto, locale);
   }
 
   @Post('templates/background-image')
@@ -62,8 +65,11 @@ export class LmsCertificateController {
   }
 
   @Delete('templates/:id')
-  deleteTemplate(@Param('id', ParseIntPipe) id: number) {
-    return this.certificateService.deleteTemplate(id);
+  deleteTemplate(
+    @Param('id', ParseIntPipe) id: number,
+    @Headers('accept-language') locale?: string,
+  ) {
+    return this.certificateService.deleteTemplate(id, locale);
   }
 
   @Get('issued')
@@ -80,4 +86,12 @@ export class LmsCertificateController {
       type,
     });
   }
+
+  @Patch('issued/:id/public-access')
+  updateIssuedPublicAccess(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateCertificatePublicAccessDto,
+  ) {
+    return this.certificateService.updatePublicAccess(id, dto.publicAccess);
+  }
 }

package/src/certificate/certificate.mcp-tools.ts

@@ -0,0 +1,131 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { LmsCertificateService } from './certificate.service';
+
+@Injectable()
+export class LmsCertificateMcpTools {
+  constructor(private readonly certificateService: LmsCertificateService) {}
+
+  @McpTool({
+    name: 'lms.certificates.templates.list',
+    description: 'Lists certificate templates with optional pagination, search and status filter.',
+    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 (name, slug, description)' },
+        status: { type: 'string', description: 'Filter by status (draft|active|inactive)' },
+      },
+    },
+    readOnly: true,
+  })
+  async listTemplates(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.certificateService.listTemplates(args);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.templates.get',
+    description: 'Returns a single certificate template by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Template ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getTemplate(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.certificateService.getTemplateById(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.templates.create',
+    description: 'Creates a new certificate template.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Template name (required)' },
+        slug: { type: 'string', description: 'Unique slug (auto-generated if omitted)' },
+        description: { type: 'string', description: 'Description' },
+        templateContent: { type: 'string', description: 'Template content as JSON string (required)' },
+        status: { type: 'string', description: 'Status (draft|active|inactive, default: draft)' },
+      },
+      required: ['name', 'templateContent'],
+    },
+  })
+  async createTemplate(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.certificateService.createTemplate(args as any);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.templates.update',
+    description: 'Updates an existing certificate template.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Template ID' },
+        name: { type: 'string', description: 'Template name' },
+        slug: { type: 'string', description: 'Unique slug' },
+        description: { type: 'string', description: 'Description' },
+        templateContent: { type: 'string', description: 'Template content as JSON string' },
+        status: { type: 'string', description: 'Status (draft|active|inactive)' },
+      },
+      required: ['id'],
+    },
+  })
+  async updateTemplate(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.certificateService.updateTemplate(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.templates.delete',
+    description: 'Deletes a certificate template by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Template ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteTemplate(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.certificateService.deleteTemplate(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.issued.list',
+    description: 'Lists issued certificates with optional pagination, search and type filter.',
+    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 (student name, course name, verification code)' },
+        type: { type: 'string', description: 'Filter by certificate type (course|exam|course_class_group|learning_path)' },
+      },
+    },
+    readOnly: true,
+  })
+  async listIssued(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.certificateService.listIssued(args);
+  }
+
+  @McpTool({
+    name: 'lms.certificates.issued.update-public-access',
+    description: 'Enables or disables public access for an issued certificate.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Certificate ID' },
+        publicAccess: { type: 'boolean', description: 'Whether to allow public access to the certificate' },
+      },
+      required: ['id', 'publicAccess'],
+    },
+  })
+  async updatePublicAccess(args: { id: number; publicAccess: boolean }, _context: McpContext): Promise<any> {
+    return this.certificateService.updatePublicAccess(args.id, args.publicAccess);
+  }
+}

package/src/certificate/certificate.module.ts

@@ -2,12 +2,13 @@ import { PrismaModule } from '@hed-hog/api-prisma';
 import { FileModule } from '@hed-hog/core';
 import { forwardRef, Module } from '@nestjs/common';
 import { LmsCertificateController } from './certificate.controller';
+import { LmsCertificateMcpTools } from './certificate.mcp-tools';
 import { LmsCertificateService } from './certificate.service';
 
 @Module({
   imports: [forwardRef(() => PrismaModule), forwardRef(() => FileModule)],
   controllers: [LmsCertificateController],
-  providers: [LmsCertificateService],
+  providers: [LmsCertificateService, LmsCertificateMcpTools],
   exports: [forwardRef(() => LmsCertificateService)],
 })
 export class LmsCertificateModule {}