@kipicore/dbcore 1.1.32 → 1.1.33

package/dist/models/psql/lectureModel.js

@@ -6,471 +6,208 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const sequelize_1 = require("sequelize");
 const index_1 = require("./index");
 const app_1 = require("../../constants/app");
-const userModel_1 = __importDefault(require("./userModel"));
-const instituteModel_1 = __importDefault(require("./instituteModel"));
-const typeManagementModel_1 = __importDefault(require("./typeManagementModel"));
-const workingDayModel_1 = __importDefault(require("./workingDayModel"));
-const classRoomModel_1 = __importDefault(require("./classRoomModel"));
+const userInstituteMetaModel_1 = __importDefault(require("../mongodb/userInstituteMetaModel"));
 const errorMessages_1 = require("../../constants/errorMessages");
-const batchModel_1 = __importDefault(require("./batchModel"));
 const utils_1 = require("../../helpers/utils");
-const instituteEntityModel_1 = __importDefault(require("./instituteEntityModel"));
-const slotModel_1 = __importDefault(require("./slotModel"));
-const workingShiftModel_1 = __importDefault(require("./workingShiftModel"));
-const userHasBatchModel_1 = __importDefault(require("./userHasBatchModel"));
-const userInstituteMetaModel_1 = __importDefault(require("../mongodb/userInstituteMetaModel"));
 class LectureModel extends sequelize_1.Model {
-}
-LectureModel.init({
-    id: {
-        type: sequelize_1.DataTypes.UUID,
-        defaultValue: sequelize_1.DataTypes.UUIDV4,
-        allowNull: false,
-        primaryKey: true,
-    },
-    title: {
-        type: sequelize_1.DataTypes.STRING,
-        allowNull: true,
-        defaultValue: app_1.LECTURE_TITLE.LECTURE,
-    },
-    descriptions: {
-        type: sequelize_1.DataTypes.STRING,
-        allowNull: true,
-    },
-    type: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: true,
-    },
-    slotDuration: {
-        type: sequelize_1.DataTypes.INTEGER,
-        field: 'slot_duration',
-        allowNull: false,
-    },
-    subject: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: true,
-    },
-    startTime: {
-        type: sequelize_1.DataTypes.DATE,
-        field: 'start_time',
-        allowNull: false,
-    },
-    endTime: {
-        type: sequelize_1.DataTypes.DATE,
-        field: 'end_time',
-        allowNull: false,
-    },
-    instituteId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'institute_id',
-        allowNull: true,
-    },
-    classRoomId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'class_room_id',
-        allowNull: true,
-    },
-    groupId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'group_id',
-        allowNull: true,
-    },
-    primaryUserId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'primary_user_id',
-        allowNull: true,
-    },
-    secondaryUserId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'secondary_user_id',
-        allowNull: true,
-    },
-    workingDayId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'working_day_id',
-        allowNull: false,
-    },
-    batchId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'batch_id',
-        allowNull: true,
-    },
-    status: {
-        type: sequelize_1.DataTypes.ENUM,
-        allowNull: false,
-        values: Object.values(app_1.LECTURE_STATUS),
-        defaultValue: app_1.LECTURE_STATUS.NOT_STARTED,
-    },
-    checkedInAt: {
-        type: sequelize_1.DataTypes.DATE,
-        field: 'checked_in_at',
-        allowNull: true,
-    },
-    checkedOutAt: {
-        type: sequelize_1.DataTypes.DATE,
-        field: 'checked_out_at',
-        allowNull: true,
-    },
-    color: {
-        type: sequelize_1.DataTypes.STRING,
-        allowNull: true,
-    },
-    plannerSyncStatus: {
-        type: sequelize_1.DataTypes.STRING,
-        field: 'planner_sync_status',
-        allowNull: true,
-        defaultValue: app_1.PLANNER_SYNC_STATUS.PENDING,
-    },
-    shiftId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'shift_id',
-        allowNull: true,
-    },
-    slotId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'slot_id',
-        allowNull: true,
-    },
-}, {
-    modelName: 'LectureModel',
-    tableName: 'lectures',
-    timestamps: true,
-    sequelize: index_1.sequelize,
-});
-// Associations
-LectureModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-LectureModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-LectureModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-LectureModel.belongsTo(typeManagementModel_1.default, {
-    foreignKey: 'type',
-    as: 'lectureType',
-});
-LectureModel.belongsTo(instituteModel_1.default, {
-    foreignKey: 'instituteId',
-    as: 'institute',
-});
-instituteModel_1.default.hasMany(LectureModel, {
-    foreignKey: 'instituteId',
-    as: 'instituteHasLectures',
-});
-LectureModel.belongsTo(workingDayModel_1.default, {
-    foreignKey: 'workingDayId',
-    as: 'workingDay',
-});
-workingDayModel_1.default.hasMany(LectureModel, {
-    foreignKey: 'workingDayId',
-    as: 'workingDayHasLectures',
-});
-LectureModel.belongsTo(slotModel_1.default, {
-    foreignKey: 'slotId',
-    as: 'lectureSlot',
-});
-slotModel_1.default.hasMany(LectureModel, {
-    foreignKey: 'slotId',
-    as: 'slotLectureList',
-});
-LectureModel.belongsTo(workingShiftModel_1.default, {
-    foreignKey: 'shiftId',
-    as: 'lectureShift',
-});
-workingShiftModel_1.default.hasMany(LectureModel, {
-    foreignKey: 'shiftId',
-    as: 'shiftLectureList',
-});
-LectureModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'primaryUserId',
-        field: 'primary_user_id',
-        allowNull: true,
-    },
-    as: 'user',
-});
-userModel_1.default.hasMany(LectureModel, {
-    foreignKey: {
-        name: 'primaryUserId',
-        field: 'primary_user_id',
-        allowNull: true,
-    },
-    as: 'userHasLectures',
-});
-LectureModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'secondaryUserId',
-        field: 'secondary_user_id',
-        allowNull: true,
-    },
-    as: 'secondaryUser',
-});
-userModel_1.default.hasMany(LectureModel, {
-    foreignKey: {
-        name: 'secondaryUserId',
-        field: 'secondary_user_id',
-        allowNull: true,
-    },
-    as: 'secondaryUserHasLectures',
-});
-LectureModel.belongsTo(classRoomModel_1.default, {
-    foreignKey: 'classRoomId',
-    as: 'classRoom',
-});
-classRoomModel_1.default.hasMany(LectureModel, {
-    foreignKey: 'classRoomId',
-    as: 'classRoomHasLectures',
-});
-LectureModel.belongsTo(batchModel_1.default, {
-    foreignKey: 'batchId',
-    as: 'batch',
-});
-batchModel_1.default.hasMany(LectureModel, {
-    foreignKey: 'batchId',
-    as: 'batchHasLectures',
-});
-LectureModel.belongsTo(instituteEntityModel_1.default, {
-    foreignKey: 'subject',
-    as: 'subjectDetails',
-});
-instituteEntityModel_1.default.hasMany(LectureModel, {
-    foreignKey: 'subject',
-    as: 'subjectHasLectures',
-});
-const beforeCreateOrUpdateHook = async (lecture, transaction = null) => {
-    const options = {};
-    if (transaction)
-        options.transaction = transaction;
-    if (lecture.instituteId) {
-        const institute = await instituteModel_1.default.findByPk(lecture.instituteId);
-        if (!institute) {
-            throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
-        }
-    }
-    if (lecture.workingDayId) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let workingDay = await workingDayModel_1.default.findOne({
-            where: { id: lecture.workingDayId },
-            include: [
-                {
-                    association: 'workingDayShift',
-                    required: false,
-                    include: [{ association: 'shiftSlot', required: false }],
-                },
-            ],
-        });
-        if (!workingDay) {
-            throw new Error(errorMessages_1.WORKING_DAYS_ERROR_MESSAGES.NOT_FOUND);
-        }
-        workingDay = JSON.parse(JSON.stringify(workingDay));
-        if (lecture.slotId) {
-            if (!workingDay.workingDayShift.length)
-                throw new Error(errorMessages_1.SCHOOL_SHIFT_ERROR_MESSAGES.NOT_FOUND);
-            const validShift = workingDay.workingDayShift.find((shift) => shift.slotId === lecture.slotId);
-            if (!validShift) {
-                throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.INVALID_SLOT_OR_SHIFT);
+    static addHooks(models) {
+        const beforeCreateOrUpdateHook = async (lecture, transaction = null) => {
+            const { InstituteModel, WorkingDayModel, ClassRoomModel, UserHasBatchModel, BatchModel, TypeManagementModel, InstituteEntityModel } = models;
+            const options = {};
+            if (transaction)
+                options.transaction = transaction;
+            if (lecture.instituteId) {
+                const institute = await InstituteModel.findByPk(lecture.instituteId);
+                if (!institute)
+                    throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
             }
-            validShift.startTime = new Date(validShift.startTime);
-            validShift.endTime = new Date(validShift.endTime);
-            const isValidStartTime = (0, utils_1.isTimeWithinRange)(lecture.startTime, validShift.startTime, validShift.endTime);
-            const isValidEndTime = (0, utils_1.isTimeWithinRange)(lecture.endTime, validShift.startTime, validShift.endTime);
-            if (!isValidStartTime || !isValidEndTime) {
-                throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.INVALID_LECTURE_TIME);
+            if (lecture.workingDayId) {
+                let workingDay = await WorkingDayModel.findOne({
+                    where: { id: lecture.workingDayId },
+                    include: [
+                        {
+                            association: 'workingDayShift',
+                            required: false,
+                            include: [{ association: 'shiftSlot', required: false }],
+                        },
+                    ],
+                });
+                if (!workingDay)
+                    throw new Error(errorMessages_1.WORKING_DAYS_ERROR_MESSAGES.NOT_FOUND);
+                workingDay = JSON.parse(JSON.stringify(workingDay));
+                if (lecture.slotId) {
+                    if (!workingDay.workingDayShift.length)
+                        throw new Error(errorMessages_1.SCHOOL_SHIFT_ERROR_MESSAGES.NOT_FOUND);
+                    const validShift = workingDay.workingDayShift.find((shift) => shift.slotId === lecture.slotId);
+                    if (!validShift)
+                        throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.INVALID_SLOT_OR_SHIFT);
+                    validShift.startTime = new Date(validShift.startTime);
+                    validShift.endTime = new Date(validShift.endTime);
+                    const isValidStartTime = (0, utils_1.isTimeWithinRange)(lecture.startTime, validShift.startTime, validShift.endTime);
+                    const isValidEndTime = (0, utils_1.isTimeWithinRange)(lecture.endTime, validShift.startTime, validShift.endTime);
+                    if (!isValidStartTime || !isValidEndTime)
+                        throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.INVALID_LECTURE_TIME);
+                }
+                else {
+                    workingDay.startTime = new Date(workingDay.startTime);
+                    workingDay.endTime = new Date(workingDay.endTime);
+                    const isValidStartTime = (0, utils_1.isTimeWithinRange)(lecture.startTime, workingDay.startTime, workingDay.endTime);
+                    const isValidEndTime = (0, utils_1.isTimeWithinRange)(lecture.endTime, workingDay.startTime, workingDay.endTime);
+                    if (!isValidStartTime || !isValidEndTime)
+                        throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.INVALID_LECTURE_TIME);
+                }
             }
-        }
-        else {
-            workingDay.startTime = new Date(workingDay.startTime);
-            workingDay.endTime = new Date(workingDay.endTime);
-            const isValidStartTime = (0, utils_1.isTimeWithinRange)(lecture.startTime, workingDay.startTime, workingDay.endTime);
-            const isValidEndTime = (0, utils_1.isTimeWithinRange)(lecture.endTime, workingDay.startTime, workingDay.endTime);
-            if (!isValidStartTime || !isValidEndTime) {
-                throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.INVALID_LECTURE_TIME);
+            if (lecture.classRoomId) {
+                const classRoom = await ClassRoomModel.findByPk(lecture.classRoomId);
+                if (!classRoom)
+                    throw new Error(errorMessages_1.CLASSROOM_ERROR_MESSAGES.NOT_FOUND);
             }
-        }
-    }
-    // Validate the classRoomId
-    if (lecture.classRoomId) {
-        const classRoom = await classRoomModel_1.default.findByPk(lecture.classRoomId);
-        if (!classRoom) {
-            throw new Error(errorMessages_1.CLASSROOM_ERROR_MESSAGES.NOT_FOUND);
-        }
-    }
-    // Validate the primaryUserId
-    if (lecture.primaryUserId) {
-        if (!lecture.batchId)
-            throw new Error(errorMessages_1.BATCH_ERROR_MESSAGES.NOT_FOUND);
-        const batchWhere = {
-            batchId: lecture.batchId,
-            userId: lecture.primaryUserId,
-        };
-        if (lecture.subject)
-            batchWhere.subjects = { [sequelize_1.Op.overlap]: [lecture.subject] };
-        const user = await userHasBatchModel_1.default.findOne({
-            where: batchWhere,
-            ...options,
-            include: [{ association: 'user', where: { type: app_1.USER_TYPES.TEACHER } }],
-        });
-        if (!user) {
-            throw new Error(errorMessages_1.BATCH_ERROR_MESSAGES.INVALID_SELECTED);
-        }
-    }
-    // Validate the secondaryUserId
-    // if (lecture.secondaryUserId) {
-    //     if (!lecture.batchId) throw new Error(BATCH_ERROR_MESSAGES.NOT_FOUND);
-    //     const batchWhere: WhereOptions = {
-    //         batchId: lecture.batchId,
-    //         userId: lecture.secondaryUserId,
-    //     };
-    //     if (lecture.subject) batchWhere.subjects = { [Op.overlap]: [lecture.subject] };
-    //     const user = await userHasBatchService.findOne(batchWhere, { include: [{ association: 'user', where: { type: USER_TYPES.TEACHER } }] });
-    //     if (!user) {
-    //         throw new Error(BATCH_ERROR_MESSAGES.INVALID_SELECTED);
-    //     }
-    // }
-    if (lecture.workingDayId && lecture.startTime && lecture.endTime) {
-        let where = {
-            [sequelize_1.Op.or]: [
-                {
-                    [sequelize_1.Op.and]: [{ startTime: { [sequelize_1.Op.lte]: lecture.startTime } }, { endTime: { [sequelize_1.Op.gt]: lecture.startTime } }],
-                },
-                {
-                    [sequelize_1.Op.and]: [{ startTime: { [sequelize_1.Op.lt]: lecture.endTime } }, { endTime: { [sequelize_1.Op.gte]: lecture.endTime } }],
-                },
-                {
-                    [sequelize_1.Op.and]: [{ startTime: { [sequelize_1.Op.gte]: lecture.startTime } }, { endTime: { [sequelize_1.Op.lte]: lecture.endTime } }],
-                },
-            ],
-            instituteId: lecture.instituteId,
-            workingDayId: lecture.workingDayId,
-        };
-        if (lecture.id)
-            where = { ...where, id: { [sequelize_1.Op.ne]: lecture.id } };
-        // if (lecture.batchId) where = { ...where, batchId: lecture.batchId };
-        // if (lecture.classRoomId) where = { ...where, classRoomId: lecture.classRoomId };
-        // const existLecture = await LectureModel.findOne({ where });
-        // if (existLecture) throw new Error(LECTURE_ERROR_MESSAGES.DUPLICATE);
-        if (lecture.batchId) {
-            if (lecture.slotId)
-                where.slotId = lecture.slotId;
-            const batchConflict = await LectureModel.findOne({
-                where: {
-                    ...where,
+            if (lecture.primaryUserId) {
+                if (!lecture.batchId)
+                    throw new Error(errorMessages_1.BATCH_ERROR_MESSAGES.NOT_FOUND);
+                const batchWhere = {
                     batchId: lecture.batchId,
-                },
-                ...options,
-            });
-            if (batchConflict)
-                throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.BATCH_OCCUPIED);
-        }
-        if (lecture.classRoomId) {
-            const classRoomConflict = await LectureModel.findOne({
-                where: {
-                    ...where,
-                    classRoomId: lecture.classRoomId,
-                },
-                ...options,
-            });
-            if (classRoomConflict)
-                throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.CLASSROOM_OCCUPIED);
-        }
-        if (lecture.primaryUserId) {
-            const teacherConflict = await LectureModel.findOne({
-                where: {
-                    ...where,
-                    primaryUserId: lecture.primaryUserId,
-                },
-                ...options,
-            });
-            if (teacherConflict)
-                throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.TEACHER_OCCUPIED);
-        }
-        if (lecture.secondaryUserId) {
-            const teacherConflict = await LectureModel.findOne({
-                where: {
-                    ...where,
-                    secondaryUserId: lecture.secondaryUserId,
-                },
-                ...options,
-            });
-            if (teacherConflict)
-                throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.TEACHER_OCCUPIED);
-        }
-    }
-    // Validate the batchId
-    if (lecture.batchId) {
-        const batchWhere = {
-            id: lecture.batchId,
+                    userId: lecture.primaryUserId,
+                };
+                if (lecture.subject)
+                    batchWhere.subjects = { [sequelize_1.Op.overlap]: [lecture.subject] };
+                const user = await UserHasBatchModel.findOne({
+                    where: batchWhere,
+                    ...options,
+                    include: [{ association: 'user', where: { type: app_1.USER_TYPES.TEACHER } }],
+                });
+                if (!user)
+                    throw new Error(errorMessages_1.BATCH_ERROR_MESSAGES.INVALID_SELECTED);
+            }
+            if (lecture.workingDayId && lecture.startTime && lecture.endTime) {
+                let where = {
+                    [sequelize_1.Op.or]: [
+                        { [sequelize_1.Op.and]: [{ startTime: { [sequelize_1.Op.lte]: lecture.startTime } }, { endTime: { [sequelize_1.Op.gt]: lecture.startTime } }] },
+                        { [sequelize_1.Op.and]: [{ startTime: { [sequelize_1.Op.lt]: lecture.endTime } }, { endTime: { [sequelize_1.Op.gte]: lecture.endTime } }] },
+                        { [sequelize_1.Op.and]: [{ startTime: { [sequelize_1.Op.gte]: lecture.startTime } }, { endTime: { [sequelize_1.Op.lte]: lecture.endTime } }] },
+                    ],
+                    instituteId: lecture.instituteId,
+                    workingDayId: lecture.workingDayId,
+                };
+                if (lecture.id)
+                    where = { ...where, id: { [sequelize_1.Op.ne]: lecture.id } };
+                if (lecture.batchId) {
+                    if (lecture.slotId)
+                        where.slotId = lecture.slotId;
+                    const batchConflict = await LectureModel.findOne({ where: { ...where, batchId: lecture.batchId }, ...options });
+                    if (batchConflict)
+                        throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.BATCH_OCCUPIED);
+                }
+                if (lecture.classRoomId) {
+                    const classRoomConflict = await LectureModel.findOne({ where: { ...where, classRoomId: lecture.classRoomId }, ...options });
+                    if (classRoomConflict)
+                        throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.CLASSROOM_OCCUPIED);
+                }
+                if (lecture.primaryUserId) {
+                    const teacherConflict = await LectureModel.findOne({ where: { ...where, primaryUserId: lecture.primaryUserId }, ...options });
+                    if (teacherConflict)
+                        throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.TEACHER_OCCUPIED);
+                }
+                if (lecture.secondaryUserId) {
+                    const teacherConflict = await LectureModel.findOne({ where: { ...where, secondaryUserId: lecture.secondaryUserId }, ...options });
+                    if (teacherConflict)
+                        throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.TEACHER_OCCUPIED);
+                }
+            }
+            if (lecture.batchId) {
+                const batchWhere = { id: lecture.batchId };
+                if (lecture.shiftId)
+                    batchWhere.shiftId = lecture.shiftId;
+                const batch = await BatchModel.findOne({ where: batchWhere, ...options });
+                if (!batch)
+                    throw new Error(errorMessages_1.BATCH_ERROR_MESSAGES.NOT_FOUND);
+            }
+            if (lecture.type) {
+                const type = await TypeManagementModel.findOne({ where: { id: lecture.type, type: app_1.TYPE_MANAGEMENT_TYPE.LECTURE } });
+                if (!type)
+                    throw new Error(errorMessages_1.TYPE_MANAGEMENT_ERROR_MESSAGES.NOT_FOUND);
+            }
+            if (lecture.subject) {
+                const subject = await InstituteEntityModel.findOne({
+                    where: { id: lecture.subject },
+                    include: [{ association: 'entityType', where: { sequence: app_1.INSTITUTE_ENTITY_TYPE_SEQUENCE.LAST } }],
+                });
+                if (!subject)
+                    throw new Error(errorMessages_1.INSTITUTE_ENTITY_ERROR_MESSAGES.NOT_FOUND);
+                const existSubjectInMeta = await userInstituteMetaModel_1.default.findOne({ entities: lecture.subject });
+                if (!existSubjectInMeta)
+                    throw new Error(errorMessages_1.INSTITUTE_ENTITY_ERROR_MESSAGES.NOT_FOUND);
+            }
         };
-        if (lecture.shiftId)
-            batchWhere.shiftId = lecture.shiftId;
-        const batch = await batchModel_1.default.findOne({ where: batchWhere, ...options });
-        if (!batch) {
-            throw new Error(errorMessages_1.BATCH_ERROR_MESSAGES.NOT_FOUND);
-        }
-    }
-    // Validate the type
-    if (lecture.type) {
-        const type = await typeManagementModel_1.default.findOne({
-            where: {
-                id: lecture.type,
-                type: app_1.TYPE_MANAGEMENT_TYPE.LECTURE,
-            },
+        LectureModel.beforeCreate(async (instance, options) => {
+            const transaction = options.transaction || null;
+            await beforeCreateOrUpdateHook(instance, transaction);
         });
-        if (!type) {
-            throw new Error(errorMessages_1.TYPE_MANAGEMENT_ERROR_MESSAGES.NOT_FOUND);
-        }
-    }
-    // Validate the workingDayId
-    if (lecture.subject) {
-        const subject = await instituteEntityModel_1.default.findOne({
-            where: { id: lecture.subject },
-            include: [
-                {
-                    association: 'entityType',
-                    where: { sequence: app_1.INSTITUTE_ENTITY_TYPE_SEQUENCE.LAST },
-                },
-            ],
+        LectureModel.beforeBulkUpdate(async (options) => {
+            const transaction = options.transaction || null;
+            await beforeCreateOrUpdateHook(options.attributes, transaction);
         });
-        if (!subject) {
-            throw new Error(errorMessages_1.INSTITUTE_ENTITY_ERROR_MESSAGES.NOT_FOUND);
-        }
-        const existSubjectInMeta = await userInstituteMetaModel_1.default.findOne({
-            entities: lecture.subject,
+        LectureModel.beforeBulkCreate(async (instances, options) => {
+            const transaction = options.transaction || null;
+            for (const instance of instances) {
+                await beforeCreateOrUpdateHook(instance, transaction);
+            }
         });
-        if (!existSubjectInMeta) {
-            throw new Error(errorMessages_1.INSTITUTE_ENTITY_ERROR_MESSAGES.NOT_FOUND);
-        }
     }
-};
-LectureModel.beforeCreate(async (instance, options) => {
-    const transaction = options.transaction || null;
-    await beforeCreateOrUpdateHook(instance, transaction);
-});
-LectureModel.beforeBulkUpdate(async (options) => {
-    const transaction = options.transaction || null;
-    await beforeCreateOrUpdateHook(options.attributes, transaction);
-});
-LectureModel.beforeBulkCreate(async (instances, options) => {
-    const transaction = options.transaction || null;
-    for (const instance of instances) {
-        await beforeCreateOrUpdateHook(instance, transaction);
+    static associate(models) {
+        const { UserModel, TypeManagementModel, InstituteModel, WorkingDayModel, SlotModel, WorkingShiftModel, ClassRoomModel, BatchModel, InstituteEntityModel, } = models;
+        LectureModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+        LectureModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+        LectureModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        LectureModel.belongsTo(TypeManagementModel, { foreignKey: 'type', as: 'lectureType' });
+        LectureModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        InstituteModel.hasMany(LectureModel, { foreignKey: 'instituteId', as: 'instituteHasLectures' });
+        LectureModel.belongsTo(WorkingDayModel, { foreignKey: 'workingDayId', as: 'workingDay' });
+        WorkingDayModel.hasMany(LectureModel, { foreignKey: 'workingDayId', as: 'workingDayHasLectures' });
+        LectureModel.belongsTo(SlotModel, { foreignKey: 'slotId', as: 'lectureSlot' });
+        SlotModel.hasMany(LectureModel, { foreignKey: 'slotId', as: 'slotLectureList' });
+        LectureModel.belongsTo(WorkingShiftModel, { foreignKey: 'shiftId', as: 'lectureShift' });
+        WorkingShiftModel.hasMany(LectureModel, { foreignKey: 'shiftId', as: 'shiftLectureList' });
+        LectureModel.belongsTo(UserModel, { foreignKey: { name: 'primaryUserId', field: 'primary_user_id', allowNull: true }, as: 'user' });
+        UserModel.hasMany(LectureModel, { foreignKey: { name: 'primaryUserId', field: 'primary_user_id', allowNull: true }, as: 'userHasLectures' });
+        LectureModel.belongsTo(UserModel, {
+            foreignKey: { name: 'secondaryUserId', field: 'secondary_user_id', allowNull: true },
+            as: 'secondaryUser',
+        });
+        UserModel.hasMany(LectureModel, {
+            foreignKey: { name: 'secondaryUserId', field: 'secondary_user_id', allowNull: true },
+            as: 'secondaryUserHasLectures',
+        });
+        LectureModel.belongsTo(ClassRoomModel, { foreignKey: 'classRoomId', as: 'classRoom' });
+        ClassRoomModel.hasMany(LectureModel, { foreignKey: 'classRoomId', as: 'classRoomHasLectures' });
+        LectureModel.belongsTo(BatchModel, { foreignKey: 'batchId', as: 'batch' });
+        BatchModel.hasMany(LectureModel, { foreignKey: 'batchId', as: 'batchHasLectures' });
+        LectureModel.belongsTo(InstituteEntityModel, { foreignKey: 'subject', as: 'subjectDetails' });
+        InstituteEntityModel.hasMany(LectureModel, { foreignKey: 'subject', as: 'subjectHasLectures' });
     }
-});
+}
+LectureModel.init({
+    id: { type: sequelize_1.DataTypes.UUID, defaultValue: sequelize_1.DataTypes.UUIDV4, allowNull: false, primaryKey: true },
+    title: { type: sequelize_1.DataTypes.STRING, allowNull: true, defaultValue: app_1.LECTURE_TITLE.LECTURE },
+    descriptions: { type: sequelize_1.DataTypes.STRING, allowNull: true },
+    type: { type: sequelize_1.DataTypes.UUID, allowNull: true },
+    slotDuration: { type: sequelize_1.DataTypes.INTEGER, field: 'slot_duration', allowNull: false },
+    subject: { type: sequelize_1.DataTypes.UUID, allowNull: true },
+    startTime: { type: sequelize_1.DataTypes.DATE, field: 'start_time', allowNull: false },
+    endTime: { type: sequelize_1.DataTypes.DATE, field: 'end_time', allowNull: false },
+    instituteId: { type: sequelize_1.DataTypes.UUID, field: 'institute_id', allowNull: true },
+    classRoomId: { type: sequelize_1.DataTypes.UUID, field: 'class_room_id', allowNull: true },
+    groupId: { type: sequelize_1.DataTypes.UUID, field: 'group_id', allowNull: true },
+    primaryUserId: { type: sequelize_1.DataTypes.UUID, field: 'primary_user_id', allowNull: true },
+    secondaryUserId: { type: sequelize_1.DataTypes.UUID, field: 'secondary_user_id', allowNull: true },
+    workingDayId: { type: sequelize_1.DataTypes.UUID, field: 'working_day_id', allowNull: false },
+    batchId: { type: sequelize_1.DataTypes.UUID, field: 'batch_id', allowNull: true },
+    status: { type: sequelize_1.DataTypes.ENUM, allowNull: false, values: Object.values(app_1.LECTURE_STATUS), defaultValue: app_1.LECTURE_STATUS.NOT_STARTED },
+    checkedInAt: { type: sequelize_1.DataTypes.DATE, field: 'checked_in_at', allowNull: true },
+    checkedOutAt: { type: sequelize_1.DataTypes.DATE, field: 'checked_out_at', allowNull: true },
+    color: { type: sequelize_1.DataTypes.STRING, allowNull: true },
+    plannerSyncStatus: { type: sequelize_1.DataTypes.STRING, field: 'planner_sync_status', allowNull: true, defaultValue: app_1.PLANNER_SYNC_STATUS.PENDING },
+    shiftId: { type: sequelize_1.DataTypes.UUID, field: 'shift_id', allowNull: true },
+    slotId: { type: sequelize_1.DataTypes.UUID, field: 'slot_id', allowNull: true },
+}, { modelName: 'LectureModel', tableName: 'lectures', timestamps: true, sequelize: index_1.sequelize });
 exports.default = LectureModel;