@hed-hog/lms 0.0.361 → 0.0.364

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

@@ -0,0 +1,205 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { CreateXpSkillDto } from './dto/create-xp-skill.dto';
+import { UpdateXpSkillDto } from './dto/update-xp-skill.dto';
+
+@Injectable()
+export class XpSkillService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async list(params: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    status?: string;
+    areaId?: number;
+  }) {
+    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(`(s.slug ILIKE ${p} OR COALESCE(l.name, '') ILIKE ${p})`);
+    }
+    if (params.status?.trim()) {
+      where.push(`s.status::text = ${this.param(values, params.status.trim())}`);
+    }
+    if (params.areaId) {
+      where.push(`s.xp_area_id = ${this.param(values, params.areaId)}`);
+    }
+
+    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_skill s
+         LEFT JOIN xp_skill_locale l ON l.xp_skill_id = s.id AND l.locale_id = ${ptLocaleSubquery}
+        WHERE ${whereClause}`,
+      values,
+    );
+
+    const q = [...values];
+    const rows = await this.queryRows<any>(
+      `SELECT
+          s.id,
+          s.xp_area_id AS "xpAreaId",
+          s.slug,
+          s.sort_order AS "sortOrder",
+          s.status::text AS status,
+          COALESCE(l.name, s.slug) AS name,
+          l.description,
+          s.created_at::text AS "createdAt",
+          s.updated_at::text AS "updatedAt"
+        FROM xp_skill s
+        LEFT JOIN xp_skill_locale l ON l.xp_skill_id = s.id AND l.locale_id = ${ptLocaleSubquery}
+       WHERE ${whereClause}
+       ORDER BY s.sort_order ASC, s.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, unassigned] = await Promise.all([
+      this.querySingle<{ count: string }>(`SELECT COUNT(*)::text AS count FROM xp_skill`, []),
+      this.querySingle<{ count: string }>(`SELECT COUNT(*)::text AS count FROM xp_skill WHERE status = 'active'`, []),
+      this.querySingle<{ count: string }>(`SELECT COUNT(*)::text AS count FROM xp_skill WHERE status = 'inactive'`, []),
+      this.querySingle<{ count: string }>(`SELECT COUNT(*)::text AS count FROM xp_skill WHERE xp_area_id IS NULL`, []),
+    ]);
+    return {
+      total: Number(total?.count ?? 0),
+      active: Number(active?.count ?? 0),
+      inactive: Number(inactive?.count ?? 0),
+      unassigned: Number(unassigned?.count ?? 0),
+    };
+  }
+
+  async getAll(areaId?: number) {
+    const values: unknown[] = [];
+    const where: string[] = [`s.status = 'active'`];
+    if (areaId) where.push(`s.xp_area_id = ${this.param(values, areaId)}`);
+
+    return this.queryRows<any>(
+      `SELECT
+          s.id, s.xp_area_id AS "xpAreaId", s.slug, s.sort_order AS "sortOrder",
+          COALESCE(lpt.name, len.name, s.slug) AS name
+        FROM xp_skill s
+        LEFT JOIN xp_skill_locale lpt ON lpt.xp_skill_id = s.id
+          AND lpt.locale_id = (SELECT id FROM locale WHERE code = 'pt' LIMIT 1)
+        LEFT JOIN xp_skill_locale len ON len.xp_skill_id = s.id
+          AND len.locale_id = (SELECT id FROM locale WHERE code = 'en' LIMIT 1)
+       WHERE ${where.join(' AND ')}
+       ORDER BY s.sort_order ASC, s.slug ASC`,
+      values,
+    );
+  }
+
+  async getById(id: number) {
+    const row = await this.querySingle<any>(
+      `SELECT id, xp_area_id AS "xpAreaId", slug, sort_order AS "sortOrder",
+              status::text AS status, created_at::text AS "createdAt", updated_at::text AS "updatedAt"
+         FROM xp_skill WHERE id = $1`,
+      [id],
+    );
+    if (!row) throw new NotFoundException('XP skill not found');
+
+    const locales = await this.queryRows<any>(
+      `SELECT l.code, sl.name, sl.description
+         FROM xp_skill_locale sl JOIN locale l ON l.id = sl.locale_id
+        WHERE sl.xp_skill_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: CreateXpSkillDto) {
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO xp_skill (xp_area_id, slug, sort_order, status, created_at, updated_at)
+       VALUES ($1, $2, $3, $4::xp_skill_status_b2c3d4e5f6_enum, NOW(), NOW())
+       RETURNING id`,
+      [dto.xpAreaId ?? null, dto.slug.trim(), dto.sortOrder ?? 0, dto.status ?? 'active'],
+    );
+    await this.upsertLocales(created!.id, dto);
+    return this.getById(created!.id);
+  }
+
+  async update(id: number, dto: UpdateXpSkillDto) {
+    await this.ensureExists(id);
+
+    const updates: string[] = [];
+    const values: unknown[] = [];
+
+    if (dto.xpAreaId !== undefined) updates.push(`xp_area_id = ${this.param(values, dto.xpAreaId)}`);
+    if (dto.slug !== undefined) updates.push(`slug = ${this.param(values, dto.slug.trim())}`);
+    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_skill_status_b2c3d4e5f6_enum`);
+
+    if (updates.length > 0) {
+      values.push(id);
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE xp_skill 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_skill 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_skill_locale (xp_skill_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_skill_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_skill WHERE id = $1`, [id]);
+    if (!row) throw new NotFoundException('XP skill 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;
+  }
+}