@hed-hog/lms 0.0.361 → 0.0.365

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

@@ -0,0 +1,170 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { CreateXpLearningTypeDto } from './dto/create-xp-learning-type.dto';
+import { UpdateXpLearningTypeDto } from './dto/update-xp-learning-type.dto';
+
+@Injectable()
+export class XpLearningTypeService {
+  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(`(t.slug ILIKE ${p} OR COALESCE(l.name, '') ILIKE ${p})`);
+    }
+    if (params.status?.trim()) {
+      where.push(`t.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_learning_type t
+         LEFT JOIN xp_learning_type_locale l ON l.xp_learning_type_id = t.id AND l.locale_id = ${ptLocaleSubquery}
+        WHERE ${whereClause}`,
+      values,
+    );
+
+    const q = [...values];
+    const rows = await this.queryRows<any>(
+      `SELECT
+          t.id, t.slug, t.multiplier::float AS multiplier, t.sort_order AS "sortOrder", t.status::text AS status,
+          COALESCE(l.name, t.slug) AS name, l.description,
+          t.created_at::text AS "createdAt", t.updated_at::text AS "updatedAt"
+        FROM xp_learning_type t
+        LEFT JOIN xp_learning_type_locale l ON l.xp_learning_type_id = t.id AND l.locale_id = ${ptLocaleSubquery}
+       WHERE ${whereClause}
+       ORDER BY t.sort_order ASC, t.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 getAll() {
+    return this.queryRows<any>(
+      `SELECT
+          t.id, t.slug, t.multiplier::float AS multiplier, t.sort_order AS "sortOrder",
+          COALESCE(lpt.name, len.name, t.slug) AS name
+        FROM xp_learning_type t
+        LEFT JOIN xp_learning_type_locale lpt ON lpt.xp_learning_type_id = t.id
+          AND lpt.locale_id = (SELECT id FROM locale WHERE code = 'pt' LIMIT 1)
+        LEFT JOIN xp_learning_type_locale len ON len.xp_learning_type_id = t.id
+          AND len.locale_id = (SELECT id FROM locale WHERE code = 'en' LIMIT 1)
+       WHERE t.status = 'active'
+       ORDER BY t.sort_order ASC, t.slug ASC`,
+    );
+  }
+
+  async getById(id: number) {
+    const row = await this.querySingle<any>(
+      `SELECT id, slug, multiplier::float AS multiplier, sort_order AS "sortOrder", status::text AS status,
+              created_at::text AS "createdAt", updated_at::text AS "updatedAt"
+         FROM xp_learning_type WHERE id = $1`,
+      [id],
+    );
+    if (!row) throw new NotFoundException('XP learning type not found');
+
+    const locales = await this.queryRows<any>(
+      `SELECT l.code, tl.name, tl.description
+         FROM xp_learning_type_locale tl JOIN locale l ON l.id = tl.locale_id
+        WHERE tl.xp_learning_type_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: CreateXpLearningTypeDto) {
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO xp_learning_type (slug, multiplier, sort_order, status, created_at, updated_at)
+       VALUES ($1, $2, $3, $4::xp_learning_type_status_c3d4e5f6a7_enum, NOW(), NOW())
+       RETURNING id`,
+      [dto.slug.trim(), dto.multiplier ?? 1, dto.sortOrder ?? 0, dto.status ?? 'active'],
+    );
+    await this.upsertLocales(created!.id, dto);
+    return this.getById(created!.id);
+  }
+
+  async update(id: number, dto: UpdateXpLearningTypeDto) {
+    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.multiplier !== undefined) updates.push(`multiplier = ${this.param(values, dto.multiplier)}`);
+    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_learning_type_status_c3d4e5f6a7_enum`);
+
+    if (updates.length > 0) {
+      values.push(id);
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE xp_learning_type 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_learning_type 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_learning_type_locale (xp_learning_type_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_learning_type_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_learning_type WHERE id = $1`, [id]);
+    if (!row) throw new NotFoundException('XP learning type 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-skill.controller.ts

@@ -0,0 +1,71 @@
+import { Role } from '@hed-hog/api';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { CreateXpSkillDto } from './dto/create-xp-skill.dto';
+import { UpdateXpSkillDto } from './dto/update-xp-skill.dto';
+import { XpSkillService } from './xp-skill.service';
+
+@Role()
+@Controller('lms/xp/skills')
+export class XpSkillController {
+  constructor(private readonly xpSkillService: XpSkillService) {}
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+    @Query('areaId') areaId?: string,
+  ) {
+    return this.xpSkillService.list({
+      page: Number(page) || 1,
+      pageSize: Number(pageSize) || 20,
+      search,
+      status,
+      areaId: areaId ? Number(areaId) : undefined,
+    });
+  }
+
+  @Get('all')
+  getAll(@Query('areaId') areaId?: string) {
+    return this.xpSkillService.getAll(areaId ? Number(areaId) : undefined);
+  }
+
+  @Get('stats')
+  stats() {
+    return this.xpSkillService.stats();
+  }
+
+  @Get(':id')
+  getById(@Param('id', ParseIntPipe) id: number) {
+    return this.xpSkillService.getById(id);
+  }
+
+  @Post()
+  create(@Body() dto: CreateXpSkillDto) {
+    return this.xpSkillService.create(dto);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIntPipe) id: number, @Body() dto: UpdateXpSkillDto) {
+    return this.xpSkillService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.xpSkillService.delete(id);
+  }
+}

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

package/hedhog/data/video_resolution_profile.yaml

@@ -1,7 +0,0 @@
-- name: 1080p Full HD
-  ffmpeg_params: '-vf "yadif=mode=0,scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" -c:v libx264 -preset slower -profile:v high -level:v 4.0 -crf 23 -x264-params "aq-mode=2:aq-strength=1.0" -fps_mode cfr -movflags +faststart -c:a aac -ac 2'
-  status: active
-
-- name: 720p HD
-  ffmpeg_params: '-vf "yadif=mode=0,scale=1280:720:force_original_aspect_ratio=decrease,pad=1280:720:(ow-iw)/2:(oh-ih)/2" -c:v libx264 -preset slower -profile:v high -level:v 4.0 -crf 23 -x264-params "aq-mode=2:aq-strength=1.0" -fps_mode cfr -movflags +faststart -c:a aac -ac 2'
-  status: active