@driveup/schema 0.2.6 → 0.2.9

package/lib/profile/company/course/schedule.entity.js

@@ -0,0 +1,744 @@
+"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.CompanyCourseScheduleEntity = void 0;
+const common_1 = require("@driveup/common");
+const shared_1 = require("@driveup/shared");
+const luxon_1 = require("luxon");
+const typeorm_1 = require("typeorm");
+const activity_helper_1 = require("../../../utils/activity.helper");
+const trackable_1 = require("../../../utils/trackable");
+const appointment_entity_1 = require("../../student/program/training/appointment.entity");
+const instructor_entity_1 = require("../instructor/instructor.entity");
+const lesson_entity_1 = require("./lesson.entity");
+/**
+ * Represents a series of training appointment offers managed by the company.
+ *
+ * This entity defines appointment templates that serve as available time slots
+ * for student training sessions. Companies manage these appointments to organize
+ * their course training schedules, which students can then book.
+ *
+ * Supports both single and recurring appointments with flexible scheduling options
+ * including:
+ * - Weekly repetitions on specific weekdays
+ * - Custom date ranges for recurring appointments
+ * - Exception handling for skipped dates
+ * - Per-date overrides for time, instructor, and duration
+ *
+ * @remarks
+ * This is a company-managed entity that creates the foundation for student
+ * training bookings. Each appointment definition can generate multiple actual
+ * student appointments based on its repetition settings.
+ *
+ * @see {@link CompanyCourseLessonEntity} for the associated course lesson
+ * @see {@link StudentTrainingEntity} for student bookings
+ */
+let CompanyCourseScheduleEntity = class CompanyCourseScheduleEntity extends trackable_1.TrackableEntity {
+    /**
+     * Creates a new CompanyCourseScheduleEntity instance
+     * @param props - Partial properties to initialize the entity with
+     */
+    constructor(props) {
+        super();
+        Object.assign(this, props);
+    }
+    /**
+     * Converts the entity to a RecurringAppointment model instance
+     * @returns Promise resolving to RecurringAppointment model with lesson, instructor, and scheduling details
+     */
+    async toModel() {
+        const lesson = this.lessonId ? (await this.lesson).toSummary() : null;
+        const instructor = this.instructorId ? await (await this.instructor).toSummary() : null;
+        return new common_1.RecurringAppointment({
+            id: this.id,
+            lesson: lesson,
+            instructor: instructor,
+            startDate: this.startDate,
+            endDate: this.endDate,
+            duration: this.duration,
+            repetition: this.repetition,
+            weekdays: this.weekdays,
+            skippedDates: this.skippedDates,
+            updates: this.updates,
+            instructors: this.instructors,
+            durations: this.durations
+        });
+    }
+    /**
+     * Returns a summary representation of the appointment
+     * @returns Promise resolving to RecurringAppointment model (same as toModel())
+     */
+    async toSummary() {
+        return await this.toModel();
+    }
+    /**
+     * Retrieves all tracked activities for this appointment
+     * Includes creation and update timestamps and associated users
+     * @returns Promise resolving to array of Activity objects filtered to exclude null values
+     */
+    async getActivities() {
+        const activities = [];
+        activities.push(await (0, activity_helper_1.toActivity)(this.createdBy, this.createdOn, shared_1.ActivityType.created));
+        activities.push(await (0, activity_helper_1.toActivity)(this.updatedBy, this.updatedOn, shared_1.ActivityType.updated));
+        return activities.filter(a => a);
+    }
+    async getCompany() {
+        const lesson = await this.lesson;
+        return lesson.getCompany();
+    }
+    async getCourse() {
+        const lesson = await this.lesson;
+        return lesson.getCourse();
+    }
+    async getLesson() {
+        return await this.lesson;
+    }
+    async getInstructor() {
+        return await this.instructor;
+    }
+    async getInstructorByDate(date) {
+        const d = this.instructors?.find(i => i.date === date);
+        return d?.id ? await instructor_entity_1.CompanyInstructorEntity.findOneBy({ id: d.id }) : null;
+    }
+    /************************* Manage student appointments *************************/
+    /**
+     * Get list of related student training appointments, which's training is not terminated
+     * @param date Date - defaulted to this.startDate - Must be provided for flexible course appointments
+     * @returns StudentTrainingAppointmentEntity[]
+     */
+    async getStudentAppointments(date = this.startDate) {
+        const course = await (await this.lesson).course;
+        if (!course.isFixed && !date) {
+            return [];
+        }
+        return await appointment_entity_1.StudentTrainingAppointmentEntity.createQueryBuilder('ta') // training appointment
+            .innerJoin('ta.training', 't') // training
+            .where('ta.scheduleId = :id', { id: this.id })
+            .andWhere('ta.startDate = :date', { date: date })
+            .andWhere('t.status != :terminatedStatus', { terminatedStatus: shared_1.StatusType.Terminated })
+            .getMany();
+    }
+    /**
+     * Get total number of students who attended the appointment in the given date
+     * @param date Date - defaulted to this.startDate - Must be provided for flexible course appointments
+     */
+    async getTotalAttended(date = this.startDate) {
+        const course = await (await this.lesson).course;
+        if (!course.isFixed && !date) {
+            return null;
+        }
+        return await appointment_entity_1.StudentTrainingAppointmentEntity.countBy({
+            scheduleId: this.id,
+            startDate: date,
+            attended: true
+        });
+    }
+    /**
+     * Get total number of students who where absent in the appointment in the given date
+     * @param date Date - defaulted to this.startDate - Must be provided for flexible course appointments
+     */
+    async getTotalAbsent(date = this.startDate) {
+        const course = await (await this.lesson).course;
+        if (!course.isFixed && !date) {
+            return null;
+        }
+        return await appointment_entity_1.StudentTrainingAppointmentEntity.countBy({
+            scheduleId: this.id,
+            startDate: date,
+            attended: false
+        });
+    }
+    /**
+     * Get the count of taken seats for this appointment
+     * - Only applicable for preparation catalog type courses. Returns null for other catalog types.
+     * @param startDate Date - Optional - Only send for flexible courses to specify the desired appointment's startDate
+     * @returns number - count of registered student appointments for this appointment
+     */
+    async getTakenSeats(startDate) {
+        const course = await this.getCourse();
+        const product = await course.product;
+        if (product.catalogType !== shared_1.CatalogType.Preparation) {
+            return null;
+        }
+        const count = await appointment_entity_1.StudentTrainingAppointmentEntity.countBy({
+            scheduleId: this.id,
+            startDate: startDate ?? this.startDate
+        });
+        return count;
+    }
+    /**
+     * Get the count of present students for this appointment
+     * - Only applicable for preparation catalog type courses. Returns null for other catalog types.
+     * @param startDate Date - Optional - Only send for flexible courses to specify the desired appointment's startDate
+     * @returns number - count of attended student appointments for this appointment
+     */
+    async getTotalPresentStudents(startDate) {
+        const course = await this.getCourse();
+        const product = await course.product;
+        if (product.catalogType !== shared_1.CatalogType.Preparation) {
+            return null;
+        }
+        const count = await appointment_entity_1.StudentTrainingAppointmentEntity.countBy({
+            scheduleId: this.id,
+            startDate: startDate ?? this.startDate,
+            attended: true
+        });
+        return count;
+    }
+    /************************* Flexible courses *************************/
+    /**
+     * Finds if there is an appointment in the given date (checking all of the updates), and returning it if is found
+     * @param date Date - the date to check if belongs to an existing appointment
+     * @returns Appointment if an appointment is found in the given date, null otherwise
+     */
+    async getAppointment(date) {
+        // Note: other parts of the app depend on this method returning the instructor
+        // do not remove unless the dependencies are covered
+        // step 0 : prepare local variables
+        date = new Date(date);
+        let appointmentDate = luxon_1.DateTime.fromJSDate(date);
+        // step 1 : manage single appointment
+        if (!this.repetition) {
+            // if the start date matches the given date, return appointment information
+            // otherwise, appointment is not found
+            if (this.startDate.getTime() === date.getTime()) {
+                const instructor = await this.getAppointmentInstructor(appointmentDate);
+                const endDate = luxon_1.DateTime.fromJSDate(this.startDate)
+                    .plus({ minutes: this.duration })
+                    .toJSDate();
+                return new common_1.Appointment({
+                    id: this.id,
+                    startDate: this.startDate,
+                    endDate,
+                    instructor: instructor
+                });
+            }
+            return null;
+        }
+        // step 2 : make sure the date is inside the definition's time frame
+        if (date < this.startDate || (this.endDate && date > this.endDate)) {
+            return null;
+        }
+        // step 3 : check if the weekday of the given date, is one of the weekdays of the series
+        const weekdayMatches = this.weekdays.some(i => appointmentDate.weekday === common_1.DateHelper.getWeekdayNumber(i));
+        if (!weekdayMatches) {
+            return null;
+        }
+        // step 4 : check for updates in the time of the appointment
+        // if an update is made, then the given date doesn't point to an existing appointment
+        appointmentDate = this.getUpdatedDate(appointmentDate);
+        if (appointmentDate.toJSDate().getTime() !== date.getTime()) {
+            return null;
+        }
+        // step 5 : check if the appointment is deleted
+        const isDeleted = this.isDateSkipped(appointmentDate);
+        if (isDeleted) {
+            return null;
+        }
+        // step 6 : get the appointment instructor
+        const instructor = await this.getAppointmentInstructor(appointmentDate);
+        // step 7 : get the appointment duration and calculate the endDate
+        const appointmentDuration = this.getAppointmentDuration(appointmentDate);
+        const endDate = appointmentDate.plus({ minutes: appointmentDuration });
+        return new common_1.Appointment({
+            id: this.id,
+            startDate: appointmentDate.toJSDate(),
+            endDate: endDate.toJSDate(),
+            instructor: instructor
+        });
+    }
+    /**
+     * Load all appointments of the definition within the given period
+     * @description currently only works for flexible course schedules, and will return an empty array if the related course is fixed. but can and must be extended in the future to return the entire appointment list of the schedule, even if the appointment is fixed, or for another product type entirely.
+     * @param period Period
+     * @param instructorIds number[] - instructorId to filter by (return only appointments related to this instructor id)
+     * @param searchPhrase string - optional search phrase to filter appointments by (course title / part title / registered student name)
+     * @returns All appointments of the definition within the given period, filtered by instructorId if provided
+     */
+    async getAppointments(period, instructorIds, searchPhrase) {
+        // check if course if flexible
+        const lesson = await lesson_entity_1.CompanyCourseLessonEntity.findOneBy({ id: this.lessonId });
+        const course = await lesson.course;
+        if (course.isFixed)
+            return [];
+        // step 0 : prepare local variables
+        period.startDate = new Date(period.startDate);
+        period.endDate = new Date(period.endDate);
+        const appointments = [];
+        // step 1 : get first appointment date
+        // if there is no match for given period, first appointment is not found
+        // if not found, return empty array (not appointments)
+        let current = this.getFirstAppointmentDateInPeriod(period);
+        if (!current)
+            return [];
+        if (current.toJSDate() > period.endDate ||
+            (this.endDate && current.toJSDate() > this.endDate))
+            return [];
+        // step 2 : from the first appointment and forward
+        // 1 -> set appointment information (and check for filtered instructor)
+        // 2 -> check if there is a filter by course title / part title / student name required and apply if so
+        // 3 -> push to the appointments array
+        // 4 -> find the next appointment date "inside the given period"
+        // repeat the process
+        let appointment = await this.getAppointmentInformation(current, instructorIds);
+        if (appointment) {
+            if (searchPhrase) {
+                const isMatch = lesson.title.toLowerCase().includes(searchPhrase.toLowerCase()) ||
+                    course.title.toLowerCase().includes(searchPhrase.toLowerCase()) ||
+                    (await this.isStudentRegistered(appointment, searchPhrase));
+                if (isMatch) {
+                    appointments.push(appointment);
+                }
+            }
+            else {
+                appointments.push(appointment);
+            }
+        }
+        current = this.getNextAppointmentDate(current);
+        if (!current) {
+            return appointments;
+        }
+        while (current.toJSDate() <= period.endDate &&
+            (!this.endDate || current.toJSDate() <= this.endDate)) {
+            appointment = await this.getAppointmentInformation(current, instructorIds);
+            if (appointment) {
+                if (searchPhrase) {
+                    const isMatch = lesson.title.toLowerCase().includes(searchPhrase.toLowerCase()) ||
+                        course.title.toLowerCase().includes(searchPhrase.toLowerCase()) ||
+                        (await this.isStudentRegistered(appointment, searchPhrase));
+                    if (isMatch) {
+                        appointments.push(appointment);
+                    }
+                }
+                else {
+                    appointments.push(appointment);
+                }
+            }
+            current = this.getNextAppointmentDate(current);
+        }
+        // step 3 : when no more appointments are found inside the given period
+        // return the found appointments
+        return appointments;
+    }
+    /**
+     * Check if there is one appointment with empty seats
+     *
+     * If the definition has no appointments in the given period, returns true.
+     * Since the functions is supposed to return wether any of the definition's appointments have empty seats
+     */
+    async hasAppointmentWithEmptySeats(period) {
+        // step 0 : prepare local variables
+        period.startDate = new Date(period.startDate);
+        period.endDate = new Date(period.endDate);
+        // step 1 : get first appointment date
+        // if there is no match for given period, first appointment is not found
+        // if not found, return empty array (not appointments)
+        let current = this.getFirstAppointmentDateInPeriod(period);
+        if (!current) {
+            return true;
+        }
+        if (current.toJSDate() > period.endDate ||
+            (this.endDate && current.toJSDate() > this.endDate)) {
+            return true;
+        }
+        // step 2 : from the first appointment and forward
+        // 1 -> set appointment information (and check for filtered instructor)
+        // 2 -> if appointment is found, and there are remaining seats, return true
+        // 3 -> find the next appointment date "inside the given period"
+        // repeat the process
+        let appointment = await this.getAppointmentInformation(current);
+        if (appointment) {
+            const remainingSeats = await this.getRemainingSeats(current.toJSDate());
+            if (remainingSeats > 0) {
+                return true;
+            }
+        }
+        current = this.getNextAppointmentDate(current);
+        if (!current) {
+            return false;
+        }
+        while (current.toJSDate() <= period.endDate &&
+            (!this.endDate || current.toJSDate() <= this.endDate)) {
+            appointment = await this.getAppointmentInformation(current);
+            if (appointment) {
+                const remainingSeats = await this.getRemainingSeats(current.toJSDate());
+                if (remainingSeats > 0) {
+                    return true;
+                }
+            }
+            current = this.getNextAppointmentDate(current);
+        }
+        return false;
+    }
+    /**
+     *
+     * @param period Period
+     * @returns DateTime if a first appointment is found, null otherwise
+     */
+    getFirstAppointmentDateInPeriod(period) {
+        // if this is a single appointment
+        // only check if the definition's start date is within the given period
+        if (!this.repetition) {
+            if (common_1.DateHelper.isBetween(this.startDate, period.startDate, period.endDate)) {
+                return luxon_1.DateTime.fromJSDate(this.startDate);
+            }
+            return null;
+        }
+        // check if given period contains some/all of the definition's start and end date
+        const periodMatches = common_1.DateHelper.isBetween(this.startDate, period.startDate, period.endDate) ||
+            (this.startDate <= period.endDate &&
+                (!this.endDate || this.endDate >= period.startDate));
+        if (!periodMatches)
+            return null;
+        const defStart = luxon_1.DateTime.fromJSDate(this.startDate);
+        // get the greater from period start date and definition start date
+        // to start counting days from that point forward
+        let date = period.startDate > this.startDate ? luxon_1.DateTime.fromJSDate(period.startDate) : defStart;
+        date = date.set({
+            hour: defStart.hour,
+            minute: defStart.minute,
+            second: defStart.second,
+            millisecond: defStart.millisecond
+        });
+        // weekdays: sorted array of WeekdayNumbers
+        const weekdays = this.weekdays
+            .map(i => common_1.DateHelper.getWeekdayNumber(i))
+            .sort((a, b) => a - b);
+        if (this.repetition && !weekdays?.length) {
+            // to avoid infinite loop, if the definition is repeated, but somehow no weekdays are assigned, return null
+            return null;
+        }
+        // find the first valid appointment date considering weekdays, updates, and skipped dates
+        while (!this.endDate || date.toJSDate() <= this.endDate) {
+            if (weekdays.includes(common_1.DateHelper.toWeekdayNumber(date.weekday))) {
+                const updatedDate = this.getUpdatedDate(date);
+                if (!this.isDateSkipped(updatedDate)) {
+                    return updatedDate;
+                }
+            }
+            // move to the next day
+            date = date.plus({ days: 1 });
+        }
+        return null;
+    }
+    /**
+     * @description Get detailed information about an appointment
+     * @param date - DateTime - is presumed to be related to an appointment in this definition
+     * @param filteredInstructorIds - number - optional - instrucotr id to filter the appointment by
+     * @returns Appointment - appointment information (id, start and end date, instructor information)
+     */
+    async getAppointmentInformation(date, filteredInstructorIds) {
+        date = this.getUpdatedDate(date);
+        const isDeleted = this.isDateSkipped(date);
+        if (isDeleted)
+            return null;
+        const instructorId = this.getAppointmentInstructorId(date);
+        if (filteredInstructorIds?.length && !filteredInstructorIds.includes(instructorId))
+            return null;
+        const instructor = await this.getInstructorById(instructorId);
+        const duration = this.getAppointmentDuration(date);
+        const endDate = date.plus({ minutes: duration });
+        const appointment = new common_1.Appointment({
+            id: this.id,
+            startDate: date.toJSDate(),
+            endDate: endDate.toJSDate(),
+            instructor: instructor
+        });
+        return appointment;
+    }
+    /**
+     * @description Only for repeted definitions (repetition = true)
+     * @description Finds the final date of the appointment, considering any date updates (updates in the startDate)
+     * @description If no date updates are found, the original date will be returned
+     * @param date DateTime - original date of the appointment (default return value, if no date updates are found)
+     * @returns DateTime - final date of the appointment
+     */
+    getUpdatedDate(date) {
+        if (!this.updates?.length)
+            return date;
+        let updates = this.updates.map(i => {
+            return {
+                from: new Date(i.from),
+                to: new Date(i.to)
+            };
+        });
+        updates = updates.filter(i => i.from.getTime() === date.toJSDate().getTime());
+        if (!updates?.length) {
+            return date;
+        }
+        return common_1.DateHelper.toDateTimeInstance(common_1.ArrayHelper.getLastItem(updates).to);
+    }
+    /**
+     * @description Only for repeted definitions (repetition = true)
+     * @description Checks wether or not the appointment related to the given date has been removed from schedule (pushed in the skippedDates array)
+     * @param date DateTime - date of the appointment
+     * @returns DateTime - true if the appointment is skipped, false otherwise
+     */
+    isDateSkipped(date) {
+        if (!this.skippedDates?.length)
+            return false;
+        const exists = this.skippedDates.some(i => new Date(i).getTime() === date.toJSDate().getTime());
+        return exists;
+    }
+    /**
+     * @description Only for repeted definitions (repetition = true)
+     * @description Finds the final duration of the appointment, considering any duration updates
+     * @description If no duration updates are found, this.duration will be returned by default
+     * @param date DateTime - date of the appointment
+     * @returns number - duration of the appointment (in minutes)
+     */
+    getAppointmentDuration(date) {
+        if (!this.durations?.length)
+            return this.duration;
+        const durations = this.durations.filter(i => new Date(i.date).getTime() === date.toJSDate().getTime());
+        if (!durations?.length)
+            return this.duration;
+        return common_1.ArrayHelper.getLastItem(durations).duration;
+    }
+    /**
+     * @description Checks weather or not there is a student with a matching name registered in this schedule for the given appointment
+     * @description Currently only works for flexible course trainings (MVP logic), and will always return false for fixed course trainings
+     * Must be renamed and extended in the future to support fixed course trainings as well, but will remain as is for the sake of MVP Migration
+     * @param appointment Appointment - appointment to check for registered students
+     * @param studentName string - name of the student to check for registration
+     * @returns boolean - Weather or not there a student with the given name registered for the appointment
+     */
+    async isStudentRegistered(appointment, studentName) {
+        const course = await this.getCourse();
+        return await appointment_entity_1.StudentTrainingAppointmentEntity
+            .createQueryBuilder('a')
+            .innerJoin('a.training', 't')
+            .innerJoin('t.course', 'c')
+            .where('c.id = :courseid', { courseId: course.id })
+            .andWhere('c.isFixed = :false', { false: false })
+            .andWhere('a.lessonId = :lessonId', { lessonId: this.lessonId })
+            .andWhere('a.scheduleId = :scheduleId', { scheduleId: this.id })
+            .andWhere('a.startDate = :startDate', { startDate: appointment.startDate })
+            .andWhere(`t.studentSnapshot ->> '$.name' like :studentname`, { studentname: `%${studentName}%` })
+            .getExists();
+    }
+    /**
+     * @description Doesn't check for the definition's endDate, or updates and skippedDates
+     * @returns the next appointment based on repetition logic and weekdays assigned
+     */
+    getNextAppointmentDate(date) {
+        if (!this.weekdays?.length)
+            return null;
+        const startDate = common_1.DateHelper.toDateTimeInstance(this.startDate);
+        // after going to the next day, set the time to the startDate's time
+        // since the param date can be the last appointment's date, and the last appointment's time could've been updated
+        date = date.plus({ days: 1 }).set({
+            hour: startDate.hour,
+            minute: startDate.minute,
+            second: startDate.second,
+            millisecond: startDate.millisecond
+        });
+        // weekdays: sorted array of WeekdayNumbers
+        const weekdays = this.weekdays
+            .map(i => common_1.DateHelper.getWeekdayNumber(i))
+            .sort((a, b) => a - b);
+        while (!weekdays.includes(common_1.DateHelper.toWeekdayNumber(date.weekday))) {
+            date = date.plus({ days: 1 }).set({
+                hour: startDate.hour,
+                minute: startDate.minute,
+                second: startDate.second,
+                millisecond: startDate.millisecond
+            });
+        }
+        return date;
+    }
+    /**
+     * Get the instructor registered for the appointment (works for repeated and single appointments)
+     * @param date Date - the date of the appointment
+     * @returns Instructor - simple instructor model
+     */
+    async getAppointmentInstructor(date) {
+        const instructorId = this.getAppointmentInstructorId(date);
+        return await this.getInstructorById(instructorId);
+    }
+    /**
+     * @param date DateTime - is presumed to belong to an existing appointment
+     * @returns number - instructor id for the appointment of the given date
+     */
+    getAppointmentInstructorId(date) {
+        if (!this.instructors?.length)
+            return this.instructorId;
+        const instructors = this.instructors.filter(i => new Date(i.date).getTime() === date.toJSDate().getTime());
+        if (!instructors?.length)
+            return this.instructorId;
+        return common_1.ArrayHelper.getLastItem(instructors).id;
+    }
+    /**
+     * Find instructor by id and map with simple information to User model
+     * @param id instructor id
+     * @returns Object - For the MVP it returns an object mapped like CompanyInstructorMapper.toSimple with the same interface. should be replaced with Person model in the future
+     */
+    async getInstructorById(id) {
+        const companyInstructor = await instructor_entity_1.CompanyInstructorEntity.findOneBy({ id });
+        if (!companyInstructor)
+            return null;
+        const instructor = await companyInstructor.instructor;
+        const user = await instructor.user;
+        return {
+            id: companyInstructor.id,
+            name: instructor.name,
+            image: instructor.imageUrl,
+            phone: user.phone,
+            role: companyInstructor.role,
+            status: companyInstructor.status,
+            canReinstate: await companyInstructor.canReinstate(),
+            calendarLinks: companyInstructor.calendarLinks || []
+        };
+    }
+    /**
+     * Get total number of appointments that have any update (duration/instructor/date) after the given date
+     * @param from Date - if null, from definition start date
+     * @returns number - total updated appointments
+     */
+    getTotalUpdatedAppointments(from) {
+        if (!from) {
+            from = this.startDate;
+        }
+        const durationExceptions = this.durations?.filter(i => new Date(i.date) > from);
+        const updateExceptions = this.updates?.filter(i => new Date(i.from) > from || new Date(i.to) > from);
+        const instructorExceptions = this.instructors?.filter(i => new Date(i.date) > from);
+        // Collect unique appointment dates that have any exception
+        // This is to avoid counting multiple exceptions for the same appointment more than once
+        // i.e if an appointment has duration and instructor and date (updates) exceptions, it should be counted once, not three times
+        const uniqueExceptionDates = new Set();
+        durationExceptions?.forEach(i => {
+            uniqueExceptionDates.add(new Date(i.date).toISOString());
+        });
+        updateExceptions?.forEach(i => {
+            uniqueExceptionDates.add(new Date(i.to).toISOString());
+        });
+        instructorExceptions?.forEach(i => {
+            uniqueExceptionDates.add(new Date(i.date).toISOString());
+        });
+        // Count unique appointments with exceptions
+        return uniqueExceptionDates.size;
+    }
+    async getRemainingSeats(date) {
+        const lesson = await lesson_entity_1.CompanyCourseLessonEntity.findOneBy({ id: this.lessonId });
+        const course = await lesson.course;
+        if (!course.maxStudents)
+            return;
+        const takenSeats = await this.getTakenSeats(date);
+        return +course.maxStudents - (takenSeats || 0);
+    }
+    /**
+     * This method must be called anytime when definition's endDate is changed to a value other than null/undefined
+     *
+     * Removes all 'updates', 'skippedDates', 'instructors' and 'durations' after the definition's endDate
+     *
+     * - Does not save the definition
+     */
+    removeUpdatesAfterEndDate() {
+        this.updates = (this.updates ?? []).filter(i => new Date(i.from) <= this.endDate);
+        this.skippedDates = (this.skippedDates ?? []).filter(i => new Date(i) <= this.endDate);
+        this.instructors = (this.instructors ?? []).filter(i => new Date(i.date) <= this.endDate);
+        this.durations = (this.durations ?? []).filter(i => new Date(i.date) <= this.endDate);
+        return true;
+    }
+};
+exports.CompanyCourseScheduleEntity = CompanyCourseScheduleEntity;
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", Number)
+], CompanyCourseScheduleEntity.prototype, "lessonId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        nullable: true,
+        default: null
+    }),
+    __metadata("design:type", Number)
+], CompanyCourseScheduleEntity.prototype, "instructorId", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    (0, typeorm_1.Generated)('uuid'),
+    __metadata("design:type", String)
+], CompanyCourseScheduleEntity.prototype, "uid", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", Date)
+], CompanyCourseScheduleEntity.prototype, "startDate", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        nullable: true,
+        default: null
+    }),
+    __metadata("design:type", Date)
+], CompanyCourseScheduleEntity.prototype, "endDate", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ default: 60 }),
+    __metadata("design:type", Number)
+], CompanyCourseScheduleEntity.prototype, "duration", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ default: false }),
+    __metadata("design:type", Boolean)
+], CompanyCourseScheduleEntity.prototype, "repetition", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'simple-json',
+        nullable: true,
+        default: null
+    }),
+    __metadata("design:type", Array)
+], CompanyCourseScheduleEntity.prototype, "weekdays", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'simple-json',
+        nullable: true,
+        default: null
+    }),
+    __metadata("design:type", Array)
+], CompanyCourseScheduleEntity.prototype, "skippedDates", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'simple-json',
+        nullable: true,
+        default: null
+    }),
+    __metadata("design:type", Array)
+], CompanyCourseScheduleEntity.prototype, "updates", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'simple-json',
+        nullable: true,
+        default: null
+    }),
+    __metadata("design:type", Array)
+], CompanyCourseScheduleEntity.prototype, "instructors", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'simple-json',
+        nullable: true,
+        default: null
+    }),
+    __metadata("design:type", Array)
+], CompanyCourseScheduleEntity.prototype, "durations", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => lesson_entity_1.CompanyCourseLessonEntity, lesson => lesson.schedule),
+    __metadata("design:type", Promise)
+], CompanyCourseScheduleEntity.prototype, "lesson", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => instructor_entity_1.CompanyInstructorEntity, lesson => lesson.companyCourseSchedule),
+    __metadata("design:type", Promise)
+], CompanyCourseScheduleEntity.prototype, "instructor", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => appointment_entity_1.StudentTrainingAppointmentEntity, appointment => appointment.schedule),
+    __metadata("design:type", Promise)
+], CompanyCourseScheduleEntity.prototype, "studentSchedule", void 0);
+exports.CompanyCourseScheduleEntity = CompanyCourseScheduleEntity = __decorate([
+    (0, typeorm_1.Entity)('companyCourseSchedules'),
+    __metadata("design:paramtypes", [Object])
+], CompanyCourseScheduleEntity);
+//# sourceMappingURL=schedule.entity.js.map