@hed-hog/lms 0.0.364 → 0.0.365

package/hedhog/frontend/messages/pt.json

@@ -588,6 +588,8 @@
         "statusProgress": "{completed}/{total} itens obrigatórios concluídos",
         "ready": "Pronto para publicar",
         "notReady": "Ainda não pronto",
+        "publishButton": "Publicar curso",
+        "alreadyPublished": "Curso já publicado",
         "items": {
           "title": "Título comercial preenchido",
           "description": "Descrição pública preenchida",
@@ -1206,36 +1208,32 @@
         },
         "addResource": "Adicionar recurso",
         "noResources": "Nenhum recurso adicionado",
-        "fileStorageVideosByResolution": "Vídeos por resolução (File Storage)",
-        "videoResolutionPlaceholder": "Ex.: 1080p",
-        "uploadVideoForResolution": "Enviar vídeo para esta resolução",
-        "noResolutionVideosYet": "Nenhum vídeo por resolução enviado ainda.",
-        "loadingVideoProfiles": "Carregando perfis de vídeo do curso...",
-        "videoProfilesLoadError": "Não foi possível carregar os perfis de vídeo do curso.",
-        "retryLoadVideoProfiles": "Tentar carregar novamente",
-        "noVideoProfilesConfigured": "Configure os perfis de vídeo na aba Resoluções do curso antes de anexar vídeos File Storage.",
+        "hlsStatusTitle": "Streaming HLS",
+        "hlsStatusReady": "Streaming disponível para os alunos.",
+        "hlsStatusProcessing": "Processando vídeo...",
+        "hlsStatusPending": "Nenhum vídeo processado ainda.",
         "originalVideoTitle": "Vídeo original em alta resolução",
-        "originalVideoHint": "Envie um original para gerar automaticamente os vídeos dos perfis do curso.",
-        "originalVideoPurpose": "Este arquivo original é usado apenas para gerar as versões de vídeo do curso.",
-        "fileStorageVideoHint": "Use o vídeo original abaixo para gerar automaticamente as versões por perfil do curso.",
-        "uploadOriginalForConversion": "Enviar original para conversão",
+        "originalVideoHint": "Envie um original para gerar automaticamente o streaming HLS do curso.",
+        "originalVideoPurpose": "Este arquivo original é usado apenas para gerar o streaming adaptativo do curso.",
+        "fileStorageVideoHint": "Use o vídeo original abaixo para gerar automaticamente o streaming HLS do curso.",
+        "uploadOriginalForConversion": "Enviar vídeo para processamento",
         "replaceOriginalForConversion": "Substituir vídeo original",
         "retryConversionWithSavedOriginal": "Iniciar novo job com o original salvo",
-        "videoUploadBlockedWhileProcessing": "O upload de original fica bloqueado enquanto a conversão atual estiver em andamento.",
+        "videoUploadBlockedWhileProcessing": "O upload de original fica bloqueado enquanto o processamento atual estiver em andamento.",
         "videoJobStateLoading": "Aguardando o status mais recente do job atual para liberar novas ações.",
         "videoProviderSavePending": "Aguarde o provedor ser salvo antes de enviar o vídeo original.",
         "videoUploadMaxSizeError": "O vídeo excede o limite de {size}.",
-        "videoConversionQueued": "Conversão de vídeo enviada para a fila #{id}.",
-        "videoConversionFailed": "Não foi possível enviar o vídeo para conversão.",
+        "videoConversionQueued": "Processamento de vídeo enviado para a fila #{id}.",
+        "videoConversionFailed": "Não foi possível enviar o vídeo para processamento.",
         "videoConversionRetryFailed": "Não foi possível iniciar um novo job com o vídeo original salvo.",
-        "videoConversionJob": "Conversão na fila #{id}",
-        "videoJobFeedbackTitle": "Acompanhamento da conversão",
-        "videoJobToggleDetails": "Alternar detalhes da conversão",
-        "videoJobCollapsedSummary": "Conversão concluída com sucesso. Os vídeos processados aparecem na lista de resoluções acima.",
-        "videoJobLoading": "Carregando andamento da conversão...",
-        "videoJobPendingLoad": "Preparando acompanhamento do job de conversão...",
-        "awaitingConversion": "Aguardando conversão...",
-        "videoJobLoadError": "Não foi possível carregar o andamento da conversão.",
+        "videoConversionJob": "Processamento na fila #{id}",
+        "videoJobFeedbackTitle": "Acompanhamento do processamento",
+        "videoJobToggleDetails": "Alternar detalhes do processamento",
+        "videoJobCollapsedSummary": "Processamento concluído com sucesso. O streaming HLS está disponível para os alunos.",
+        "videoJobLoading": "Carregando andamento do processamento...",
+        "videoJobPendingLoad": "Preparando acompanhamento do processamento...",
+        "awaitingConversion": "Aguardando processamento...",
+        "videoJobLoadError": "Não foi possível carregar o andamento do processamento.",
         "retryLoadVideoJob": "Tentar novamente",
         "videoJobIdLabel": "Job",
         "videoJobAttemptsLabel": "Tentativas",
@@ -1251,7 +1249,6 @@
         "videoJobRecentEvents": "Eventos recentes",
         "videoJobTranscriptionEvents": "Eventos recentes da transcrição",
         "videoJobNoEvents": "Nenhum evento registrado ainda.",
-        "videoProfilesLockedWhileProcessing": "Os vídeos por perfil ficam bloqueados enquanto a conversão do original está ativa.",
         "videoJobStatuses": {
           "pending": "Na fila",
           "scheduled": "Agendado",
@@ -1283,8 +1280,9 @@
         },
         "videoJobProgress": {
           "download_original": "Baixando vídeo original...",
-          "probe_duration": "Lendo duração do vídeo...",
-          "convert_profile": "Convertendo vídeo para o perfil {profileName}...",
+          "probe_duration": "Lendo dimensões e duração do vídeo...",
+          "hls_encode": "Gerando streaming HLS...",
+          "hls_upload": "Enviando segmentos HLS para storage...",
           "extract_frames": "Extraindo imagens do vídeo...",
           "extract_frames_done": "Imagens extraídas: {count}.",
           "extract_audio": "Extraindo áudio do vídeo...",
@@ -1351,8 +1349,7 @@
       "types": {
         "video": "Vídeo",
         "post": "Post",
-        "questao": "Questão",
-        "exercicio": "Exercício"
+        "questao": "Questão"
       },
       "statuses": {
         "preparada": "Preparada",
@@ -1391,6 +1388,7 @@
         "videoUploadFailed": "Falha ao enviar {count} arquivo(s) de vídeo.",
         "newQuestion": "Nova questão",
         "editQuestion": "Editar questão",
+        "loadingQuestions": "Carregando questões...",
         "selectQuestion": "Selecionar questão...",
         "searchQuestion": "Buscar questão...",
         "noQuestionsFound": "Nenhuma questão encontrada",

package/hedhog/table/course_export.yaml

@@ -0,0 +1,62 @@
+columns:
+  - type: pk
+  - name: course_id
+    type: fk
+    references:
+      table: course
+      column: id
+      onDelete: CASCADE
+  - name: user_id
+    type: fk
+    references:
+      table: user
+      column: id
+      onDelete: CASCADE
+  - name: format
+    type: varchar
+    length: 32
+  - name: status
+    type: enum
+    values: [pending, processing, completed, failed]
+    default: pending
+  - name: queue_job_id
+    type: fk
+    isNullable: true
+    references:
+      table: queue_job
+      column: id
+      onDelete: SET NULL
+  - name: file_id
+    type: fk
+    isNullable: true
+    references:
+      table: file
+      column: id
+      onDelete: SET NULL
+  - name: settings
+    type: jsonb
+    isNullable: true
+  - name: duration_seconds
+    type: int
+    isNullable: true
+  - name: error_message
+    type: text
+    isNullable: true
+  - name: notification_id
+    type: int
+    isNullable: true
+  - name: started_at
+    type: datetime
+    isNullable: true
+  - name: finished_at
+    type: datetime
+    isNullable: true
+  - type: created_at
+  - type: updated_at
+
+indices:
+  - columns: [course_id]
+  - columns: [user_id]
+  - columns: [course_id, status]
+  - columns: [queue_job_id]
+  - columns: [file_id]

package/package.json

@@ -1,25 +1,29 @@
 {
   "name": "@hed-hog/lms",
-  "version": "0.0.364",
+  "version": "0.0.365",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.888.0",
+    "@aws-sdk/client-s3": "3.1014.0",
+    "archiver": "^5.3.2",
+    "@types/archiver": "^5.3.4",
+    "@aws-sdk/s3-request-presigner": "3.1014.0",
     "@nestjs/common": "*",
     "@nestjs/config": "^4.0.2",
     "@nestjs/core": "^11",
     "@nestjs/jwt": "^11",
     "@nestjs/mapped-types": "*",
-    "@hed-hog/api-types": "0.0.1",
     "@hed-hog/api-prisma": "0.0.6",
     "@hed-hog/api-locale": "0.0.14",
-    "@hed-hog/api": "0.0.8",
     "@hed-hog/api-pagination": "0.0.7",
-    "@hed-hog/finance": "0.0.364",
-    "@hed-hog/category": "0.0.364",
-    "@hed-hog/core": "0.0.364",
-    "@hed-hog/crm": "0.0.364",
-    "@hed-hog/queue": "0.0.364"
+    "@hed-hog/api-types": "0.0.1",
+    "@hed-hog/category": "0.0.365",
+    "@hed-hog/crm": "0.0.365",
+    "@hed-hog/api": "0.0.8",
+    "@hed-hog/finance": "0.0.365",
+    "@hed-hog/commerce": "0.0.365",
+    "@hed-hog/queue": "0.0.365",
+    "@hed-hog/core": "0.0.365"
   },
   "exports": {
     ".": {

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

@@ -223,10 +223,8 @@ export class BitcodeWalletService {
   }
 
   async getCurrentUserWallet(userId: number) {
-    const personId = await this.resolvePersonIdFromUser(userId);
-    const existingWallet = await this.findWalletByPersonId(personId);
-
-    return existingWallet ? this.getById(existingWallet.id) : null;
+    const personId = await this.resolveOrCreatePersonForUser(userId);
+    return this.getOrCreateWalletByPersonId(personId);
   }
 
   async creditCurrentUserWallet(
@@ -344,6 +342,47 @@ export class BitcodeWalletService {
     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`,

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