@hed-hog/lms 0.0.361 → 0.0.365

package/src/xp-catalog/dto/create-xp-area.dto.ts

@@ -0,0 +1,40 @@
+import { IsEnum, IsInt, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class CreateXpAreaDto {
+  @IsString()
+  @MaxLength(100)
+  slug: string;
+
+  @IsString()
+  namePt: string;
+
+  @IsString()
+  nameEn: string;
+
+  @IsOptional()
+  @IsString()
+  descriptionPt?: string | null;
+
+  @IsOptional()
+  @IsString()
+  descriptionEn?: string | null;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  iconSlug?: string | null;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(9)
+  color?: string | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  sortOrder?: number;
+
+  @IsOptional()
+  @IsEnum(['active', 'inactive'])
+  status?: 'active' | 'inactive';
+}

package/src/xp-catalog/dto/create-xp-learning-type.dto.ts

@@ -0,0 +1,35 @@
+import { IsEnum, IsInt, IsNumber, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class CreateXpLearningTypeDto {
+  @IsString()
+  @MaxLength(100)
+  slug: string;
+
+  @IsString()
+  namePt: string;
+
+  @IsString()
+  nameEn: string;
+
+  @IsOptional()
+  @IsString()
+  descriptionPt?: string | null;
+
+  @IsOptional()
+  @IsString()
+  descriptionEn?: string | null;
+
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  multiplier?: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  sortOrder?: number;
+
+  @IsOptional()
+  @IsEnum(['active', 'inactive'])
+  status?: 'active' | 'inactive';
+}

package/src/xp-catalog/dto/create-xp-skill.dto.ts

@@ -0,0 +1,35 @@
+import { IsEnum, IsInt, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class CreateXpSkillDto {
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  xpAreaId?: number | null;
+
+  @IsString()
+  @MaxLength(100)
+  slug: string;
+
+  @IsString()
+  namePt: string;
+
+  @IsString()
+  nameEn: string;
+
+  @IsOptional()
+  @IsString()
+  descriptionPt?: string | null;
+
+  @IsOptional()
+  @IsString()
+  descriptionEn?: string | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  sortOrder?: number;
+
+  @IsOptional()
+  @IsEnum(['active', 'inactive'])
+  status?: 'active' | 'inactive';
+}

package/src/xp-catalog/dto/update-xp-area.dto.ts

@@ -0,0 +1,43 @@
+import { IsEnum, IsInt, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class UpdateXpAreaDto {
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  slug?: string;
+
+  @IsOptional()
+  @IsString()
+  namePt?: string;
+
+  @IsOptional()
+  @IsString()
+  nameEn?: string;
+
+  @IsOptional()
+  @IsString()
+  descriptionPt?: string | null;
+
+  @IsOptional()
+  @IsString()
+  descriptionEn?: string | null;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  iconSlug?: string | null;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(9)
+  color?: string | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  sortOrder?: number;
+
+  @IsOptional()
+  @IsEnum(['active', 'inactive'])
+  status?: 'active' | 'inactive';
+}

package/src/xp-catalog/dto/update-xp-learning-type.dto.ts

@@ -0,0 +1,38 @@
+import { IsEnum, IsInt, IsNumber, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class UpdateXpLearningTypeDto {
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  slug?: string;
+
+  @IsOptional()
+  @IsString()
+  namePt?: string;
+
+  @IsOptional()
+  @IsString()
+  nameEn?: string;
+
+  @IsOptional()
+  @IsString()
+  descriptionPt?: string | null;
+
+  @IsOptional()
+  @IsString()
+  descriptionEn?: string | null;
+
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  multiplier?: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  sortOrder?: number;
+
+  @IsOptional()
+  @IsEnum(['active', 'inactive'])
+  status?: 'active' | 'inactive';
+}

package/src/xp-catalog/dto/update-xp-skill.dto.ts

@@ -0,0 +1,38 @@
+import { IsEnum, IsInt, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class UpdateXpSkillDto {
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  xpAreaId?: number | null;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  slug?: string;
+
+  @IsOptional()
+  @IsString()
+  namePt?: string;
+
+  @IsOptional()
+  @IsString()
+  nameEn?: string;
+
+  @IsOptional()
+  @IsString()
+  descriptionPt?: string | null;
+
+  @IsOptional()
+  @IsString()
+  descriptionEn?: string | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  sortOrder?: number;
+
+  @IsOptional()
+  @IsEnum(['active', 'inactive'])
+  status?: 'active' | 'inactive';
+}

package/src/xp-catalog/xp-area.controller.ts

@@ -0,0 +1,64 @@
+import { Role } from '@hed-hog/api';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { CreateXpAreaDto } from './dto/create-xp-area.dto';
+import { UpdateXpAreaDto } from './dto/update-xp-area.dto';
+import { XpAreaService } from './xp-area.service';
+
+@Role()
+@Controller('lms/xp/areas')
+export class XpAreaController {
+  constructor(private readonly xpAreaService: XpAreaService) {}
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+  ) {
+    return this.xpAreaService.list({ page: Number(page) || 1, pageSize: Number(pageSize) || 20, search, status });
+  }
+
+  @Get('all')
+  getAll() {
+    return this.xpAreaService.getAll();
+  }
+
+  @Get('stats')
+  stats() {
+    return this.xpAreaService.stats();
+  }
+
+  @Get(':id')
+  getById(@Param('id', ParseIntPipe) id: number) {
+    return this.xpAreaService.getById(id);
+  }
+
+  @Post()
+  create(@Body() dto: CreateXpAreaDto) {
+    return this.xpAreaService.create(dto);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIntPipe) id: number, @Body() dto: UpdateXpAreaDto) {
+    return this.xpAreaService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.xpAreaService.delete(id);
+  }
+}

package/src/xp-catalog/xp-area.service.ts

@@ -0,0 +1,196 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { CreateXpAreaDto } from './dto/create-xp-area.dto';
+import { UpdateXpAreaDto } from './dto/update-xp-area.dto';
+
+@Injectable()
+export class XpAreaService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async list(params: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    status?: 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 values: unknown[] = [];
+    const where: string[] = ['1 = 1'];
+
+    if (params.search?.trim()) {
+      const p = this.param(values, `%${params.search.trim()}%`);
+      where.push(`(a.slug ILIKE ${p} OR COALESCE(l.name, '') ILIKE ${p})`);
+    }
+    if (params.status?.trim()) {
+      where.push(`a.status::text = ${this.param(values, params.status.trim())}`);
+    }
+
+    const whereClause = where.join(' AND ');
+    const ptLocaleSubquery = `(SELECT id FROM locale WHERE code = 'pt' LIMIT 1)`;
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM xp_area a
+         LEFT JOIN xp_area_locale l ON l.xp_area_id = a.id AND l.locale_id = ${ptLocaleSubquery}
+        WHERE ${whereClause}`,
+      values,
+    );
+
+    const q = [...values];
+    const rows = await this.queryRows<any>(
+      `SELECT
+          a.id,
+          a.slug,
+          a.icon_slug AS "iconSlug",
+          a.color,
+          a.sort_order AS "sortOrder",
+          a.status::text AS status,
+          COALESCE(l.name, a.slug) AS name,
+          l.description,
+          a.created_at::text AS "createdAt",
+          a.updated_at::text AS "updatedAt"
+        FROM xp_area a
+        LEFT JOIN xp_area_locale l ON l.xp_area_id = a.id AND l.locale_id = ${ptLocaleSubquery}
+       WHERE ${whereClause}
+       ORDER BY a.sort_order ASC, a.slug ASC
+       LIMIT ${this.param(q, pageSize)} OFFSET ${this.param(q, offset)}`,
+      q,
+    );
+
+    const total = Number(totalRow?.total ?? 0);
+    return { data: rows, total, page, pageSize, lastPage: Math.ceil(total / pageSize) };
+  }
+
+  async stats() {
+    const [total, active, inactive] = await Promise.all([
+      this.querySingle<{ count: string }>(`SELECT COUNT(*)::text AS count FROM xp_area`, []),
+      this.querySingle<{ count: string }>(`SELECT COUNT(*)::text AS count FROM xp_area WHERE status = 'active'`, []),
+      this.querySingle<{ count: string }>(`SELECT COUNT(*)::text AS count FROM xp_area WHERE status = 'inactive'`, []),
+    ]);
+    return {
+      total: Number(total?.count ?? 0),
+      active: Number(active?.count ?? 0),
+      inactive: Number(inactive?.count ?? 0),
+    };
+  }
+
+  async getAll() {
+    return this.queryRows<any>(
+      `SELECT
+          a.id, a.slug, a.icon_slug AS "iconSlug", a.color, a.sort_order AS "sortOrder",
+          COALESCE(lpt.name, len.name, a.slug) AS name
+        FROM xp_area a
+        LEFT JOIN xp_area_locale lpt ON lpt.xp_area_id = a.id
+          AND lpt.locale_id = (SELECT id FROM locale WHERE code = 'pt' LIMIT 1)
+        LEFT JOIN xp_area_locale len ON len.xp_area_id = a.id
+          AND len.locale_id = (SELECT id FROM locale WHERE code = 'en' LIMIT 1)
+       WHERE a.status = 'active'
+       ORDER BY a.sort_order ASC, a.slug ASC`,
+    );
+  }
+
+  async getById(id: number) {
+    const row = await this.querySingle<any>(
+      `SELECT id, slug, icon_slug AS "iconSlug", color, sort_order AS "sortOrder",
+              status::text AS status, created_at::text AS "createdAt", updated_at::text AS "updatedAt"
+         FROM xp_area WHERE id = $1`,
+      [id],
+    );
+    if (!row) throw new NotFoundException('XP area not found');
+
+    const locales = await this.queryRows<any>(
+      `SELECT l.code, al.name, al.description
+         FROM xp_area_locale al JOIN locale l ON l.id = al.locale_id
+        WHERE al.xp_area_id = $1`,
+      [id],
+    );
+
+    const translations: Record<string, { name: string; description: string | null }> = {};
+    for (const loc of locales) translations[loc.code] = { name: loc.name, description: loc.description };
+
+    return { ...row, translations };
+  }
+
+  async create(dto: CreateXpAreaDto) {
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO xp_area (slug, icon_slug, color, sort_order, status, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5::xp_area_status_a1b2c3d4e5_enum, NOW(), NOW())
+       RETURNING id`,
+      [dto.slug.trim(), dto.iconSlug ?? null, dto.color ?? null, dto.sortOrder ?? 0, dto.status ?? 'active'],
+    );
+    await this.upsertLocales(created!.id, dto);
+    return this.getById(created!.id);
+  }
+
+  async update(id: number, dto: UpdateXpAreaDto) {
+    await this.ensureExists(id);
+
+    const updates: string[] = [];
+    const values: unknown[] = [];
+
+    if (dto.slug !== undefined) updates.push(`slug = ${this.param(values, dto.slug.trim())}`);
+    if (dto.iconSlug !== undefined) updates.push(`icon_slug = ${this.param(values, dto.iconSlug)}`);
+    if (dto.color !== undefined) updates.push(`color = ${this.param(values, dto.color)}`);
+    if (dto.sortOrder !== undefined) updates.push(`sort_order = ${this.param(values, dto.sortOrder)}`);
+    if (dto.status !== undefined) updates.push(`status = ${this.param(values, dto.status)}::xp_area_status_a1b2c3d4e5_enum`);
+
+    if (updates.length > 0) {
+      values.push(id);
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE xp_area SET ${updates.join(', ')}, updated_at = NOW() WHERE id = $${values.length}`,
+        ...values,
+      );
+    }
+
+    await this.upsertLocales(id, dto);
+    return this.getById(id);
+  }
+
+  async delete(id: number) {
+    await this.ensureExists(id);
+    await this.prisma.$executeRawUnsafe(`DELETE FROM xp_area WHERE id = $1`, id);
+  }
+
+  private async upsertLocales(
+    id: number,
+    dto: { namePt?: string; nameEn?: string; descriptionPt?: string | null; descriptionEn?: string | null },
+  ) {
+    const pairs = [
+      { code: 'pt', name: dto.namePt, description: dto.descriptionPt },
+      { code: 'en', name: dto.nameEn, description: dto.descriptionEn },
+    ];
+    for (const { code, name, description } of pairs) {
+      if (name !== undefined) {
+        await this.prisma.$executeRawUnsafe(
+          `INSERT INTO xp_area_locale (xp_area_id, locale_id, name, description, created_at, updated_at)
+           SELECT $1, l.id, $2, $3, NOW(), NOW() FROM locale l WHERE l.code = $4
+           ON CONFLICT (xp_area_id, locale_id) DO UPDATE
+             SET name = EXCLUDED.name, description = EXCLUDED.description, updated_at = NOW()`,
+          id, name, description ?? null, code,
+        );
+      }
+    }
+  }
+
+  private async ensureExists(id: number) {
+    const row = await this.querySingle<{ id: number }>(`SELECT id FROM xp_area WHERE id = $1`, [id]);
+    if (!row) throw new NotFoundException('XP area not found');
+  }
+
+  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/xp-catalog/xp-catalog.module.ts

@@ -0,0 +1,16 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { XpAreaController } from './xp-area.controller';
+import { XpAreaService } from './xp-area.service';
+import { XpLearningTypeController } from './xp-learning-type.controller';
+import { XpLearningTypeService } from './xp-learning-type.service';
+import { XpSkillController } from './xp-skill.controller';
+import { XpSkillService } from './xp-skill.service';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule)],
+  controllers: [XpAreaController, XpSkillController, XpLearningTypeController],
+  providers: [XpAreaService, XpSkillService, XpLearningTypeService],
+  exports: [XpAreaService, XpSkillService, XpLearningTypeService],
+})
+export class XpCatalogModule {}

package/src/xp-catalog/xp-learning-type.controller.ts

@@ -0,0 +1,59 @@
+import { Role } from '@hed-hog/api';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { CreateXpLearningTypeDto } from './dto/create-xp-learning-type.dto';
+import { UpdateXpLearningTypeDto } from './dto/update-xp-learning-type.dto';
+import { XpLearningTypeService } from './xp-learning-type.service';
+
+@Role()
+@Controller('lms/xp/learning-types')
+export class XpLearningTypeController {
+  constructor(private readonly xpLearningTypeService: XpLearningTypeService) {}
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+  ) {
+    return this.xpLearningTypeService.list({ page: Number(page) || 1, pageSize: Number(pageSize) || 20, search, status });
+  }
+
+  @Get('all')
+  getAll() {
+    return this.xpLearningTypeService.getAll();
+  }
+
+  @Get(':id')
+  getById(@Param('id', ParseIntPipe) id: number) {
+    return this.xpLearningTypeService.getById(id);
+  }
+
+  @Post()
+  create(@Body() dto: CreateXpLearningTypeDto) {
+    return this.xpLearningTypeService.create(dto);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIntPipe) id: number, @Body() dto: UpdateXpLearningTypeDto) {
+    return this.xpLearningTypeService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.xpLearningTypeService.delete(id);
+  }
+}