@hed-hog/lms 0.0.304 → 0.0.306

package/dist/class-group/class-group.service.js

@@ -0,0 +1,1356 @@
+"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);
+};
+var ClassGroupService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassGroupService = void 0;
+const api_prisma_1 = require("@hed-hog/api-prisma");
+const common_1 = require("@nestjs/common");
+const library_1 = require("@prisma/client/runtime/library");
+const node_crypto_1 = require("node:crypto");
+let ClassGroupService = ClassGroupService_1 = class ClassGroupService {
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    isEmailCode(code) {
+        return (code !== null && code !== void 0 ? code : '').toLowerCase() === 'email';
+    }
+    isPhoneCode(code) {
+        const normalized = (code !== null && code !== void 0 ? code : '').toLowerCase();
+        return normalized === 'phone' || normalized === 'mobile';
+    }
+    getClassGroupInclude() {
+        const include = {
+            course: {
+                select: {
+                    id: true,
+                    title: true,
+                    primary_color: true,
+                },
+            },
+            _count: {
+                select: {
+                    course_enrollment: {
+                        where: {
+                            status: { not: 'cancelled' },
+                        },
+                    },
+                    course_class_session: true,
+                },
+            },
+            instructor: {
+                select: {
+                    id: true,
+                    person: {
+                        select: {
+                            name: true,
+                        },
+                    },
+                },
+            },
+        };
+        return include;
+    }
+    getSessionInclude() {
+        return {
+            course_class_session_instructor: {
+                orderBy: { id: 'asc' },
+                select: {
+                    instructor_id: true,
+                    role: true,
+                    instructor: {
+                        select: {
+                            person: {
+                                select: {
+                                    name: true,
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    }
+    async list(params) {
+        var _a;
+        const page = Math.max(Number(params.page) || 1, 1);
+        const pageSize = Math.max(Number(params.pageSize) || 12, 1);
+        const skip = (page - 1) * pageSize;
+        const where = {};
+        const status = this.normalizeStatus(params.status);
+        if (status) {
+            where.status = status;
+        }
+        const deliveryMode = this.normalizeDeliveryMode(params.deliveryMode);
+        if (deliveryMode) {
+            where.delivery_mode = deliveryMode;
+        }
+        if (params.courseId) {
+            where.course_id = params.courseId;
+        }
+        if ((_a = params.search) === null || _a === void 0 ? void 0 : _a.trim()) {
+            const search = params.search.trim();
+            where.OR = [
+                { code: { contains: search, mode: 'insensitive' } },
+                { title: { contains: search, mode: 'insensitive' } },
+                { course: { title: { contains: search, mode: 'insensitive' } } },
+            ];
+        }
+        const [classes, total] = await Promise.all([
+            this.prisma.course_class_group.findMany({
+                skip,
+                take: pageSize,
+                where,
+                orderBy: { created_at: 'desc' },
+                include: this.getClassGroupInclude(),
+            }),
+            this.prisma.course_class_group.count({ where }),
+        ]);
+        return {
+            total,
+            page,
+            pageSize,
+            lastPage: Math.max(1, Math.ceil(total / pageSize)),
+            data: classes.map((item) => this.mapClassGroup(item)),
+        };
+    }
+    async stats() {
+        const [totalClasses, ongoingClasses, classes] = await Promise.all([
+            this.prisma.course_class_group.count(),
+            this.prisma.course_class_group.count({ where: { status: 'ongoing' } }),
+            this.prisma.course_class_group.findMany({
+                select: {
+                    id: true,
+                    status: true,
+                    capacity: true,
+                    _count: {
+                        select: {
+                            course_enrollment: {
+                                where: {
+                                    status: { not: 'cancelled' },
+                                },
+                            },
+                        },
+                    },
+                },
+            }),
+        ]);
+        const openVacancies = classes
+            .filter((item) => item.status === 'open')
+            .reduce((sum, item) => { var _a; return sum + Math.max(((_a = item.capacity) !== null && _a !== void 0 ? _a : 0) - item._count.course_enrollment, 0); }, 0);
+        const occupancyRate = classes.length > 0
+            ? Math.round((classes.reduce((sum, item) => {
+                var _a;
+                return sum +
+                    item._count.course_enrollment / Math.max((_a = item.capacity) !== null && _a !== void 0 ? _a : 1, 1);
+            }, 0) /
+                classes.length) *
+                100)
+            : 0;
+        return {
+            totalClasses,
+            ongoingClasses,
+            openVacancies,
+            occupancyRate,
+        };
+    }
+    async getById(id) {
+        var _a, _b;
+        const item = await this.prisma.course_class_group.findUnique({
+            where: { id },
+            include: this.getClassGroupInclude(),
+        });
+        if (!item) {
+            return null;
+        }
+        const sessionTemplateSummary = await this.getClassSessionTemplateSummary(id);
+        return Object.assign(Object.assign({}, this.mapClassGroup(item)), { sessionTitle: (_a = sessionTemplateSummary === null || sessionTemplateSummary === void 0 ? void 0 : sessionTemplateSummary.title) !== null && _a !== void 0 ? _a : null, sessionRecurrenceSummary: sessionTemplateSummary
+                ? Object.assign(Object.assign({}, ((_b = sessionTemplateSummary.recurrence) !== null && _b !== void 0 ? _b : {})), { isRecurring: sessionTemplateSummary.isRecurring }) : null });
+    }
+    async create(dto) {
+        await this.assertCourseExists(dto.courseId);
+        if (dto.instructorId) {
+            await this.assertInstructorExists(dto.instructorId);
+        }
+        this.assertDatesAndTimes({
+            startDate: dto.startDate,
+            endDate: dto.endDate,
+            startTime: dto.startTime,
+            endTime: dto.endTime,
+        });
+        try {
+            const created = await this.prisma.$transaction(async (tx) => {
+                var _a, _b;
+                const createdClass = await tx.course_class_group.create({
+                    data: {
+                        code: dto.code,
+                        course_id: dto.courseId,
+                        instructor_id: dto.instructorId,
+                        title: dto.title,
+                        description: dto.description,
+                        delivery_mode: dto.deliveryMode,
+                        status: (_a = dto.status) !== null && _a !== void 0 ? _a : 'open',
+                        start_date: new Date(dto.startDate),
+                        end_date: dto.endDate ? new Date(dto.endDate) : null,
+                        start_time: dto.startTime,
+                        end_time: dto.endTime,
+                        week_days: dto.weekDays,
+                        capacity: (_b = dto.capacity) !== null && _b !== void 0 ? _b : 30,
+                        location: dto.location,
+                        virtual_room_url: dto.virtualRoomUrl,
+                    },
+                    include: this.getClassGroupInclude(),
+                });
+                if (dto.sessionTemplate) {
+                    await this.syncClassSessionsFromTemplate(tx, createdClass.id, createdClass, dto.sessionTemplate);
+                }
+                return createdClass;
+            });
+            return this.mapClassGroup(created);
+        }
+        catch (error) {
+            this.handlePrismaError(error);
+        }
+    }
+    async update(id, dto) {
+        var _a, _b, _c, _d, _e;
+        const existing = await this.prisma.course_class_group.findUnique({
+            where: { id },
+            select: {
+                id: true,
+                course_id: true,
+                code: true,
+                title: true,
+                description: true,
+                delivery_mode: true,
+                instructor_id: true,
+                start_date: true,
+                end_date: true,
+                start_time: true,
+                end_time: true,
+                location: true,
+                virtual_room_url: true,
+            },
+        });
+        if (!existing) {
+            throw new common_1.NotFoundException('Class not found');
+        }
+        const courseId = (_a = dto.courseId) !== null && _a !== void 0 ? _a : existing.course_id;
+        await this.assertCourseExists(courseId);
+        if (dto.instructorId) {
+            await this.assertInstructorExists(dto.instructorId);
+        }
+        this.assertDatesAndTimes({
+            startDate: (_b = dto.startDate) !== null && _b !== void 0 ? _b : existing.start_date.toISOString(),
+            endDate: dto.endDate !== undefined
+                ? dto.endDate
+                : (_c = existing.end_date) === null || _c === void 0 ? void 0 : _c.toISOString(),
+            startTime: dto.startTime !== undefined ? dto.startTime : (_d = existing.start_time) !== null && _d !== void 0 ? _d : undefined,
+            endTime: dto.endTime !== undefined ? dto.endTime : (_e = existing.end_time) !== null && _e !== void 0 ? _e : undefined,
+        });
+        const status = dto.status !== undefined ? this.normalizeStatus(dto.status) : undefined;
+        const deliveryMode = dto.deliveryMode !== undefined
+            ? this.normalizeDeliveryMode(dto.deliveryMode)
+            : undefined;
+        try {
+            const updated = await this.prisma.$transaction(async (tx) => {
+                const updatedClass = await tx.course_class_group.update({
+                    where: { id },
+                    data: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (dto.code !== undefined && { code: dto.code })), (dto.courseId !== undefined && { course_id: dto.courseId })), (dto.instructorId !== undefined && {
+                        instructor_id: dto.instructorId,
+                    })), (dto.title !== undefined && { title: dto.title })), (dto.description !== undefined && { description: dto.description })), (deliveryMode !== undefined && { delivery_mode: deliveryMode })), (status !== undefined && { status })), (dto.startDate !== undefined && { start_date: new Date(dto.startDate) })), (dto.endDate !== undefined && {
+                        end_date: dto.endDate ? new Date(dto.endDate) : null,
+                    })), (dto.startTime !== undefined && { start_time: dto.startTime })), (dto.endTime !== undefined && { end_time: dto.endTime })), (dto.weekDays !== undefined && { week_days: dto.weekDays })), (dto.capacity !== undefined && { capacity: dto.capacity })), (dto.location !== undefined && { location: dto.location })), (dto.virtualRoomUrl !== undefined && {
+                        virtual_room_url: dto.virtualRoomUrl,
+                    })),
+                    include: this.getClassGroupInclude(),
+                });
+                if (dto.sessionTemplate) {
+                    await this.syncClassSessionsFromTemplate(tx, id, updatedClass, dto.sessionTemplate, { futureOnly: true });
+                }
+                return updatedClass;
+            });
+            return this.mapClassGroup(updated);
+        }
+        catch (error) {
+            this.handlePrismaError(error);
+        }
+    }
+    async remove(id) {
+        await this.prisma.course_class_group.delete({ where: { id } });
+        return { success: true };
+    }
+    async getClassSessionTemplateSummary(classGroupId) {
+        var _a;
+        const today = this.getSessionMutationFloorDate();
+        const session = (_a = (await this.prisma.course_class_session.findFirst({
+            where: {
+                course_class_group_id: classGroupId,
+                session_date: { gte: today },
+                status: { notIn: ['completed', 'cancelled'] },
+            },
+            orderBy: [{ session_date: 'asc' }, { occurrence_index: 'asc' }],
+            select: {
+                title: true,
+                recurrence_rule: true,
+                recurrence_id: true,
+            },
+        }))) !== null && _a !== void 0 ? _a : (await this.prisma.course_class_session.findFirst({
+            where: { course_class_group_id: classGroupId },
+            orderBy: [{ session_date: 'asc' }, { occurrence_index: 'asc' }],
+            select: {
+                title: true,
+                recurrence_rule: true,
+                recurrence_id: true,
+            },
+        }));
+        if (!session) {
+            return null;
+        }
+        return {
+            title: session.title,
+            recurrence: this.parseRecurrenceRule(session.recurrence_rule),
+            isRecurring: Boolean(session.recurrence_id),
+        };
+    }
+    getSessionMutationFloorDate() {
+        return this.normalizeSessionDate(new Date());
+    }
+    buildClassSessionDto(classGroup, sessionTemplate) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (!classGroup.start_date) {
+            throw new common_1.BadRequestException('Class start date is required to generate sessions');
+        }
+        if (!classGroup.start_time || !classGroup.end_time) {
+            throw new common_1.BadRequestException('Class start and end times are required to generate sessions');
+        }
+        const deliveryMode = classGroup.delivery_mode;
+        const isOnline = deliveryMode === 'online';
+        const isHybrid = deliveryMode === 'hybrid';
+        return {
+            title: sessionTemplate.title.trim(),
+            description: (_b = (_a = sessionTemplate.description) !== null && _a !== void 0 ? _a : classGroup.description) !== null && _b !== void 0 ? _b : undefined,
+            sessionDate: this.toDateKey(this.normalizeSessionDate(classGroup.start_date)),
+            startTime: classGroup.start_time,
+            endTime: classGroup.end_time,
+            location: isOnline && !isHybrid
+                ? undefined
+                : (_d = (_c = sessionTemplate.location) !== null && _c !== void 0 ? _c : classGroup.location) !== null && _d !== void 0 ? _d : undefined,
+            meetingUrl: !isOnline && !isHybrid
+                ? undefined
+                : (_f = (_e = sessionTemplate.meetingUrl) !== null && _e !== void 0 ? _e : classGroup.virtual_room_url) !== null && _f !== void 0 ? _f : undefined,
+            color: (_g = sessionTemplate.color) !== null && _g !== void 0 ? _g : undefined,
+            status: 'scheduled',
+            instructorId: (_h = classGroup.instructor_id) !== null && _h !== void 0 ? _h : undefined,
+            recurrence: sessionTemplate.recurrence
+                ? this.toSessionRecurrenceDto(sessionTemplate.recurrence)
+                : undefined,
+        };
+    }
+    toSessionRecurrenceDto(recurrence) {
+        return {
+            frequency: recurrence.frequency,
+            interval: recurrence.interval,
+            until: recurrence.until,
+            daysOfWeek: recurrence.daysOfWeek,
+        };
+    }
+    async syncClassSessionsFromTemplate(tx, classGroupId, classGroup, sessionTemplate, options) {
+        const createDto = this.buildClassSessionDto(classGroup, sessionTemplate);
+        const mutableWhere = {
+            course_class_group_id: classGroupId,
+        };
+        if (options === null || options === void 0 ? void 0 : options.futureOnly) {
+            mutableWhere.session_date = { gte: this.getSessionMutationFloorDate() };
+            mutableWhere.status = { notIn: ['completed', 'cancelled'] };
+        }
+        const mutableSessions = await tx.course_class_session.findMany({
+            where: mutableWhere,
+            select: { id: true },
+        });
+        if (mutableSessions.length > 0) {
+            const sessionIds = mutableSessions.map((session) => session.id);
+            await tx.course_class_attendance.deleteMany({
+                where: { course_class_session_id: { in: sessionIds } },
+            });
+            await tx.course_class_session_instructor.deleteMany({
+                where: { course_class_session_id: { in: sessionIds } },
+            });
+            await tx.course_class_session.deleteMany({
+                where: { id: { in: sessionIds } },
+            });
+        }
+        await this.createSessionSeriesInTransaction(tx, classGroupId, createDto, {
+            minDate: (options === null || options === void 0 ? void 0 : options.futureOnly) ? this.getSessionMutationFloorDate() : undefined,
+        });
+    }
+    mapClassGroup(item) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
+        const instructorName = (_k = (_g = (_d = (_c = (_b = (_a = item.instructor) === null || _a === void 0 ? void 0 : _a.person) === null || _b === void 0 ? void 0 : _b.name) === null || _c === void 0 ? void 0 : _c.trim()) !== null && _d !== void 0 ? _d : (_f = (_e = item.instructorName) === null || _e === void 0 ? void 0 : _e.trim) === null || _f === void 0 ? void 0 : _f.call(_e)) !== null && _g !== void 0 ? _g : (_j = (_h = item.professorName) === null || _h === void 0 ? void 0 : _h.trim) === null || _j === void 0 ? void 0 : _j.call(_h)) !== null && _k !== void 0 ? _k : '';
+        return {
+            id: item.id,
+            code: item.code,
+            title: item.title,
+            description: (_l = item.description) !== null && _l !== void 0 ? _l : '',
+            deliveryMode: item.delivery_mode,
+            status: item.status,
+            startDate: item.start_date,
+            endDate: item.end_date,
+            startTime: item.start_time,
+            endTime: item.end_time,
+            weekDays: item.week_days,
+            capacity: item.capacity,
+            location: item.location,
+            virtualRoomUrl: item.virtual_room_url,
+            courseId: item.course_id,
+            instructorId: (_p = (_m = item.instructor_id) !== null && _m !== void 0 ? _m : (_o = item.instructor) === null || _o === void 0 ? void 0 : _o.id) !== null && _p !== void 0 ? _p : null,
+            instructorName,
+            instructor: instructorName,
+            professorName: instructorName,
+            professor: instructorName,
+            courseTitle: (_r = (_q = item.course) === null || _q === void 0 ? void 0 : _q.title) !== null && _r !== void 0 ? _r : '',
+            primaryColor: (_t = (_s = item.course) === null || _s === void 0 ? void 0 : _s.primary_color) !== null && _t !== void 0 ? _t : null,
+            enrolledCount: (_v = (_u = item._count) === null || _u === void 0 ? void 0 : _u.course_enrollment) !== null && _v !== void 0 ? _v : 0,
+            sessionCount: (_x = (_w = item._count) === null || _w === void 0 ? void 0 : _w.course_class_session) !== null && _x !== void 0 ? _x : 0,
+            occupancyRate: Math.round((((_z = (_y = item._count) === null || _y === void 0 ? void 0 : _y.course_enrollment) !== null && _z !== void 0 ? _z : 0) / Math.max((_0 = item.capacity) !== null && _0 !== void 0 ? _0 : 1, 1)) *
+                100),
+            createdAt: item.created_at,
+            updatedAt: item.updated_at,
+        };
+    }
+    normalizeStatus(value) {
+        if (!value)
+            return undefined;
+        const normalized = value.trim().toLowerCase();
+        const valid = ['open', 'ongoing', 'completed', 'cancelled'];
+        if (!valid.includes(normalized)) {
+            throw new common_1.BadRequestException('Invalid status');
+        }
+        return normalized;
+    }
+    normalizeDeliveryMode(value) {
+        if (!value)
+            return undefined;
+        const normalized = value.trim().toLowerCase();
+        const valid = ['presential', 'online', 'hybrid'];
+        if (!valid.includes(normalized)) {
+            throw new common_1.BadRequestException('Invalid delivery mode');
+        }
+        return normalized;
+    }
+    assertDatesAndTimes(params) {
+        const startDate = new Date(params.startDate);
+        if (Number.isNaN(startDate.getTime())) {
+            throw new common_1.BadRequestException('Invalid start date');
+        }
+        if (params.endDate) {
+            const endDate = new Date(params.endDate);
+            if (Number.isNaN(endDate.getTime())) {
+                throw new common_1.BadRequestException('Invalid end date');
+            }
+            if (endDate.getTime() < startDate.getTime()) {
+                throw new common_1.BadRequestException('End date cannot be before start date');
+            }
+        }
+        if (params.startTime && params.endTime) {
+            const start = this.timeToMinutes(params.startTime);
+            const end = this.timeToMinutes(params.endTime);
+            if (start >= end) {
+                throw new common_1.BadRequestException('End time must be after start time');
+            }
+        }
+    }
+    timeToMinutes(value) {
+        const [hours, minutes] = value.split(':').map(Number);
+        return hours * 60 + minutes;
+    }
+    async assertCourseExists(courseId) {
+        const exists = await this.prisma.course.findUnique({
+            where: { id: courseId },
+            select: { id: true },
+        });
+        if (!exists) {
+            throw new common_1.NotFoundException('Course not found');
+        }
+    }
+    // ── Students ────────────────────────────────────────────────────────────────
+    async listStudents(classGroupId, search) {
+        const group = await this.prisma.course_class_group.findUnique({
+            where: { id: classGroupId },
+            select: { id: true, course_id: true },
+        });
+        if (!group)
+            throw new common_1.NotFoundException('Class not found');
+        const enrollments = await this.prisma.course_enrollment.findMany({
+            where: {
+                course_class_group_id: classGroupId,
+                status: { not: 'cancelled' },
+            },
+            include: {
+                person: {
+                    select: {
+                        id: true,
+                        name: true,
+                        contact: {
+                            select: { value: true, contact_type: { select: { code: true } } },
+                        },
+                    },
+                },
+            },
+            orderBy: { enrolled_at: 'asc' },
+        });
+        const mapped = enrollments.map((e) => {
+            var _a, _b, _c, _d;
+            const contacts = e.person.contact;
+            const email = (_b = (_a = contacts.find((c) => this.isEmailCode(c.contact_type.code))) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : '';
+            const phone = (_d = (_c = contacts.find((c) => this.isPhoneCode(c.contact_type.code))) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : '';
+            return {
+                id: e.person.id,
+                enrollmentId: e.id,
+                nome: e.person.name,
+                email,
+                telefone: phone,
+                matriculadoEm: e.enrolled_at,
+                progresso: e.progress_percent,
+                status: e.status,
+            };
+        });
+        if (search === null || search === void 0 ? void 0 : search.trim()) {
+            const q = search.trim().toLowerCase();
+            return mapped.filter((s) => s.nome.toLowerCase().includes(q) ||
+                s.email.toLowerCase().includes(q));
+        }
+        return mapped;
+    }
+    async enrollStudent(classGroupId, personId) {
+        const group = await this.prisma.course_class_group.findUnique({
+            where: { id: classGroupId },
+            select: { id: true, course_id: true, capacity: true },
+        });
+        if (!group)
+            throw new common_1.NotFoundException('Class not found');
+        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: group.course_id,
+                status: 'active',
+                enrolled_at: new Date(),
+            },
+        });
+    }
+    async createAndEnrollStudent(classGroupId, dto) {
+        var _a, _b, _c, _d, _e;
+        const group = await this.prisma.course_class_group.findUnique({
+            where: { id: classGroupId },
+            select: { id: true },
+        });
+        if (!group) {
+            throw new common_1.NotFoundException('Class not found');
+        }
+        const name = dto.name.trim();
+        const email = (_a = dto.email) === null || _a === void 0 ? void 0 : _a.trim();
+        const phone = (_b = dto.phone) === null || _b === void 0 ? void 0 : _b.trim();
+        if (!name) {
+            throw new common_1.BadRequestException('Name is required');
+        }
+        let personId;
+        if (email) {
+            const existingByEmail = await this.prisma.person.findFirst({
+                where: {
+                    contact: {
+                        some: {
+                            value: { equals: email, mode: 'insensitive' },
+                            contact_type: { code: { in: ['email', 'EMAIL'] } },
+                        },
+                    },
+                },
+                select: { id: true },
+            });
+            if (existingByEmail) {
+                personId = existingByEmail.id;
+            }
+        }
+        if (!personId) {
+            const [emailType, phoneType] = await Promise.all([
+                this.prisma.contact_type.findFirst({
+                    where: { code: { in: ['email', 'EMAIL'] } },
+                    select: { id: true },
+                }),
+                this.prisma.contact_type.findFirst({
+                    where: { code: { in: ['mobile', 'MOBILE', 'phone', 'PHONE'] } },
+                    orderBy: { id: 'asc' },
+                    select: { id: true },
+                }),
+            ]);
+            const createdPerson = await this.prisma.person.create({
+                data: {
+                    name,
+                    type: 'individual',
+                    status: 'active',
+                },
+                select: { id: true },
+            });
+            personId = createdPerson.id;
+            const contactsToCreate = [];
+            if (email && emailType) {
+                contactsToCreate.push({
+                    person_id: personId,
+                    contact_type_id: emailType.id,
+                    value: email,
+                    is_primary: true,
+                });
+            }
+            if (phone && phoneType) {
+                contactsToCreate.push({
+                    person_id: personId,
+                    contact_type_id: phoneType.id,
+                    value: phone,
+                    is_primary: true,
+                });
+            }
+            if (contactsToCreate.length > 0) {
+                await this.prisma.contact.createMany({
+                    data: contactsToCreate,
+                });
+            }
+        }
+        const person = await this.prisma.person.findUnique({
+            where: { id: personId },
+            include: {
+                contact: {
+                    select: {
+                        value: true,
+                        contact_type: { select: { code: true } },
+                    },
+                },
+            },
+        });
+        return {
+            id: person === null || person === void 0 ? void 0 : person.id,
+            nome: (_c = person === null || person === void 0 ? void 0 : person.name) !== null && _c !== void 0 ? _c : '',
+            email: (_e = (_d = person === null || person === void 0 ? void 0 : person.contact.find((c) => this.isEmailCode(c.contact_type.code))) === null || _d === void 0 ? void 0 : _d.value) !== null && _e !== void 0 ? _e : '',
+        };
+    }
+    async removeStudent(classGroupId, personId) {
+        const enrollment = await this.prisma.course_enrollment.findFirst({
+            where: {
+                course_class_group_id: classGroupId,
+                person_id: personId,
+                status: { not: 'cancelled' },
+            },
+        });
+        if (!enrollment)
+            throw new common_1.NotFoundException('Enrollment not found');
+        await this.prisma.course_enrollment.update({
+            where: { id: enrollment.id },
+            data: { status: 'cancelled' },
+        });
+        return { success: true };
+    }
+    async getStudentProfile(classGroupId, personId) {
+        var _a, _b, _c, _d;
+        const enrollment = await this.prisma.course_enrollment.findFirst({
+            where: {
+                course_class_group_id: classGroupId,
+                person_id: personId,
+                status: { not: 'cancelled' },
+            },
+            include: {
+                person: {
+                    select: {
+                        id: true,
+                        name: true,
+                        contact: {
+                            select: {
+                                id: true,
+                                value: true,
+                                contact_type: { select: { code: true } },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        if (!enrollment) {
+            throw new common_1.NotFoundException('Student not found in this class');
+        }
+        const email = (_b = (_a = enrollment.person.contact.find((c) => this.isEmailCode(c.contact_type.code))) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : '';
+        const phone = (_d = (_c = enrollment.person.contact.find((c) => this.isPhoneCode(c.contact_type.code))) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : '';
+        return {
+            id: enrollment.person.id,
+            enrollmentId: enrollment.id,
+            nome: enrollment.person.name,
+            email,
+            telefone: phone,
+            matriculadoEm: enrollment.enrolled_at,
+            progresso: enrollment.progress_percent,
+            status: enrollment.status,
+        };
+    }
+    async updateStudentProfile(classGroupId, personId, dto) {
+        var _a, _b, _c;
+        const enrollment = await this.prisma.course_enrollment.findFirst({
+            where: {
+                course_class_group_id: classGroupId,
+                person_id: personId,
+                status: { not: 'cancelled' },
+            },
+            select: { id: true },
+        });
+        if (!enrollment) {
+            throw new common_1.NotFoundException('Student not found in this class');
+        }
+        const name = (_a = dto.name) === null || _a === void 0 ? void 0 : _a.trim();
+        const email = (_b = dto.email) === null || _b === void 0 ? void 0 : _b.trim();
+        const phone = (_c = dto.phone) === null || _c === void 0 ? void 0 : _c.trim();
+        if (dto.name !== undefined && !name) {
+            throw new common_1.BadRequestException('Name is required');
+        }
+        if (name) {
+            await this.prisma.person.update({
+                where: { id: personId },
+                data: { name },
+            });
+        }
+        const [emailType, phoneType] = await Promise.all([
+            this.prisma.contact_type.findFirst({
+                where: { code: { in: ['email', 'EMAIL'] } },
+                select: { id: true },
+            }),
+            this.prisma.contact_type.findFirst({
+                where: { code: { in: ['mobile', 'MOBILE', 'phone', 'PHONE'] } },
+                orderBy: { id: 'asc' },
+                select: { id: true },
+            }),
+        ]);
+        if (dto.email !== undefined && emailType) {
+            const existingEmail = await this.prisma.contact.findFirst({
+                where: { person_id: personId, contact_type_id: emailType.id },
+                select: { id: true },
+            });
+            if (email) {
+                if (existingEmail) {
+                    await this.prisma.contact.update({
+                        where: { id: existingEmail.id },
+                        data: { value: email },
+                    });
+                }
+                else {
+                    await this.prisma.contact.create({
+                        data: {
+                            person_id: personId,
+                            contact_type_id: emailType.id,
+                            value: email,
+                            is_primary: true,
+                        },
+                    });
+                }
+            }
+            else if (existingEmail) {
+                await this.prisma.contact.delete({ where: { id: existingEmail.id } });
+            }
+        }
+        if (dto.phone !== undefined) {
+            const existingPhone = await this.prisma.contact.findFirst({
+                where: {
+                    person_id: personId,
+                    contact_type: { code: { in: ['mobile', 'MOBILE', 'phone', 'PHONE'] } },
+                },
+                orderBy: { id: 'asc' },
+                select: { id: true },
+            });
+            if (phone) {
+                if (existingPhone) {
+                    await this.prisma.contact.update({
+                        where: { id: existingPhone.id },
+                        data: { value: phone },
+                    });
+                }
+                else if (phoneType) {
+                    await this.prisma.contact.create({
+                        data: {
+                            person_id: personId,
+                            contact_type_id: phoneType.id,
+                            value: phone,
+                            is_primary: true,
+                        },
+                    });
+                }
+            }
+            else if (existingPhone) {
+                await this.prisma.contact.delete({ where: { id: existingPhone.id } });
+            }
+        }
+        return this.getStudentProfile(classGroupId, personId);
+    }
+    async searchPeople(search, classGroupId) {
+        const q = search.trim();
+        if (!q)
+            return [];
+        const enrolledIds = classGroupId
+            ? (await this.prisma.course_enrollment.findMany({
+                where: {
+                    course_class_group_id: classGroupId,
+                    status: { not: 'cancelled' },
+                },
+                select: { person_id: true },
+            })).map((e) => e.person_id)
+            : [];
+        const people = await this.prisma.person.findMany({
+            where: {
+                AND: [
+                    {
+                        OR: [
+                            { name: { contains: q, mode: 'insensitive' } },
+                            {
+                                contact: {
+                                    some: {
+                                        value: { contains: q, mode: 'insensitive' },
+                                        contact_type: { code: { in: ['email', 'EMAIL'] } },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                    enrolledIds.length > 0 ? { id: { notIn: enrolledIds } } : {},
+                ],
+            },
+            include: {
+                contact: {
+                    select: { value: true, contact_type: { select: { code: true } } },
+                },
+            },
+            take: 20,
+        });
+        const personIds = people.map((person) => person.id);
+        const [instructors, enrolledPeople] = personIds.length > 0
+            ? await Promise.all([
+                this.prisma.instructor.findMany({
+                    where: {
+                        person_id: { in: personIds },
+                        status: 'active',
+                    },
+                    select: {
+                        person_id: true,
+                        can_teach_courses: true,
+                    },
+                }),
+                this.prisma.course_enrollment.findMany({
+                    where: {
+                        person_id: { in: personIds },
+                        status: { not: 'cancelled' },
+                    },
+                    select: { person_id: true },
+                    distinct: ['person_id'],
+                }),
+            ])
+            : [[], []];
+        const instructorByPersonId = new Map(instructors.map((instructor) => [instructor.person_id, instructor]));
+        const enrolledPersonIds = new Set(enrolledPeople.map((enrollment) => enrollment.person_id));
+        return people.map((p) => {
+            var _a, _b;
+            const instructor = instructorByPersonId.get(p.id);
+            const isInstructor = Boolean(instructor);
+            const canTeachCourses = Boolean(instructor === null || instructor === void 0 ? void 0 : instructor.can_teach_courses);
+            const isStudentByEnrollment = enrolledPersonIds.has(p.id);
+            return {
+                id: p.id,
+                nome: p.name,
+                email: (_b = (_a = p.contact.find((c) => this.isEmailCode(c.contact_type.code))) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : '',
+                isInstructor,
+                canTeachCourses,
+                isStudentByEnrollment,
+            };
+        });
+    }
+    // ── Sessions ─────────────────────────────────────────────────────────────────
+    async listSessions(classGroupId) {
+        const group = await this.prisma.course_class_group.findUnique({
+            where: { id: classGroupId },
+            select: { id: true },
+        });
+        if (!group)
+            throw new common_1.NotFoundException('Class not found');
+        const sessions = await this.prisma.course_class_session.findMany({
+            where: { course_class_group_id: classGroupId },
+            orderBy: [{ session_date: 'asc' }, { occurrence_index: 'asc' }],
+            include: this.getSessionInclude(),
+        });
+        return sessions.map((s) => this.mapSession(s));
+    }
+    async createSession(classGroupId, dto) {
+        const group = await this.prisma.course_class_group.findUnique({
+            where: { id: classGroupId },
+            select: { id: true },
+        });
+        if (!group)
+            throw new common_1.NotFoundException('Class not found');
+        if (dto.instructorId) {
+            await this.assertInstructorExists(dto.instructorId);
+        }
+        const created = await this.prisma.$transaction((tx) => this.createSessionSeriesInTransaction(tx, classGroupId, dto));
+        if (!created) {
+            throw new common_1.BadRequestException('No sessions were generated for the provided recurrence');
+        }
+        return this.mapSession(created);
+    }
+    async createSessionSeriesInTransaction(tx, classGroupId, dto, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const normalizedRecurrence = dto.recurrence
+            ? this.normalizeSessionRecurrence(dto.recurrence, dto.sessionDate)
+            : null;
+        const fullOccurrenceDates = normalizedRecurrence
+            ? this.buildRecurringSessionDates(dto.sessionDate, normalizedRecurrence)
+            : [this.toSessionDate(dto.sessionDate)];
+        const occurrenceDates = (options === null || options === void 0 ? void 0 : options.minDate)
+            ? fullOccurrenceDates.filter((date) => this.normalizeSessionDate(date).getTime() >=
+                this.normalizeSessionDate(options.minDate).getTime())
+            : fullOccurrenceDates;
+        if (occurrenceDates.length === 0) {
+            return null;
+        }
+        const recurrenceId = normalizedRecurrence ? (0, node_crypto_1.randomUUID)() : null;
+        const recurrenceRule = normalizedRecurrence
+            ? JSON.stringify(normalizedRecurrence)
+            : null;
+        const first = await tx.course_class_session.create({
+            data: Object.assign({ course_class_group_id: classGroupId, title: dto.title, description: (_a = dto.description) !== null && _a !== void 0 ? _a : null, session_date: occurrenceDates[0], start_time: dto.startTime, end_time: dto.endTime, location: (_b = dto.location) !== null && _b !== void 0 ? _b : null, meeting_url: (_c = dto.meetingUrl) !== null && _c !== void 0 ? _c : null, color: (_d = dto.color) !== null && _d !== void 0 ? _d : null, status: (_e = dto.status) !== null && _e !== void 0 ? _e : 'scheduled', recurrence_id: recurrenceId, recurrence_rule: recurrenceRule, occurrence_index: normalizedRecurrence ? 0 : null, is_exception: false }, (dto.instructorId && {
+                course_class_session_instructor: {
+                    create: {
+                        instructor_id: dto.instructorId,
+                        role: 'lead',
+                    },
+                },
+            })),
+            include: this.getSessionInclude(),
+        });
+        for (let index = 1; index < occurrenceDates.length; index += 1) {
+            await tx.course_class_session.create({
+                data: Object.assign({ course_class_group_id: classGroupId, title: dto.title, description: (_f = dto.description) !== null && _f !== void 0 ? _f : null, session_date: occurrenceDates[index], start_time: dto.startTime, end_time: dto.endTime, location: (_g = dto.location) !== null && _g !== void 0 ? _g : null, meeting_url: (_h = dto.meetingUrl) !== null && _h !== void 0 ? _h : null, color: (_j = dto.color) !== null && _j !== void 0 ? _j : null, status: (_k = dto.status) !== null && _k !== void 0 ? _k : 'scheduled', recurrence_id: recurrenceId, recurrence_rule: recurrenceRule, occurrence_index: normalizedRecurrence ? index : null, is_exception: false, parent_session_id: first.id }, (dto.instructorId && {
+                    course_class_session_instructor: {
+                        create: {
+                            instructor_id: dto.instructorId,
+                            role: 'lead',
+                        },
+                    },
+                })),
+            });
+        }
+        return first;
+    }
+    async updateSession(classGroupId, sessionId, dto) {
+        var _a, _b;
+        const session = await this.prisma.course_class_session.findFirst({
+            where: { id: sessionId, course_class_group_id: classGroupId },
+        });
+        if (!session)
+            throw new common_1.NotFoundException('Session not found');
+        if (dto.instructorId) {
+            await this.assertInstructorExists(dto.instructorId);
+        }
+        const scope = (_a = dto.applyScope) !== null && _a !== void 0 ? _a : 'single';
+        const normalizedRecurrence = dto.recurrence
+            ? this.normalizeSessionRecurrence(dto.recurrence, (_b = dto.sessionDate) !== null && _b !== void 0 ? _b : this.toDateKey(session.session_date))
+            : null;
+        const nextRecurrenceRule = normalizedRecurrence
+            ? JSON.stringify(normalizedRecurrence)
+            : dto.recurrence === undefined
+                ? undefined
+                : null;
+        if (scope === 'series' && session.recurrence_id) {
+            const seriesSessions = await this.prisma.course_class_session.findMany({
+                where: {
+                    course_class_group_id: classGroupId,
+                    recurrence_id: session.recurrence_id,
+                },
+                orderBy: [{ session_date: 'asc' }, { occurrence_index: 'asc' }],
+            });
+            const dayDelta = dto.sessionDate
+                ? this.diffInDays(this.toSessionDate(dto.sessionDate), this.normalizeSessionDate(session.session_date))
+                : 0;
+            await this.prisma.$transaction(async (tx) => {
+                for (const seriesSession of seriesSessions) {
+                    await tx.course_class_session.update({
+                        where: { id: seriesSession.id },
+                        data: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (dto.title !== undefined && { title: dto.title })), (dto.description !== undefined && {
+                            description: dto.description,
+                        })), (dto.startTime !== undefined && { start_time: dto.startTime })), (dto.endTime !== undefined && { end_time: dto.endTime })), (dto.location !== undefined && { location: dto.location })), (dto.meetingUrl !== undefined && {
+                            meeting_url: dto.meetingUrl,
+                        })), (dto.color !== undefined && { color: dto.color })), (dto.status !== undefined && { status: dto.status })), (dto.sessionDate !== undefined && {
+                            session_date: this.addDaysUtc(seriesSession.session_date, dayDelta),
+                        })), (nextRecurrenceRule !== undefined && {
+                            recurrence_rule: nextRecurrenceRule,
+                        })),
+                    });
+                    if (dto.instructorId !== undefined) {
+                        await tx.course_class_session_instructor.deleteMany({
+                            where: { course_class_session_id: seriesSession.id },
+                        });
+                        if (dto.instructorId) {
+                            await tx.course_class_session_instructor.create({
+                                data: {
+                                    course_class_session_id: seriesSession.id,
+                                    instructor_id: dto.instructorId,
+                                    role: 'lead',
+                                },
+                            });
+                        }
+                    }
+                }
+            });
+            const updated = await this.prisma.course_class_session.findUnique({
+                where: { id: sessionId },
+                include: this.getSessionInclude(),
+            });
+            if (!updated) {
+                throw new common_1.NotFoundException('Session not found');
+            }
+            return this.mapSession(updated);
+        }
+        const updated = await this.prisma.course_class_session.update({
+            where: { id: sessionId },
+            data: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (dto.title !== undefined && { title: dto.title })), (dto.description !== undefined && { description: dto.description })), (dto.sessionDate !== undefined && {
+                session_date: this.toSessionDate(dto.sessionDate),
+            })), (dto.startTime !== undefined && { start_time: dto.startTime })), (dto.endTime !== undefined && { end_time: dto.endTime })), (dto.location !== undefined && { location: dto.location })), (dto.meetingUrl !== undefined && { meeting_url: dto.meetingUrl })), (dto.color !== undefined && { color: dto.color })), (dto.status !== undefined && { status: dto.status })), (nextRecurrenceRule !== undefined && {
+                recurrence_rule: nextRecurrenceRule,
+            })), (session.recurrence_id && { is_exception: true })), (dto.instructorId !== undefined && {
+                course_class_session_instructor: Object.assign({ deleteMany: {} }, (dto.instructorId
+                    ? {
+                        create: {
+                            instructor_id: dto.instructorId,
+                            role: 'lead',
+                        },
+                    }
+                    : {})),
+            })),
+            include: this.getSessionInclude(),
+        });
+        return this.mapSession(updated);
+    }
+    async deleteSession(classGroupId, sessionId, scope = 'single') {
+        const session = await this.prisma.course_class_session.findFirst({
+            where: { id: sessionId, course_class_group_id: classGroupId },
+        });
+        if (!session)
+            throw new common_1.NotFoundException('Session not found');
+        if (scope === 'series' && session.recurrence_id) {
+            await this.prisma.course_class_session.deleteMany({
+                where: {
+                    course_class_group_id: classGroupId,
+                    recurrence_id: session.recurrence_id,
+                },
+            });
+            return { success: true };
+        }
+        await this.prisma.course_class_session.delete({ where: { id: sessionId } });
+        return { success: true };
+    }
+    // ── Attendance ───────────────────────────────────────────────────────────────
+    async getAttendance(classGroupId, sessionId) {
+        const session = await this.prisma.course_class_session.findFirst({
+            where: { id: sessionId, course_class_group_id: classGroupId },
+        });
+        if (!session)
+            throw new common_1.NotFoundException('Session not found');
+        return this.prisma.course_class_attendance.findMany({
+            where: { course_class_session_id: sessionId },
+            include: {
+                person_course_class_attendance_student_idToperson: {
+                    select: { id: true, name: true },
+                },
+            },
+        });
+    }
+    async saveAttendance(classGroupId, sessionId, entries) {
+        const session = await this.prisma.course_class_session.findFirst({
+            where: { id: sessionId, course_class_group_id: classGroupId },
+        });
+        if (!session)
+            throw new common_1.NotFoundException('Session not found');
+        await this.prisma.$transaction(async (tx) => {
+            var _a, _b;
+            const normalizedEntries = Array.from(new Map(entries.map((entry) => [entry.studentId, entry])).values());
+            const selectedStudentIds = normalizedEntries.map((entry) => entry.studentId);
+            if (selectedStudentIds.length > 0) {
+                await tx.course_class_attendance.deleteMany({
+                    where: {
+                        course_class_session_id: sessionId,
+                        student_id: { notIn: selectedStudentIds },
+                    },
+                });
+            }
+            else {
+                await tx.course_class_attendance.deleteMany({
+                    where: { course_class_session_id: sessionId },
+                });
+            }
+            for (const e of normalizedEntries) {
+                const existing = await tx.course_class_attendance.findFirst({
+                    where: {
+                        course_class_session_id: sessionId,
+                        student_id: e.studentId,
+                    },
+                    select: { id: true },
+                });
+                if (existing) {
+                    await tx.course_class_attendance.update({
+                        where: { id: existing.id },
+                        data: {
+                            present: e.present,
+                            justification: (_a = e.justification) !== null && _a !== void 0 ? _a : null,
+                        },
+                    });
+                    continue;
+                }
+                await tx.course_class_attendance.create({
+                    data: {
+                        course_class_session_id: sessionId,
+                        student_id: e.studentId,
+                        present: e.present,
+                        justification: (_b = e.justification) !== null && _b !== void 0 ? _b : null,
+                    },
+                });
+            }
+        });
+        return { success: true };
+    }
+    mapSession(s) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const leadInstructor = (_a = s.course_class_session_instructor) === null || _a === void 0 ? void 0 : _a.find((entry) => entry.role === 'lead');
+        const fallbackInstructor = (_b = s.course_class_session_instructor) === null || _b === void 0 ? void 0 : _b[0];
+        const sessionInstructor = leadInstructor !== null && leadInstructor !== void 0 ? leadInstructor : fallbackInstructor;
+        const recurrence = this.parseRecurrenceRule(s.recurrence_rule);
+        return {
+            id: s.id,
+            titulo: s.title,
+            descricao: (_c = s.description) !== null && _c !== void 0 ? _c : '',
+            data: s.session_date,
+            horaInicio: s.start_time,
+            horaFim: s.end_time,
+            local: (_d = s.location) !== null && _d !== void 0 ? _d : '',
+            meetingUrl: (_e = s.meeting_url) !== null && _e !== void 0 ? _e : '',
+            cor: (_f = s.color) !== null && _f !== void 0 ? _f : undefined,
+            status: s.status,
+            tipo: s.meeting_url ? 'online' : 'presencial',
+            instructorId: (_g = sessionInstructor === null || sessionInstructor === void 0 ? void 0 : sessionInstructor.instructor_id) !== null && _g !== void 0 ? _g : null,
+            instructorName: (_k = (_j = (_h = sessionInstructor === null || sessionInstructor === void 0 ? void 0 : sessionInstructor.instructor) === null || _h === void 0 ? void 0 : _h.person) === null || _j === void 0 ? void 0 : _j.name) !== null && _k !== void 0 ? _k : '',
+            recurrenceId: (_l = s.recurrence_id) !== null && _l !== void 0 ? _l : null,
+            occurrenceIndex: (_m = s.occurrence_index) !== null && _m !== void 0 ? _m : null,
+            isException: Boolean(s.is_exception),
+            recurrence,
+            isRecurring: Boolean(s.recurrence_id),
+        };
+    }
+    normalizeSessionRecurrence(recurrence, sessionDate) {
+        var _a, _b;
+        const startDate = this.toSessionDate(sessionDate);
+        const untilDate = this.toSessionDate(recurrence.until);
+        if (untilDate.getTime() < startDate.getTime()) {
+            throw new common_1.BadRequestException('Recurrence end date must be on or after session date');
+        }
+        const normalizedDays = ((_a = recurrence.daysOfWeek) === null || _a === void 0 ? void 0 : _a.length)
+            ? [...new Set(recurrence.daysOfWeek)].sort((left, right) => ClassGroupService_1.DAY_ORDER.indexOf(left) -
+                ClassGroupService_1.DAY_ORDER.indexOf(right))
+            : recurrence.frequency === 'weekly'
+                ? [this.getDayCode(startDate)]
+                : undefined;
+        return Object.assign({ frequency: recurrence.frequency, interval: (_b = recurrence.interval) !== null && _b !== void 0 ? _b : 1, until: this.toDateKey(untilDate) }, ((normalizedDays === null || normalizedDays === void 0 ? void 0 : normalizedDays.length) ? { daysOfWeek: normalizedDays } : {}));
+    }
+    buildRecurringSessionDates(sessionDate, recurrence) {
+        const startDate = this.toSessionDate(sessionDate);
+        const untilDate = this.toSessionDate(recurrence.until);
+        switch (recurrence.frequency) {
+            case 'daily':
+                return this.buildDailyOccurrences(startDate, untilDate, recurrence.interval);
+            case 'weekly':
+                return this.buildWeeklyOccurrences(startDate, untilDate, recurrence.interval, recurrence.daysOfWeek);
+            case 'monthly':
+                return this.buildMonthlyOccurrences(startDate, untilDate, recurrence.interval);
+            case 'yearly':
+                return this.buildYearlyOccurrences(startDate, untilDate, recurrence.interval);
+            default:
+                return [startDate];
+        }
+    }
+    buildDailyOccurrences(startDate, untilDate, interval) {
+        const dates = [];
+        for (let current = startDate; current.getTime() <= untilDate.getTime(); current = this.addDaysUtc(current, interval)) {
+            dates.push(current);
+        }
+        return dates;
+    }
+    buildWeeklyOccurrences(startDate, untilDate, interval, daysOfWeek) {
+        const dates = [];
+        const weekStart = this.startOfWeekMonday(startDate);
+        const normalizedDays = (daysOfWeek === null || daysOfWeek === void 0 ? void 0 : daysOfWeek.length)
+            ? daysOfWeek
+            : [this.getDayCode(startDate)];
+        for (let currentWeek = weekStart; currentWeek.getTime() <= untilDate.getTime(); currentWeek = this.addDaysUtc(currentWeek, interval * 7)) {
+            for (const dayCode of normalizedDays) {
+                const candidate = this.addDaysUtc(currentWeek, ClassGroupService_1.DAY_ORDER.indexOf(dayCode));
+                if (candidate.getTime() < startDate.getTime()) {
+                    continue;
+                }
+                if (candidate.getTime() > untilDate.getTime()) {
+                    continue;
+                }
+                dates.push(candidate);
+            }
+        }
+        return dates.sort((left, right) => left.getTime() - right.getTime());
+    }
+    buildMonthlyOccurrences(startDate, untilDate, interval) {
+        const dates = [];
+        for (let offset = 0;; offset += interval) {
+            const candidate = this.addMonthsUtc(startDate, offset);
+            if (!candidate) {
+                continue;
+            }
+            if (candidate.getTime() > untilDate.getTime()) {
+                break;
+            }
+            dates.push(candidate);
+        }
+        return dates;
+    }
+    buildYearlyOccurrences(startDate, untilDate, interval) {
+        const dates = [];
+        for (let offset = 0;; offset += interval) {
+            const candidate = this.addYearsUtc(startDate, offset);
+            if (!candidate) {
+                continue;
+            }
+            if (candidate.getTime() > untilDate.getTime()) {
+                break;
+            }
+            dates.push(candidate);
+        }
+        return dates;
+    }
+    parseRecurrenceRule(value) {
+        if (!value) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(value);
+            return (parsed === null || parsed === void 0 ? void 0 : parsed.frequency) ? parsed : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    toSessionDate(value) {
+        if (value instanceof Date) {
+            return this.normalizeSessionDate(value);
+        }
+        const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(value !== null && value !== void 0 ? value : '');
+        if (!match) {
+            throw new common_1.BadRequestException('Invalid session date');
+        }
+        return new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]), 12, 0, 0, 0));
+    }
+    normalizeSessionDate(value) {
+        return new Date(Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate(), 12, 0, 0, 0));
+    }
+    toDateKey(value) {
+        return value.toISOString().slice(0, 10);
+    }
+    getDayCode(value) {
+        return ClassGroupService_1.UTC_DAY_TO_CODE[value.getUTCDay()];
+    }
+    startOfWeekMonday(value) {
+        const day = value.getUTCDay();
+        const diff = day === 0 ? -6 : 1 - day;
+        return this.addDaysUtc(value, diff);
+    }
+    addDaysUtc(value, amount) {
+        const next = new Date(value.getTime());
+        next.setUTCDate(next.getUTCDate() + amount);
+        return this.normalizeSessionDate(next);
+    }
+    addMonthsUtc(value, amount) {
+        const year = value.getUTCFullYear();
+        const month = value.getUTCMonth() + amount;
+        const day = value.getUTCDate();
+        const candidate = new Date(Date.UTC(year, month, day, 12, 0, 0, 0));
+        if (candidate.getUTCDate() !== day) {
+            return null;
+        }
+        return candidate;
+    }
+    addYearsUtc(value, amount) {
+        const year = value.getUTCFullYear() + amount;
+        const month = value.getUTCMonth();
+        const day = value.getUTCDate();
+        const candidate = new Date(Date.UTC(year, month, day, 12, 0, 0, 0));
+        if (candidate.getUTCMonth() !== month || candidate.getUTCDate() !== day) {
+            return null;
+        }
+        return candidate;
+    }
+    diffInDays(left, right) {
+        const msPerDay = 24 * 60 * 60 * 1000;
+        return Math.round((this.normalizeSessionDate(left).getTime() - this.normalizeSessionDate(right).getTime()) /
+            msPerDay);
+    }
+    async assertInstructorExists(instructorId) {
+        const instructor = await this.prisma.instructor.findUnique({
+            where: { id: instructorId },
+            select: { id: true },
+        });
+        if (!instructor) {
+            throw new common_1.NotFoundException('Instructor not found');
+        }
+    }
+    handlePrismaError(error) {
+        if (error instanceof library_1.PrismaClientKnownRequestError &&
+            error.code === 'P2002') {
+            throw new common_1.ConflictException('Class code already exists');
+        }
+        throw error;
+    }
+};
+exports.ClassGroupService = ClassGroupService;
+ClassGroupService.DAY_ORDER = [
+    'MO',
+    'TU',
+    'WE',
+    'TH',
+    'FR',
+    'SA',
+    'SU',
+];
+ClassGroupService.UTC_DAY_TO_CODE = [
+    'SU',
+    'MO',
+    'TU',
+    'WE',
+    'TH',
+    'FR',
+    'SA',
+];
+exports.ClassGroupService = ClassGroupService = ClassGroupService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_prisma_1.PrismaService])
+], ClassGroupService);
+//# sourceMappingURL=class-group.service.js.map