@hed-hog/lms 0.0.355 → 0.0.358

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}`
@@ -70,6 +76,7 @@ export class CourseStructureService {
                       person: {
                         select: {
                           name: true,
+                          avatar_id: true,
                         },
                       },
                     },
@@ -96,9 +103,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 +120,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 +150,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,
@@ -153,7 +172,8 @@ export class CourseStructureService {
           instrutores: lesson.course_lesson_instructor.map((item) => ({
             id: String(item.instructor_id),
             role: item.role,
-            nome: this.personName(item.instructor?.person),
+            name: this.personName(item.instructor?.person),
+            avatarId: item.instructor?.person?.avatar_id ?? null,
           })),
           operationsTaskId: lessonTaskLinks.get(lesson.id)?.taskId ?? null,
           operationsTaskName: lessonTaskLinks.get(lesson.id)?.taskName ?? null,
@@ -169,6 +189,7 @@ export class CourseStructureService {
       instructors: instructors.map((instructor) => ({
         id: instructor.id,
         name: instructor.name,
+        avatarId: instructor.avatarId ?? null,
       })),
       curso: courseRecord
         ? {
@@ -244,11 +265,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 +307,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 +366,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 +392,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 +463,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);
 
@@ -437,6 +516,7 @@ export class CourseStructureService {
       throw new NotFoundException('Lesson not found for this session');
     }
 
+    await this.operationsIntegration.deleteTasksForLesson(lessonId, this.prisma);
     await this.prisma.course_lesson.delete({ where: { id: lessonId } });
 
     return { success: true };
@@ -756,6 +836,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 +858,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 +911,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 +964,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 +1056,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 +1275,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 +1299,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 +1386,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 +1415,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.module.ts

@@ -4,6 +4,7 @@ import { QueueModule } from '@hed-hog/queue';
 import { forwardRef, Module } from '@nestjs/common';
 import { InstructorModule } from '../instructor/instructor.module';
 import { CourseLessonController } from './course-lesson.controller';
+import { CourseOperationsController } from './course-operations.controller';
 import { CourseOperationsIntegrationService } from './course-operations-integration.service';
 import { CourseStructureController } from './course-structure.controller';
 import { LmsSettingController } from './lms-setting.controller';
@@ -12,6 +13,7 @@ import { CourseVideoConversionService } from './course-video-conversion.service'
 import { CourseController } from './course.controller';
 import { LmsCoursesMcpTools } from './course.mcp-tools';
 import { CourseService } from './course.service';
+import { LmsOperationsTaskSubscriber } from './lms-operations-task.subscriber';
 
 @Module({
   imports: [
@@ -20,13 +22,14 @@ import { CourseService } from './course.service';
     forwardRef(() => CoreModule),
     forwardRef(() => QueueModule),
   ],
-  controllers: [CourseController, CourseStructureController, CourseLessonController, LmsSettingController],
+  controllers: [CourseController, CourseStructureController, CourseLessonController, LmsSettingController, CourseOperationsController],
   providers: [
     CourseOperationsIntegrationService,
     CourseService,
     CourseStructureService,
     CourseVideoConversionService,
     LmsCoursesMcpTools,
+    LmsOperationsTaskSubscriber,
   ],
   exports: [
     forwardRef(() => CourseService),

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/course/dto/update-course-operations-config.dto.ts

@@ -0,0 +1,16 @@
+import { IsIn, IsInt, IsOptional, IsPositive, IsString } from 'class-validator';
+
+export class UpdateCourseOperationsConfigDto {
+  @IsOptional()
+  @IsInt()
+  @IsPositive()
+  projectId?: number | null;
+
+  @IsOptional()
+  @IsIn(['per_lesson', 'per_production_status'])
+  taskMode?: 'per_lesson' | 'per_production_status' | null;
+
+  @IsOptional()
+  @IsString()
+  completionStatus?: string | null;
+}

package/src/course/lms-operations-task.subscriber.ts

@@ -0,0 +1,44 @@
+import { IntegrationDeveloperApiService } from '@hed-hog/core';
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { PrismaService } from '@hed-hog/api-prisma';
+import { CourseOperationsIntegrationService } from './course-operations-integration.service';
+
+@Injectable()
+export class LmsOperationsTaskSubscriber implements OnModuleInit {
+  private readonly logger = new Logger(LmsOperationsTaskSubscriber.name);
+
+  constructor(
+    private readonly integrationApi: IntegrationDeveloperApiService,
+    private readonly operationsIntegration: CourseOperationsIntegrationService,
+    private readonly prisma: PrismaService,
+  ) {}
+
+  onModuleInit(): void {
+    this.integrationApi.subscribeMany([
+      {
+        eventName: 'operations.task.updated',
+        consumerName: 'lms.lesson-status-from-task',
+        priority: 5,
+        handler: async (event) => {
+          try {
+            const status = event.payload?.status as string | undefined;
+            if (status !== 'done') return;
+
+            const taskId = Number(event.aggregateId);
+            if (!taskId || !Number.isInteger(taskId) || taskId <= 0) return;
+
+            await this.operationsIntegration.applyTaskCompletionToLesson(
+              taskId,
+              '',
+              this.prisma,
+            );
+          } catch (err) {
+            this.logger.error(
+              `Error applying task completion to lesson: ${String(err)}`,
+            );
+          }
+        },
+      },
+    ]);
+  }
+}

package/src/enterprise/enterprise.service.ts

@@ -67,7 +67,7 @@ export class EnterpriseService {
         take: pageSize,
         orderBy: { name: 'asc' },
         include: {
-          person: { select: { id: true, name: true } },
+          person: { select: { id: true, name: true, avatar_id: true } },
           _count: {
             select: {
               enterprise_user: true,

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