@hed-hog/lms 0.0.357 → 0.0.358

package/src/course/course-operations-integration.service.ts

@@ -16,6 +16,32 @@ type LessonTaskLink = {
   projectId: number | null;
 };
 
+export type OperationsConfig = {
+  isAvailable: boolean;
+  projectId: number | null;
+  projectCode: string | null;
+  projectName: string | null;
+  taskMode: 'per_lesson' | 'per_production_status' | null;
+  completionStatus: string | null;
+  missingTasksCount: number;
+};
+
+export type UpdateOperationsConfigInput = {
+  projectId?: number | null;
+  taskMode?: 'per_lesson' | 'per_production_status' | null;
+  completionStatus?: string | null;
+};
+
+const PRODUCTION_STAGES = [
+  'preparacao',
+  'gravacao',
+  'edicao',
+  'finalizacao',
+  'publicacao',
+] as const;
+
+type ProductionStage = (typeof PRODUCTION_STAGES)[number];
+
 @Injectable()
 export class CourseOperationsIntegrationService {
   private operationsAvailability: boolean | null = null;
@@ -51,6 +77,162 @@ export class CourseOperationsIntegrationService {
     return this.operationsAvailability;
   }
 
+  async getOperationsConfig(
+    courseId: number,
+    client: PrismaClientLike = this.prisma,
+  ): Promise<OperationsConfig> {
+    const isAvailable = await this.isOperationsModuleAvailable(client);
+
+    const courseRows = (await client.$queryRawUnsafe(
+      `
+        SELECT c.operations_project_id   AS "projectId",
+               c.operations_task_mode    AS "taskMode",
+               c.operations_lesson_completion_status AS "completionStatus"
+        FROM course c
+        WHERE c.id = $1
+        LIMIT 1
+      `,
+      courseId,
+    )) as Array<{
+      projectId: number | null;
+      taskMode: string | null;
+      completionStatus: string | null;
+    }>;
+
+    const courseRow = courseRows[0];
+    if (!courseRow) {
+      return {
+        isAvailable,
+        projectId: null,
+        projectCode: null,
+        projectName: null,
+        taskMode: null,
+        completionStatus: null,
+        missingTasksCount: 0,
+      };
+    }
+
+    const projectId = courseRow.projectId;
+    const taskMode = (courseRow.taskMode ?? null) as
+      | 'per_lesson'
+      | 'per_production_status'
+      | null;
+    const completionStatus = courseRow.completionStatus ?? null;
+
+    let projectCode: string | null = null;
+    let projectName: string | null = null;
+
+    if (projectId && isAvailable) {
+      const projectRows = (await client.$queryRawUnsafe(
+        `
+          SELECT code AS "projectCode", name AS "projectName"
+          FROM operations_project
+          WHERE id = $1 AND deleted_at IS NULL
+          LIMIT 1
+        `,
+        projectId,
+      )) as Array<{ projectCode: string | null; projectName: string | null }>;
+
+      projectCode = projectRows[0]?.projectCode ?? null;
+      projectName = projectRows[0]?.projectName ?? null;
+    }
+
+    const missingTasksCount = await this.countMissingTasks(
+      courseId,
+      taskMode,
+      client,
+    );
+
+    return {
+      isAvailable,
+      projectId,
+      projectCode,
+      projectName,
+      taskMode,
+      completionStatus,
+      missingTasksCount,
+    };
+  }
+
+  private async countMissingTasks(
+    courseId: number,
+    taskMode: 'per_lesson' | 'per_production_status' | null,
+    client: PrismaClientLike,
+  ): Promise<number> {
+    if (!taskMode) return 0;
+
+    try {
+      if (taskMode === 'per_lesson') {
+        const rows = (await client.$queryRawUnsafe(
+          `
+            SELECT COUNT(*) AS cnt
+            FROM course_lesson l
+            JOIN course_module m ON m.id = l.course_module_id
+            WHERE m.course_id = $1
+              AND l.operations_task_id IS NULL
+          `,
+          courseId,
+        )) as Array<{ cnt: string | number }>;
+        return Number(rows[0]?.cnt ?? 0);
+      }
+
+      const rows = (await client.$queryRawUnsafe(
+        `
+          SELECT COUNT(DISTINCT l.id) AS cnt
+          FROM course_lesson l
+          JOIN course_module m ON m.id = l.course_module_id
+          WHERE m.course_id = $1
+            AND (
+              SELECT COUNT(*)
+              FROM course_lesson_operations_task clot
+              WHERE clot.course_lesson_id = l.id
+            ) < $2
+        `,
+        courseId,
+        PRODUCTION_STAGES.length,
+      )) as Array<{ cnt: string | number }>;
+      return Number(rows[0]?.cnt ?? 0);
+    } catch {
+      return 0;
+    }
+  }
+
+  async updateOperationsConfig(
+    courseId: number,
+    input: UpdateOperationsConfigInput,
+    client: PrismaClientLike = this.prisma,
+  ) {
+    const setParts: string[] = [];
+    const values: unknown[] = [];
+    let idx = 1;
+
+    if (input.projectId !== undefined) {
+      if (input.projectId !== null && input.projectId > 0) {
+        await this.resolveOperationsProjectId(input.projectId, client);
+      }
+      setParts.push(`operations_project_id = $${idx++}`);
+      values.push(input.projectId ?? null);
+    }
+
+    if (input.taskMode !== undefined) {
+      setParts.push(`operations_task_mode = $${idx++}`);
+      values.push(input.taskMode ?? null);
+    }
+
+    if (input.completionStatus !== undefined) {
+      setParts.push(`operations_lesson_completion_status = $${idx++}`);
+      values.push(input.completionStatus ?? null);
+    }
+
+    if (setParts.length === 0) return;
+
+    values.push(courseId);
+    await client.$executeRawUnsafe(
+      `UPDATE course SET ${setParts.join(', ')}, updated_at = NOW() WHERE id = $${idx}`,
+      ...values,
+    );
+  }
+
   async resolveOperationsProjectId(
     value?: number | null,
     client: PrismaClientLike = this.prisma,
@@ -373,6 +555,150 @@ export class CourseOperationsIntegrationService {
     return taskId;
   }
 
+  async createProductionTasksForLesson(
+    client: PrismaClientLike,
+    input: {
+      courseId: number;
+      lessonId: number;
+      projectId: number;
+      courseTitle?: string | null;
+      sessionTitle?: string | null;
+      lessonTitle: string;
+      lessonDescription?: string | null;
+    },
+  ) {
+    if (!(await this.isOperationsModuleAvailable(client))) {
+      return 0;
+    }
+
+    const projectRows = (await client.$queryRawUnsafe(
+      `SELECT id FROM operations_project WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+      input.projectId,
+    )) as Array<{ id: number }>;
+
+    if (!projectRows[0]?.id) {
+      throw new BadRequestException('Operations project not found');
+    }
+
+    const maxPositionRows = (await client.$queryRawUnsafe(
+      `
+        SELECT MAX(position) AS max_position
+        FROM operations_task
+        WHERE project_id = $1 AND status = 'todo' AND deleted_at IS NULL
+      `,
+      input.projectId,
+    )) as Array<{ max_position: number | null }>;
+
+    let nextPosition = Number(maxPositionRows[0]?.max_position ?? -1) + 1;
+    let created = 0;
+
+    for (const stage of PRODUCTION_STAGES) {
+      const existing = (await client.$queryRawUnsafe(
+        `SELECT id FROM course_lesson_operations_task WHERE course_lesson_id = $1 AND production_stage = $2 LIMIT 1`,
+        input.lessonId,
+        stage,
+      )) as Array<{ id: number }>;
+
+      if (existing[0]?.id) continue;
+
+      const stageLabel = this.stageLabel(stage);
+      const taskName = `${this.buildTaskName(input.lessonTitle)} — ${stageLabel}`;
+      const taskDescription = this.buildTaskDescription({
+        courseTitle: input.courseTitle,
+        sessionTitle: input.sessionTitle,
+        lessonDescription: input.lessonDescription,
+      });
+      const tags = `lms,course-${input.courseId},lesson-${input.lessonId},stage-${stage}`;
+
+      const createdRows = (await client.$queryRawUnsafe(
+        `
+          INSERT INTO operations_task (
+            project_id, name, description, priority, status, position,
+            tags, total_doing_minutes, created_at, updated_at
+          )
+          VALUES ($1, $2, $3, 'medium', 'todo', $4, $5, 0, NOW(), NOW())
+          RETURNING id
+        `,
+        input.projectId,
+        taskName,
+        taskDescription,
+        nextPosition++,
+        tags,
+      )) as Array<{ id: number }>;
+
+      const taskId = createdRows[0]?.id;
+      if (!taskId) continue;
+
+      await client.$executeRawUnsafe(
+        `INSERT INTO operations_task_activity (task_id, actor_collaborator_id, action, created_at)
+         VALUES ($1, NULL, 'task_created', NOW())`,
+        taskId,
+      );
+
+      await client.$executeRawUnsafe(
+        `INSERT INTO course_lesson_operations_task (course_lesson_id, operations_task_id, production_stage, created_at, updated_at)
+         VALUES ($1, $2, $3, NOW(), NOW())
+         ON CONFLICT (course_lesson_id, production_stage) DO NOTHING`,
+        input.lessonId,
+        taskId,
+        stage,
+      );
+
+      created++;
+    }
+
+    return created;
+  }
+
+  async deleteTasksForLesson(
+    lessonId: number,
+    client: PrismaClientLike = this.prisma,
+  ) {
+    if (!(await this.isOperationsModuleAvailable(client))) {
+      return;
+    }
+
+    try {
+      // per_lesson mode: delete the single linked task
+      const lessonRows = (await client.$queryRawUnsafe(
+        `SELECT operations_task_id AS "taskId" FROM course_lesson WHERE id = $1 LIMIT 1`,
+        lessonId,
+      )) as Array<{ taskId: number | null }>;
+
+      const singleTaskId = lessonRows[0]?.taskId ?? null;
+      if (singleTaskId) {
+        await client.$executeRawUnsafe(
+          `UPDATE operations_task SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`,
+          singleTaskId,
+        );
+        await client.$executeRawUnsafe(
+          `UPDATE course_lesson SET operations_task_id = NULL WHERE id = $1`,
+          lessonId,
+        );
+      }
+
+      // per_production_status mode: soft-delete all linked production tasks
+      const multiRows = (await client.$queryRawUnsafe(
+        `SELECT operations_task_id AS "taskId" FROM course_lesson_operations_task WHERE course_lesson_id = $1`,
+        lessonId,
+      )) as Array<{ taskId: number }>;
+
+      for (const row of multiRows) {
+        await client.$executeRawUnsafe(
+          `UPDATE operations_task SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`,
+          row.taskId,
+        );
+      }
+
+      await client.$executeRawUnsafe(
+        `DELETE FROM course_lesson_operations_task WHERE course_lesson_id = $1`,
+        lessonId,
+      );
+    } catch {
+      // Graceful no-op if tables not present yet
+    }
+  }
+
   async syncTaskForLesson(
     lessonId: number,
     client: PrismaClientLike = this.prisma,
@@ -433,14 +759,21 @@ export class CourseOperationsIntegrationService {
     courseId: number,
     client: PrismaClientLike = this.prisma,
   ) {
-    const projectLinks = await this.getCourseProjectLinks([courseId], client);
-    const projectId = projectLinks.get(courseId)?.projectId ?? null;
+    const courseRows = (await client.$queryRawUnsafe(
+      `SELECT operations_project_id AS "projectId", operations_task_mode AS "taskMode"
+       FROM course WHERE id = $1 LIMIT 1`,
+      courseId,
+    )) as Array<{ projectId: number | null; taskMode: string | null }>;
 
-    if (!projectId || !(await this.isOperationsModuleAvailable(client))) {
+    const courseRow = courseRows[0];
+    const projectId = courseRow?.projectId ?? null;
+    const taskMode = courseRow?.taskMode ?? null;
+
+    if (!projectId || !taskMode || !(await this.isOperationsModuleAvailable(client))) {
       return 0;
     }
 
-    const rows = (await client.$queryRawUnsafe(
+    const lessonsRows = (await client.$queryRawUnsafe(
       `
         SELECT l.id,
                l.title AS "lessonTitle",
@@ -448,12 +781,9 @@ export class CourseOperationsIntegrationService {
                m.title AS "sessionTitle",
                c.title AS "courseTitle"
         FROM course_lesson l
-        JOIN course_module m
-          ON m.id = l.course_module_id
-        JOIN course c
-          ON c.id = m.course_id
+        JOIN course_module m ON m.id = l.course_module_id
+        JOIN course c ON c.id = m.course_id
         WHERE c.id = $1
-          AND l.operations_task_id IS NULL
         ORDER BY m."order" ASC, l."order" ASC, l.id ASC
       `,
       courseId,
@@ -467,25 +797,133 @@ export class CourseOperationsIntegrationService {
 
     let createdCount = 0;
 
-    for (const row of rows) {
-      const taskId = await this.createTaskForLesson(client, {
-        courseId,
-        lessonId: row.id,
-        projectId,
-        courseTitle: row.courseTitle,
-        sessionTitle: row.sessionTitle,
-        lessonTitle: row.lessonTitle,
-        lessonDescription: row.lessonDescription,
-      });
-
-      if (taskId) {
-        createdCount += 1;
+    for (const row of lessonsRows) {
+      if (taskMode === 'per_lesson') {
+        const existing = (await client.$queryRawUnsafe(
+          `SELECT operations_task_id FROM course_lesson WHERE id = $1 LIMIT 1`,
+          row.id,
+        )) as Array<{ operations_task_id: number | null }>;
+        if (existing[0]?.operations_task_id) continue;
+
+        const taskId = await this.createTaskForLesson(client, {
+          courseId,
+          lessonId: row.id,
+          projectId,
+          courseTitle: row.courseTitle,
+          sessionTitle: row.sessionTitle,
+          lessonTitle: row.lessonTitle,
+          lessonDescription: row.lessonDescription,
+        });
+        if (taskId) createdCount++;
+      } else if (taskMode === 'per_production_status') {
+        const n = await this.createProductionTasksForLesson(client, {
+          courseId,
+          lessonId: row.id,
+          projectId,
+          courseTitle: row.courseTitle,
+          sessionTitle: row.sessionTitle,
+          lessonTitle: row.lessonTitle,
+          lessonDescription: row.lessonDescription,
+        });
+        createdCount += n;
       }
     }
 
     return createdCount;
   }
 
+  async applyTaskCompletionToLesson(
+    taskId: number,
+    taskTags: string,
+    client: PrismaClientLike = this.prisma,
+  ) {
+    if (!(await this.isOperationsModuleAvailable(client))) return;
+
+    // Detect per_lesson mode: lesson is linked via course_lesson.operations_task_id
+    const perLessonRows = (await client.$queryRawUnsafe(
+      `
+        SELECT l.id AS "lessonId", c.operations_lesson_completion_status AS "completionStatus"
+        FROM course_lesson l
+        JOIN course_module m ON m.id = l.course_module_id
+        JOIN course c ON c.id = m.course_id
+        WHERE l.operations_task_id = $1
+          AND c.operations_task_mode = 'per_lesson'
+          AND c.operations_lesson_completion_status IS NOT NULL
+        LIMIT 1
+      `,
+      taskId,
+    )) as Array<{ lessonId: number; completionStatus: string }>;
+
+    if (perLessonRows[0]) {
+      const { lessonId, completionStatus } = perLessonRows[0];
+      await this.applyLessonProductionStatus(lessonId, completionStatus, client);
+      return;
+    }
+
+    // Detect per_production_status mode: lesson is linked via course_lesson_operations_task
+    const perStageRows = (await client.$queryRawUnsafe(
+      `
+        SELECT clot.course_lesson_id AS "lessonId", clot.production_stage AS "stage"
+        FROM course_lesson_operations_task clot
+        WHERE clot.operations_task_id = $1
+        LIMIT 1
+      `,
+      taskId,
+    )) as Array<{ lessonId: number; stage: string }>;
+
+    if (perStageRows[0]) {
+      const { lessonId, stage } = perStageRows[0];
+      const statusForStage = this.stageToProductionStatus(
+        stage as ProductionStage,
+        taskTags,
+      );
+      if (statusForStage) {
+        await this.applyLessonProductionStatus(lessonId, statusForStage, client);
+      }
+    }
+  }
+
+  private async applyLessonProductionStatus(
+    lessonId: number,
+    status: string,
+    client: PrismaClientLike,
+  ) {
+    try {
+      await client.$executeRawUnsafe(
+        `UPDATE course_lesson SET status_producao = $1, updated_at = NOW() WHERE id = $2`,
+        status,
+        lessonId,
+      );
+    } catch {
+      // Column may not exist in older schema versions — ignore gracefully
+    }
+  }
+
+  private stageToProductionStatus(
+    stage: ProductionStage,
+    _tags: string,
+  ): string | null {
+    const map: Record<ProductionStage, string> = {
+      preparacao: 'preparada',
+      gravacao: 'gravada',
+      edicao: 'editada',
+      finalizacao: 'finalizada',
+      publicacao: 'publicada',
+    };
+    return map[stage] ?? null;
+  }
+
+  private stageLabel(stage: ProductionStage): string {
+    const labels: Record<ProductionStage, string> = {
+      preparacao: 'Preparação',
+      gravacao: 'Gravação',
+      edicao: 'Edição',
+      finalizacao: 'Finalização',
+      publicacao: 'Publicação',
+    };
+    return labels[stage];
+  }
+
   private normalizeIds(ids: number[]) {
     return [...new Set(ids)]
       .map((id) => Number(id))

package/src/course/course-operations.controller.ts

@@ -0,0 +1,45 @@
+import { Role } from '@hed-hog/api';
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+} from '@nestjs/common';
+import { CourseOperationsIntegrationService } from './course-operations-integration.service';
+import { UpdateCourseOperationsConfigDto } from './dto/update-course-operations-config.dto';
+
+@Role()
+@Controller('lms/courses/:id/operations')
+export class CourseOperationsController {
+  constructor(
+    private readonly operationsIntegration: CourseOperationsIntegrationService,
+  ) {}
+
+  @Get()
+  getConfig(@Param('id', ParseIntPipe) courseId: number) {
+    return this.operationsIntegration.getOperationsConfig(courseId);
+  }
+
+  @Patch()
+  updateConfig(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Body() dto: UpdateCourseOperationsConfigDto,
+  ) {
+    return this.operationsIntegration.updateOperationsConfig(courseId, {
+      projectId: dto.projectId,
+      taskMode: dto.taskMode,
+      completionStatus: dto.completionStatus,
+    });
+  }
+
+  @Post('recreate-tasks')
+  @HttpCode(HttpStatus.OK)
+  recreateTasks(@Param('id', ParseIntPipe) courseId: number) {
+    return this.operationsIntegration.createMissingTasksForCourseLessons(courseId);
+  }
+}

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

@@ -76,6 +76,7 @@ export class CourseStructureService {
                       person: {
                         select: {
                           name: true,
+                          avatar_id: true,
                         },
                       },
                     },
@@ -171,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,
@@ -187,6 +189,7 @@ export class CourseStructureService {
       instructors: instructors.map((instructor) => ({
         id: instructor.id,
         name: instructor.name,
+        avatarId: instructor.avatarId ?? null,
       })),
       curso: courseRecord
         ? {
@@ -513,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 };

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/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)}`,
+            );
+          }
+        },
+      },
+    ]);
+  }
+}