@hed-hog/lms 0.0.361 → 0.0.365

package/src/course/course.service.ts

@@ -1,10 +1,36 @@
 import { PrismaService } from '@hed-hog/api-prisma';
-import { FileService, IntegrationDeveloperApiService } from '@hed-hog/core';
-import { BadRequestException, Inject, Injectable, forwardRef } from '@nestjs/common';
+import {
+    FileService,
+    IntegrationDeveloperApiService,
+    NotificationService,
+} from '@hed-hog/core';
+import { IJobHandler, QueueHandlerRegistry, QueueJobService } from '@hed-hog/queue';
+import {
+    BadRequestException,
+    Inject,
+    Injectable,
+    Logger,
+    NotFoundException,
+    OnModuleInit,
+    forwardRef,
+} from '@nestjs/common';
 import { CourseOperationsIntegrationService } from './course-operations-integration.service';
+import {
+    COURSE_STORAGE_CLEANUP_CATEGORIES,
+    type CourseStorageCleanupCategory,
+} from './dto/cleanup-course-storage.dto';
 import { CreateCourseDto } from './dto/create-course.dto';
 import { UpdateCourseDto } from './dto/update-course.dto';
 
+export const LMS_COURSE_DELETE_JOB = 'lms.course.delete';
+export const LMS_COURSE_STORAGE_CLEANUP_JOB = 'lms.course.storage.cleanup';
+
+type CourseStorageRow = {
+  file_id: number | null;
+  file_size: number | null;
+  storage_category: string;
+};
+
 type CourseImageTypeSlug = 'course-logo' | 'course-banner';
 
 type CourseExtraFields = {
@@ -30,15 +56,249 @@ type PersistCourseExtrasInput = {
 };
 
 @Injectable()
-export class CourseService {
+export class CourseService implements OnModuleInit, IJobHandler {
+  private readonly logger = new Logger(CourseService.name);
+
   constructor(
     private readonly prisma: PrismaService,
     private readonly fileService: FileService,
     @Inject(forwardRef(() => IntegrationDeveloperApiService))
     private readonly integrationApi: IntegrationDeveloperApiService,
+    @Inject(forwardRef(() => QueueJobService))
+    private readonly queueJobService: QueueJobService,
+    @Inject(forwardRef(() => QueueHandlerRegistry))
+    private readonly queueRegistry: QueueHandlerRegistry,
+    @Inject(forwardRef(() => NotificationService))
+    private readonly notificationService: NotificationService,
     private readonly operationsIntegration: CourseOperationsIntegrationService,
   ) {}
 
+  onModuleInit() {
+    this.queueRegistry.register(LMS_COURSE_DELETE_JOB, this);
+    this.queueRegistry.register(LMS_COURSE_STORAGE_CLEANUP_JOB, this);
+    this.logger.log(`Registered handler for "${LMS_COURSE_DELETE_JOB}"`);
+    this.logger.log(`Registered handler for "${LMS_COURSE_STORAGE_CLEANUP_JOB}"`);
+  }
+
+  async handle(job: {
+    id: number;
+    type: string;
+    queue_name: string;
+    payload: Record<string, any>;
+    attempts: number;
+    max_attempts: number;
+    source_module?: string | null;
+    source_entity?: string | null;
+    source_entity_id?: string | null;
+  }) {
+    if (job.type === LMS_COURSE_STORAGE_CLEANUP_JOB) {
+      return this.handleStorageCleanupJob(job);
+    }
+
+    if (job.type === LMS_COURSE_DELETE_JOB) {
+      return this.handleCourseDeleteJob(job);
+    }
+
+    throw new BadRequestException(`Unsupported job type: ${job.type}`);
+  }
+
+  private async handleCourseDeleteJob(job: {
+    id: number;
+    type: string;
+    queue_name: string;
+    payload: Record<string, any>;
+    attempts: number;
+    max_attempts: number;
+    source_module?: string | null;
+    source_entity?: string | null;
+    source_entity_id?: string | null;
+  }) {
+    const { courseId, notificationId, notificationUserId } = job.payload as {
+      courseId?: number;
+      notificationId?: number;
+      notificationUserId?: number;
+    };
+
+    if (!courseId) {
+      throw new BadRequestException('Missing courseId in job payload');
+    }
+
+    const notify = async (
+      progress: number,
+      body: string,
+      success?: boolean,
+    ) => {
+      if (!notificationId || !notificationUserId) return;
+
+      await this.notificationService
+        .updateProgress(notificationUserId, notificationId, {
+          progress,
+          body,
+          ...(success !== undefined ? { success } : {}),
+        })
+        .catch(() => undefined);
+    };
+
+    try {
+      await notify(5, 'Preparando exclusão completa do curso...');
+
+      const course = await this.prisma.course.findUnique({
+        where: { id: courseId },
+        select: { id: true, status: true, title: true, slug: true },
+      });
+
+      if (!course) {
+        throw new NotFoundException('Course not found');
+      }
+
+      if (course.status !== 'archived') {
+        throw new BadRequestException('ONLY_ARCHIVED_COURSE_CAN_BE_DELETED');
+      }
+
+      const impact = await this.getCourseDeletionImpact(courseId);
+      await notify(
+        20,
+        `Removendo ${impact.deletionImpact.fileCount} arquivo(s) relacionados ao curso...`,
+      );
+
+      if (impact.deletionImpact.fileIds.length > 0) {
+        await this.fileService
+          .delete('pt', { ids: impact.deletionImpact.fileIds })
+          .catch(() => undefined);
+      }
+
+      await notify(75, 'Removendo registros do curso e dependências...');
+
+      await this.prisma.course.delete({ where: { id: courseId } });
+
+      await notify(90, 'Finalizando exclusão e publicando evento...');
+
+      await this.integrationApi
+        .publishEvent({
+          eventName: 'lms.course.deleted',
+          sourceModule: 'lms',
+          aggregateType: 'course',
+          aggregateId: String(courseId),
+          payload: { id: courseId },
+        })
+        .catch(() => null);
+
+      await notify(100, 'Curso e todos os arquivos relacionados foram excluídos.', true);
+
+      return { success: true, courseId };
+    } catch (error) {
+      const message =
+        error instanceof Error && error.message
+          ? error.message
+          : 'Falha ao excluir o curso.';
+      await notify(100, message, false);
+      throw error;
+    }
+  }
+
+  private async handleStorageCleanupJob(job: {
+    id: number;
+    type: string;
+    queue_name: string;
+    payload: Record<string, any>;
+    attempts: number;
+    max_attempts: number;
+    source_module?: string | null;
+    source_entity?: string | null;
+    source_entity_id?: string | null;
+  }) {
+    const { courseId, category, notificationId, notificationUserId } =
+      job.payload as {
+        courseId?: number;
+        category?: string;
+        notificationId?: number;
+        notificationUserId?: number;
+      };
+
+    if (!courseId) {
+      throw new BadRequestException('Missing courseId in job payload');
+    }
+
+    if (!this.isSupportedStorageCleanupCategory(category)) {
+      throw new BadRequestException('Invalid storage category');
+    }
+
+    const notify = async (
+      progress: number,
+      body: string,
+      success?: boolean,
+    ) => {
+      if (!notificationId || !notificationUserId) return;
+
+      await this.notificationService
+        .updateProgress(notificationUserId, notificationId, {
+          progress,
+          body,
+          ...(success !== undefined ? { success } : {}),
+        })
+        .catch(() => undefined);
+    };
+
+    try {
+      const categoryLabel = this.getStorageCategoryLabel(category);
+      await notify(5, `Preparando limpeza da categoria ${categoryLabel}...`);
+
+      const impact = await this.getCourseStorageCategoryImpact(courseId, category);
+
+      if (impact.fileCount === 0) {
+        await notify(100, `Nenhum arquivo encontrado em ${categoryLabel}.`, true);
+        return {
+          success: true,
+          status: 'empty',
+          courseId,
+          category,
+          cleanupImpact: impact,
+        };
+      }
+
+      await notify(
+        25,
+        `Removendo vínculos da categoria ${categoryLabel} (${impact.fileCount} arquivo(s))...`,
+      );
+
+      await this.deleteCourseStorageCategoryLinks(courseId, category);
+
+      await notify(
+        65,
+        `Excluindo ${impact.fileCount} arquivo(s) da categoria ${categoryLabel}...`,
+      );
+
+      if (impact.fileIds.length > 0) {
+        await this.fileService.delete('pt', { ids: impact.fileIds }).catch(() => undefined);
+      }
+
+      await notify(
+        100,
+        `Categoria ${categoryLabel} limpa com sucesso (${this.formatBytes(impact.totalBytes)} liberados).`,
+        true,
+      );
+
+      return {
+        success: true,
+        status: 'processed',
+        courseId,
+        category,
+        cleanupImpact: {
+          fileCount: impact.fileCount,
+          totalBytes: impact.totalBytes,
+          formattedSize: this.formatBytes(impact.totalBytes),
+        },
+      };
+    } catch (error) {
+      const message =
+        error instanceof Error && error.message
+          ? error.message
+          : 'Falha ao limpar a categoria de armazenamento.';
+      await notify(100, message, false);
+      throw error;
+    }
+  }
+
   private normalizeLevel(value?: string | null) {
     if (!value) return undefined;
     const normalized = String(value).trim().toLowerCase();
@@ -220,10 +480,12 @@ export class CourseService {
     ]);
 
     const courseIds = courses.map((course) => course.id);
-    const [extrasById, projectLinksById] = await Promise.all([
-      this.getCourseExtras(courseIds),
-      this.operationsIntegration.getCourseProjectLinks(courseIds),
-    ]);
+    const [extrasById, projectLinksById, coursesWithRunningJobs] =
+      await Promise.all([
+        this.getCourseExtras(courseIds),
+        this.operationsIntegration.getCourseProjectLinks(courseIds),
+        this.getCoursesWithRunningJobs(courseIds),
+      ]);
 
     return {
       total,
@@ -236,6 +498,8 @@ export class CourseService {
           undefined,
           extrasById.get(c.id),
           projectLinksById.get(c.id),
+          undefined,
+          coursesWithRunningJobs.has(c.id),
         ),
       ),
     };
@@ -285,7 +549,16 @@ export class CourseService {
                 },
               },
               file: {
-                select: { id: true, filename: true },
+                select: {
+                  id: true,
+                  filename: true,
+                  size: true,
+                  file_mimetype: {
+                    select: {
+                      name: true,
+                    },
+                  },
+                },
               },
             },
             orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
@@ -386,7 +659,7 @@ export class CourseService {
       };
     });
 
-    return this.mapCourse(
+    const mapped = this.mapCourse(
       c,
       {
         lessonCount,
@@ -399,6 +672,19 @@ export class CourseService {
       projectLinksById.get(id),
       lessonInstructors,
     );
+
+    const deletionImpact = await this.getCourseDeletionImpact(id);
+
+    return {
+      ...mapped,
+      deletionImpact: {
+        fileCount: deletionImpact.deletionImpact.fileCount,
+        totalBytes: deletionImpact.deletionImpact.totalBytes,
+        formattedSize: this.formatBytes(deletionImpact.deletionImpact.totalBytes),
+        countsBySource: deletionImpact.deletionImpact.countsBySource,
+        enrollmentCount: mapped.enrollmentCount ?? 0,
+      },
+    };
   }
 
   async create(dto: CreateCourseDto) {
@@ -713,10 +999,10 @@ export class CourseService {
     return updateResult;
   }
 
-  async remove(id: number) {
+  async remove(id: number, userId?: number | null) {
     const course = await this.prisma.course.findUnique({
       where: { id },
-      select: { id: true, status: true },
+      select: { id: true, status: true, title: true, slug: true },
     });
 
     if (!course) {
@@ -727,69 +1013,465 @@ export class CourseService {
       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);
+    if (!userId) {
+      throw new BadRequestException('Authenticated user is required');
     }
 
-    await this.prisma.course.delete({ where: { id } });
+    const impact = await this.getCourseDeletionImpact(id);
+
+    const notification = await this.notificationService.create({
+      user_id: userId,
+      title: `Excluindo curso "${course.title ?? course.slug}"`,
+      body: `Preparando remoção de ${impact.deletionImpact.fileCount} arquivo(s) (${this.formatBytes(impact.deletionImpact.totalBytes)}).`,
+      type: 'progress' as any,
+      progress: 1,
+      started_at: new Date().toISOString(),
+      auto_remove: false,
+      action_type: 'url' as any,
+      action_url: '/lms/courses',
+      action_data: {
+        source: 'lms-course-delete',
+        courseId: id,
+      },
+    });
 
-    await this.integrationApi.publishEvent({
-      eventName: 'lms.course.deleted',
-      sourceModule: 'lms',
-      aggregateType: 'course',
-      aggregateId: String(id),
-      payload: { id },
-    }).catch(() => null);
+    const job = await this.queueJobService.enqueue(
+      {
+        type: LMS_COURSE_DELETE_JOB,
+        queueName: LMS_COURSE_DELETE_JOB,
+        payload: {
+          courseId: id,
+          notificationId: notification.id,
+          notificationUserId: userId,
+        },
+        sourceModule: 'lms',
+        sourceEntity: 'course',
+        sourceEntityId: String(id),
+        maxAttempts: 3,
+      },
+      userId,
+    );
 
-    return { success: true };
+    return {
+      success: true,
+      status: 'queued',
+      queueJobId: job.id,
+      notificationId: notification.id,
+      deletionImpact: {
+        fileCount: impact.deletionImpact.fileCount,
+        totalBytes: impact.deletionImpact.totalBytes,
+        formattedSize: this.formatBytes(impact.deletionImpact.totalBytes),
+      },
+    };
   }
 
-  private async getCourseRelatedFileIds(courseId: number) {
+  async enqueueStorageCategoryCleanup(
+    courseId: number,
+    category: CourseStorageCleanupCategory,
+    userId?: number | null,
+  ) {
+    if (!userId) {
+      throw new BadRequestException('Authenticated user is required');
+    }
+
+    if (!this.isSupportedStorageCleanupCategory(category)) {
+      throw new BadRequestException('Invalid storage category');
+    }
+
+    const course = await this.prisma.course.findUnique({
+      where: { id: courseId },
+      select: { id: true, title: true, slug: true },
+    });
+
+    if (!course) {
+      throw new NotFoundException('Course not found');
+    }
+
+    const categoryLabel = this.getStorageCategoryLabel(category);
+    const impact = await this.getCourseStorageCategoryImpact(courseId, category);
+
+    if (impact.fileCount === 0) {
+      return {
+        success: true,
+        status: 'empty',
+        cleanupImpact: {
+          fileCount: 0,
+          totalBytes: 0,
+          formattedSize: this.formatBytes(0),
+        },
+      };
+    }
+
+    const notification = await this.notificationService.create({
+      user_id: userId,
+      title: `Limpando armazenamento (${categoryLabel})`,
+      body: `Preparando remoção de ${impact.fileCount} arquivo(s) (${this.formatBytes(impact.totalBytes)}).`,
+      type: 'progress' as any,
+      progress: 1,
+      started_at: new Date().toISOString(),
+      auto_remove: false,
+      action_type: 'url' as any,
+      action_url: `/lms/courses/${courseId}`,
+      action_data: {
+        source: 'lms-course-storage-cleanup',
+        courseId,
+        category,
+      },
+    });
+
+    const job = await this.queueJobService.enqueue(
+      {
+        type: LMS_COURSE_STORAGE_CLEANUP_JOB,
+        queueName: LMS_COURSE_STORAGE_CLEANUP_JOB,
+        payload: {
+          courseId,
+          category,
+          notificationId: notification.id,
+          notificationUserId: userId,
+        },
+        sourceModule: 'lms',
+        sourceEntity: 'course',
+        sourceEntityId: String(courseId),
+        maxAttempts: 3,
+      },
+      userId,
+    );
+
+    return {
+      success: true,
+      status: 'queued',
+      queueJobId: job.id,
+      notificationId: notification.id,
+      category,
+      cleanupImpact: {
+        fileCount: impact.fileCount,
+        totalBytes: impact.totalBytes,
+        formattedSize: this.formatBytes(impact.totalBytes),
+      },
+    };
+  }
+
+  private isSupportedStorageCleanupCategory(
+    value: unknown,
+  ): value is CourseStorageCleanupCategory {
+    return (
+      typeof value === 'string' &&
+      COURSE_STORAGE_CLEANUP_CATEGORIES.includes(
+        value as CourseStorageCleanupCategory,
+      )
+    );
+  }
+
+  private getStorageCategoryLabel(category: CourseStorageCleanupCategory) {
+    const labels: Record<CourseStorageCleanupCategory, string> = {
+      video_original: 'Vídeos originais',
+      video_profile: 'Vídeos convertidos',
+      lesson_audio: 'Áudios',
+      extracted_image: 'Imagens extraídas',
+      student_download: 'Downloads do aluno',
+      supplementary_material: 'Materiais de apoio',
+      course_image: 'Imagens do curso',
+      course_file: 'Arquivos do curso',
+      other_lesson_file: 'Outros arquivos',
+      course_export: 'Arquivos de exportação',
+    };
+
+    return labels[category];
+  }
+
+  private async getCourseStorageCategoryImpact(
+    courseId: number,
+    category: CourseStorageCleanupCategory,
+  ) {
+    const rows = await this.getCourseStorageRows(courseId);
+
+    const uniqueFiles = new Map<number, number>();
+    for (const row of rows) {
+      const rowCategory = String(row.storage_category || 'other_lesson_file');
+      if (rowCategory !== category) continue;
+
+      const fileId = Number(row.file_id ?? 0);
+      if (fileId <= 0) continue;
+
+      if (!uniqueFiles.has(fileId)) {
+        uniqueFiles.set(fileId, Number(row.file_size ?? 0) || 0);
+      }
+    }
+
+    const fileIds = Array.from(uniqueFiles.keys());
+    const totalBytes = Array.from(uniqueFiles.values()).reduce(
+      (sum, size) => sum + size,
+      0,
+    );
+
+    return {
+      category,
+      fileIds,
+      fileCount: fileIds.length,
+      totalBytes,
+    };
+  }
+
+  private async deleteCourseStorageCategoryLinks(
+    courseId: number,
+    category: CourseStorageCleanupCategory,
+  ) {
+    if (category === 'course_image') {
+      await this.prisma.course_image.deleteMany({ where: { course_id: courseId } });
+      return;
+    }
+
+    if (category === 'course_file') {
+      await this.prisma.course_file.deleteMany({ where: { course_id: courseId } });
+      return;
+    }
+
+    if (category === 'extracted_image') {
+      await this.prisma.$executeRaw`
+        DELETE FROM course_lesson_video_frame clvf
+        USING course_lesson cl, course_module cm
+        WHERE clvf.course_lesson_id = cl.id
+          AND cl.course_module_id = cm.id
+          AND cm.course_id = ${courseId}
+      `;
+      return;
+    }
+
+    if (category === 'video_profile') {
+      await this.prisma.$executeRaw`
+        DELETE FROM course_lesson_file clf
+        USING course_lesson cl, course_module cm
+        WHERE clf.course_lesson_id = cl.id
+          AND cl.course_module_id = cm.id
+          AND cm.course_id = ${courseId}
+          AND clf.type LIKE 'video_profile:%'
+      `;
+      return;
+    }
+
+    if (category === 'other_lesson_file') {
+      await this.prisma.$executeRaw`
+        DELETE FROM course_lesson_file clf
+        USING course_lesson cl, course_module cm
+        WHERE clf.course_lesson_id = cl.id
+          AND cl.course_module_id = cm.id
+          AND cm.course_id = ${courseId}
+          AND (
+            clf.type IS NULL
+            OR (
+              clf.type <> 'video_original'
+              AND clf.type <> 'lesson_audio'
+              AND clf.type <> 'student_download'
+              AND clf.type <> 'supplementary_material'
+              AND clf.type NOT LIKE 'video_profile:%'
+            )
+          )
+      `;
+      return;
+    }
+
+    if (category === 'course_export') {
+      const exports = await this.prisma.course_export.findMany({
+        where: {
+          course_id: courseId,
+          file_id: { not: null },
+          status: { in: ['completed', 'failed'] },
+        },
+        select: { id: true, file_id: true },
+      });
+
+      const fileIds = exports
+        .map((e) => e.file_id)
+        .filter((id): id is number => id != null);
+
+      await this.prisma.course_export.deleteMany({
+        where: { id: { in: exports.map((e) => e.id) } },
+      });
+
+      if (fileIds.length > 0) {
+        await this.fileService.delete('pt', { ids: fileIds }).catch(() => undefined);
+      }
+      return;
+    }
+
+    await this.prisma.course_lesson_file.deleteMany({
+      where: {
+        course_lesson: { course_module: { course_id: courseId } },
+        type: category,
+      },
+    });
+  }
+
+  private async getCourseStorageRows(courseId: number) {
+    return this.prisma.$queryRaw<CourseStorageRow[]>`
+      SELECT files.file_id, files.file_size, files.storage_category
+      FROM (
+        SELECT ci.file_id, f.size AS file_size, 'course_image' AS storage_category
+        FROM course_image ci
+        INNER JOIN file f ON f.id = ci.file_id
+        WHERE ci.course_id = ${courseId}
+
+        UNION ALL
+
+        SELECT cf.file_id, f.size AS file_size, 'course_file' AS storage_category
+        FROM course_file cf
+        INNER JOIN file f ON f.id = cf.file_id
+        WHERE cf.course_id = ${courseId}
+
+        UNION ALL
+
+        SELECT clf.file_id,
+                f.size AS file_size,
+                CASE
+                  WHEN clf.type = 'video_original' THEN 'video_original'
+                  WHEN clf.type LIKE 'video_profile:%' THEN 'video_profile'
+                  WHEN clf.type = 'lesson_audio' THEN 'lesson_audio'
+                  WHEN clf.type = 'student_download' THEN 'student_download'
+                  WHEN clf.type = 'supplementary_material' THEN 'supplementary_material'
+                  ELSE 'other_lesson_file'
+                END AS storage_category
+        FROM course_lesson_file clf
+        INNER JOIN file f ON f.id = clf.file_id
+        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, f.size AS file_size, 'extracted_image' AS storage_category
+        FROM course_lesson_video_frame clvf
+        INNER JOIN file f ON f.id = clvf.file_id
+        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 ce.file_id, f.size AS file_size, 'course_export' AS storage_category
+        FROM course_export ce
+        INNER JOIN file f ON f.id = ce.file_id
+        WHERE ce.course_id = ${courseId}
+          AND ce.status = 'completed'
+          AND ce.file_id IS NOT NULL
+      ) AS files
+      WHERE files.file_id IS NOT NULL
+    `;
+  }
+
+  private async getCourseDeletionImpact(courseId: number) {
     const rows = await this.prisma.$queryRaw<
-      Array<{ file_id: number | null }>
+      Array<{
+        file_id: number | null;
+        file_size: number | null;
+        source_type: string;
+      }>
     >`
-      SELECT DISTINCT files.file_id
+      SELECT DISTINCT files.file_id, files.file_size, files.source_type
       FROM (
-        SELECT ci.file_id
+        SELECT ci.file_id, f.size AS file_size, 'course_image' AS source_type
         FROM course_image ci
+        INNER JOIN file f ON f.id = ci.file_id
         WHERE ci.course_id = ${courseId}
 
         UNION ALL
 
-        SELECT cf.file_id
+        SELECT cf.file_id, f.size AS file_size, 'course_file' AS source_type
         FROM course_file cf
+        INNER JOIN file f ON f.id = cf.file_id
         WHERE cf.course_id = ${courseId}
 
         UNION ALL
 
-        SELECT clf.file_id
+        SELECT clf.file_id, f.size AS file_size, 'course_lesson_file' AS source_type
         FROM course_lesson_file clf
+        INNER JOIN file f ON f.id = clf.file_id
         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
+        SELECT clvf.file_id, f.size AS file_size, 'course_lesson_video_frame' AS source_type
         FROM course_lesson_video_frame clvf
+        INNER JOIN file f ON f.id = clvf.file_id
         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
+        SELECT cgm.file_id, f.size AS file_size, 'course_class_group_material' AS source_type
         FROM course_class_group_material cgm
+        INNER JOIN file f ON f.id = cgm.file_id
         INNER JOIN course_class_group ccg ON ccg.id = cgm.course_class_group_id
         WHERE ccg.course_id = ${courseId}
+
+        UNION ALL
+
+        SELECT cln.frame_file_id AS file_id, f.size AS file_size, 'course_lesson_note_frame' AS source_type
+        FROM course_lesson_note cln
+        INNER JOIN file f ON f.id = cln.frame_file_id
+        INNER JOIN course_lesson cl ON cl.id = cln.course_lesson_id
+        INNER JOIN course_module cm ON cm.id = cl.course_module_id
+        WHERE cm.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);
+    const uniqueRows = Array.from(
+      rows.reduce((map, row) => {
+        const fileId = Number(row.file_id ?? 0);
+        if (fileId > 0 && !map.has(fileId)) {
+          map.set(fileId, {
+            fileId,
+            size: Number(row.file_size ?? 0) || 0,
+            sourceType: row.source_type,
+          });
+        }
+        return map;
+      }, new Map<number, { fileId: number; size: number; sourceType: string }>()).values(),
+    );
+
+    const countsBySource = rows.reduce<Record<string, number>>((acc, row) => {
+      const key = String(row.source_type || 'unknown');
+      acc[key] = (acc[key] ?? 0) + 1;
+      return acc;
+    }, {});
+
+    return {
+      deletionImpact: {
+        fileIds: uniqueRows.map((row) => row.fileId),
+        fileCount: uniqueRows.length,
+        totalBytes: uniqueRows.reduce((sum, row) => sum + row.size, 0),
+        countsBySource,
+      },
+    };
+  }
+
+  private formatBytes(bytes: number) {
+    if (!Number.isFinite(bytes) || bytes <= 0) {
+      return '0 B';
+    }
+
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let value = bytes;
+    let unitIndex = 0;
+
+    while (value >= 1024 && unitIndex < units.length - 1) {
+      value /= 1024;
+      unitIndex += 1;
+    }
+
+    const digits = unitIndex === 0 ? 0 : value >= 10 ? 1 : 2;
+    return `${value.toFixed(digits)} ${units[unitIndex]}`;
+  }
+
+  private async getCourseRelatedFileIds(courseId: number) {
+    const impact = await this.getCourseDeletionImpact(courseId);
+
+    return impact.deletionImpact.fileIds.filter(
+      (id) => Number.isInteger(id) && id > 0,
+    );
   }
 
   private mapCourse(
@@ -819,6 +1501,7 @@ export class CourseService {
         } | null;
       } | null;
     }>,
+    hasRunningJobs = false,
   ) {
     const resolvedName = extras?.name ?? c.name ?? null;
     const resolvedTitle = this.normalizeOptionalText(c.title) ?? c.slug;
@@ -905,6 +1588,7 @@ export class CourseService {
         (c.certificate_template_id
           ? String(c.certificate_template_id)
           : null),
+      hasRunningJobs,
       progressByModule: metrics?.progressByModule ?? [],
       instructors: Array.from(
         new Map(
@@ -980,6 +1664,25 @@ export class CourseService {
     return extrasById;
   }
 
+  private async getCoursesWithRunningJobs(
+    courseIds: number[],
+  ): Promise<Set<number>> {
+    if (courseIds.length === 0) return new Set();
+
+    const rows = (await this.prisma.$queryRawUnsafe(`
+      SELECT DISTINCT cm.course_id
+      FROM queue_job qj
+      INNER JOIN course_lesson cl ON cl.id = CAST(qj.source_entity_id AS INTEGER)
+      INNER JOIN course_module cm ON cm.id = cl.course_module_id
+      WHERE qj.source_entity = 'course_lesson'
+        AND qj.source_module = 'lms'
+        AND qj.status IN ('pending', 'scheduled', 'processing', 'retrying')
+        AND cm.course_id IN (${courseIds.join(',')})
+    `)) as Array<{ course_id: number }>;
+
+    return new Set(rows.map((r) => Number(r.course_id)));
+  }
+
   private async persistCourseExtras(
     id: number,
     data: PersistCourseExtrasInput,
@@ -1009,7 +1712,8 @@ export class CourseService {
     }
 
     if (data.offeringType !== undefined) {
-      pushSetClause('offering_type', data.offeringType);
+      values.push(data.offeringType);
+      setClauses.push(`offering_type = $${values.length}::course_offering_type_8af4d2739d_enum`);
     }
 
     if (setClauses.length === 0) {
@@ -1026,8 +1730,8 @@ export class CourseService {
         `,
         ...values,
       );
-    } catch {
-      // Some environments may still be behind the current course schema.
+    } catch (err) {
+      console.error('[persistCourseExtras] failed:', err);
     }
   }
 
@@ -1192,50 +1896,176 @@ export class CourseService {
     });
   }
 
-  async getCourseVideoProfiles(courseId: number) {
-    const rows = await (this.prisma as any).course_video_resolution_profile.findMany({
-      where: { course_id: courseId },
-      include: { video_resolution_profile: true },
-      orderBy: { video_resolution_profile: { name: 'asc' } },
-    });
+  async getCourseContentOverview(courseId: number) {
+    const [
+      moduleCount,
+      lessons,
+      transcriptionRows,
+      xpMapRows,
+      extractedImageCount,
+      resourceFileCount,
+      storageRows,
+    ] = await Promise.all([
+      this.prisma.course_module.count({ where: { course_id: courseId } }),
+      this.prisma.course_lesson.findMany({
+        where: { course_module: { course_id: courseId } },
+        select: { id: true, type: true, content: true, published: true },
+      }),
+      this.prisma.course_lesson_transcription_segment.findMany({
+        where: { course_lesson: { course_module: { course_id: courseId } } },
+        select: { course_lesson_id: true },
+        distinct: ['course_lesson_id'],
+      }),
+      this.prisma.lesson_xp_map.findMany({
+        where: { course_lesson: { course_module: { course_id: courseId } } },
+        select: { course_lesson_id: true },
+      }),
+      this.prisma.course_lesson_video_frame.count({
+        where: { course_lesson: { course_module: { course_id: courseId } } },
+      }),
+      this.prisma.course_lesson_file.count({
+        where: {
+          course_lesson: { course_module: { course_id: courseId } },
+          type: { in: ['student_download', 'supplementary_material'] },
+        },
+      }),
+      this.getCourseStorageRows(courseId),
+    ]);
 
-    return (rows as any[]).map((row) => ({
-      id: row.video_resolution_profile.id,
-      name: row.video_resolution_profile.name,
-      ffmpeg_params: row.video_resolution_profile.ffmpeg_params,
-      status: row.video_resolution_profile.status,
-    }));
-  }
+    const transcriptionLessonIds = new Set(
+      transcriptionRows.map((r) => r.course_lesson_id),
+    );
+    const xpLessonIds = new Set(xpMapRows.map((r) => r.course_lesson_id));
+
+    const lessonsByType = { video: 0, questao: 0, post: 0 };
+    let publishedLessonCount = 0;
+    let videoWithTranscription = 0;
+    let videoWithXp = 0;
+
+    const categoryOrder = [
+      'video_original',
+      'video_profile',
+      'lesson_audio',
+      'extracted_image',
+      'student_download',
+      'supplementary_material',
+      'course_image',
+      'course_file',
+      'other_lesson_file',
+      'course_export',
+    ];
+
+    const uniqueStorageFiles = new Map<number, number>();
+    const uniqueStorageCategoryEntries = new Set<string>();
+    const storageCategoryMap = new Map<
+      string,
+      { key: string; fileCount: number; totalBytes: number }
+    >();
+
+    for (const row of storageRows) {
+      const fileId = Number(row.file_id ?? 0);
+      if (fileId <= 0) continue;
+
+      const size = Number(row.file_size ?? 0) || 0;
+      const category = String(row.storage_category || 'other_lesson_file');
+
+      if (!uniqueStorageFiles.has(fileId)) {
+        uniqueStorageFiles.set(fileId, size);
+      }
 
-  async syncCourseVideoProfiles(courseId: number, profileIds: number[]) {
-    const linkClient = (this.prisma as any).course_video_resolution_profile;
+      const categoryEntryKey = `${category}:${fileId}`;
+      if (uniqueStorageCategoryEntries.has(categoryEntryKey)) {
+        continue;
+      }
 
-    await this.prisma.$transaction(async (tx: any) => {
-      await tx.course_video_resolution_profile.deleteMany({
-        where: { course_id: courseId },
-      });
+      uniqueStorageCategoryEntries.add(categoryEntryKey);
 
-      if (profileIds.length > 0) {
-        await tx.course_video_resolution_profile.createMany({
-          data: profileIds.map((id) => ({
-            course_id: courseId,
-            video_resolution_profile_id: id,
-          })),
-        });
-      }
-    });
+      const current = storageCategoryMap.get(category) ?? {
+        key: category,
+        fileCount: 0,
+        totalBytes: 0,
+      };
 
-    return linkClient.findMany({
-      where: { course_id: courseId },
-      include: { video_resolution_profile: true },
-      orderBy: { video_resolution_profile: { name: 'asc' } },
-    }).then((rows: any[]) =>
-      rows.map((row: any) => ({
-        id: row.video_resolution_profile.id,
-        name: row.video_resolution_profile.name,
-        ffmpeg_params: row.video_resolution_profile.ffmpeg_params,
-        status: row.video_resolution_profile.status,
-      })),
+      current.fileCount += 1;
+      current.totalBytes += size;
+      storageCategoryMap.set(category, current);
+    }
+
+    const storageCategories = Array.from(storageCategoryMap.values()).sort(
+      (a, b) => {
+        const orderA = categoryOrder.indexOf(a.key);
+        const orderB = categoryOrder.indexOf(b.key);
+
+        if (orderA !== -1 || orderB !== -1) {
+          return (orderA === -1 ? Number.MAX_SAFE_INTEGER : orderA) -
+            (orderB === -1 ? Number.MAX_SAFE_INTEGER : orderB);
+        }
+
+        return b.totalBytes - a.totalBytes;
+      },
     );
+
+    for (const lesson of lessons) {
+      if (lesson.published) publishedLessonCount++;
+
+      let sourceType: string | undefined;
+      try {
+        const parsed = lesson.content
+          ? (JSON.parse(lesson.content as string) as Record<string, unknown>)
+          : null;
+        sourceType =
+          typeof parsed?.sourceType === 'string'
+            ? parsed.sourceType
+            : undefined;
+      } catch {
+        // ignore malformed content
+      }
+
+      let uiType: 'video' | 'questao' | 'post';
+      if (
+        sourceType === 'video' ||
+        sourceType === 'questao' ||
+        sourceType === 'post'
+      ) {
+        uiType = sourceType;
+      } else if (lesson.type === 'video') {
+        uiType = 'video';
+      } else if (lesson.type === 'quiz') {
+        uiType = 'questao';
+      } else {
+        uiType = 'post';
+      }
+
+      lessonsByType[uiType]++;
+
+      if (uiType === 'video') {
+        if (transcriptionLessonIds.has(lesson.id)) videoWithTranscription++;
+        if (xpLessonIds.has(lesson.id)) videoWithXp++;
+      }
+    }
+
+    return {
+      structure: {
+        moduleCount,
+        lessonCount: lessons.length,
+        publishedLessonCount,
+        lessonsByType,
+      },
+      videos: {
+        lessonCount: lessonsByType.video,
+        withTranscription: videoWithTranscription,
+        withXp: videoWithXp,
+      },
+      media: { extractedImageCount },
+      resources: { fileCount: resourceFileCount },
+      storage: {
+        totalBytes: Array.from(uniqueStorageFiles.values()).reduce(
+          (sum, size) => sum + size,
+          0,
+        ),
+        totalFileCount: uniqueStorageFiles.size,
+        categories: storageCategories,
+      },
+    };
   }
 }