@hed-hog/lms 0.0.319 → 0.0.320

package/dist/enterprise/training/training-admin.service.js

@@ -0,0 +1,2283 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrainingAdminService = void 0;
+const api_prisma_1 = require("@hed-hog/api-prisma");
+const common_1 = require("@nestjs/common");
+let TrainingAdminService = class TrainingAdminService {
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    async getDashboard(userId, requestedEnterpriseId) {
+        if (requestedEnterpriseId !== undefined) {
+            const allowed = await this.prisma.enterprise_user.findFirst({
+                where: { user_id: userId, enterprise_id: requestedEnterpriseId, status: 'active' },
+                select: { enterprise_id: true },
+            });
+            if (!allowed) {
+                throw new common_1.ForbiddenException('Access denied to the requested enterprise');
+            }
+        }
+        const enterpriseUser = requestedEnterpriseId !== undefined
+            ? { enterprise_id: requestedEnterpriseId }
+            : await this.prisma.enterprise_user.findFirst({
+                where: { user_id: userId, status: 'active' },
+                select: { enterprise_id: true },
+            });
+        if (!enterpriseUser) {
+            throw new common_1.NotFoundException('No active enterprise found for this user');
+        }
+        const enterpriseId = enterpriseUser.enterprise_id;
+        const now = new Date();
+        const currentMonthStart = this.startOfMonth(now);
+        const previousMonthStart = this.startOfMonth(this.addMonths(now, -1));
+        const [kpis, upcomingClasses, alerts, licenseInfo] = await Promise.all([
+            this.getKpis(enterpriseId, now, currentMonthStart, previousMonthStart),
+            this.getUpcomingClasses(enterpriseId, now),
+            this.getAlerts(enterpriseId),
+            this.getLicenseInfo(enterpriseId),
+        ]);
+        return {
+            kpis,
+            upcomingClasses,
+            alerts,
+            licenseInfo,
+        };
+    }
+    // ── Private helpers ───────────────────────────────────────────────────────────
+    async getKpis(enterpriseId, now, currentMonthStart, previousMonthStart) {
+        var _a;
+        const previousMonthEnd = this.endOfMonth(this.addMonths(now, -1));
+        const [totalStudents, previousTotalStudents, activeClasses, previousActiveClasses, slotsInUse, previousSlotsInUse, avgProgress,] = await Promise.all([
+            this.prisma.enterprise_student.count({
+                where: { enterprise_id: enterpriseId },
+            }),
+            this.prisma.enterprise_student.count({
+                where: { enterprise_id: enterpriseId, created_at: { lt: currentMonthStart } },
+            }),
+            this.prisma.enterprise_class_group.count({
+                where: {
+                    enterprise_id: enterpriseId,
+                    course_class_group: { status: 'ongoing' },
+                },
+            }),
+            this.prisma.enterprise_class_group.count({
+                where: {
+                    enterprise_id: enterpriseId,
+                    course_class_group: { status: 'ongoing', created_at: { lt: currentMonthStart } },
+                },
+            }),
+            this.prisma.course_enrollment.count({
+                where: {
+                    status: { not: 'cancelled' },
+                    course_class_group: {
+                        enterprise_class_group: { some: { enterprise_id: enterpriseId } },
+                    },
+                },
+            }),
+            this.prisma.course_enrollment.count({
+                where: {
+                    status: { not: 'cancelled' },
+                    enrolled_at: { lt: currentMonthStart },
+                    course_class_group: {
+                        enterprise_class_group: { some: { enterprise_id: enterpriseId } },
+                    },
+                },
+            }),
+            this.prisma.course_enrollment.aggregate({
+                where: {
+                    status: { in: ['active', 'completed'] },
+                    course_class_group: {
+                        enterprise_class_group: { some: { enterprise_id: enterpriseId } },
+                    },
+                },
+                _avg: { progress_percent: true },
+            }),
+        ]);
+        return {
+            totalStudents: {
+                value: totalStudents,
+                change: this.percentChange(totalStudents, previousTotalStudents),
+                changeType: 'percent',
+            },
+            activeClasses: {
+                value: activeClasses,
+                change: activeClasses - previousActiveClasses,
+                changeType: 'absolute',
+            },
+            slotsInUse: {
+                value: slotsInUse,
+                change: slotsInUse - previousSlotsInUse,
+                changeType: 'absolute',
+            },
+            averageProgress: {
+                value: this.round((_a = avgProgress._avg.progress_percent) !== null && _a !== void 0 ? _a : 0, 1),
+                change: null,
+                changeType: 'percent',
+            },
+        };
+    }
+    async getUpcomingClasses(enterpriseId, now) {
+        const rows = await this.prisma.enterprise_class_group.findMany({
+            where: {
+                enterprise_id: enterpriseId,
+                course_class_group: { status: { in: ['open', 'ongoing'] } },
+            },
+            take: 10,
+            include: {
+                course_class_group: {
+                    include: {
+                        course: {
+                            select: {
+                                id: true,
+                                title: true,
+                                course_image: {
+                                    where: { image_type: { slug: 'course-logo' } },
+                                    orderBy: { is_primary: 'desc' },
+                                    take: 1,
+                                    select: { file: { select: { location: true } } },
+                                },
+                            },
+                        },
+                        _count: {
+                            select: {
+                                course_enrollment: { where: { status: { not: 'cancelled' } } },
+                            },
+                        },
+                        course_class_session: {
+                            where: { session_date: { gte: now } },
+                            orderBy: { session_date: 'asc' },
+                            take: 1,
+                            include: {
+                                course_class_session_instructor: {
+                                    where: { role: 'lead' },
+                                    take: 1,
+                                    include: {
+                                        instructor: {
+                                            include: { person: { select: { name: true } } },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        return rows.map((row) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+            const cg = row.course_class_group;
+            const nextSession = (_a = cg.course_class_session[0]) !== null && _a !== void 0 ? _a : null;
+            const leadInstructor = (_e = (_d = (_c = (_b = nextSession === null || nextSession === void 0 ? void 0 : nextSession.course_class_session_instructor[0]) === null || _b === void 0 ? void 0 : _b.instructor) === null || _c === void 0 ? void 0 : _c.person) === null || _d === void 0 ? void 0 : _d.name) !== null && _e !== void 0 ? _e : null;
+            return {
+                id: cg.id,
+                name: cg.title,
+                courseId: (_g = (_f = cg.course) === null || _f === void 0 ? void 0 : _f.id) !== null && _g !== void 0 ? _g : null,
+                courseName: (_j = (_h = cg.course) === null || _h === void 0 ? void 0 : _h.title) !== null && _j !== void 0 ? _j : null,
+                courseLogoUrl: (_p = (_o = (_m = (_l = (_k = cg.course) === null || _k === void 0 ? void 0 : _k.course_image) === null || _l === void 0 ? void 0 : _l[0]) === null || _m === void 0 ? void 0 : _m.file) === null || _o === void 0 ? void 0 : _o.location) !== null && _p !== void 0 ? _p : null,
+                instructor: leadInstructor,
+                startDate: cg.start_date,
+                nextSession: nextSession
+                    ? {
+                        date: nextSession.session_date,
+                        time: nextSession.start_time,
+                        location: (_q = nextSession.location) !== null && _q !== void 0 ? _q : null,
+                    }
+                    : null,
+                slots: cg._count.course_enrollment,
+                totalSlots: (_r = cg.capacity) !== null && _r !== void 0 ? _r : null,
+                status: cg.status,
+                deliveryMode: (_s = cg.delivery_mode) !== null && _s !== void 0 ? _s : null,
+            };
+        });
+    }
+    async getLicenseInfo(enterpriseId) {
+        var _a;
+        const [enterprise, totalStudents, activePersonRows] = await Promise.all([
+            this.prisma.enterprise.findUnique({
+                where: { id: enterpriseId },
+                select: { license_limit: true },
+            }),
+            this.prisma.enterprise_student.count({
+                where: { enterprise_id: enterpriseId },
+            }),
+            this.prisma.course_enrollment.findMany({
+                where: {
+                    status: 'active',
+                    course_class_group: {
+                        enterprise_class_group: { some: { enterprise_id: enterpriseId } },
+                    },
+                },
+                select: { person_id: true },
+                distinct: ['person_id'],
+            }),
+        ]);
+        return {
+            limit: (_a = enterprise === null || enterprise === void 0 ? void 0 : enterprise.license_limit) !== null && _a !== void 0 ? _a : null,
+            totalStudents,
+            activeStudents: activePersonRows.length,
+        };
+    }
+    async getAlerts(enterpriseId) {
+        var _a;
+        const alerts = [];
+        // Classes near capacity (>= 90%)
+        const openRows = await this.prisma.enterprise_class_group.findMany({
+            where: {
+                enterprise_id: enterpriseId,
+                course_class_group: { status: 'open' },
+            },
+            include: {
+                course_class_group: {
+                    include: {
+                        _count: {
+                            select: {
+                                course_enrollment: { where: { status: { not: 'cancelled' } } },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        for (const row of openRows) {
+            const cg = row.course_class_group;
+            const max = (_a = cg.capacity) !== null && _a !== void 0 ? _a : 0;
+            if (max > 0 && cg._count.course_enrollment / max >= 0.9) {
+                alerts.push({
+                    type: 'capacity',
+                    message: `Turma "${cg.title}" está quase lotada (${cg._count.course_enrollment}/${max} vagas)`,
+                    severity: 'warning',
+                });
+            }
+        }
+        // Open classes without any sessions scheduled
+        const withoutSessions = await this.prisma.enterprise_class_group.count({
+            where: {
+                enterprise_id: enterpriseId,
+                course_class_group: {
+                    status: 'open',
+                    course_class_session: { none: {} },
+                },
+            },
+        });
+        if (withoutSessions > 0) {
+            alerts.push({
+                type: 'no_sessions',
+                message: `${withoutSessions} turma(s) aberta(s) sem sessões agendadas`,
+                severity: 'info',
+            });
+        }
+        return alerts;
+    }
+    async getClassGroups(userId, options = {}) {
+        if (options.enterpriseId !== undefined) {
+            const allowed = await this.prisma.enterprise_user.findFirst({
+                where: { user_id: userId, enterprise_id: options.enterpriseId, status: 'active' },
+                select: { enterprise_id: true },
+            });
+            if (!allowed) {
+                throw new common_1.ForbiddenException('Access denied to the requested enterprise');
+            }
+        }
+        const enterpriseUser = options.enterpriseId !== undefined
+            ? { enterprise_id: options.enterpriseId }
+            : await this.prisma.enterprise_user.findFirst({
+                where: { user_id: userId, status: 'active' },
+                select: { enterprise_id: true },
+            });
+        if (!enterpriseUser) {
+            throw new common_1.NotFoundException('No active enterprise found for this user');
+        }
+        const enterpriseId = enterpriseUser.enterprise_id;
+        const { search, status, deliveryMode, instructorId } = options;
+        const now = new Date();
+        const classGroups = await this.prisma.course_class_group.findMany({
+            where: {
+                AND: [
+                    { enterprise_class_group: { some: { enterprise_id: enterpriseId } } },
+                    ...(status ? [{ status: status }] : []),
+                    ...(deliveryMode ? [{ delivery_mode: deliveryMode }] : []),
+                    ...(instructorId !== undefined ? [{ instructor_id: instructorId }] : []),
+                    ...(search
+                        ? [
+                            {
+                                OR: [
+                                    { title: { contains: search, mode: 'insensitive' } },
+                                    { code: { contains: search, mode: 'insensitive' } },
+                                    { course: { title: { contains: search, mode: 'insensitive' } } },
+                                ],
+                            },
+                        ]
+                        : []),
+                ],
+            },
+            orderBy: { start_date: 'desc' },
+            include: {
+                course: {
+                    select: {
+                        id: true,
+                        title: true,
+                        course_image: {
+                            where: { image_type: { slug: { in: ['course-logo', 'course-banner'] } } },
+                            orderBy: { is_primary: 'desc' },
+                            select: {
+                                file: { select: { location: true } },
+                                image_type: { select: { slug: true } },
+                            },
+                        },
+                    },
+                },
+                instructor: {
+                    include: { person: { select: { name: true } } },
+                },
+                _count: {
+                    select: {
+                        course_enrollment: { where: { status: { not: 'cancelled' } } },
+                    },
+                },
+                course_class_session: {
+                    where: { session_date: { gte: now } },
+                    orderBy: { session_date: 'asc' },
+                    take: 1,
+                    select: { session_date: true, start_time: true, location: true },
+                },
+            },
+        });
+        const cgIds = classGroups.map((cg) => cg.id);
+        const completedCounts = cgIds.length > 0
+            ? await this.prisma.course_enrollment.groupBy({
+                by: ['course_class_group_id'],
+                where: {
+                    course_class_group_id: { in: cgIds },
+                    status: { not: 'cancelled' },
+                    completed_at: { not: null },
+                },
+                _count: true,
+            })
+            : [];
+        const completedCountMap = new Map(completedCounts.map((r) => [r.course_class_group_id, r._count]));
+        const data = classGroups.map((cg) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+            const nextSession = (_a = cg.course_class_session[0]) !== null && _a !== void 0 ? _a : null;
+            const totalEnrolled = cg._count.course_enrollment;
+            const completedCount = (_b = completedCountMap.get(cg.id)) !== null && _b !== void 0 ? _b : 0;
+            const completionRate = totalEnrolled > 0 ? this.round((completedCount / totalEnrolled) * 100, 0) : 0;
+            return {
+                id: cg.id,
+                name: cg.title,
+                code: (_c = cg.code) !== null && _c !== void 0 ? _c : '',
+                courseId: (_e = (_d = cg.course) === null || _d === void 0 ? void 0 : _d.id) !== null && _e !== void 0 ? _e : null,
+                courseName: (_g = (_f = cg.course) === null || _f === void 0 ? void 0 : _f.title) !== null && _g !== void 0 ? _g : null,
+                courseLogoUrl: (_l = (_k = (_j = (_h = cg.course) === null || _h === void 0 ? void 0 : _h.course_image.find((ci) => { var _a; return ((_a = ci.image_type) === null || _a === void 0 ? void 0 : _a.slug) === 'course-logo'; })) === null || _j === void 0 ? void 0 : _j.file) === null || _k === void 0 ? void 0 : _k.location) !== null && _l !== void 0 ? _l : null,
+                courseBannerUrl: (_q = (_p = (_o = (_m = cg.course) === null || _m === void 0 ? void 0 : _m.course_image.find((ci) => { var _a; return ((_a = ci.image_type) === null || _a === void 0 ? void 0 : _a.slug) === 'course-banner'; })) === null || _o === void 0 ? void 0 : _o.file) === null || _p === void 0 ? void 0 : _p.location) !== null && _q !== void 0 ? _q : null,
+                instructorName: (_t = (_s = (_r = cg.instructor) === null || _r === void 0 ? void 0 : _r.person) === null || _s === void 0 ? void 0 : _s.name) !== null && _t !== void 0 ? _t : null,
+                instructorAvatarUrl: null,
+                startDate: cg.start_date,
+                endDate: (_u = cg.end_date) !== null && _u !== void 0 ? _u : null,
+                nextSession: nextSession
+                    ? {
+                        date: nextSession.session_date,
+                        time: nextSession.start_time,
+                        location: (_v = nextSession.location) !== null && _v !== void 0 ? _v : null,
+                    }
+                    : null,
+                slots: totalEnrolled,
+                totalSlots: (_w = cg.capacity) !== null && _w !== void 0 ? _w : null,
+                status: cg.status,
+                deliveryMode: (_x = cg.delivery_mode) !== null && _x !== void 0 ? _x : null,
+                completionRate,
+            };
+        });
+        return { data, total: data.length };
+    }
+    // ── Class-group detail endpoints ─────────────────────────────────────────────
+    async assertAdminHasAccessToClassGroup(userId, classGroupId) {
+        const enterpriseUser = await this.prisma.enterprise_user.findFirst({
+            where: { user_id: userId, status: 'active' },
+            select: { enterprise_id: true },
+        });
+        if (!enterpriseUser)
+            throw new common_1.NotFoundException('No active enterprise found for this user');
+        const cg = await this.prisma.course_class_group.findFirst({
+            where: {
+                id: classGroupId,
+                enterprise_class_group: { some: { enterprise_id: enterpriseUser.enterprise_id } },
+            },
+            select: { id: true },
+        });
+        if (!cg)
+            throw new common_1.NotFoundException('Class group not found or not accessible');
+        return enterpriseUser.enterprise_id;
+    }
+    async getClassGroupDetail(userId, classGroupId) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        await this.assertAdminHasAccessToClassGroup(userId, classGroupId);
+        const now = new Date();
+        const cg = await this.prisma.course_class_group.findUnique({
+            where: { id: classGroupId },
+            include: {
+                course: { select: { id: true, title: true } },
+                instructor: { select: { person: { select: { name: true } } } },
+                _count: {
+                    select: {
+                        course_enrollment: { where: { status: { not: 'cancelled' } } },
+                        course_class_session: true,
+                    },
+                },
+                course_class_session: {
+                    where: { session_date: { gte: now } },
+                    orderBy: { session_date: 'asc' },
+                    take: 1,
+                    select: { session_date: true, start_time: true, location: true, meeting_url: true },
+                },
+            },
+        });
+        if (!cg)
+            throw new common_1.NotFoundException(`Class group #${classGroupId} not found`);
+        const completedSessions = await this.prisma.course_class_session.count({
+            where: { course_class_group_id: classGroupId, session_date: { lt: now } },
+        });
+        const pastSessions = await this.prisma.course_class_session.findMany({
+            where: { course_class_group_id: classGroupId, session_date: { lt: now } },
+            select: {
+                id: true,
+                course_class_attendance: { where: { present: true }, select: { student_id: true } },
+            },
+        });
+        const totalEnrolled = cg._count.course_enrollment;
+        let avgAttendance = 0;
+        if (pastSessions.length > 0 && totalEnrolled > 0) {
+            const pcts = pastSessions.map((s) => (s.course_class_attendance.length / totalEnrolled) * 100);
+            avgAttendance = this.round(pcts.reduce((a, b) => a + b, 0) / pcts.length, 0);
+        }
+        const completedEnrollments = await this.prisma.course_enrollment.count({
+            where: { course_class_group_id: classGroupId, status: { not: 'cancelled' }, completed_at: { not: null } },
+        });
+        const completionRate = totalEnrolled > 0 ? this.round((completedEnrollments / totalEnrolled) * 100, 0) : 0;
+        const nextSession = (_a = cg.course_class_session[0]) !== null && _a !== void 0 ? _a : null;
+        return {
+            id: cg.id,
+            courseName: (_c = (_b = cg.course) === null || _b === void 0 ? void 0 : _b.title) !== null && _c !== void 0 ? _c : null,
+            className: cg.title,
+            code: (_d = cg.code) !== null && _d !== void 0 ? _d : null,
+            instructorName: (_g = (_f = (_e = cg.instructor) === null || _e === void 0 ? void 0 : _e.person) === null || _f === void 0 ? void 0 : _f.name) !== null && _g !== void 0 ? _g : null,
+            instructorAvatarUrl: null,
+            instructorBio: null,
+            startDate: cg.start_date,
+            endDate: (_h = cg.end_date) !== null && _h !== void 0 ? _h : null,
+            status: cg.status,
+            deliveryMode: cg.delivery_mode,
+            totalSlots: (_j = cg.capacity) !== null && _j !== void 0 ? _j : null,
+            enrolledCount: totalEnrolled,
+            totalSessions: cg._count.course_class_session,
+            completedSessions,
+            avgAttendance,
+            completionRate,
+            nextSession: nextSession
+                ? {
+                    date: nextSession.session_date,
+                    time: nextSession.start_time,
+                    location: (_k = nextSession.location) !== null && _k !== void 0 ? _k : null,
+                    meetingUrl: (_l = nextSession.meeting_url) !== null && _l !== void 0 ? _l : null,
+                }
+                : null,
+        };
+    }
+    async getClassGroupStudents(userId, classGroupId, params = {}) {
+        await this.assertAdminHasAccessToClassGroup(userId, classGroupId);
+        const page = Math.max(Number(params.page) || 1, 1);
+        const pageSize = Math.max(Number(params.pageSize) || 20, 1);
+        const skip = (page - 1) * pageSize;
+        const where = {
+            course_class_group_id: classGroupId,
+            status: { not: 'cancelled' },
+        };
+        if (params.search) {
+            where.person = { name: { contains: params.search, mode: 'insensitive' } };
+        }
+        const [enrollments, total, totalSessions] = await Promise.all([
+            this.prisma.course_enrollment.findMany({
+                where,
+                skip,
+                take: pageSize,
+                orderBy: { person: { name: 'asc' } },
+                include: { person: { select: { id: true, name: true } } },
+            }),
+            this.prisma.course_enrollment.count({ where }),
+            this.prisma.course_class_session.count({ where: { course_class_group_id: classGroupId } }),
+        ]);
+        if (enrollments.length === 0) {
+            return { total, page, pageSize, lastPage: Math.max(1, Math.ceil(total / pageSize)), data: [] };
+        }
+        const personIds = enrollments.map((e) => e.person_id).filter(Boolean);
+        const attendanceRows = await this.prisma.course_class_attendance.groupBy({
+            by: ['student_id'],
+            where: { student_id: { in: personIds }, present: true },
+            _count: { id: true },
+        });
+        const attendanceMap = new Map(attendanceRows.map((r) => [r.student_id, r._count.id]));
+        const allData = enrollments.map((e) => {
+            var _a, _b, _c, _d, _e;
+            const presentCount = (_b = attendanceMap.get((_a = e.person_id) !== null && _a !== void 0 ? _a : 0)) !== null && _b !== void 0 ? _b : 0;
+            const attendance = totalSessions > 0 ? this.round((presentCount / totalSessions) * 100, 0) : 0;
+            const progress = (_c = e.progress_percent) !== null && _c !== void 0 ? _c : 0;
+            const grade = e.final_score != null ? Number(e.final_score) : null;
+            let status;
+            if (e.status === 'paused')
+                status = 'inactive';
+            else if (attendance < 60 || progress < 50)
+                status = 'risk';
+            else
+                status = 'ok';
+            return { id: e.person_id, name: (_e = (_d = e.person) === null || _d === void 0 ? void 0 : _d.name) !== null && _e !== void 0 ? _e : null, avatarUrl: null, progress, attendance, grade, status };
+        }).filter((s) => !params.status || s.status === params.status);
+        return { total, page, pageSize, lastPage: Math.max(1, Math.ceil(total / pageSize)), data: allData };
+    }
+    async getClassGroupSessions(userId, classGroupId) {
+        await this.assertAdminHasAccessToClassGroup(userId, classGroupId);
+        const now = new Date();
+        const sessions = await this.prisma.course_class_session.findMany({
+            where: { course_class_group_id: classGroupId },
+            orderBy: { session_date: 'asc' },
+            select: {
+                id: true,
+                title: true,
+                session_date: true,
+                start_time: true,
+                end_time: true,
+                location: true,
+                meeting_url: true,
+                course_class_attendance: { where: { present: true }, select: { student_id: true } },
+            },
+        });
+        const totalStudents = await this.prisma.course_enrollment.count({
+            where: { course_class_group_id: classGroupId, status: { not: 'cancelled' } },
+        });
+        let hasFoundNext = false;
+        return sessions.map((s) => {
+            var _a, _b, _c;
+            const isPast = s.session_date < now;
+            let status;
+            if (isPast) {
+                status = 'completed';
+            }
+            else if (!hasFoundNext) {
+                status = 'next';
+                hasFoundNext = true;
+            }
+            else {
+                status = 'upcoming';
+            }
+            return {
+                id: s.id,
+                title: s.title,
+                date: s.session_date,
+                time: s.start_time,
+                endTime: (_a = s.end_time) !== null && _a !== void 0 ? _a : null,
+                location: (_b = s.location) !== null && _b !== void 0 ? _b : null,
+                meetingUrl: (_c = s.meeting_url) !== null && _c !== void 0 ? _c : null,
+                status,
+                attendanceCount: isPast ? s.course_class_attendance.length : null,
+                totalStudents,
+            };
+        });
+    }
+    async getClassGroupMaterials(userId, classGroupId) {
+        await this.assertAdminHasAccessToClassGroup(userId, classGroupId);
+        const materials = await this.prisma.course_class_group_material.findMany({
+            where: { course_class_group_id: classGroupId },
+            orderBy: [{ sort_order: 'asc' }, { created_at: 'asc' }],
+            select: {
+                id: true,
+                title: true,
+                description: true,
+                material_type: true,
+                url: true,
+                sort_order: true,
+                created_at: true,
+            },
+        });
+        return materials.map((m) => {
+            var _a, _b;
+            return ({
+                id: m.id,
+                title: m.title,
+                description: (_a = m.description) !== null && _a !== void 0 ? _a : null,
+                materialType: m.material_type,
+                url: (_b = m.url) !== null && _b !== void 0 ? _b : null,
+            });
+        });
+    }
+    // ── License management methods ────────────────────────────────────────────────
+    async listLicenses(userId, params) {
+        var _a, _b;
+        const enterpriseUser = await this.prisma.enterprise_user.findFirst({
+            where: { user_id: userId, status: 'active' },
+            select: { enterprise_id: true },
+        });
+        if (!enterpriseUser)
+            throw new common_1.NotFoundException('No active enterprise found for this user');
+        const enterpriseId = enterpriseUser.enterprise_id;
+        const page = Math.max(Number(params.page) || 1, 1);
+        const pageSize = Math.max(Number(params.pageSize) || 10, 1);
+        const skip = (page - 1) * pageSize;
+        const where = { enterprise_id: enterpriseId };
+        if ((_a = params.search) === null || _a === void 0 ? void 0 : _a.trim()) {
+            where.person = { name: { contains: params.search.trim(), mode: 'insensitive' } };
+        }
+        if (params.status && params.status !== 'all') {
+            where.status = params.status;
+        }
+        const [rows, total, enterprise] = await Promise.all([
+            this.prisma.enterprise_student.findMany({
+                where,
+                skip,
+                take: pageSize,
+                orderBy: { created_at: 'desc' },
+                include: {
+                    person: {
+                        select: {
+                            id: true,
+                            name: true,
+                            contact: {
+                                where: { is_primary: true, contact_type: { code: { in: ['email', 'EMAIL'] } } },
+                                select: { value: true },
+                                take: 1,
+                            },
+                        },
+                    },
+                },
+            }),
+            this.prisma.enterprise_student.count({ where }),
+            this.prisma.enterprise.findUnique({
+                where: { id: enterpriseId },
+                select: { license_limit: true },
+            }),
+        ]);
+        return {
+            total,
+            page,
+            pageSize,
+            lastPage: Math.max(1, Math.ceil(total / pageSize)),
+            licenseLimit: (_b = enterprise === null || enterprise === void 0 ? void 0 : enterprise.license_limit) !== null && _b !== void 0 ? _b : null,
+            data: rows.map((r) => {
+                var _a, _b, _c, _d, _e, _f;
+                return ({
+                    id: r.id,
+                    personId: r.person_id,
+                    name: (_b = (_a = r.person) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : null,
+                    email: (_f = (_e = (_d = (_c = r.person) === null || _c === void 0 ? void 0 : _c.contact) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.value) !== null && _f !== void 0 ? _f : null,
+                    status: r.status,
+                    createdAt: r.created_at,
+                });
+            }),
+        };
+    }
+    async assignLicense(userId, dto) {
+        var _a;
+        const enterpriseUser = await this.prisma.enterprise_user.findFirst({
+            where: { user_id: userId, status: 'active' },
+            select: { enterprise_id: true },
+        });
+        if (!enterpriseUser)
+            throw new common_1.NotFoundException('No active enterprise found for this user');
+        const enterpriseId = enterpriseUser.enterprise_id;
+        const licenseInfo = await this.getLicenseInfo(enterpriseId);
+        if (licenseInfo.limit !== null && licenseInfo.totalStudents >= licenseInfo.limit) {
+            throw new common_1.ConflictException('Enterprise license limit reached');
+        }
+        const name = dto.name.trim();
+        if (!name)
+            throw new common_1.BadRequestException('Name is required');
+        const email = (_a = dto.email) === null || _a === void 0 ? void 0 : _a.trim();
+        let personId;
+        if (email) {
+            const existing = await this.prisma.person.findFirst({
+                where: {
+                    contact: {
+                        some: {
+                            value: { equals: email, mode: 'insensitive' },
+                            contact_type: { code: { in: ['email', 'EMAIL'] } },
+                        },
+                    },
+                },
+                select: { id: true },
+            });
+            if (existing)
+                personId = existing.id;
+        }
+        if (!personId) {
+            const emailType = email
+                ? await this.prisma.contact_type.findFirst({
+                    where: { code: { in: ['email', 'EMAIL'] } },
+                    select: { id: true },
+                })
+                : null;
+            const created = await this.prisma.person.create({
+                data: { name, type: 'individual', status: 'active' },
+                select: { id: true },
+            });
+            personId = created.id;
+            if (email && emailType) {
+                await this.prisma.contact.create({
+                    data: {
+                        person_id: personId,
+                        contact_type_id: emailType.id,
+                        value: email,
+                        is_primary: true,
+                    },
+                });
+            }
+        }
+        const existingStudent = await this.prisma.enterprise_student.findFirst({
+            where: { enterprise_id: enterpriseId, person_id: personId },
+            select: { id: true, status: true },
+        });
+        if (existingStudent) {
+            if (existingStudent.status !== 'inactive') {
+                throw new common_1.ConflictException('This person already has an active license');
+            }
+            return this.prisma.enterprise_student.update({
+                where: { id: existingStudent.id },
+                data: { status: 'active' },
+                select: { id: true, person_id: true, status: true, created_at: true },
+            });
+        }
+        return this.prisma.enterprise_student.create({
+            data: { enterprise_id: enterpriseId, person_id: personId, status: 'pending' },
+            select: { id: true, person_id: true, status: true, created_at: true },
+        });
+    }
+    async revokeLicense(userId, personId) {
+        const enterpriseUser = await this.prisma.enterprise_user.findFirst({
+            where: { user_id: userId, status: 'active' },
+            select: { enterprise_id: true },
+        });
+        if (!enterpriseUser)
+            throw new common_1.NotFoundException('No active enterprise found for this user');
+        const existing = await this.prisma.enterprise_student.findFirst({
+            where: { enterprise_id: enterpriseUser.enterprise_id, person_id: personId },
+            select: { id: true },
+        });
+        if (!existing)
+            throw new common_1.NotFoundException('Student not found in your enterprise');
+        return this.prisma.enterprise_student.update({
+            where: { id: existing.id },
+            data: { status: 'inactive' },
+            select: { id: true },
+        });
+    }
+    // ── Enrollment methods ────────────────────────────────────────────────────────
+    async getEnrollableStudents(userId, classGroupId, search) {
+        const enterpriseId = await this.assertAdminHasAccessToClassGroup(userId, classGroupId);
+        const enrolled = await this.prisma.course_enrollment.findMany({
+            where: {
+                course_class_group_id: classGroupId,
+                status: { not: 'cancelled' },
+            },
+            select: { person_id: true },
+        });
+        const enrolledIds = enrolled.map((e) => e.person_id);
+        const where = { enterprise_id: enterpriseId };
+        if (enrolledIds.length > 0) {
+            where.person_id = { notIn: enrolledIds };
+        }
+        if (search === null || search === void 0 ? void 0 : search.trim()) {
+            where.person = { name: { contains: search.trim(), mode: 'insensitive' } };
+        }
+        const rows = await this.prisma.enterprise_student.findMany({
+            where: where,
+            take: 50,
+            orderBy: { person: { name: 'asc' } },
+            include: {
+                person: {
+                    select: {
+                        id: true,
+                        name: true,
+                        contact: {
+                            where: { is_primary: true, contact_type: { code: { in: ['email', 'EMAIL'] } } },
+                            select: { value: true },
+                            take: 1,
+                        },
+                    },
+                },
+            },
+        });
+        return {
+            data: rows.map((r) => {
+                var _a, _b, _c, _d, _e, _f;
+                return ({
+                    id: r.id,
+                    personId: r.person_id,
+                    name: (_b = (_a = r.person) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : null,
+                    email: (_f = (_e = (_d = (_c = r.person) === null || _c === void 0 ? void 0 : _c.contact) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.value) !== null && _f !== void 0 ? _f : null,
+                    status: r.status,
+                });
+            }),
+        };
+    }
+    async getLicenseAvailability(userId) {
+        const enterpriseUser = await this.prisma.enterprise_user.findFirst({
+            where: { user_id: userId, status: 'active' },
+            select: { enterprise_id: true },
+        });
+        if (!enterpriseUser)
+            throw new common_1.NotFoundException('No active enterprise found for this user');
+        const info = await this.getLicenseInfo(enterpriseUser.enterprise_id);
+        return {
+            limit: info.limit,
+            totalStudents: info.totalStudents,
+            hasAvailableSlot: info.limit === null || info.totalStudents < info.limit,
+        };
+    }
+    async enrollExistingStudent(userId, classGroupId, personId) {
+        const enterpriseId = await this.assertAdminHasAccessToClassGroup(userId, classGroupId);
+        const esRecord = await this.prisma.enterprise_student.findFirst({
+            where: { enterprise_id: enterpriseId, person_id: personId },
+            select: { id: true },
+        });
+        if (!esRecord)
+            throw new common_1.NotFoundException('Student not found in your enterprise');
+        const classGroup = await this.prisma.course_class_group.findUnique({
+            where: { id: classGroupId },
+            select: {
+                capacity: true,
+                course_id: true,
+                _count: { select: { course_enrollment: { where: { status: { not: 'cancelled' } } } } },
+            },
+        });
+        if ((classGroup === null || classGroup === void 0 ? void 0 : classGroup.capacity) &&
+            classGroup._count.course_enrollment >= classGroup.capacity) {
+            throw new common_1.ConflictException('Class group is at full capacity');
+        }
+        const licenseInfo = await this.getLicenseInfo(enterpriseId);
+        if (licenseInfo.limit !== null && licenseInfo.totalStudents >= licenseInfo.limit) {
+            throw new common_1.ConflictException('Enterprise license limit reached');
+        }
+        const existing = await this.prisma.course_enrollment.findFirst({
+            where: { course_class_group_id: classGroupId, person_id: personId },
+        });
+        if (existing) {
+            if (existing.status === 'cancelled') {
+                return this.prisma.course_enrollment.update({
+                    where: { id: existing.id },
+                    data: { status: 'active', enrolled_at: new Date() },
+                });
+            }
+            throw new common_1.ConflictException('Student already enrolled');
+        }
+        return this.prisma.course_enrollment.create({
+            data: {
+                person_id: personId,
+                course_class_group_id: classGroupId,
+                course_id: classGroup.course_id,
+                status: 'active',
+                enrolled_at: new Date(),
+            },
+        });
+    }
+    async createAndEnrollNewStudent(userId, classGroupId, dto) {
+        var _a;
+        const enterpriseId = await this.assertAdminHasAccessToClassGroup(userId, classGroupId);
+        const classGroup = await this.prisma.course_class_group.findUnique({
+            where: { id: classGroupId },
+            select: {
+                capacity: true,
+                course_id: true,
+                _count: { select: { course_enrollment: { where: { status: { not: 'cancelled' } } } } },
+            },
+        });
+        if ((classGroup === null || classGroup === void 0 ? void 0 : classGroup.capacity) &&
+            classGroup._count.course_enrollment >= classGroup.capacity) {
+            throw new common_1.ConflictException('Class group is at full capacity');
+        }
+        const licenseInfo = await this.getLicenseInfo(enterpriseId);
+        if (licenseInfo.limit !== null && licenseInfo.totalStudents >= licenseInfo.limit) {
+            throw new common_1.ConflictException('Enterprise license limit reached');
+        }
+        const name = dto.name.trim();
+        if (!name)
+            throw new common_1.BadRequestException('Name is required');
+        const email = (_a = dto.email) === null || _a === void 0 ? void 0 : _a.trim();
+        let personId;
+        if (email) {
+            const existing = await this.prisma.person.findFirst({
+                where: {
+                    contact: {
+                        some: {
+                            value: { equals: email, mode: 'insensitive' },
+                            contact_type: { code: { in: ['email', 'EMAIL'] } },
+                        },
+                    },
+                },
+                select: { id: true },
+            });
+            if (existing)
+                personId = existing.id;
+        }
+        if (!personId) {
+            const emailType = email
+                ? await this.prisma.contact_type.findFirst({
+                    where: { code: { in: ['email', 'EMAIL'] } },
+                    select: { id: true },
+                })
+                : null;
+            const created = await this.prisma.person.create({
+                data: { name, type: 'individual', status: 'active' },
+                select: { id: true },
+            });
+            personId = created.id;
+            if (email && emailType) {
+                await this.prisma.contact.create({
+                    data: {
+                        person_id: personId,
+                        contact_type_id: emailType.id,
+                        value: email,
+                        is_primary: true,
+                    },
+                });
+            }
+        }
+        let esRecord = await this.prisma.enterprise_student.findFirst({
+            where: { enterprise_id: enterpriseId, person_id: personId },
+            select: { id: true },
+        });
+        if (!esRecord) {
+            esRecord = await this.prisma.enterprise_student.create({
+                data: {
+                    enterprise_id: enterpriseId,
+                    person_id: personId,
+                    status: 'active',
+                },
+                select: { id: true },
+            });
+        }
+        const existingEnrollment = await this.prisma.course_enrollment.findFirst({
+            where: { course_class_group_id: classGroupId, person_id: personId },
+        });
+        if (existingEnrollment) {
+            if (existingEnrollment.status === 'cancelled') {
+                return this.prisma.course_enrollment.update({
+                    where: { id: existingEnrollment.id },
+                    data: { status: 'active', enrolled_at: new Date() },
+                });
+            }
+            throw new common_1.ConflictException('Student already enrolled');
+        }
+        return this.prisma.course_enrollment.create({
+            data: {
+                person_id: personId,
+                course_class_group_id: classGroupId,
+                course_id: classGroup.course_id,
+                status: 'active',
+                enrolled_at: new Date(),
+            },
+        });
+    }
+    // ── Enterprise ID resolution ─────────────────────────────────────────────────
+    async resolveEnterpriseId(userId, requestedEnterpriseId) {
+        if (requestedEnterpriseId !== undefined) {
+            const allowed = await this.prisma.enterprise_user.findFirst({
+                where: { user_id: userId, enterprise_id: requestedEnterpriseId, status: 'active' },
+                select: { enterprise_id: true },
+            });
+            if (!allowed)
+                throw new common_1.ForbiddenException('Access denied to the requested enterprise');
+            return requestedEnterpriseId;
+        }
+        const enterpriseUser = await this.prisma.enterprise_user.findFirst({
+            where: { user_id: userId, status: 'active' },
+            select: { enterprise_id: true },
+        });
+        if (!enterpriseUser)
+            throw new common_1.NotFoundException('No active enterprise found for this user');
+        return enterpriseUser.enterprise_id;
+    }
+    // ── Course listing endpoints ──────────────────────────────────────────────────
+    async getCourses(userId, options = {}) {
+        var _a, _b, _c;
+        const enterpriseId = await this.resolveEnterpriseId(userId, options.enterpriseId);
+        const page = Math.max(Number(options.page) || 1, 1);
+        const pageSize = Math.max(Number(options.pageSize) || 20, 1);
+        const skip = (page - 1) * pageSize;
+        const courseWhere = {};
+        if ((_a = options.search) === null || _a === void 0 ? void 0 : _a.trim()) {
+            courseWhere.title = { contains: options.search.trim(), mode: 'insensitive' };
+        }
+        if (options.level) {
+            courseWhere.level = options.level;
+        }
+        if ((_b = options.category) === null || _b === void 0 ? void 0 : _b.trim()) {
+            courseWhere.course_category = {
+                some: { category: { slug: { equals: options.category.trim(), mode: 'insensitive' } } },
+            };
+        }
+        const [courses, total] = await Promise.all([
+            this.prisma.course.findMany({
+                where: courseWhere,
+                skip,
+                take: pageSize,
+                orderBy: { title: 'asc' },
+                include: {
+                    course_module: {
+                        select: {
+                            id: true,
+                            _count: { select: { course_lesson: true } },
+                        },
+                    },
+                    course_instructor: {
+                        include: {
+                            instructor: {
+                                include: { person: { select: { id: true, name: true } } },
+                            },
+                        },
+                    },
+                    course_category: {
+                        include: { category: { select: { slug: true } } },
+                    },
+                },
+            }),
+            this.prisma.course.count({ where: courseWhere }),
+        ]);
+        if (courses.length === 0) {
+            return { total, page, pageSize, lastPage: Math.max(1, Math.ceil(total / pageSize)), data: [] };
+        }
+        const courseIds = courses.map((c) => c.id);
+        const enterpriseStudents = await this.prisma.enterprise_student.findMany({
+            where: { enterprise_id: enterpriseId },
+            select: { person_id: true },
+        });
+        const personIds = enterpriseStudents.map((s) => s.person_id);
+        const enrollmentRows = personIds.length > 0
+            ? await this.prisma.course_enrollment.findMany({
+                where: { course_id: { in: courseIds }, person_id: { in: personIds } },
+                select: { course_id: true, status: true, progress_percent: true },
+            })
+            : [];
+        const statsMap = new Map();
+        for (const row of enrollmentRows) {
+            if (!statsMap.has(row.course_id)) {
+                statsMap.set(row.course_id, {
+                    enrolledCount: 0,
+                    completedCount: 0,
+                    inProgressCount: 0,
+                    totalProgress: 0,
+                });
+            }
+            const s = statsMap.get(row.course_id);
+            s.enrolledCount++;
+            s.totalProgress += (_c = row.progress_percent) !== null && _c !== void 0 ? _c : 0;
+            if (row.status === 'completed')
+                s.completedCount++;
+            if (row.status === 'active')
+                s.inProgressCount++;
+        }
+        const data = courses.map((c) => {
+            var _a, _b;
+            const stats = (_a = statsMap.get(c.id)) !== null && _a !== void 0 ? _a : {
+                enrolledCount: 0,
+                completedCount: 0,
+                inProgressCount: 0,
+                totalProgress: 0,
+            };
+            const moduleCount = c.course_module.length;
+            const lessonCount = c.course_module.reduce((sum, m) => sum + m._count.course_lesson, 0);
+            return {
+                id: c.id,
+                title: c.title,
+                description: (_b = c.description) !== null && _b !== void 0 ? _b : null,
+                level: c.level,
+                categories: c.course_category.map((cc) => { var _a, _b; return (_b = (_a = cc.category) === null || _a === void 0 ? void 0 : _a.slug) !== null && _b !== void 0 ? _b : ''; }).filter(Boolean),
+                durationHours: c.duration_hours,
+                moduleCount,
+                lessonCount,
+                instructors: c.course_instructor.map((ci) => {
+                    var _a, _b, _c;
+                    return ({
+                        id: ci.instructor_id,
+                        name: (_c = (_b = (_a = ci.instructor) === null || _a === void 0 ? void 0 : _a.person) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : '',
+                        avatarId: null,
+                    });
+                }),
+                createdAt: c.created_at,
+                enrolledCount: stats.enrolledCount,
+                completedCount: stats.completedCount,
+                inProgressCount: stats.inProgressCount,
+                avgProgress: stats.enrolledCount > 0
+                    ? this.round(stats.totalProgress / stats.enrolledCount, 1)
+                    : 0,
+            };
+        });
+        return { total, page, pageSize, lastPage: Math.max(1, Math.ceil(total / pageSize)), data };
+    }
+    async getCourseStats(userId, enterpriseId) {
+        const resolvedEnterpriseId = await this.resolveEnterpriseId(userId, enterpriseId);
+        const enterpriseStudents = await this.prisma.enterprise_student.findMany({
+            where: { enterprise_id: resolvedEnterpriseId },
+            select: { person_id: true },
+        });
+        const personIds = enterpriseStudents.map((s) => s.person_id);
+        if (personIds.length === 0) {
+            return { totalCourses: 0, totalEnrolled: 0, totalCompleted: 0, avgCompletion: 0 };
+        }
+        const enrollmentRows = await this.prisma.course_enrollment.findMany({
+            where: { person_id: { in: personIds } },
+            select: { course_id: true, status: true, progress_percent: true },
+        });
+        const courseSet = new Set(enrollmentRows.map((r) => r.course_id));
+        const totalEnrolled = enrollmentRows.length;
+        const totalCompleted = enrollmentRows.filter((r) => r.status === 'completed').length;
+        const totalProgress = enrollmentRows.reduce((sum, r) => { var _a; return sum + ((_a = r.progress_percent) !== null && _a !== void 0 ? _a : 0); }, 0);
+        return {
+            totalCourses: courseSet.size,
+            totalEnrolled,
+            totalCompleted,
+            avgCompletion: totalEnrolled > 0 ? this.round(totalProgress / totalEnrolled, 1) : 0,
+        };
+    }
+    async getCourseDetail(userId, courseId, enterpriseId) {
+        var _a, _b, _c;
+        const resolvedEnterpriseId = await this.resolveEnterpriseId(userId, enterpriseId);
+        const course = await this.prisma.course.findUnique({
+            where: { id: courseId },
+            include: {
+                course_module: {
+                    orderBy: { order: 'asc' },
+                    include: {
+                        course_lesson: {
+                            orderBy: { order: 'asc' },
+                            select: {
+                                id: true,
+                                order: true,
+                                title: true,
+                                type: true,
+                                duration_seconds: true,
+                            },
+                        },
+                    },
+                },
+                course_instructor: {
+                    include: {
+                        instructor: {
+                            include: { person: { select: { id: true, name: true } } },
+                        },
+                    },
+                },
+                course_category: {
+                    include: { category: { select: { slug: true } } },
+                },
+            },
+        });
+        if (!course)
+            throw new common_1.NotFoundException(`Course #${courseId} not found`);
+        const enterpriseStudents = await this.prisma.enterprise_student.findMany({
+            where: { enterprise_id: resolvedEnterpriseId },
+            select: { person_id: true },
+        });
+        const personIds = enterpriseStudents.map((s) => s.person_id);
+        const enrollments = personIds.length > 0
+            ? await this.prisma.course_enrollment.findMany({
+                where: { course_id: courseId, person_id: { in: personIds } },
+                include: {
+                    person: {
+                        select: {
+                            id: true,
+                            name: true,
+                            contact: {
+                                where: {
+                                    is_primary: true,
+                                    contact_type: { code: { in: ['email', 'EMAIL'] } },
+                                },
+                                select: { value: true },
+                                take: 1,
+                            },
+                        },
+                    },
+                },
+            })
+            : [];
+        const enrolledCount = enrollments.length;
+        const completedCount = enrollments.filter((e) => e.status === 'completed').length;
+        const inProgressCount = enrollments.filter((e) => e.status === 'active').length;
+        const totalProgress = enrollments.reduce((sum, e) => { var _a; return sum + ((_a = e.progress_percent) !== null && _a !== void 0 ? _a : 0); }, 0);
+        const moduleCount = course.course_module.length;
+        const lessonCount = course.course_module.reduce((sum, m) => sum + m.course_lesson.length, 0);
+        return {
+            id: course.id,
+            title: course.title,
+            description: (_a = course.description) !== null && _a !== void 0 ? _a : null,
+            level: course.level,
+            categories: course.course_category.map((cc) => { var _a, _b; return (_b = (_a = cc.category) === null || _a === void 0 ? void 0 : _a.slug) !== null && _b !== void 0 ? _b : ''; }).filter(Boolean),
+            durationHours: course.duration_hours,
+            moduleCount,
+            lessonCount,
+            instructors: course.course_instructor.map((ci) => {
+                var _a, _b, _c;
+                return ({
+                    id: ci.instructor_id,
+                    name: (_c = (_b = (_a = ci.instructor) === null || _a === void 0 ? void 0 : _a.person) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : '',
+                    avatarId: null,
+                });
+            }),
+            createdAt: course.created_at,
+            objectives: (_b = course.objectives) !== null && _b !== void 0 ? _b : null,
+            requirements: (_c = course.requirements) !== null && _c !== void 0 ? _c : null,
+            enrolledCount,
+            completedCount,
+            inProgressCount,
+            avgProgress: enrolledCount > 0 ? this.round(totalProgress / enrolledCount, 1) : 0,
+            structure: course.course_module.map((m) => ({
+                id: m.id,
+                order: m.order,
+                title: m.title,
+                lessons: m.course_lesson.map((l) => {
+                    var _a;
+                    return ({
+                        id: l.id,
+                        order: l.order,
+                        title: l.title,
+                        type: l.type,
+                        durationMinutes: Math.round(((_a = l.duration_seconds) !== null && _a !== void 0 ? _a : 0) / 60),
+                    });
+                }),
+            })),
+            students: enrollments.map((e) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+                return ({
+                    id: (_b = (_a = e.person) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : e.person_id,
+                    name: (_d = (_c = e.person) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : null,
+                    email: (_h = (_g = (_f = (_e = e.person) === null || _e === void 0 ? void 0 : _e.contact) === null || _f === void 0 ? void 0 : _f[0]) === null || _g === void 0 ? void 0 : _g.value) !== null && _h !== void 0 ? _h : null,
+                    department: null,
+                    status: e.status,
+                    progress: (_j = e.progress_percent) !== null && _j !== void 0 ? _j : 0,
+                    enrolledAt: e.enrolled_at,
+                    completedAt: (_k = e.completed_at) !== null && _k !== void 0 ? _k : null,
+                    lastAccess: null,
+                });
+            }),
+        };
+    }
+    // ── Student listing endpoints ─────────────────────────────────────────────────
+    async getStudents(userId, options = {}) {
+        var _a, _b, _c;
+        const enterpriseId = await this.resolveEnterpriseId(userId, options.enterpriseId);
+        const page = Math.max(Number(options.page) || 1, 1);
+        const pageSize = Math.max(Number(options.pageSize) || 20, 1);
+        const skip = (page - 1) * pageSize;
+        const where = { enterprise_id: enterpriseId };
+        if (options.status && options.status !== 'all') {
+            where.status = options.status;
+        }
+        if ((_a = options.search) === null || _a === void 0 ? void 0 : _a.trim()) {
+            where.OR = [
+                { person: { name: { contains: options.search.trim(), mode: 'insensitive' } } },
+                {
+                    person: {
+                        contact: {
+                            some: { value: { contains: options.search.trim(), mode: 'insensitive' } },
+                        },
+                    },
+                },
+            ];
+        }
+        const [rows, total] = await Promise.all([
+            this.prisma.enterprise_student.findMany({
+                where,
+                skip,
+                take: pageSize,
+                orderBy: { person: { name: 'asc' } },
+                include: {
+                    person: {
+                        select: {
+                            id: true,
+                            name: true,
+                            contact: {
+                                where: { is_primary: true, contact_type: { code: { in: ['email', 'EMAIL'] } } },
+                                select: { value: true },
+                                take: 1,
+                            },
+                            person_metadata: {
+                                where: { key: 'department' },
+                                select: { value: true },
+                                take: 1,
+                            },
+                        },
+                    },
+                },
+            }),
+            this.prisma.enterprise_student.count({ where }),
+        ]);
+        if (rows.length === 0) {
+            return { total, page, pageSize, lastPage: Math.max(1, Math.ceil(total / pageSize)), data: [] };
+        }
+        const personIds = rows.map((r) => r.person_id);
+        const [enrollmentRows, certificateRows] = await Promise.all([
+            this.prisma.course_enrollment.findMany({
+                where: { person_id: { in: personIds } },
+                select: { person_id: true, course_class_group_id: true, status: true, progress_percent: true },
+            }),
+            this.prisma.certificate.findMany({
+                where: { student_id: { in: personIds } },
+                select: { student_id: true },
+            }),
+        ]);
+        const enrollMap = new Map();
+        for (const e of enrollmentRows) {
+            if (!enrollMap.has(e.person_id))
+                enrollMap.set(e.person_id, []);
+            enrollMap.get(e.person_id).push({
+                course_class_group_id: e.course_class_group_id,
+                status: e.status,
+                progress_percent: (_b = e.progress_percent) !== null && _b !== void 0 ? _b : 0,
+            });
+        }
+        const certMap = new Map();
+        for (const c of certificateRows) {
+            certMap.set(c.student_id, ((_c = certMap.get(c.student_id)) !== null && _c !== void 0 ? _c : 0) + 1);
+        }
+        const data = rows.map((r) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+            const enrollments = (_a = enrollMap.get(r.person_id)) !== null && _a !== void 0 ? _a : [];
+            const enrolledClasses = enrollments.filter((e) => e.course_class_group_id !== null && e.status === 'active').length;
+            const completedCourses = enrollments.filter((e) => e.status === 'completed').length;
+            const certificates = (_b = certMap.get(r.person_id)) !== null && _b !== void 0 ? _b : 0;
+            const avgProgress = enrollments.length > 0
+                ? this.round(enrollments.reduce((sum, e) => sum + e.progress_percent, 0) / enrollments.length, 1)
+                : 0;
+            const rawDept = (_e = (_d = (_c = r.person) === null || _c === void 0 ? void 0 : _c.person_metadata) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.value;
+            const department = typeof rawDept === 'string' ? rawDept : (_g = (_f = rawDept === null || rawDept === void 0 ? void 0 : rawDept.toString) === null || _f === void 0 ? void 0 : _f.call(rawDept)) !== null && _g !== void 0 ? _g : '';
+            return {
+                id: r.person_id,
+                personId: r.person_id,
+                name: (_j = (_h = r.person) === null || _h === void 0 ? void 0 : _h.name) !== null && _j !== void 0 ? _j : null,
+                email: (_o = (_m = (_l = (_k = r.person) === null || _k === void 0 ? void 0 : _k.contact) === null || _l === void 0 ? void 0 : _l[0]) === null || _m === void 0 ? void 0 : _m.value) !== null && _o !== void 0 ? _o : null,
+                department,
+                status: r.status,
+                enrolledClasses,
+                completedCourses,
+                certificates,
+                avgProgress,
+                joinedAt: r.created_at,
+            };
+        });
+        return { total, page, pageSize, lastPage: Math.max(1, Math.ceil(total / pageSize)), data };
+    }
+    async getStudentStats(userId, enterpriseId) {
+        var _a;
+        const resolvedEnterpriseId = await this.resolveEnterpriseId(userId, enterpriseId);
+        const [totalStudents, activeStudents, inactiveStudents, pendingStudents, personRows] = await Promise.all([
+            this.prisma.enterprise_student.count({ where: { enterprise_id: resolvedEnterpriseId } }),
+            this.prisma.enterprise_student.count({ where: { enterprise_id: resolvedEnterpriseId, status: 'active' } }),
+            this.prisma.enterprise_student.count({ where: { enterprise_id: resolvedEnterpriseId, status: 'inactive' } }),
+            this.prisma.enterprise_student.count({ where: { enterprise_id: resolvedEnterpriseId, status: 'pending' } }),
+            this.prisma.enterprise_student.findMany({
+                where: { enterprise_id: resolvedEnterpriseId },
+                select: { person_id: true },
+            }),
+        ]);
+        const personIds = personRows.map((r) => r.person_id);
+        let avgProgress = 0;
+        if (personIds.length > 0) {
+            const agg = await this.prisma.course_enrollment.aggregate({
+                where: { person_id: { in: personIds } },
+                _avg: { progress_percent: true },
+            });
+            avgProgress = this.round((_a = agg._avg.progress_percent) !== null && _a !== void 0 ? _a : 0, 1);
+        }
+        return { totalStudents, activeStudents, inactiveStudents, pendingStudents, avgProgress };
+    }
+    async getStudentDetail(userId, personId, enterpriseId) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const resolvedEnterpriseId = await this.resolveEnterpriseId(userId, enterpriseId);
+        const esRecord = await this.prisma.enterprise_student.findFirst({
+            where: { enterprise_id: resolvedEnterpriseId, person_id: personId },
+            select: { id: true, status: true, created_at: true },
+        });
+        if (!esRecord)
+            throw new common_1.NotFoundException('Student not found in your enterprise');
+        const [person, enrollments, certificates, examAttempts, personUsers] = await Promise.all([
+            this.prisma.person.findUnique({
+                where: { id: personId },
+                select: {
+                    id: true,
+                    name: true,
+                    contact: {
+                        where: { is_primary: true, contact_type: { code: { in: ['email', 'EMAIL'] } } },
+                        select: { value: true },
+                        take: 1,
+                    },
+                    person_metadata: {
+                        where: { key: 'department' },
+                        select: { value: true },
+                        take: 1,
+                    },
+                },
+            }),
+            this.prisma.course_enrollment.findMany({
+                where: { person_id: personId },
+                include: {
+                    course: {
+                        select: {
+                            id: true,
+                            title: true,
+                            duration_hours: true,
+                            course_category: {
+                                include: { category: { select: { slug: true } } },
+                            },
+                        },
+                    },
+                    course_class_group: {
+                        select: {
+                            id: true,
+                            title: true,
+                            code: true,
+                            status: true,
+                            start_date: true,
+                            end_date: true,
+                            instructor: {
+                                select: { person: { select: { name: true } } },
+                            },
+                        },
+                    },
+                },
+                orderBy: { enrolled_at: 'desc' },
+            }),
+            this.prisma.certificate.findMany({
+                where: { student_id: personId },
+                select: {
+                    id: true,
+                    verification_code: true,
+                    course_name: true,
+                    issued_at: true,
+                    certificate_type: true,
+                },
+                orderBy: { issued_at: 'desc' },
+            }),
+            this.prisma.exam_attempt.findMany({
+                where: { student_id: personId },
+                include: { exam: { select: { id: true, title: true } } },
+                orderBy: { started_at: 'desc' },
+            }),
+            this.prisma.person_user.findMany({
+                where: { person_id: personId },
+                select: { user_id: true },
+            }),
+        ]);
+        if (!person)
+            throw new common_1.NotFoundException(`Person #${personId} not found`);
+        const rawDept = (_b = (_a = person.person_metadata) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value;
+        const department = typeof rawDept === 'string' ? rawDept : (_d = (_c = rawDept === null || rawDept === void 0 ? void 0 : rawDept.toString) === null || _c === void 0 ? void 0 : _c.call(rawDept)) !== null && _d !== void 0 ? _d : '';
+        const userIds = personUsers.map((pu) => pu.user_id);
+        const acessos = userIds.length > 0
+            ? await this.prisma.user_session.findMany({
+                where: { user_id: { in: userIds } },
+                select: { id: true, ip_address: true, user_agent: true, created_at: true },
+                orderBy: { created_at: 'desc' },
+                take: 20,
+            })
+            : [];
+        const turmas = enrollments
+            .filter((e) => e.course_class_group_id !== null)
+            .map((e) => {
+            var _a, _b, _c, _d, _e;
+            const cg = e.course_class_group;
+            return {
+                id: cg.id,
+                code: cg.code,
+                title: cg.title,
+                status: cg.status,
+                progress: (_a = e.progress_percent) !== null && _a !== void 0 ? _a : 0,
+                instructorName: (_d = (_c = (_b = cg.instructor) === null || _b === void 0 ? void 0 : _b.person) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : null,
+                startDate: cg.start_date,
+                endDate: (_e = cg.end_date) !== null && _e !== void 0 ? _e : null,
+            };
+        });
+        const cursos = enrollments.map((e) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            return ({
+                id: (_b = (_a = e.course) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : e.course_id,
+                title: (_d = (_c = e.course) === null || _c === void 0 ? void 0 : _c.title) !== null && _d !== void 0 ? _d : null,
+                categories: (_g = (_f = (_e = e.course) === null || _e === void 0 ? void 0 : _e.course_category) === null || _f === void 0 ? void 0 : _f.map((cc) => { var _a, _b; return (_b = (_a = cc.category) === null || _a === void 0 ? void 0 : _a.slug) !== null && _b !== void 0 ? _b : ''; }).filter(Boolean)) !== null && _g !== void 0 ? _g : [],
+                durationHours: (_j = (_h = e.course) === null || _h === void 0 ? void 0 : _h.duration_hours) !== null && _j !== void 0 ? _j : null,
+                status: e.status,
+                progress: (_k = e.progress_percent) !== null && _k !== void 0 ? _k : 0,
+                enrolledAt: e.enrolled_at,
+                completedAt: (_l = e.completed_at) !== null && _l !== void 0 ? _l : null,
+            });
+        });
+        const certificadosList = certificates.map((c) => ({
+            id: c.id,
+            verificationCode: c.verification_code,
+            courseName: c.course_name,
+            issuedAt: c.issued_at,
+            type: c.certificate_type,
+        }));
+        const avaliacoes = examAttempts.map((a) => {
+            var _a, _b, _c, _d;
+            return ({
+                id: a.id,
+                title: (_b = (_a = a.exam) === null || _a === void 0 ? void 0 : _a.title) !== null && _b !== void 0 ? _b : null,
+                score: (_c = a.score) !== null && _c !== void 0 ? _c : null,
+                status: a.finished_at ? 'graded' : 'pending',
+                submittedAt: (_d = a.finished_at) !== null && _d !== void 0 ? _d : a.started_at,
+            });
+        });
+        const acessosList = acessos.map((s) => ({
+            id: s.id,
+            ipAddress: s.ip_address,
+            userAgent: s.user_agent,
+            createdAt: s.created_at,
+        }));
+        return {
+            id: person.id,
+            name: person.name,
+            email: (_g = (_f = (_e = person.contact) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.value) !== null && _g !== void 0 ? _g : null,
+            department,
+            status: esRecord.status,
+            joinedAt: esRecord.created_at,
+            enrolledClasses: turmas.length,
+            completedCourses: cursos.filter((c) => c.status === 'completed').length,
+            certificates: certificadosList.length,
+            avgProgress: cursos.length > 0
+                ? this.round(cursos.reduce((sum, c) => sum + c.progress, 0) / cursos.length, 1)
+                : 0,
+            turmas,
+            cursos,
+            certificados: certificadosList,
+            avaliacoes,
+            acessos: acessosList,
+        };
+    }
+    // ── Admin management ─────────────────────────────────────────────────────────
+    async resolveEnterpriseIdAsAdmin(userId, requestedEnterpriseId) {
+        if (requestedEnterpriseId !== undefined) {
+            const allowed = await this.prisma.enterprise_user.findFirst({
+                where: { user_id: userId, enterprise_id: requestedEnterpriseId, status: 'active', role: 'enterprise_admin' },
+                select: { enterprise_id: true },
+            });
+            if (!allowed)
+                throw new common_1.ForbiddenException('Access denied: enterprise admin role required');
+            return requestedEnterpriseId;
+        }
+        const enterpriseUser = await this.prisma.enterprise_user.findFirst({
+            where: { user_id: userId, status: 'active', role: 'enterprise_admin' },
+            select: { enterprise_id: true },
+        });
+        if (!enterpriseUser)
+            throw new common_1.ForbiddenException('Enterprise admin role required');
+        return enterpriseUser.enterprise_id;
+    }
+    mapRoleToPermission(role) {
+        if (role === 'enterprise_admin')
+            return 'admin';
+        if (role === 'hr_manager')
+            return 'hr-manager';
+        return 'viewer';
+    }
+    mapPermissionToRole(permission) {
+        if (permission === 'admin')
+            return 'enterprise_admin';
+        if (permission === 'hr-manager')
+            return 'hr_manager';
+        return 'viewer';
+    }
+    async getAdminStats(userId, enterpriseId) {
+        const resolvedId = await this.resolveEnterpriseIdAsAdmin(userId, enterpriseId);
+        const rows = await this.prisma.enterprise_user.groupBy({
+            by: ['role'],
+            where: { enterprise_id: resolvedId, role: { not: 'instructor' } },
+            _count: { id: true },
+        });
+        let adminCount = 0;
+        let hrManagerCount = 0;
+        let viewerCount = 0;
+        let total = 0;
+        for (const r of rows) {
+            const count = r._count.id;
+            total += count;
+            if (r.role === 'enterprise_admin')
+                adminCount = count;
+            else if (r.role === 'hr_manager')
+                hrManagerCount = count;
+            else if (r.role === 'viewer')
+                viewerCount = count;
+        }
+        return { total, adminCount, hrManagerCount, viewerCount };
+    }
+    async getAdmins(userId, options = {}) {
+        var _a;
+        const resolvedId = await this.resolveEnterpriseIdAsAdmin(userId, options.enterpriseId);
+        const page = Math.max(Number(options.page) || 1, 1);
+        const pageSize = Math.max(Number(options.pageSize) || 20, 1);
+        const skip = (page - 1) * pageSize;
+        const where = {
+            enterprise_id: resolvedId,
+            role: options.role ? this.mapPermissionToRole(options.role) : { not: 'instructor' },
+        };
+        if ((_a = options.search) === null || _a === void 0 ? void 0 : _a.trim()) {
+            where.OR = [
+                { user: { name: { contains: options.search.trim(), mode: 'insensitive' } } },
+                { person: { name: { contains: options.search.trim(), mode: 'insensitive' } } },
+            ];
+        }
+        const [rows, total] = await Promise.all([
+            this.prisma.enterprise_user.findMany({
+                where,
+                skip,
+                take: pageSize,
+                orderBy: { created_at: 'desc' },
+                include: {
+                    user: { select: { id: true, name: true, last_login_at: true } },
+                    person: {
+                        select: {
+                            id: true,
+                            name: true,
+                            person_metadata: { where: { key: 'department' }, select: { value: true }, take: 1 },
+                            contact: {
+                                where: { contact_type: { code: { in: ['email', 'EMAIL'] } } },
+                                select: { value: true },
+                                take: 1,
+                            },
+                        },
+                    },
+                },
+            }),
+            this.prisma.enterprise_user.count({ where }),
+        ]);
+        const data = rows.map((eu) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+            const name = (_b = (_a = eu.person) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : eu.user.name;
+            const email = (_f = (_e = (_d = (_c = eu.person) === null || _c === void 0 ? void 0 : _c.contact) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.value) !== null && _f !== void 0 ? _f : null;
+            const rawDept = (_j = (_h = (_g = eu.person) === null || _g === void 0 ? void 0 : _g.person_metadata) === null || _h === void 0 ? void 0 : _h[0]) === null || _j === void 0 ? void 0 : _j.value;
+            const department = typeof rawDept === 'string' ? rawDept : (_l = (_k = rawDept === null || rawDept === void 0 ? void 0 : rawDept.toString) === null || _k === void 0 ? void 0 : _k.call(rawDept)) !== null && _l !== void 0 ? _l : '';
+            return {
+                id: eu.id,
+                personId: eu.person_id,
+                name,
+                email,
+                department,
+                permission: this.mapRoleToPermission(eu.role),
+                status: eu.status,
+                addedAt: eu.created_at.toISOString(),
+                lastAccess: (_o = (_m = eu.user.last_login_at) === null || _m === void 0 ? void 0 : _m.toISOString()) !== null && _o !== void 0 ? _o : null,
+            };
+        });
+        return { total, page, pageSize, lastPage: Math.max(1, Math.ceil(total / pageSize)), data };
+    }
+    async addAdmin(userId, dto) {
+        var _a, _b, _c, _d, _e;
+        const enterpriseId = await this.resolveEnterpriseIdAsAdmin(userId);
+        const name = (_a = dto.name) === null || _a === void 0 ? void 0 : _a.trim();
+        if (!name)
+            throw new common_1.BadRequestException('Name is required');
+        const email = (_b = dto.email) === null || _b === void 0 ? void 0 : _b.trim();
+        const dbRole = this.mapPermissionToRole((_c = dto.role) !== null && _c !== void 0 ? _c : 'viewer');
+        let personId;
+        let linkedUserId;
+        if (email) {
+            const existingPerson = await this.prisma.person.findFirst({
+                where: {
+                    contact: {
+                        some: {
+                            value: { equals: email, mode: 'insensitive' },
+                            contact_type: { code: { in: ['email', 'EMAIL'] } },
+                        },
+                    },
+                },
+                select: { id: true, person_user: { select: { user_id: true }, take: 1 } },
+            });
+            if (existingPerson) {
+                personId = existingPerson.id;
+                linkedUserId = (_e = (_d = existingPerson.person_user) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.user_id;
+            }
+        }
+        if (!personId) {
+            const emailType = email
+                ? await this.prisma.contact_type.findFirst({
+                    where: { code: { in: ['email', 'EMAIL'] } },
+                    select: { id: true },
+                })
+                : null;
+            const created = await this.prisma.person.create({
+                data: { name, type: 'individual', status: 'active' },
+                select: { id: true },
+            });
+            personId = created.id;
+            if (email && emailType) {
+                await this.prisma.contact.create({
+                    data: { person_id: personId, contact_type_id: emailType.id, value: email, is_primary: true },
+                });
+            }
+        }
+        if (!linkedUserId) {
+            const newUser = await this.prisma.user.create({
+                data: { name },
+                select: { id: true },
+            });
+            linkedUserId = newUser.id;
+            await this.prisma.person_user.create({
+                data: { person_id: personId, user_id: linkedUserId },
+            });
+        }
+        const existing = await this.prisma.enterprise_user.findFirst({
+            where: { enterprise_id: enterpriseId, user_id: linkedUserId },
+            select: { id: true },
+        });
+        if (existing)
+            throw new common_1.ConflictException('This user already has access to this enterprise');
+        return this.prisma.enterprise_user.create({
+            data: {
+                enterprise_id: enterpriseId,
+                user_id: linkedUserId,
+                person_id: personId,
+                role: dbRole,
+                status: 'active',
+            },
+            select: { id: true, role: true, status: true, created_at: true },
+        });
+    }
+    async updateAdminRole(userId, enterpriseUserId, permission) {
+        const enterpriseId = await this.resolveEnterpriseIdAsAdmin(userId);
+        const target = await this.prisma.enterprise_user.findFirst({
+            where: { id: enterpriseUserId, enterprise_id: enterpriseId },
+            select: { id: true, user_id: true },
+        });
+        if (!target)
+            throw new common_1.NotFoundException('Admin not found in your enterprise');
+        if (target.user_id === userId)
+            throw new common_1.ForbiddenException('Cannot change your own role');
+        const dbRole = this.mapPermissionToRole(permission);
+        return this.prisma.enterprise_user.update({
+            where: { id: enterpriseUserId },
+            data: { role: dbRole },
+            select: { id: true, role: true },
+        });
+    }
+    async removeAdmin(userId, enterpriseUserId) {
+        const enterpriseId = await this.resolveEnterpriseIdAsAdmin(userId);
+        const target = await this.prisma.enterprise_user.findFirst({
+            where: { id: enterpriseUserId, enterprise_id: enterpriseId },
+            select: { id: true, user_id: true },
+        });
+        if (!target)
+            throw new common_1.NotFoundException('Admin not found in your enterprise');
+        if (target.user_id === userId)
+            throw new common_1.ForbiddenException('Cannot remove yourself');
+        await this.prisma.enterprise_user.delete({ where: { id: enterpriseUserId } });
+        return { success: true };
+    }
+    // ── Evaluation endpoints ───────────────────────────────────────────────────────
+    async getEvaluationStats(userId, enterpriseId) {
+        const entId = await this.resolveEnterpriseId(userId, enterpriseId);
+        const cgRows = await this.prisma.enterprise_class_group.findMany({
+            where: { enterprise_id: entId },
+            select: { course_class_group_id: true },
+        });
+        const cgIds = cgRows.map((r) => r.course_class_group_id);
+        if (cgIds.length === 0) {
+            return { activeClassGroups: 0, totalEvaluations: 0, avgScore: 0, evaluatedStudentCount: 0 };
+        }
+        const ratings = await this.prisma.evaluation_rating.findMany({
+            where: {
+                evaluation_topic: {
+                    target_type: 'course_class_session',
+                    course_class_session: { course_class_group_id: { in: cgIds } },
+                },
+            },
+            select: {
+                score: true,
+                evaluator_id: true,
+                evaluation_topic: {
+                    select: {
+                        course_class_session_id: true,
+                        course_class_session: { select: { course_class_group_id: true } },
+                    },
+                },
+            },
+        });
+        const evaluatorSet = new Set(ratings.map((r) => r.evaluator_id).filter(Boolean));
+        const ratedCgIds = new Set(ratings
+            .map((r) => { var _a; return (_a = r.evaluation_topic.course_class_session) === null || _a === void 0 ? void 0 : _a.course_class_group_id; })
+            .filter(Boolean));
+        const evalPairs = new Set(ratings.map((r) => `${r.evaluator_id}-${r.evaluation_topic.course_class_session_id}`));
+        const totalScore = ratings.reduce((s, r) => s + Number(r.score), 0);
+        const avgScore = ratings.length > 0 ? this.round(totalScore / ratings.length, 2) : 0;
+        return {
+            activeClassGroups: ratedCgIds.size,
+            totalEvaluations: evalPairs.size,
+            avgScore,
+            evaluatedStudentCount: evaluatorSet.size,
+        };
+    }
+    async getEvaluationClassGroups(userId, options = {}) {
+        var _a;
+        const entId = await this.resolveEnterpriseId(userId, options.enterpriseId);
+        const page = Math.max(Number(options.page) || 1, 1);
+        const pageSize = Math.max(Number(options.pageSize) || 20, 1);
+        const skip = (page - 1) * pageSize;
+        const where = { enterprise_class_group: { some: { enterprise_id: entId } } };
+        if ((_a = options.search) === null || _a === void 0 ? void 0 : _a.trim()) {
+            where.OR = [
+                { title: { contains: options.search.trim(), mode: 'insensitive' } },
+                { course: { title: { contains: options.search.trim(), mode: 'insensitive' } } },
+            ];
+        }
+        const [total, classGroups] = await Promise.all([
+            this.prisma.course_class_group.count({ where }),
+            this.prisma.course_class_group.findMany({
+                where,
+                skip,
+                take: pageSize,
+                orderBy: { start_date: 'desc' },
+                include: {
+                    course: { select: { id: true, title: true } },
+                    _count: {
+                        select: { course_enrollment: { where: { status: { not: 'cancelled' } } } },
+                    },
+                    course_class_session: {
+                        select: {
+                            id: true,
+                            evaluation_topic: {
+                                where: { target_type: 'course_class_session' },
+                                select: {
+                                    id: true,
+                                    evaluation_rating: { select: { evaluator_id: true, score: true } },
+                                },
+                            },
+                        },
+                    },
+                },
+            }),
+        ]);
+        const data = classGroups.map((cg) => {
+            var _a, _b, _c, _d, _e;
+            const allRatings = cg.course_class_session.flatMap((s) => s.evaluation_topic.flatMap((t) => t.evaluation_rating));
+            const evaluatorSet = new Set(allRatings.map((r) => r.evaluator_id).filter(Boolean));
+            const evaluatedSessionCount = cg.course_class_session.filter((s) => s.evaluation_topic.some((t) => t.evaluation_rating.length > 0)).length;
+            const totalScore = allRatings.reduce((sum, r) => sum + Number(r.score), 0);
+            const avgScore = allRatings.length > 0 ? this.round(totalScore / allRatings.length, 2) : 0;
+            return {
+                id: cg.id,
+                title: cg.title,
+                courseId: (_b = (_a = cg.course) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null,
+                courseTitle: (_d = (_c = cg.course) === null || _c === void 0 ? void 0 : _c.title) !== null && _d !== void 0 ? _d : null,
+                startDate: cg.start_date,
+                endDate: (_e = cg.end_date) !== null && _e !== void 0 ? _e : null,
+                totalStudentCount: cg._count.course_enrollment,
+                sessionCount: cg.course_class_session.length,
+                evaluatedSessionCount,
+                avgScore,
+                evaluatedStudentCount: evaluatorSet.size,
+            };
+        });
+        return { total, page, pageSize, lastPage: Math.max(Math.ceil(total / pageSize), 1), data };
+    }
+    async getEvaluationClassGroupDetail(userId, classGroupId, enterpriseId) {
+        var _a, _b, _c, _d, _e;
+        const entId = await this.resolveEnterpriseId(userId, enterpriseId);
+        const cgCheck = await this.prisma.enterprise_class_group.findFirst({
+            where: { enterprise_id: entId, course_class_group_id: classGroupId },
+        });
+        if (!cgCheck)
+            throw new common_1.NotFoundException('Class group not found in your enterprise');
+        const classGroup = await this.prisma.course_class_group.findUnique({
+            where: { id: classGroupId },
+            include: {
+                course: { select: { id: true, title: true } },
+                course_class_session: {
+                    orderBy: { session_date: 'asc' },
+                    include: {
+                        evaluation_topic: {
+                            where: { target_type: 'course_class_session' },
+                            orderBy: { order: 'asc' },
+                            include: {
+                                evaluation_rating: {
+                                    include: { person: { select: { id: true, name: true } } },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        if (!classGroup)
+            throw new common_1.NotFoundException('Class group not found');
+        // Course-level topics + rater IDs for evaluatedCourse flag
+        let courseTopics = [];
+        const courseRaterIds = new Set();
+        if (classGroup.course_id) {
+            const cTopics = await this.prisma.evaluation_topic.findMany({
+                where: { course_id: classGroup.course_id, target_type: 'course' },
+                orderBy: { order: 'asc' },
+                include: { evaluation_rating: { select: { evaluator_id: true } } },
+            });
+            courseTopics = cTopics.map((t) => ({ id: t.id, name: t.name }));
+            cTopics.forEach((t) => t.evaluation_rating.forEach((r) => {
+                if (r.evaluator_id)
+                    courseRaterIds.add(r.evaluator_id);
+            }));
+        }
+        // Deduplicate topics across all sessions
+        const topicMap = new Map();
+        classGroup.course_class_session.forEach((s) => s.evaluation_topic.forEach((t) => topicMap.set(t.id, t.name)));
+        const sessions = classGroup.course_class_session.map((session) => {
+            const raterMap = new Map();
+            session.evaluation_topic.forEach((topic) => {
+                topic.evaluation_rating.forEach((rating) => {
+                    if (!rating.evaluator_id || !rating.person)
+                        return;
+                    if (!raterMap.has(rating.evaluator_id)) {
+                        raterMap.set(rating.evaluator_id, {
+                            name: rating.person.name,
+                            topicScores: {},
+                            comment: null,
+                        });
+                    }
+                    const entry = raterMap.get(rating.evaluator_id);
+                    entry.topicScores[topic.id] = Number(rating.score);
+                    if (rating.comment && !entry.comment)
+                        entry.comment = rating.comment;
+                });
+            });
+            const allRatings = session.evaluation_topic.flatMap((t) => t.evaluation_rating);
+            const totalScore = allRatings.reduce((s, r) => s + Number(r.score), 0);
+            const avg = allRatings.length > 0 ? this.round(totalScore / allRatings.length, 2) : 0;
+            return {
+                id: session.id,
+                title: session.title,
+                date: session.session_date,
+                avg,
+                ratings: Array.from(raterMap.entries()).map(([personId, d]) => ({
+                    personId,
+                    name: d.name,
+                    topicScores: d.topicScores,
+                    comment: d.comment,
+                    evaluatedCourse: courseRaterIds.has(personId),
+                })),
+            };
+        });
+        return {
+            classGroup: {
+                id: classGroup.id,
+                title: classGroup.title,
+                courseId: (_b = (_a = classGroup.course) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null,
+                courseTitle: (_d = (_c = classGroup.course) === null || _c === void 0 ? void 0 : _c.title) !== null && _d !== void 0 ? _d : null,
+                startDate: classGroup.start_date,
+                endDate: (_e = classGroup.end_date) !== null && _e !== void 0 ? _e : null,
+            },
+            topics: Array.from(topicMap.entries()).map(([id, name]) => ({ id, name })),
+            sessions,
+            courseTopics,
+        };
+    }
+    // ── Admin reports endpoint ─────────────────────────────────────────────────────
+    async getAdminReports(userId, options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        const entId = await this.resolveEnterpriseId(userId, options.enterpriseId);
+        const now = new Date();
+        const dateFrom = options.dateFrom
+            ? new Date(`${options.dateFrom}T00:00:00.000Z`)
+            : new Date(Date.UTC(now.getFullYear(), 0, 1));
+        const dateTo = options.dateTo
+            ? new Date(`${options.dateTo}T23:59:59.999Z`)
+            : new Date(Date.UTC(now.getFullYear(), 11, 31, 23, 59, 59));
+        const [esRows, ecgRows] = await Promise.all([
+            this.prisma.enterprise_student.findMany({
+                where: { enterprise_id: entId },
+                select: { person_id: true, status: true },
+            }),
+            this.prisma.enterprise_class_group.findMany({
+                where: { enterprise_id: entId },
+                select: { course_class_group_id: true },
+            }),
+        ]);
+        const personIds = esRows.map((r) => r.person_id);
+        const cgIds = ecgRows.map((r) => r.course_class_group_id);
+        if (personIds.length === 0) {
+            return {
+                kpis: { totalStudents: 0, enrollmentsInPeriod: 0, completedInPeriod: 0, activeClassGroups: 0, avgSatisfaction: 0, certificatesIssued: 0, atRiskStudentsCount: 0, activeCoursesCount: 0 },
+                enrollmentEvents: [],
+                sessionAttendance: [],
+                courseStats: [],
+                studentStatusCounts: { active: 0, atRisk: 0, inactive: 0 },
+                evalSessions: [],
+                evalTopicAverages: [],
+                atRiskStudents: [],
+            };
+        }
+        const [enrollmentsInPeriodCount, completedInPeriodCount, activeClassGroupsCount, certificatesIssuedCount, allEnrollments, sessionAttendanceRaw, evalRatings, attendanceForRisk,] = await Promise.all([
+            this.prisma.course_enrollment.count({
+                where: { person_id: { in: personIds }, enrolled_at: { gte: dateFrom, lte: dateTo } },
+            }),
+            this.prisma.course_enrollment.count({
+                where: { person_id: { in: personIds }, completed_at: { gte: dateFrom, lte: dateTo } },
+            }),
+            this.prisma.course_class_group.count({
+                where: { enterprise_class_group: { some: { enterprise_id: entId } }, status: 'ongoing' },
+            }),
+            this.prisma.certificate.count({
+                where: { student_id: { in: personIds }, issued_at: { gte: dateFrom, lte: dateTo } },
+            }),
+            this.prisma.course_enrollment.findMany({
+                where: { person_id: { in: personIds } },
+                select: {
+                    course_id: true,
+                    status: true,
+                    enrolled_at: true,
+                    completed_at: true,
+                    course: { select: { id: true, title: true } },
+                },
+            }),
+            cgIds.length > 0
+                ? this.prisma.course_class_attendance.findMany({
+                    where: {
+                        course_class_session: {
+                            course_class_group_id: { in: cgIds },
+                            session_date: { gte: dateFrom, lte: dateTo },
+                        },
+                        student_id: { in: personIds },
+                    },
+                    select: {
+                        student_id: true,
+                        present: true,
+                        course_class_session: { select: { id: true, session_date: true, title: true } },
+                    },
+                })
+                : Promise.resolve([]),
+            cgIds.length > 0
+                ? this.prisma.evaluation_rating.findMany({
+                    where: {
+                        evaluation_topic: {
+                            course_class_session: {
+                                course_class_group_id: { in: cgIds },
+                                session_date: { gte: dateFrom, lte: dateTo },
+                            },
+                        },
+                    },
+                    select: {
+                        score: true,
+                        evaluation_topic: {
+                            select: {
+                                name: true,
+                                course_class_session: {
+                                    select: {
+                                        session_date: true,
+                                        title: true,
+                                        course_class_group: { select: { course_id: true } },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                })
+                : Promise.resolve([]),
+            cgIds.length > 0
+                ? this.prisma.course_class_attendance.findMany({
+                    where: {
+                        course_class_session: { course_class_group_id: { in: cgIds } },
+                        student_id: { in: personIds },
+                    },
+                    select: {
+                        student_id: true,
+                        present: true,
+                        course_class_session: { select: { session_date: true, course_class_group_id: true } },
+                    },
+                })
+                : Promise.resolve([]),
+        ]);
+        // ── Course stats ─────────────────────────────────────────────────────────────
+        const courseMap = new Map();
+        for (const e of allEnrollments) {
+            if (!courseMap.has(e.course_id)) {
+                courseMap.set(e.course_id, { title: (_b = (_a = e.course) === null || _a === void 0 ? void 0 : _a.title) !== null && _b !== void 0 ? _b : `Curso #${e.course_id}`, enrolledCount: 0, completedCount: 0 });
+            }
+            const cs = courseMap.get(e.course_id);
+            cs.enrolledCount++;
+            if (e.status === 'completed')
+                cs.completedCount++;
+        }
+        const courseSatisfactionMap = new Map();
+        for (const r of evalRatings) {
+            const courseId = (_e = (_d = (_c = r.evaluation_topic) === null || _c === void 0 ? void 0 : _c.course_class_session) === null || _d === void 0 ? void 0 : _d.course_class_group) === null || _e === void 0 ? void 0 : _e.course_id;
+            if (!courseId)
+                continue;
+            if (!courseSatisfactionMap.has(courseId))
+                courseSatisfactionMap.set(courseId, { total: 0, count: 0 });
+            const cs = courseSatisfactionMap.get(courseId);
+            cs.total += Number(r.score);
+            cs.count++;
+        }
+        const courseStats = Array.from(courseMap.entries())
+            .sort(([, a], [, b]) => b.enrolledCount - a.enrolledCount)
+            .slice(0, 10)
+            .map(([courseId, cs]) => {
+            const sat = courseSatisfactionMap.get(courseId);
+            return {
+                courseId,
+                title: cs.title,
+                enrolledCount: cs.enrolledCount,
+                completedCount: cs.completedCount,
+                completionPct: cs.enrolledCount > 0 ? this.round((cs.completedCount / cs.enrolledCount) * 100, 0) : 0,
+                avgSatisfaction: sat ? this.round(sat.total / sat.count, 2) : 0,
+            };
+        });
+        const totalEvalScore = evalRatings.reduce((s, r) => s + Number(r.score), 0);
+        const avgSatisfaction = evalRatings.length > 0 ? this.round(totalEvalScore / evalRatings.length, 2) : 0;
+        // ── Enrollment events for time-series chart ───────────────────────────────────
+        const enrollmentEvents = allEnrollments
+            .filter((e) => {
+            const inPeriodEnrolled = e.enrolled_at >= dateFrom && e.enrolled_at <= dateTo;
+            const inPeriodCompleted = e.completed_at != null && e.completed_at >= dateFrom && e.completed_at <= dateTo;
+            return inPeriodEnrolled || inPeriodCompleted;
+        })
+            .map((e) => ({
+            enrolledDate: e.enrolled_at >= dateFrom && e.enrolled_at <= dateTo ? e.enrolled_at.toISOString().slice(0, 10) : null,
+            completedDate: e.completed_at != null && e.completed_at >= dateFrom && e.completed_at <= dateTo ? e.completed_at.toISOString().slice(0, 10) : null,
+        }));
+        // ── Session attendance for frequency chart ────────────────────────────────────
+        const sessionAttMap = new Map();
+        for (const att of sessionAttendanceRaw) {
+            const session = att.course_class_session;
+            if (!session)
+                continue;
+            if (!sessionAttMap.has(session.id))
+                sessionAttMap.set(session.id, { title: (_f = session.title) !== null && _f !== void 0 ? _f : '', date: session.session_date, total: 0, present: 0 });
+            const sm = sessionAttMap.get(session.id);
+            sm.total++;
+            if (att.present)
+                sm.present++;
+        }
+        const sessionAttendance = Array.from(sessionAttMap.values())
+            .map((sm) => ({ date: sm.date.toISOString().slice(0, 10), title: sm.title, totalStudents: sm.total, presentCount: sm.present, pct: sm.total > 0 ? this.round((sm.present / sm.total) * 100, 0) : 0 }))
+            .sort((a, b) => a.date.localeCompare(b.date));
+        // ── Eval sessions for trend chart ─────────────────────────────────────────────
+        const evalSessionMap = new Map();
+        for (const r of evalRatings) {
+            const session = (_g = r.evaluation_topic) === null || _g === void 0 ? void 0 : _g.course_class_session;
+            if (!session)
+                continue;
+            const key = `${session.session_date.toISOString().slice(0, 10)}|${(_h = session.title) !== null && _h !== void 0 ? _h : ''}`;
+            if (!evalSessionMap.has(key))
+                evalSessionMap.set(key, { title: (_j = session.title) !== null && _j !== void 0 ? _j : '', topicScores: new Map(), allScores: [] });
+            const esm = evalSessionMap.get(key);
+            if (!esm.topicScores.has(r.evaluation_topic.name))
+                esm.topicScores.set(r.evaluation_topic.name, []);
+            esm.topicScores.get(r.evaluation_topic.name).push(Number(r.score));
+            esm.allScores.push(Number(r.score));
+        }
+        const evalSessions = Array.from(evalSessionMap.entries())
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, esm]) => ({
+            date: key.split('|')[0],
+            sessionTitle: esm.title,
+            scores: Array.from(esm.topicScores.entries()).map(([topicName, scores]) => ({ topicName, avg: this.round(scores.reduce((s, v) => s + v, 0) / scores.length, 2) })),
+            overallAvg: esm.allScores.length > 0 ? this.round(esm.allScores.reduce((s, v) => s + v, 0) / esm.allScores.length, 2) : 0,
+        }));
+        // ── Eval topic radar ──────────────────────────────────────────────────────────
+        const topicTotalMap = new Map();
+        for (const r of evalRatings) {
+            if (!topicTotalMap.has(r.evaluation_topic.name))
+                topicTotalMap.set(r.evaluation_topic.name, { total: 0, count: 0 });
+            const tt = topicTotalMap.get(r.evaluation_topic.name);
+            tt.total += Number(r.score);
+            tt.count++;
+        }
+        const evalTopicAverages = Array.from(topicTotalMap.entries()).map(([topicName, tt]) => ({ topicName, avgScore: this.round(tt.total / tt.count, 2) }));
+        // ── At-risk students ──────────────────────────────────────────────────────────
+        const studentRiskMap = new Map();
+        for (const att of attendanceForRisk) {
+            if (!studentRiskMap.has(att.student_id))
+                studentRiskMap.set(att.student_id, { total: 0, present: 0, lastPresentDate: null, cgId: null });
+            const sa = studentRiskMap.get(att.student_id);
+            sa.total++;
+            if (att.present) {
+                sa.present++;
+                const ds = (_o = (_m = (_l = (_k = att.course_class_session) === null || _k === void 0 ? void 0 : _k.session_date) === null || _l === void 0 ? void 0 : _l.toISOString()) === null || _m === void 0 ? void 0 : _m.slice(0, 10)) !== null && _o !== void 0 ? _o : null;
+                if (ds && (!sa.lastPresentDate || ds > sa.lastPresentDate))
+                    sa.lastPresentDate = ds;
+            }
+            if (!sa.cgId && ((_p = att.course_class_session) === null || _p === void 0 ? void 0 : _p.course_class_group_id))
+                sa.cgId = att.course_class_session.course_class_group_id;
+        }
+        const atRiskPersonIds = [];
+        const atRiskAttMap = new Map();
+        for (const [personId, sa] of studentRiskMap.entries()) {
+            if (sa.total === 0)
+                continue;
+            const pct = this.round((sa.present / sa.total) * 100, 0);
+            if (pct < 75) {
+                atRiskPersonIds.push(personId);
+                atRiskAttMap.set(personId, { pct, lastPresentDate: sa.lastPresentDate, cgId: sa.cgId });
+            }
+        }
+        let atRiskStudents = [];
+        if (atRiskPersonIds.length > 0) {
+            const cgIdsForRisk = [...new Set(Array.from(atRiskAttMap.values()).map((v) => v.cgId).filter((id) => id !== null))];
+            const [atRiskPersons, cgListForRisk] = await Promise.all([
+                this.prisma.person.findMany({ where: { id: { in: atRiskPersonIds } }, select: { id: true, name: true } }),
+                cgIdsForRisk.length > 0
+                    ? this.prisma.course_class_group.findMany({ where: { id: { in: cgIdsForRisk } }, select: { id: true, title: true } })
+                    : Promise.resolve([]),
+            ]);
+            const personNameMap = new Map(atRiskPersons.map((p) => [p.id, p.name]));
+            const cgTitleMap = new Map(cgListForRisk.map((c) => [c.id, c.title]));
+            atRiskStudents = atRiskPersonIds
+                .map((pid) => {
+                var _a, _b;
+                const att = atRiskAttMap.get(pid);
+                return { personId: pid, name: (_a = personNameMap.get(pid)) !== null && _a !== void 0 ? _a : `Pessoa #${pid}`, attendancePct: att.pct, lastPresentDate: att.lastPresentDate, classGroupTitle: att.cgId ? ((_b = cgTitleMap.get(att.cgId)) !== null && _b !== void 0 ? _b : null) : null };
+            })
+                .sort((a, b) => a.attendancePct - b.attendancePct)
+                .slice(0, 10);
+        }
+        const atRiskSet = new Set(atRiskPersonIds);
+        const activeStudents = esRows.filter((r) => r.status === 'active' && !atRiskSet.has(r.person_id)).length;
+        const inactiveStudents = esRows.filter((r) => r.status !== 'active').length;
+        const activeCoursesCount = new Set(allEnrollments.filter((e) => e.status !== 'cancelled').map((e) => e.course_id)).size;
+        return {
+            kpis: { totalStudents: esRows.length, enrollmentsInPeriod: enrollmentsInPeriodCount, completedInPeriod: completedInPeriodCount, activeClassGroups: activeClassGroupsCount, avgSatisfaction, certificatesIssued: certificatesIssuedCount, atRiskStudentsCount: atRiskPersonIds.length, activeCoursesCount },
+            enrollmentEvents,
+            sessionAttendance,
+            courseStats,
+            studentStatusCounts: { active: activeStudents, atRisk: atRiskPersonIds.length, inactive: inactiveStudents },
+            evalSessions,
+            evalTopicAverages,
+            atRiskStudents,
+        };
+    }
+    // ── Date helpers ──────────────────────────────────────────────────────────────
+    percentChange(current, previous) {
+        if (previous <= 0)
+            return current > 0 ? 100 : 0;
+        return this.round(((current - previous) / previous) * 100, 1);
+    }
+    round(value, digits = 0) {
+        const factor = 10 ** digits;
+        return Math.round(value * factor) / factor;
+    }
+    addMonths(date, months) {
+        const result = new Date(date);
+        result.setMonth(result.getMonth() + months);
+        return result;
+    }
+    startOfMonth(date) {
+        return new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0);
+    }
+    endOfMonth(date) {
+        return new Date(date.getFullYear(), date.getMonth() + 1, 0, 23, 59, 59, 999);
+    }
+};
+exports.TrainingAdminService = TrainingAdminService;
+exports.TrainingAdminService = TrainingAdminService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_prisma_1.PrismaService])
+], TrainingAdminService);
+//# sourceMappingURL=training-admin.service.js.map