@hed-hog/lms 0.0.354 → 0.0.357

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

@@ -1,5 +1,5 @@
 import { PrismaService } from '@hed-hog/api-prisma';
-import { FileService, NotificationService, SettingService } from '@hed-hog/core';
+import { buildAiConfigFromIntegration, FileService, NotificationService, SettingService } from '@hed-hog/core';
 import { IJobHandler, QueueHandlerRegistry } from '@hed-hog/queue';
 import {
     Inject,
@@ -153,12 +153,9 @@ export class CourseAudioTranscriptionService implements OnModuleInit, IJobHandle
     };
 
     const settings = await this.settingService.getSettingValues([
-      'ai-openai-api-key',
-      'ai-openai-api-key-enabled',
+      'ai-openai-profile-id',
       'lms-audio-transcription-enabled',
     ]);
-    const apiKey = settings['ai-openai-api-key'] as string;
-    const enabled = settings['ai-openai-api-key-enabled'];
     const transcriptionEnabled = settings['lms-audio-transcription-enabled'] !== false;
 
     if (!transcriptionEnabled) {
@@ -176,15 +173,31 @@ export class CourseAudioTranscriptionService implements OnModuleInit, IJobHandle
       return;
     }
 
-    if (!enabled || !apiKey) {
+    const profileId = Number(settings['ai-openai-profile-id']);
+    let apiKey = '';
+
+    if (profileId) {
+      const profile = await (this.prismaService as any).integration_profile.findUnique({
+        where: { id: profileId },
+        include: { integration_provider: { select: { slug: true } } },
+      });
+      if (profile) {
+        apiKey = buildAiConfigFromIntegration(
+          profile.integration_provider.slug,
+          profile.config,
+        ).apiKey;
+      }
+    }
+
+    if (!apiKey) {
       this.logger.warn(
-        `Transcription skipped for lesson ${lessonId}: OpenAI key not configured`,
+        `Transcription skipped for lesson ${lessonId}: OpenAI profile not configured`,
       );
       if (notificationContext) {
         await this.updateAsyncNotification(
           notificationContext,
           100,
-          'Transcrição não iniciada: chave da IA não configurada.',
+          'Transcrição não iniciada: perfil de IA não configurado em Settings → AI.',
           false,
         );
       }

package/src/course/course-structure.service.ts

@@ -18,6 +18,12 @@ import { UpdateTranscriptionSegmentsDTO } from './dto/update-transcription-segme
 
 type LessonUiType = 'video' | 'questao' | 'post' | 'exercicio';
 type LessonDbType = 'video' | 'text' | 'quiz';
+type LessonProductionStatus =
+  | 'preparada'
+  | 'gravada'
+  | 'editada'
+  | 'finalizada'
+  | 'publicada';
 type LessonFileType =
   | 'video_original'
   | `video_profile:${number}`
@@ -96,9 +102,16 @@ export class CourseStructureService {
       this.operationsIntegration.getCourseProjectLinks([courseId]),
       ]);
 
-    const lessonTaskLinks = await this.operationsIntegration.getLessonTaskLinks(
-      modules.flatMap((module) => module.course_lesson.map((lesson) => lesson.id)),
+    const lessonIds = modules.flatMap((module) =>
+      module.course_lesson.map((lesson) => lesson.id),
     );
+
+    const [lessonTaskLinks, sessionPublishedById, lessonPublishedById] =
+      await Promise.all([
+        this.operationsIntegration.getLessonTaskLinks(lessonIds),
+        this.getSessionPublishedByIds(modules.map((module) => module.id)),
+        this.getLessonPublishedByIds(lessonIds),
+      ]);
     const courseProject = courseProjectLinks.get(courseId);
 
     const sessoes = modules.map((module, index) => ({
@@ -106,6 +119,7 @@ export class CourseStructureService {
       codigo: this.formatCode('S', module.order ?? index + 1),
       titulo: module.title,
       duracao: module.duration_minutes ?? 0,
+      published: sessionPublishedById.get(module.id) ?? false,
       collapsed: false,
     }));
 
@@ -135,6 +149,10 @@ export class CourseStructureService {
                 ? String(lesson.course_lesson_question[0].question_id)
                 : undefined,
           conteudoPost: parsedContent?.conteudoPost,
+          statusProducao: this.normalizeProductionStatus(
+            parsedContent?.statusProducao,
+          ),
+          published: lessonPublishedById.get(lesson.id) ?? false,
           recursos: lesson.course_lesson_file.map((fileLink) => ({
             id: String(fileLink.id),
             nome: fileLink.title,
@@ -244,11 +262,15 @@ export class CourseStructureService {
       },
     });
 
+    const published = dto.published ?? false;
+    await this.setSessionPublished(created.id, published);
+
     return {
       id: String(created.id),
       codigo: this.formatCode('S', created.order ?? nextOrder),
       titulo: created.title,
       duracao: created.duration_minutes ?? 0,
+      published,
       collapsed: false,
     };
   }
@@ -282,11 +304,17 @@ export class CourseStructureService {
       },
     });
 
+    const published = dto.published ?? (await this.getSessionPublished(sessionId));
+    if (dto.published !== undefined) {
+      await this.setSessionPublished(sessionId, dto.published);
+    }
+
     return {
       id: String(updated.id),
       codigo: this.formatCode('S', updated.order ?? 0),
       titulo: updated.title,
       duracao: updated.duration_minutes ?? 0,
+      published,
       collapsed: false,
     };
   }
@@ -335,6 +363,23 @@ export class CourseStructureService {
     const created = await this.prisma.$transaction(async (tx) => {
       const nextOrder = await this.nextLessonOrder(sessionId, tx);
       const mappedType = this.mapUiTypeToDbType(dto.tipo);
+      const normalizedStatus = this.normalizeProductionStatus(dto.statusProducao);
+      const shouldPublish = dto.published ?? false;
+
+      if (
+        shouldPublish &&
+        normalizedStatus !== 'publicada' &&
+        !dto.confirmarPublicacaoComStatus
+      ) {
+        throw new BadRequestException(
+          'LESSON_PUBLISH_REQUIRES_STATUS_CONFIRMATION',
+        );
+      }
+
+      const statusProducao: LessonProductionStatus =
+        shouldPublish && dto.confirmarPublicacaoComStatus
+          ? 'publicada'
+          : normalizedStatus;
 
       const lesson = await tx.course_lesson.create({
         data: {
@@ -344,10 +389,15 @@ export class CourseStructureService {
           type: mappedType,
           duration_seconds: dto.duracao * 60,
           order: nextOrder,
-          content: this.serializeContent(dto),
+          content: this.serializeContent({
+            ...dto,
+            statusProducao,
+          }),
         },
       });
 
+      await this.setLessonPublished(lesson.id, shouldPublish, tx);
+
       await this.syncLessonRelations(lesson.id, dto, tx);
 
       const projectLinks = await this.operationsIntegration.getCourseProjectLinks(
@@ -410,10 +460,36 @@ export class CourseStructureService {
           conteudoPost: dto.conteudoPost,
           exameVinculado: dto.exameVinculado,
           descricaoPrivada: dto.descricaoPrivada,
+          statusProducao: (() => {
+            const parsed = this.parseLessonContent(lesson.content);
+            const currentStatus = this.normalizeProductionStatus(
+              parsed?.statusProducao,
+            );
+            const nextStatus = this.normalizeProductionStatus(
+              dto.statusProducao ?? currentStatus,
+            );
+
+            const shouldPublish = dto.published;
+            if (shouldPublish === true && nextStatus !== 'publicada') {
+              if (!dto.confirmarPublicacaoComStatus) {
+                throw new BadRequestException(
+                  'LESSON_PUBLISH_REQUIRES_STATUS_CONFIRMATION',
+                );
+              }
+
+              return 'publicada';
+            }
+
+            return nextStatus;
+          })(),
         }),
       },
     });
 
+    if (dto.published !== undefined) {
+      await this.setLessonPublished(lessonId, dto.published);
+    }
+
     await this.syncLessonRelations(lessonId, dto);
     await this.operationsIntegration.syncTaskForLesson(lessonId);
 
@@ -756,6 +832,9 @@ export class CourseStructureService {
       },
     });
 
+    const sourcePublished = await this.getSessionPublished(sourceModule.id);
+    await this.setSessionPublished(newModule.id, sourcePublished);
+
     const newLessons = [];
     const projectLinks = await this.operationsIntegration.getCourseProjectLinks([
       courseId,
@@ -775,6 +854,9 @@ export class CourseStructureService {
         },
       });
 
+      const lessonPublished = await this.getLessonPublished(lesson.id);
+      await this.setLessonPublished(newLesson.id, lessonPublished);
+
       if (lesson.course_lesson_file.length > 0) {
         await (this.prisma as any).course_lesson_file.createMany({
           data: lesson.course_lesson_file.map((f) => ({
@@ -825,6 +907,7 @@ export class CourseStructureService {
         codigo: this.formatCode('S', newModule.order ?? nextOrder),
         titulo: newModule.title,
         duracao: newModule.duration_minutes ?? 0,
+        published: sourcePublished,
         collapsed: false,
       },
       lessons: newLessons,
@@ -877,6 +960,9 @@ export class CourseStructureService {
       },
     });
 
+    const sourcePublished = await this.getLessonPublished(sourceLesson.id);
+    await this.setLessonPublished(newLesson.id, sourcePublished);
+
     if (sourceLesson.course_lesson_file.length > 0) {
       await (this.prisma as any).course_lesson_file.createMany({
         data: sourceLesson.course_lesson_file.map((f) => ({
@@ -966,6 +1052,9 @@ export class CourseStructureService {
         },
       });
 
+      const sourcePublished = await this.getLessonPublished(lesson.id);
+      await this.setLessonPublished(newLesson.id, sourcePublished);
+
       if (lesson.course_lesson_file.length > 0) {
         await (this.prisma as any).course_lesson_file.createMany({
           data: lesson.course_lesson_file.map((f) => ({
@@ -1182,6 +1271,7 @@ export class CourseStructureService {
     const taskLinks = await this.operationsIntegration.getLessonTaskLinks([
       lessonId,
     ]);
+    const lessonPublished = await this.getLessonPublished(lessonId);
     const parsedContent = this.parseLessonContent(lesson.content);
     const tipo = this.mapDbTypeToUiType(lesson.type, parsedContent?.sourceType);
 
@@ -1205,6 +1295,8 @@ export class CourseStructureService {
           : lesson.course_lesson_question[0]?.question_id != null
             ? String(lesson.course_lesson_question[0].question_id)
             : undefined,
+      statusProducao: this.normalizeProductionStatus(parsedContent?.statusProducao),
+      published: lessonPublished,
       conteudoPost: parsedContent?.conteudoPost,
       recursos: lesson.course_lesson_file.map((fileLink) => ({
         id: String(fileLink.id),
@@ -1290,10 +1382,12 @@ export class CourseStructureService {
     conteudoPost?: string;
     exameVinculado?: number;
     descricaoPrivada?: string;
+    statusProducao?: LessonProductionStatus;
   }) {
     const payload: Record<string, unknown> = {
       sourceType: data.tipo,
       descricaoPrivada: data.descricaoPrivada ?? '',
+      statusProducao: this.normalizeProductionStatus(data.statusProducao),
     };
 
     if (data.tipo === 'video') {
@@ -1317,6 +1411,113 @@ export class CourseStructureService {
     return JSON.stringify(payload);
   }
 
+  private normalizeProductionStatus(
+    value?: string | null,
+  ): LessonProductionStatus {
+    if (!value) return 'preparada';
+
+    const normalized = String(value).trim().toLowerCase();
+    if (normalized === 'preparada') return 'preparada';
+    if (normalized === 'gravada') return 'gravada';
+    if (normalized === 'editada') return 'editada';
+    if (normalized === 'finalizada') return 'finalizada';
+    if (normalized === 'publicada') return 'publicada';
+
+    return 'preparada';
+  }
+
+  private normalizeIdList(ids: number[]) {
+    return ids
+      .map((id) => Number(id))
+      .filter((id) => Number.isInteger(id) && id > 0);
+  }
+
+  private buildIdCsv(ids: number[]) {
+    return this.normalizeIdList(ids).join(',');
+  }
+
+  private async getSessionPublishedByIds(sessionIds: number[]) {
+    const publishedById = new Map<number, boolean>();
+    const csv = this.buildIdCsv(sessionIds);
+
+    if (!csv) return publishedById;
+
+    try {
+      const rows = await this.prisma.$queryRawUnsafe<
+        Array<{ id: number; published: boolean }>
+      >(
+        `SELECT id, published FROM course_module WHERE id IN (${csv})`,
+      );
+
+      for (const row of rows) {
+        publishedById.set(row.id, Boolean(row.published));
+      }
+    } catch {
+      return publishedById;
+    }
+
+    return publishedById;
+  }
+
+  private async getSessionPublished(sessionId: number) {
+    const rows = await this.prisma.$queryRawUnsafe<
+      Array<{ published: boolean }>
+    >(
+      `SELECT published FROM course_module WHERE id = ${Number(sessionId)} LIMIT 1`,
+    );
+
+    return Boolean(rows[0]?.published);
+  }
+
+  private async setSessionPublished(sessionId: number, published: boolean) {
+    await this.prisma.$executeRawUnsafe(
+      `UPDATE course_module SET published = ${published ? 'true' : 'false'} WHERE id = ${Number(sessionId)}`,
+    );
+  }
+
+  private async getLessonPublishedByIds(lessonIds: number[]) {
+    const publishedById = new Map<number, boolean>();
+    const csv = this.buildIdCsv(lessonIds);
+
+    if (!csv) return publishedById;
+
+    try {
+      const rows = await this.prisma.$queryRawUnsafe<
+        Array<{ id: number; published: boolean }>
+      >(
+        `SELECT id, published FROM course_lesson WHERE id IN (${csv})`,
+      );
+
+      for (const row of rows) {
+        publishedById.set(row.id, Boolean(row.published));
+      }
+    } catch {
+      return publishedById;
+    }
+
+    return publishedById;
+  }
+
+  private async getLessonPublished(lessonId: number) {
+    const rows = await this.prisma.$queryRawUnsafe<
+      Array<{ published: boolean }>
+    >(
+      `SELECT published FROM course_lesson WHERE id = ${Number(lessonId)} LIMIT 1`,
+    );
+
+    return Boolean(rows[0]?.published);
+  }
+
+  private async setLessonPublished(
+    lessonId: number,
+    published: boolean,
+    client: any = this.prisma,
+  ) {
+    await client.$executeRawUnsafe(
+      `UPDATE course_lesson SET published = ${published ? 'true' : 'false'} WHERE id = ${Number(lessonId)}`,
+    );
+  }
+
   private parseLessonContent(content?: string | null): any {
     if (!content) return null;
 

package/src/course/course.service.ts

@@ -1,5 +1,5 @@
 import { PrismaService } from '@hed-hog/api-prisma';
-import { IntegrationDeveloperApiService } from '@hed-hog/core';
+import { FileService, IntegrationDeveloperApiService } from '@hed-hog/core';
 import { BadRequestException, Inject, Injectable, forwardRef } from '@nestjs/common';
 import { CourseOperationsIntegrationService } from './course-operations-integration.service';
 import { CreateCourseDto } from './dto/create-course.dto';
@@ -33,6 +33,7 @@ type PersistCourseExtrasInput = {
 export class CourseService {
   constructor(
     private readonly prisma: PrismaService,
+    private readonly fileService: FileService,
     @Inject(forwardRef(() => IntegrationDeveloperApiService))
     private readonly integrationApi: IntegrationDeveloperApiService,
     private readonly operationsIntegration: CourseOperationsIntegrationService,
@@ -713,6 +714,24 @@ export class CourseService {
   }
 
   async remove(id: number) {
+    const course = await this.prisma.course.findUnique({
+      where: { id },
+      select: { id: true, status: true },
+    });
+
+    if (!course) {
+      throw new BadRequestException('Course not found');
+    }
+
+    if (course.status !== 'archived') {
+      throw new BadRequestException('ONLY_ARCHIVED_COURSE_CAN_BE_DELETED');
+    }
+
+    const fileIds = await this.getCourseRelatedFileIds(id);
+    if (fileIds.length > 0) {
+      await this.fileService.delete('pt', { ids: fileIds }).catch(() => undefined);
+    }
+
     await this.prisma.course.delete({ where: { id } });
 
     await this.integrationApi.publishEvent({
@@ -726,6 +745,53 @@ export class CourseService {
     return { success: true };
   }
 
+  private async getCourseRelatedFileIds(courseId: number) {
+    const rows = await this.prisma.$queryRaw<
+      Array<{ file_id: number | null }>
+    >`
+      SELECT DISTINCT files.file_id
+      FROM (
+        SELECT ci.file_id
+        FROM course_image ci
+        WHERE ci.course_id = ${courseId}
+
+        UNION ALL
+
+        SELECT cf.file_id
+        FROM course_file cf
+        WHERE cf.course_id = ${courseId}
+
+        UNION ALL
+
+        SELECT clf.file_id
+        FROM course_lesson_file clf
+        INNER JOIN course_lesson cl ON cl.id = clf.course_lesson_id
+        INNER JOIN course_module cm ON cm.id = cl.course_module_id
+        WHERE cm.course_id = ${courseId}
+
+        UNION ALL
+
+        SELECT clvf.file_id
+        FROM course_lesson_video_frame clvf
+        INNER JOIN course_lesson cl ON cl.id = clvf.course_lesson_id
+        INNER JOIN course_module cm ON cm.id = cl.course_module_id
+        WHERE cm.course_id = ${courseId}
+
+        UNION ALL
+
+        SELECT cgm.file_id
+        FROM course_class_group_material cgm
+        INNER JOIN course_class_group ccg ON ccg.id = cgm.course_class_group_id
+        WHERE ccg.course_id = ${courseId}
+      ) AS files
+      WHERE files.file_id IS NOT NULL
+    `;
+
+    return rows
+      .map((row) => Number(row.file_id))
+      .filter((id) => Number.isInteger(id) && id > 0);
+  }
+
   private mapCourse(
     c: any,
     metrics?: {

package/src/course/dto/create-course-structure-lesson.dto.ts

@@ -82,6 +82,23 @@ export class CreateCourseStructureLessonDto {
   @IsOptional()
   duracao: number = 0;
 
+  @IsBoolean()
+  @IsOptional()
+  published?: boolean;
+
+  @IsEnum(['preparada', 'gravada', 'editada', 'finalizada', 'publicada'])
+  @IsOptional()
+  statusProducao?:
+    | 'preparada'
+    | 'gravada'
+    | 'editada'
+    | 'finalizada'
+    | 'publicada';
+
+  @IsBoolean()
+  @IsOptional()
+  confirmarPublicacaoComStatus?: boolean;
+
   @IsEnum(['youtube', 'vimeo', 'file_storage', 'bunny', 'custom'])
   @IsOptional()
   videoProvedor?: 'youtube' | 'vimeo' | 'file_storage' | 'bunny' | 'custom';

package/src/course/dto/create-course-structure-session.dto.ts

@@ -1,4 +1,12 @@
-import { IsInt, IsNotEmpty, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+import {
+    IsBoolean,
+    IsInt,
+    IsNotEmpty,
+    IsOptional,
+    IsString,
+    MaxLength,
+    Min,
+} from 'class-validator';
 
 export class CreateCourseStructureSessionDto {
   @IsString()
@@ -19,4 +27,8 @@ export class CreateCourseStructureSessionDto {
   @IsString()
   @IsOptional()
   descricao?: string;
+
+  @IsBoolean()
+  @IsOptional()
+  published?: boolean;
 }

package/src/enterprise/training/training-student.controller.ts

@@ -1,20 +1,12 @@
-import { Role, User } from '@hed-hog/api';
-import { Body, Controller, Get, Param, ParseIntPipe, Post, Query } from '@nestjs/common';
+import { NoRole, User } from '@hed-hog/api';
+import { Controller, Get, Param, ParseIntPipe, Query } from '@nestjs/common';
 import { TrainingStudentService } from './training-student.service';
 
-@Role()
+@NoRole()
 @Controller('lms/enterprise/training/student')
 export class TrainingStudentController {
   constructor(private readonly trainingStudentService: TrainingStudentService) {}
 
-  @Get()
-  getDashboard(
-    @User('id') userId: number,
-    @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
-  ) {
-    return this.trainingStudentService.getDashboard(userId, enterpriseId);
-  }
-
   @Get('class-groups')
   getClassGroups(
     @User('id') userId: number,
@@ -62,20 +54,4 @@ export class TrainingStudentController {
   ) {
     return this.trainingStudentService.getMyEvaluations(userId, classGroupId);
   }
-
-  @Get('streak')
-  getStreak(
-    @User('id') userId: number,
-    @Query('days', new ParseIntPipe({ optional: true })) days?: number,
-  ) {
-    return this.trainingStudentService.getStreak(userId, days);
-  }
-
-  @Post('streak/activities')
-  registerStreakActivity(
-    @User('id') userId: number,
-    @Body() body?: { activityType?: string; source?: string; activityDateKey?: string },
-  ) {
-    return this.trainingStudentService.registerStreakActivity(userId, body);
-  }
 }