@hed-hog/lms 0.0.358 → 0.0.364

package/dist/course/course.service.js

@@ -22,18 +22,154 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+var CourseService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CourseService = void 0;
+exports.CourseService = exports.LMS_COURSE_STORAGE_CLEANUP_JOB = exports.LMS_COURSE_DELETE_JOB = void 0;
 const api_prisma_1 = require("@hed-hog/api-prisma");
 const core_1 = require("@hed-hog/core");
+const queue_1 = require("@hed-hog/queue");
 const common_1 = require("@nestjs/common");
 const course_operations_integration_service_1 = require("./course-operations-integration.service");
-let CourseService = class CourseService {
-    constructor(prisma, fileService, integrationApi, operationsIntegration) {
+const cleanup_course_storage_dto_1 = require("./dto/cleanup-course-storage.dto");
+exports.LMS_COURSE_DELETE_JOB = 'lms.course.delete';
+exports.LMS_COURSE_STORAGE_CLEANUP_JOB = 'lms.course.storage.cleanup';
+let CourseService = CourseService_1 = class CourseService {
+    constructor(prisma, fileService, integrationApi, queueJobService, queueRegistry, notificationService, operationsIntegration) {
         this.prisma = prisma;
         this.fileService = fileService;
         this.integrationApi = integrationApi;
+        this.queueJobService = queueJobService;
+        this.queueRegistry = queueRegistry;
+        this.notificationService = notificationService;
         this.operationsIntegration = operationsIntegration;
+        this.logger = new common_1.Logger(CourseService_1.name);
+    }
+    onModuleInit() {
+        this.queueRegistry.register(exports.LMS_COURSE_DELETE_JOB, this);
+        this.queueRegistry.register(exports.LMS_COURSE_STORAGE_CLEANUP_JOB, this);
+        this.logger.log(`Registered handler for "${exports.LMS_COURSE_DELETE_JOB}"`);
+        this.logger.log(`Registered handler for "${exports.LMS_COURSE_STORAGE_CLEANUP_JOB}"`);
+    }
+    async handle(job) {
+        if (job.type === exports.LMS_COURSE_STORAGE_CLEANUP_JOB) {
+            return this.handleStorageCleanupJob(job);
+        }
+        if (job.type === exports.LMS_COURSE_DELETE_JOB) {
+            return this.handleCourseDeleteJob(job);
+        }
+        throw new common_1.BadRequestException(`Unsupported job type: ${job.type}`);
+    }
+    async handleCourseDeleteJob(job) {
+        const { courseId, notificationId, notificationUserId } = job.payload;
+        if (!courseId) {
+            throw new common_1.BadRequestException('Missing courseId in job payload');
+        }
+        const notify = async (progress, body, success) => {
+            if (!notificationId || !notificationUserId)
+                return;
+            await this.notificationService
+                .updateProgress(notificationUserId, notificationId, Object.assign({ 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 common_1.NotFoundException('Course not found');
+            }
+            if (course.status !== 'archived') {
+                throw new common_1.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;
+        }
+    }
+    async handleStorageCleanupJob(job) {
+        const { courseId, category, notificationId, notificationUserId } = job.payload;
+        if (!courseId) {
+            throw new common_1.BadRequestException('Missing courseId in job payload');
+        }
+        if (!this.isSupportedStorageCleanupCategory(category)) {
+            throw new common_1.BadRequestException('Invalid storage category');
+        }
+        const notify = async (progress, body, success) => {
+            if (!notificationId || !notificationUserId)
+                return;
+            await this.notificationService
+                .updateProgress(notificationUserId, notificationId, Object.assign({ 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;
+        }
     }
     normalizeLevel(value) {
         if (!value)
@@ -216,7 +352,7 @@ let CourseService = class CourseService {
         };
     }
     async getById(id) {
-        var _a;
+        var _a, _b;
         const [c, lessonInstructors] = await Promise.all([
             this.prisma.course.findUnique({
                 where: { id },
@@ -243,7 +379,16 @@ let CourseService = 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' }],
@@ -334,13 +479,21 @@ let CourseService = class CourseService {
                 progress: average,
             };
         });
-        return this.mapCourse(c, {
+        const mapped = this.mapCourse(c, {
             lessonCount,
             sessionCount,
             certificatesIssued,
             averageCompletion: (_a = avgProgress._avg.progress_percent) !== null && _a !== void 0 ? _a : 0,
             progressByModule,
         }, extrasById.get(id), projectLinksById.get(id), lessonInstructors);
+        const deletionImpact = await this.getCourseDeletionImpact(id);
+        return Object.assign(Object.assign({}, mapped), { deletionImpact: {
+                fileCount: deletionImpact.deletionImpact.fileCount,
+                totalBytes: deletionImpact.deletionImpact.totalBytes,
+                formattedSize: this.formatBytes(deletionImpact.deletionImpact.totalBytes),
+                countsBySource: deletionImpact.deletionImpact.countsBySource,
+                enrollmentCount: (_b = mapped.enrollmentCount) !== null && _b !== void 0 ? _b : 0,
+            } });
     }
     async create(dto) {
         var _a, _b, _c, _d, _e;
@@ -548,10 +701,11 @@ let CourseService = class CourseService {
         }).catch(() => null);
         return updateResult;
     }
-    async remove(id) {
+    async remove(id, userId) {
+        var _a;
         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) {
             throw new common_1.BadRequestException('Course not found');
@@ -559,62 +713,362 @@ let CourseService = class CourseService {
         if (course.status !== 'archived') {
             throw new common_1.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 common_1.BadRequestException('Authenticated user is required');
         }
-        await this.prisma.course.delete({ where: { id } });
-        await this.integrationApi.publishEvent({
-            eventName: 'lms.course.deleted',
+        const impact = await this.getCourseDeletionImpact(id);
+        const notification = await this.notificationService.create({
+            user_id: userId,
+            title: `Excluindo curso "${(_a = course.title) !== null && _a !== void 0 ? _a : course.slug}"`,
+            body: `Preparando remoção de ${impact.deletionImpact.fileCount} arquivo(s) (${this.formatBytes(impact.deletionImpact.totalBytes)}).`,
+            type: 'progress',
+            progress: 1,
+            started_at: new Date().toISOString(),
+            auto_remove: false,
+            action_type: 'url',
+            action_url: '/lms/courses',
+            action_data: {
+                source: 'lms-course-delete',
+                courseId: id,
+            },
+        });
+        const job = await this.queueJobService.enqueue({
+            type: exports.LMS_COURSE_DELETE_JOB,
+            queueName: exports.LMS_COURSE_DELETE_JOB,
+            payload: {
+                courseId: id,
+                notificationId: notification.id,
+                notificationUserId: userId,
+            },
             sourceModule: 'lms',
-            aggregateType: 'course',
-            aggregateId: String(id),
-            payload: { id },
-        }).catch(() => null);
-        return { success: true };
+            sourceEntity: 'course',
+            sourceEntityId: String(id),
+            maxAttempts: 3,
+        }, userId);
+        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),
+            },
+        };
     }
-    async getCourseRelatedFileIds(courseId) {
+    async enqueueStorageCategoryCleanup(courseId, category, userId) {
+        if (!userId) {
+            throw new common_1.BadRequestException('Authenticated user is required');
+        }
+        if (!this.isSupportedStorageCleanupCategory(category)) {
+            throw new common_1.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 common_1.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',
+            progress: 1,
+            started_at: new Date().toISOString(),
+            auto_remove: false,
+            action_type: 'url',
+            action_url: `/lms/courses/${courseId}`,
+            action_data: {
+                source: 'lms-course-storage-cleanup',
+                courseId,
+                category,
+            },
+        });
+        const job = await this.queueJobService.enqueue({
+            type: exports.LMS_COURSE_STORAGE_CLEANUP_JOB,
+            queueName: exports.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),
+            },
+        };
+    }
+    isSupportedStorageCleanupCategory(value) {
+        return (typeof value === 'string' &&
+            cleanup_course_storage_dto_1.COURSE_STORAGE_CLEANUP_CATEGORIES.includes(value));
+    }
+    getStorageCategoryLabel(category) {
+        const labels = {
+            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',
+        };
+        return labels[category];
+    }
+    async getCourseStorageCategoryImpact(courseId, category) {
+        var _a, _b;
+        const rows = await this.getCourseStorageRows(courseId);
+        const uniqueFiles = new Map();
+        for (const row of rows) {
+            const rowCategory = String(row.storage_category || 'other_lesson_file');
+            if (rowCategory !== category)
+                continue;
+            const fileId = Number((_a = row.file_id) !== null && _a !== void 0 ? _a : 0);
+            if (fileId <= 0)
+                continue;
+            if (!uniqueFiles.has(fileId)) {
+                uniqueFiles.set(fileId, Number((_b = row.file_size) !== null && _b !== void 0 ? _b : 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,
+        };
+    }
+    async deleteCourseStorageCategoryLinks(courseId, category) {
+        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;
+        }
+        await this.prisma.course_lesson_file.deleteMany({
+            where: {
+                course_lesson: { course_module: { course_id: courseId } },
+                type: category,
+            },
+        });
+    }
+    async getCourseStorageRows(courseId) {
+        return this.prisma.$queryRaw `
+      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}
+      ) AS files
+      WHERE files.file_id IS NOT NULL
+    `;
+    }
+    async getCourseDeletionImpact(courseId) {
         const rows = await this.prisma.$queryRaw `
-      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) => {
+            var _a, _b;
+            const fileId = Number((_a = row.file_id) !== null && _a !== void 0 ? _a : 0);
+            if (fileId > 0 && !map.has(fileId)) {
+                map.set(fileId, {
+                    fileId,
+                    size: Number((_b = row.file_size) !== null && _b !== void 0 ? _b : 0) || 0,
+                    sourceType: row.source_type,
+                });
+            }
+            return map;
+        }, new Map()).values());
+        const countsBySource = rows.reduce((acc, row) => {
+            var _a;
+            const key = String(row.source_type || 'unknown');
+            acc[key] = ((_a = acc[key]) !== null && _a !== void 0 ? _a : 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,
+            },
+        };
+    }
+    formatBytes(bytes) {
+        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]}`;
+    }
+    async getCourseRelatedFileIds(courseId) {
+        const impact = await this.getCourseDeletionImpact(courseId);
+        return impact.deletionImpact.fileIds.filter((id) => Number.isInteger(id) && id > 0);
     }
     mapCourse(c, metrics, extras, project, lessonInstructors) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38;
@@ -925,14 +1379,161 @@ let CourseService = class CourseService {
             status: row.video_resolution_profile.status,
         })));
     }
+    async getCourseContentOverview(courseId) {
+        var _a, _b, _c;
+        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),
+        ]);
+        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, exercicio: 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',
+        ];
+        const uniqueStorageFiles = new Map();
+        const uniqueStorageCategoryEntries = new Set();
+        const storageCategoryMap = new Map();
+        for (const row of storageRows) {
+            const fileId = Number((_a = row.file_id) !== null && _a !== void 0 ? _a : 0);
+            if (fileId <= 0)
+                continue;
+            const size = Number((_b = row.file_size) !== null && _b !== void 0 ? _b : 0) || 0;
+            const category = String(row.storage_category || 'other_lesson_file');
+            if (!uniqueStorageFiles.has(fileId)) {
+                uniqueStorageFiles.set(fileId, size);
+            }
+            const categoryEntryKey = `${category}:${fileId}`;
+            if (uniqueStorageCategoryEntries.has(categoryEntryKey)) {
+                continue;
+            }
+            uniqueStorageCategoryEntries.add(categoryEntryKey);
+            const current = (_c = storageCategoryMap.get(category)) !== null && _c !== void 0 ? _c : {
+                key: category,
+                fileCount: 0,
+                totalBytes: 0,
+            };
+            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;
+            try {
+                const parsed = lesson.content
+                    ? JSON.parse(lesson.content)
+                    : null;
+                sourceType =
+                    typeof (parsed === null || parsed === void 0 ? void 0 : parsed.sourceType) === 'string'
+                        ? parsed.sourceType
+                        : undefined;
+            }
+            catch (_d) {
+                // ignore malformed content
+            }
+            let uiType;
+            if (sourceType === 'video' ||
+                sourceType === 'questao' ||
+                sourceType === 'post' ||
+                sourceType === 'exercicio') {
+                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,
+            },
+        };
+    }
 };
 exports.CourseService = CourseService;
-exports.CourseService = CourseService = __decorate([
+exports.CourseService = CourseService = CourseService_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(2, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.IntegrationDeveloperApiService))),
+    __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => queue_1.QueueJobService))),
+    __param(4, (0, common_1.Inject)((0, common_1.forwardRef)(() => queue_1.QueueHandlerRegistry))),
+    __param(5, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.NotificationService))),
     __metadata("design:paramtypes", [api_prisma_1.PrismaService,
         core_1.FileService,
         core_1.IntegrationDeveloperApiService,
+        queue_1.QueueJobService,
+        queue_1.QueueHandlerRegistry,
+        core_1.NotificationService,
         course_operations_integration_service_1.CourseOperationsIntegrationService])
 ], CourseService);
 //# sourceMappingURL=course.service.js.map