@hed-hog/lms 0.0.361 → 0.0.365

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

@@ -1,9 +1,11 @@
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
+    BadRequestException,
     ConflictException,
     Injectable,
     NotFoundException,
 } from '@nestjs/common';
+import { CreateCurrentBitcodeWalletTransactionDto } from './dto/create-current-bitcode-wallet-transaction.dto';
 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';
@@ -220,6 +222,46 @@ export class BitcodeWalletService {
     return this.getById(created.id);
   }
 
+  async getCurrentUserWallet(userId: number) {
+    const personId = await this.resolveOrCreatePersonForUser(userId);
+    return this.getOrCreateWalletByPersonId(personId);
+  }
+
+  async creditCurrentUserWallet(
+    userId: number,
+    dto: CreateCurrentBitcodeWalletTransactionDto
+  ) {
+    return this.createCurrentUserTransaction(userId, {
+      ...dto,
+      type: 'credit',
+    });
+  }
+
+  async createCurrentUserTransaction(
+    userId: number,
+    dto: CreateCurrentBitcodeWalletTransactionDto
+  ) {
+    const amount = Math.trunc(Number(dto.amount));
+    const type = dto.type ?? 'credit';
+
+    if (!Number.isFinite(amount) || amount < 1) {
+      throw new BadRequestException('BitCode transaction amount must be positive');
+    }
+
+    const personId = await this.resolvePersonIdFromUser(userId);
+    const wallet = await this.getOrCreateWalletByPersonId(personId);
+
+    if (type === 'debit' && Number(wallet.currentBalance ?? 0) < amount) {
+      throw new BadRequestException('Insufficient BitCode balance');
+    }
+
+    return this.createTransaction(wallet.id, {
+      type,
+      amount,
+      description: this.buildCurrentTransactionDescription(dto, type),
+    });
+  }
+
   async update(id: number, dto: UpdateBitcodeWalletDto) {
     await this.ensureWalletExists(id);
 
@@ -287,6 +329,96 @@ export class BitcodeWalletService {
     }
   }
 
+  private async resolvePersonIdFromUser(userId: number) {
+    const row = await this.querySingle<{ personId: number }>(
+      `SELECT person_id AS "personId" FROM person_user WHERE user_id = $1 LIMIT 1`,
+      [userId]
+    );
+
+    if (!row) {
+      throw new NotFoundException('No person profile found for this user');
+    }
+
+    return Number(row.personId);
+  }
+
+  private async resolveOrCreatePersonForUser(userId: number): Promise<number> {
+    const existing = await this.querySingle<{ personId: number }>(
+      `SELECT person_id AS "personId" FROM person_user WHERE user_id = $1 LIMIT 1`,
+      [userId]
+    );
+    if (existing) return Number(existing.personId);
+
+    // Gather name: prefer commerce_customer (richer), fall back to user record
+    const customerRow = await this.querySingle<{ name: string }>(
+      `SELECT name FROM commerce_customer
+        WHERE user_id = $1 AND deleted_at IS NULL
+        ORDER BY id DESC LIMIT 1`,
+      [userId]
+    );
+
+    const userRow = await this.querySingle<{ name: string }>(
+      `SELECT name FROM "user" WHERE id = $1`,
+      [userId]
+    );
+
+    const personName = customerRow?.name || userRow?.name || `Usuário #${userId}`;
+
+    const person = await this.querySingle<{ id: number }>(
+      `INSERT INTO person (name, type, status, created_at, updated_at)
+       VALUES ($1, 'individual'::person_type_6dfa750c4d_enum, 'active'::person_status_7efb97d61c_enum, NOW(), NOW())
+       RETURNING id`,
+      [personName]
+    );
+
+    if (!person) throw new Error('Failed to create person profile');
+
+    await this.querySingle(
+      `INSERT INTO person_user (person_id, user_id, created_at, updated_at)
+       VALUES ($1, $2, NOW(), NOW())
+       ON CONFLICT DO NOTHING`,
+      [person.id, userId]
+    );
+
+    return person.id;
+  }
+
+  private async findWalletByPersonId(personId: number) {
+    return this.querySingle<{ id: number }>(
+      `SELECT id FROM bitcode_wallet WHERE person_id = $1`,
+      [personId]
+    );
+  }
+
+  private async getOrCreateWalletByPersonId(personId: number) {
+    await this.ensurePersonExists(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()
+        )
+        ON CONFLICT (person_id) DO NOTHING
+        RETURNING id`,
+      [personId]
+    );
+
+    const wallet = created ?? (await this.findWalletByPersonId(personId));
+
+    if (!wallet) {
+      throw new NotFoundException('BitCode wallet not found');
+    }
+
+    return this.getById(wallet.id);
+  }
+
   private async ensureWalletExists(id: number) {
     const row = await this.querySingle<{ id: number }>(
       `SELECT id FROM bitcode_wallet WHERE id = $1`,
@@ -345,6 +477,26 @@ export class BitcodeWalletService {
     return normalized ? normalized : null;
   }
 
+  private buildCurrentTransactionDescription(
+    dto: CreateCurrentBitcodeWalletTransactionDto,
+    type: 'credit' | 'debit'
+  ) {
+    const description = this.normalizeOptionalText(dto.description);
+    const source = this.normalizeOptionalText(dto.source);
+    const fallback = type === 'debit' ? 'Class debit' : 'Class reward';
+
+    if (description && source) {
+      return description.toLowerCase().includes(source.toLowerCase())
+        ? description
+        : `${description} - ${source}`;
+    }
+
+    if (description) return description;
+    if (source) return `${fallback}: ${source}`;
+
+    return fallback;
+  }
+
   private param(values: unknown[], value: unknown) {
     values.push(value);
     return `$${values.length}`;

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

@@ -0,0 +1,32 @@
+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 CreateCurrentBitcodeWalletTransactionDto {
+  @IsOptional()
+  @IsEnum(BITCODE_TRANSACTION_TYPE_VALUES)
+  type?: BitcodeTransactionType;
+
+  @IsInt()
+  @Min(1)
+  amount: number;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(2000)
+  description?: string | null;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(200)
+  source?: string | null;
+}

package/src/course/course-audio-transcription.service.ts

@@ -1,6 +1,6 @@
 import { PrismaService } from '@hed-hog/api-prisma';
 import { buildAiConfigFromIntegration, FileService, NotificationService, SettingService } from '@hed-hog/core';
-import { IJobHandler, QueueHandlerRegistry } from '@hed-hog/queue';
+import { DatabaseQueueProvider, IJobHandler, NonRetryableError, QueueHandlerRegistry } from '@hed-hog/queue';
 import {
     Inject,
     Injectable,
@@ -102,6 +102,8 @@ export class CourseAudioTranscriptionService implements OnModuleInit, IJobHandle
     private readonly notificationService: NotificationService,
     @Inject(forwardRef(() => QueueHandlerRegistry))
     private readonly registry: QueueHandlerRegistry,
+    @Inject(forwardRef(() => DatabaseQueueProvider))
+    private readonly dbQueue: DatabaseQueueProvider,
   ) {}
 
   onModuleInit() {
@@ -159,18 +161,11 @@ export class CourseAudioTranscriptionService implements OnModuleInit, IJobHandle
     const transcriptionEnabled = settings['lms-audio-transcription-enabled'] !== false;
 
     if (!transcriptionEnabled) {
-      this.logger.warn(
-        `Transcription skipped for lesson ${lessonId}: disabled by lms-audio-transcription-enabled setting`,
-      );
+      const msg = `Transcrição desabilitada nas configurações do LMS (lms-audio-transcription-enabled=false).`;
       if (notificationContext) {
-        await this.updateAsyncNotification(
-          notificationContext,
-          100,
-          'Transcrição desabilitada nas configurações do LMS.',
-          false,
-        );
+        await this.updateAsyncNotification(notificationContext, 100, msg, false);
       }
-      return;
+      throw new NonRetryableError(msg);
     }
 
     const profileId = Number(settings['ai-openai-profile-id']);
@@ -190,18 +185,14 @@ export class CourseAudioTranscriptionService implements OnModuleInit, IJobHandle
     }
 
     if (!apiKey) {
-      this.logger.warn(
-        `Transcription skipped for lesson ${lessonId}: OpenAI profile not configured`,
-      );
+      const profileIdValue = settings['ai-openai-profile-id'];
+      const msg = profileIdValue
+        ? `Perfil de IA (id=${profileIdValue}) não encontrado ou não possui chave de API OpenAI configurada. Verifique em Settings → Integrações → Profiles.`
+        : `Transcrição de áudio requer um perfil OpenAI configurado.\n\nComo configurar:\n1. Acesse Settings → Integrações → Profiles\n2. Crie um perfil do tipo OpenAI com sua API Key\n3. Copie o ID do perfil criado\n4. Acesse Settings → LMS e defina o campo \'ai-openai-profile-id\' com esse ID`;
       if (notificationContext) {
-        await this.updateAsyncNotification(
-          notificationContext,
-          100,
-          'Transcrição não iniciada: perfil de IA não configurado em Settings → AI.',
-          false,
-        );
+        await this.updateAsyncNotification(notificationContext, 100, msg, false);
       }
-      return;
+      throw new NonRetryableError(msg);
     }
 
     const course = await (this.prismaService as any).course.findUnique({
@@ -369,6 +360,52 @@ export class CourseAudioTranscriptionService implements OnModuleInit, IJobHandle
       this.logger.log(
         `Transcription saved for lesson ${lessonId}: ${allSegments.length} segments`,
       );
+
+      // Automatically trigger XP calculation after transcription completes.
+      try {
+        const existingMap = await (this.prismaService as any).lesson_xp_map.findUnique({
+          where: { course_lesson_id: lessonId },
+          select: { id: true },
+        });
+
+        let mapId: number;
+        if (existingMap) {
+          mapId = existingMap.id;
+          await this.prismaService.$executeRawUnsafe(
+            `UPDATE lesson_xp_map
+                SET status = 'processing'::lesson_xp_map_status_d4e5f6a7b8_enum,
+                    processing_error = NULL,
+                    updated_at = NOW()
+              WHERE id = $1`,
+            mapId,
+          );
+        } else {
+          const rows = await this.prismaService.$queryRawUnsafe<{ id: number }[]>(
+            `INSERT INTO lesson_xp_map (course_lesson_id, version, total_xp, status, created_at, updated_at)
+             VALUES ($1, 1, 0, 'processing'::lesson_xp_map_status_d4e5f6a7b8_enum, NOW(), NOW())
+             RETURNING id`,
+            lessonId,
+          );
+          mapId = rows[0].id;
+        }
+
+        await this.dbQueue.enqueue({
+          type: 'lms.lesson.xp.calculate',
+          queueName: 'lms.lesson.xp.calculate',
+          payload: { lessonId, mapId, userId: notificationUserId ?? 0 },
+          maxAttempts: 3,
+          sourceModule: 'lms',
+          sourceEntity: 'course_lesson',
+          sourceEntityId: String(lessonId),
+        });
+
+        this.logger.log(`XP calculation job enqueued for lesson ${lessonId} (map ${mapId})`);
+      } catch (xpErr) {
+        this.logger.warn(
+          `Failed to enqueue XP calculation for lesson ${lessonId}: ${xpErr instanceof Error ? xpErr.message : String(xpErr)}`,
+        );
+      }
+
       await emitProgress(
         `Transcrição concluída com ${allSegments.length} segmento(s).`,
         {

package/src/course/course-export-scorm12-worker.service.ts

@@ -0,0 +1,124 @@
+import { FileService, NotificationService } from '@hed-hog/core';
+import { IJobHandler, QueueHandlerRegistry } from '@hed-hog/queue';
+import {
+  Inject,
+  Injectable,
+  Logger,
+  OnModuleInit,
+  forwardRef,
+} from '@nestjs/common';
+import { promises as fs } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { CourseExportScorm12Service } from './course-export-scorm12.service';
+import { CourseExportService, LMS_COURSE_EXPORT_SCORM12_JOB } from './course-export.service';
+
+@Injectable()
+export class CourseExportScorm12WorkerService implements OnModuleInit, IJobHandler {
+  private readonly logger = new Logger(CourseExportScorm12WorkerService.name);
+
+  constructor(
+    @Inject(forwardRef(() => FileService))
+    private readonly fileService: FileService,
+    @Inject(forwardRef(() => NotificationService))
+    private readonly notificationService: NotificationService,
+    @Inject(forwardRef(() => QueueHandlerRegistry))
+    private readonly registry: QueueHandlerRegistry,
+    private readonly courseExportService: CourseExportService,
+    private readonly scorm12Builder: CourseExportScorm12Service,
+  ) {}
+
+  onModuleInit() {
+    this.registry.register(LMS_COURSE_EXPORT_SCORM12_JOB, this);
+    this.logger.log(`Registered handler for job type: ${LMS_COURSE_EXPORT_SCORM12_JOB}`);
+  }
+
+  async handle(job: {
+    id: number;
+    type: string;
+    payload: Record<string, any>;
+  }): Promise<void> {
+    const { exportId, courseId, userId, notificationId, settings } =
+      job.payload as {
+        exportId: number;
+        courseId: number;
+        userId: number;
+        notificationId: number;
+        settings: Record<string, any>;
+      };
+
+    const startedAt = Date.now();
+    const workDir = await fs.mkdtemp(join(tmpdir(), `scorm-${job.id}-`));
+
+    try {
+      this.logger.log(`Starting SCORM 1.2 export ${exportId} for course ${courseId}`);
+      await this.courseExportService.markStarted(exportId);
+      await this.notificationService.updateProgress(userId, notificationId, {
+        progress: 5,
+        body: 'Iniciando exportação SCORM 1.2...',
+      });
+
+      const { zipPath, filename } = await this.scorm12Builder.buildPackage({
+        courseId,
+        settings,
+        workDir,
+        onProgress: async (pct, msg) => {
+          await this.notificationService.updateProgress(userId, notificationId, {
+            progress: pct,
+            body: msg,
+          });
+        },
+      });
+
+      await this.notificationService.updateProgress(userId, notificationId, {
+        progress: 90,
+        body: 'Fazendo upload do pacote SCORM...',
+      });
+
+      const stat = await fs.stat(zipPath);
+      const uploadedFile = await this.fileService.uploadFromPath(
+        'course-exports',
+        zipPath,
+        {
+          originalname: filename,
+          mimetype: 'application/zip',
+          size: stat.size,
+        },
+      );
+
+      const durationSeconds = Math.round((Date.now() - startedAt) / 1000);
+      await this.courseExportService.markCompleted(
+        exportId,
+        uploadedFile.id,
+        durationSeconds,
+      );
+
+      await this.notificationService.updateProgress(userId, notificationId, {
+        progress: 100,
+        body: `Exportação SCORM 1.2 concluída em ${durationSeconds}s!`,
+        success: true,
+      });
+
+      this.logger.log(
+        `SCORM 1.2 export ${exportId} completed in ${durationSeconds}s, file id=${uploadedFile.id}`,
+      );
+    } catch (err) {
+      const msg =
+        err instanceof Error ? err.message : 'Erro desconhecido na exportação.';
+      this.logger.error(`SCORM 1.2 export ${exportId} failed: ${msg}`, err instanceof Error ? err.stack : undefined);
+
+      await this.courseExportService.markFailed(exportId, msg).catch(() => undefined);
+      await this.notificationService
+        .updateProgress(userId, notificationId, {
+          progress: 100,
+          body: `Falha na exportação: ${msg}`,
+          success: false,
+        })
+        .catch(() => undefined);
+
+      throw err;
+    } finally {
+      await fs.rm(workDir, { recursive: true, force: true }).catch(() => undefined);
+    }
+  }
+}