@kipicore/dbcore 1.1.13 → 1.1.14

package/dist/esm/models/psql/lectureModel.js

@@ -0,0 +1,471 @@
+import { DataTypes, Model, Op } from 'sequelize';
+import { sequelize } from './index.js';
+import { INSTITUTE_ENTITY_TYPE_SEQUENCE, LECTURE_STATUS, LECTURE_TITLE, PLANNER_SYNC_STATUS, TYPE_MANAGEMENT_TYPE, USER_TYPES, } from '../../constants/app.js';
+import UserModel from './userModel.js';
+import InstituteModel from './instituteModel.js';
+import TypeManagementModel from './typeManagementModel.js';
+import WorkingDayModel from './workingDayModel.js';
+import ClassRoomModel from './classRoomModel.js';
+import { BATCH_ERROR_MESSAGES, CLASSROOM_ERROR_MESSAGES, INSTITUTE_ENTITY_ERROR_MESSAGES, INSTITUTE_ERROR_MESSAGES, LECTURE_ERROR_MESSAGES, SCHOOL_SHIFT_ERROR_MESSAGES, TYPE_MANAGEMENT_ERROR_MESSAGES, WORKING_DAYS_ERROR_MESSAGES, } from '../../constants/errorMessages.js';
+import BatchModel from './batchModel.js';
+import { isTimeWithinRange } from '../../helpers/utils.js';
+import InstituteEntityModel from './instituteEntityModel.js';
+import SlotModel from './slotModel.js';
+import WorkingShiftModel from './workingShiftModel.js';
+import UserHasBatchModel from './userHasBatchModel.js';
+import UserInstituteMeta from '../mongodb/userInstituteMetaModel.js';
+class LectureModel extends Model {
+}
+LectureModel.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    title: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        defaultValue: LECTURE_TITLE.LECTURE,
+    },
+    descriptions: {
+        type: DataTypes.STRING,
+        allowNull: true,
+    },
+    type: {
+        type: DataTypes.UUID,
+        allowNull: true,
+    },
+    slotDuration: {
+        type: DataTypes.INTEGER,
+        field: 'slot_duration',
+        allowNull: false,
+    },
+    subject: {
+        type: DataTypes.UUID,
+        allowNull: true,
+    },
+    startTime: {
+        type: DataTypes.DATE,
+        field: 'start_time',
+        allowNull: false,
+    },
+    endTime: {
+        type: DataTypes.DATE,
+        field: 'end_time',
+        allowNull: false,
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        field: 'institute_id',
+        allowNull: true,
+    },
+    classRoomId: {
+        type: DataTypes.UUID,
+        field: 'class_room_id',
+        allowNull: true,
+    },
+    groupId: {
+        type: DataTypes.UUID,
+        field: 'group_id',
+        allowNull: true,
+    },
+    primaryUserId: {
+        type: DataTypes.UUID,
+        field: 'primary_user_id',
+        allowNull: true,
+    },
+    secondaryUserId: {
+        type: DataTypes.UUID,
+        field: 'secondary_user_id',
+        allowNull: true,
+    },
+    workingDayId: {
+        type: DataTypes.UUID,
+        field: 'working_day_id',
+        allowNull: false,
+    },
+    batchId: {
+        type: DataTypes.UUID,
+        field: 'batch_id',
+        allowNull: true,
+    },
+    status: {
+        type: DataTypes.ENUM,
+        allowNull: false,
+        values: Object.values(LECTURE_STATUS),
+        defaultValue: LECTURE_STATUS.NOT_STARTED,
+    },
+    checkedInAt: {
+        type: DataTypes.DATE,
+        field: 'checked_in_at',
+        allowNull: true,
+    },
+    checkedOutAt: {
+        type: DataTypes.DATE,
+        field: 'checked_out_at',
+        allowNull: true,
+    },
+    color: {
+        type: DataTypes.STRING,
+        allowNull: true,
+    },
+    plannerSyncStatus: {
+        type: DataTypes.STRING,
+        field: 'planner_sync_status',
+        allowNull: true,
+        defaultValue: PLANNER_SYNC_STATUS.PENDING,
+    },
+    shiftId: {
+        type: DataTypes.UUID,
+        field: 'shift_id',
+        allowNull: true,
+    },
+    slotId: {
+        type: DataTypes.UUID,
+        field: 'slot_id',
+        allowNull: true,
+    },
+}, {
+    modelName: 'LectureModel',
+    tableName: 'lectures',
+    timestamps: true,
+    sequelize,
+});
+// Associations
+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',
+});
+const beforeCreateOrUpdateHook = async (lecture, transaction = null) => {
+    const options = {};
+    if (transaction)
+        options.transaction = transaction;
+    if (lecture.instituteId) {
+        const institute = await InstituteModel.findByPk(lecture.instituteId);
+        if (!institute) {
+            throw new Error(INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+        }
+    }
+    if (lecture.workingDayId) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let workingDay = await WorkingDayModel.findOne({
+            where: { id: lecture.workingDayId },
+            include: [
+                {
+                    association: 'workingDayShift',
+                    required: false,
+                    include: [{ association: 'shiftSlot', required: false }],
+                },
+            ],
+        });
+        if (!workingDay) {
+            throw new Error(WORKING_DAYS_ERROR_MESSAGES.NOT_FOUND);
+        }
+        workingDay = JSON.parse(JSON.stringify(workingDay));
+        if (lecture.slotId) {
+            if (!workingDay.workingDayShift.length)
+                throw new Error(SCHOOL_SHIFT_ERROR_MESSAGES.NOT_FOUND);
+            const validShift = workingDay.workingDayShift.find((shift) => shift.slotId === lecture.slotId);
+            if (!validShift) {
+                throw new Error(LECTURE_ERROR_MESSAGES.INVALID_SLOT_OR_SHIFT);
+            }
+            validShift.startTime = new Date(validShift.startTime);
+            validShift.endTime = new Date(validShift.endTime);
+            const isValidStartTime = isTimeWithinRange(lecture.startTime, validShift.startTime, validShift.endTime);
+            const isValidEndTime = isTimeWithinRange(lecture.endTime, validShift.startTime, validShift.endTime);
+            if (!isValidStartTime || !isValidEndTime) {
+                throw new Error(LECTURE_ERROR_MESSAGES.INVALID_LECTURE_TIME);
+            }
+        }
+        else {
+            workingDay.startTime = new Date(workingDay.startTime);
+            workingDay.endTime = new Date(workingDay.endTime);
+            const isValidStartTime = isTimeWithinRange(lecture.startTime, workingDay.startTime, workingDay.endTime);
+            const isValidEndTime = isTimeWithinRange(lecture.endTime, workingDay.startTime, workingDay.endTime);
+            if (!isValidStartTime || !isValidEndTime) {
+                throw new Error(LECTURE_ERROR_MESSAGES.INVALID_LECTURE_TIME);
+            }
+        }
+    }
+    // Validate the classRoomId
+    if (lecture.classRoomId) {
+        const classRoom = await ClassRoomModel.findByPk(lecture.classRoomId);
+        if (!classRoom) {
+            throw new Error(CLASSROOM_ERROR_MESSAGES.NOT_FOUND);
+        }
+    }
+    // Validate the primaryUserId
+    if (lecture.primaryUserId) {
+        if (!lecture.batchId)
+            throw new Error(BATCH_ERROR_MESSAGES.NOT_FOUND);
+        const batchWhere = {
+            batchId: lecture.batchId,
+            userId: lecture.primaryUserId,
+        };
+        if (lecture.subject)
+            batchWhere.subjects = { [Op.overlap]: [lecture.subject] };
+        const user = await UserHasBatchModel.findOne({
+            where: batchWhere,
+            ...options,
+            include: [{ association: 'user', where: { type: USER_TYPES.TEACHER } }],
+        });
+        if (!user) {
+            throw new Error(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 = {
+            [Op.or]: [
+                {
+                    [Op.and]: [{ startTime: { [Op.lte]: lecture.startTime } }, { endTime: { [Op.gt]: lecture.startTime } }],
+                },
+                {
+                    [Op.and]: [{ startTime: { [Op.lt]: lecture.endTime } }, { endTime: { [Op.gte]: lecture.endTime } }],
+                },
+                {
+                    [Op.and]: [{ startTime: { [Op.gte]: lecture.startTime } }, { endTime: { [Op.lte]: lecture.endTime } }],
+                },
+            ],
+            instituteId: lecture.instituteId,
+            workingDayId: lecture.workingDayId,
+        };
+        if (lecture.id)
+            where = { ...where, id: { [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,
+                    batchId: lecture.batchId,
+                },
+                ...options,
+            });
+            if (batchConflict)
+                throw new Error(LECTURE_ERROR_MESSAGES.BATCH_OCCUPIED);
+        }
+        if (lecture.classRoomId) {
+            const classRoomConflict = await LectureModel.findOne({
+                where: {
+                    ...where,
+                    classRoomId: lecture.classRoomId,
+                },
+                ...options,
+            });
+            if (classRoomConflict)
+                throw new Error(LECTURE_ERROR_MESSAGES.CLASSROOM_OCCUPIED);
+        }
+        if (lecture.primaryUserId) {
+            const teacherConflict = await LectureModel.findOne({
+                where: {
+                    ...where,
+                    primaryUserId: lecture.primaryUserId,
+                },
+                ...options,
+            });
+            if (teacherConflict)
+                throw new Error(LECTURE_ERROR_MESSAGES.TEACHER_OCCUPIED);
+        }
+        if (lecture.secondaryUserId) {
+            const teacherConflict = await LectureModel.findOne({
+                where: {
+                    ...where,
+                    secondaryUserId: lecture.secondaryUserId,
+                },
+                ...options,
+            });
+            if (teacherConflict)
+                throw new Error(LECTURE_ERROR_MESSAGES.TEACHER_OCCUPIED);
+        }
+    }
+    // Validate the batchId
+    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(BATCH_ERROR_MESSAGES.NOT_FOUND);
+        }
+    }
+    // Validate the type
+    if (lecture.type) {
+        const type = await TypeManagementModel.findOne({
+            where: {
+                id: lecture.type,
+                type: TYPE_MANAGEMENT_TYPE.LECTURE,
+            },
+        });
+        if (!type) {
+            throw new Error(TYPE_MANAGEMENT_ERROR_MESSAGES.NOT_FOUND);
+        }
+    }
+    // Validate the workingDayId
+    if (lecture.subject) {
+        const subject = await InstituteEntityModel.findOne({
+            where: { id: lecture.subject },
+            include: [
+                {
+                    association: 'entityType',
+                    where: { sequence: INSTITUTE_ENTITY_TYPE_SEQUENCE.LAST },
+                },
+            ],
+        });
+        if (!subject) {
+            throw new Error(INSTITUTE_ENTITY_ERROR_MESSAGES.NOT_FOUND);
+        }
+        const existSubjectInMeta = await UserInstituteMeta.findOne({
+            entities: lecture.subject,
+        });
+        if (!existSubjectInMeta) {
+            throw new Error(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);
+    }
+});
+export default LectureModel;

package/dist/esm/models/psql/masterLeaveModel.d.ts

@@ -0,0 +1,22 @@
+import { Model } from 'sequelize';
+import { IMasterLeaveModelAttributes } from '../../interfaces/masterLeaveInterface.js';
+import { TMasterLeaveModelCreationAttributes } from '../../types/masterLeaveType.js';
+import { COMMAN_STATUS, LEAVE, TERM_DURATION } from '../../constants/app.js';
+declare class MasterLeaveModel extends Model<IMasterLeaveModelAttributes, TMasterLeaveModelCreationAttributes> {
+    id: string;
+    totalLeave: number;
+    instituteId: string;
+    typeManagementId: string;
+    termDuration: TERM_DURATION;
+    startTermDuration: Date;
+    endTermDuration: Date;
+    leave: LEAVE;
+    status: COMMAN_STATUS;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default MasterLeaveModel;

package/dist/esm/models/psql/masterLeaveModel.js

@@ -0,0 +1,126 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index.js';
+import { COMMAN_STATUS, LEAVE, TERM_DURATION, TYPE_MANAGEMENT_TYPE } from '../../constants/app.js';
+import InstituteModel from './instituteModel.js';
+import UserModel from './userModel.js';
+import TypeManagementModel from './typeManagementModel.js';
+import { MASTER_LEAVE_ERROR_MESSAGES } from '../../constants/errorMessages.js';
+class MasterLeaveModel extends Model {
+}
+MasterLeaveModel.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    totalLeave: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    typeManagementId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    termDuration: {
+        type: DataTypes.ENUM,
+        values: Object.values(TERM_DURATION),
+        defaultValue: TERM_DURATION.YEARLY,
+        allowNull: false,
+    },
+    leave: {
+        type: DataTypes.ENUM,
+        values: Object.values(LEAVE),
+        defaultValue: LEAVE.PAID,
+        allowNull: false,
+    },
+    status: {
+        type: DataTypes.ENUM,
+        values: Object.values(COMMAN_STATUS),
+        defaultValue: COMMAN_STATUS.ACTIVE,
+        allowNull: false,
+    },
+    startTermDuration: {
+        type: DataTypes.DATE,
+        allowNull: true,
+    },
+    endTermDuration: {
+        type: DataTypes.DATE,
+        allowNull: true,
+    },
+}, {
+    modelName: 'MasterLeaveModel',
+    tableName: 'master_leaves',
+    timestamps: true,
+    sequelize,
+});
+const validateAndCalculate = async (instance) => {
+    try {
+        if (instance.typeManagementId) {
+            const typeManagement = await TypeManagementModel.findByPk(instance.typeManagementId);
+            if (!typeManagement || typeManagement.type !== TYPE_MANAGEMENT_TYPE.LEAVE) {
+                throw new Error(MASTER_LEAVE_ERROR_MESSAGES.INVALID_TYPE_MANAGEMENT_ID);
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+};
+MasterLeaveModel.beforeCreate(async (instance) => {
+    await validateAndCalculate(instance);
+});
+MasterLeaveModel.beforeBulkUpdate(async (instance) => {
+    await validateAndCalculate(instance.attributes);
+});
+MasterLeaveModel.belongsTo(InstituteModel, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'leaveInstitute',
+});
+InstituteModel.hasMany(MasterLeaveModel, {
+    foreignKey: 'instituteId',
+    as: 'instituteHasLeaves',
+});
+MasterLeaveModel.belongsTo(TypeManagementModel, {
+    foreignKey: {
+        name: 'typeManagementId',
+        field: 'type_management_id',
+    },
+    as: 'leaveTypeManagement',
+});
+TypeManagementModel.hasMany(MasterLeaveModel, {
+    foreignKey: 'typeManagementId',
+    as: 'typeManagementHasLeaves',
+});
+MasterLeaveModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+MasterLeaveModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+MasterLeaveModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+export default MasterLeaveModel;

package/dist/esm/models/psql/moduleFeatureModel.d.ts

@@ -0,0 +1,21 @@
+import { Model } from 'sequelize';
+import { APP_TYPE, COMMAN_STATUS } from '../../constants/app.js';
+import { IModuleFeatureAttributes } from '../../interfaces/moduleFeatureInterface.js';
+import { TModuleFeatureCreationAttributes } from '../../types/moduleFeatureType.js';
+declare class ModuleFeatureModel extends Model<IModuleFeatureAttributes, TModuleFeatureCreationAttributes> {
+    id: string;
+    name: string;
+    status: COMMAN_STATUS;
+    isDefault: boolean;
+    appType: APP_TYPE;
+    roleId: string;
+    moduleId: string;
+    code: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default ModuleFeatureModel;