@kipicore/dbcore 1.0.3

package/dist/models/psql/feeHistoryModel.js

@@ -0,0 +1,334 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+const userModel_1 = __importDefault(require("./userModel"));
+const instituteModel_1 = __importDefault(require("./instituteModel"));
+const app_1 = require("../../constants/app");
+const errorMessages_1 = require("../../constants/errorMessages");
+const feesCollectionModel_1 = __importDefault(require("./feesCollectionModel"));
+const fileStorageModel_1 = __importDefault(require("./fileStorageModel"));
+const bankAccountDetailsModel_1 = __importDefault(require("./bankAccountDetailsModel"));
+const schoolFeeCollectionModel_1 = __importDefault(require("./schoolFeeCollectionModel"));
+const userInstituteMetaModel_1 = __importDefault(require("../mongodb/userInstituteMetaModel"));
+const instituteEntityModel_1 = __importDefault(require("./instituteEntityModel"));
+const userHasSubjectFeeModel_1 = __importDefault(require("./userHasSubjectFeeModel"));
+const subjectHasPayFeeHistoryModel_1 = __importDefault(require("./subjectHasPayFeeHistoryModel"));
+class FeeHistoryModel extends sequelize_1.Model {
+}
+FeeHistoryModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: "institute_id",
+        allowNull: false,
+    },
+    pdfId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: "pdf_id",
+        allowNull: true,
+    },
+    invoiceId: {
+        type: sequelize_1.DataTypes.INTEGER,
+        field: "invoice_id",
+        defaultValue: null,
+        allowNull: true,
+    },
+    userId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: "user_id",
+        allowNull: false,
+    },
+    feeCollectionId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: "fee_collection_id",
+        allowNull: true,
+    },
+    parentHistoryId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: "parent_history_id",
+        allowNull: true,
+    },
+    bankAccountId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: "bank_account_id",
+        allowNull: true,
+    },
+    feeTypeId: {
+        type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.STRING),
+        defaultValue: [],
+        field: "fee_type_id",
+        allowNull: true,
+    },
+    schoolFeeCollectionId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: "school_fee_collection_id",
+        allowNull: true,
+    },
+    // academicCalendarId: {
+    //     type: DataTypes.UUID,
+    //     field: 'academic_calendar_id',
+    //     allowNull: false,
+    // },
+    paidDate: {
+        type: sequelize_1.DataTypes.DATE,
+        defaultValue: sequelize_1.DataTypes.NOW,
+        allowNull: false,
+    },
+    paidFee: {
+        type: sequelize_1.DataTypes.INTEGER,
+        allowNull: false,
+    },
+    paymentType: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: Object.values(app_1.PAYMENT_TYPE),
+        allowNull: true,
+        // defaultValue: PAYMENT_TYPE.CASH,
+    },
+    status: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: Object.values(app_1.FEE_HISTORY_STATUS),
+        allowNull: true,
+        defaultValue: app_1.FEE_HISTORY_STATUS.PENDING,
+    },
+    bankName: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    chequeNo: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    upiId: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+}, {
+    modelName: "FeeHistoryModel",
+    tableName: "fee_history",
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+FeeHistoryModel.belongsTo(feesCollectionModel_1.default, {
+    foreignKey: {
+        name: "feeCollectionId",
+        field: "fee_collection_id",
+        allowNull: true,
+    },
+    as: "feeHistoryFeeCollection",
+});
+feesCollectionModel_1.default.hasMany(FeeHistoryModel, {
+    foreignKey: {
+        name: "feeCollectionId",
+        field: "fee_collection_id",
+        allowNull: true,
+    },
+    as: "feeCollectionHasFeeHistory",
+});
+FeeHistoryModel.belongsTo(fileStorageModel_1.default, {
+    foreignKey: {
+        name: "pdfId",
+        field: "pdf_id",
+        allowNull: true,
+    },
+    as: "feeHistoryFile",
+});
+fileStorageModel_1.default.hasMany(FeeHistoryModel, {
+    foreignKey: {
+        name: "pdfId",
+        field: "pdf_id",
+        allowNull: true,
+    },
+    as: "filesHasFeeHistory",
+});
+FeeHistoryModel.belongsTo(bankAccountDetailsModel_1.default, {
+    foreignKey: {
+        name: "bankAccountId",
+        field: "bank_account_id",
+        allowNull: true,
+    },
+    as: "feeHistoryAccount",
+});
+bankAccountDetailsModel_1.default.hasMany(FeeHistoryModel, {
+    foreignKey: {
+        name: "bankAccountId",
+        field: "bank_account_id",
+        allowNull: true,
+    },
+    as: "feeHistoryHasAccount",
+});
+FeeHistoryModel.belongsTo(FeeHistoryModel, {
+    foreignKey: {
+        name: "parentHistoryId",
+        field: "parent_history_id",
+        allowNull: true,
+    },
+    as: "feeHistory",
+});
+FeeHistoryModel.hasMany(FeeHistoryModel, {
+    foreignKey: {
+        name: "parentHistoryId",
+        field: "parent_history_id",
+        allowNull: true,
+    },
+    as: "feeHistoryHas",
+});
+FeeHistoryModel.belongsTo(schoolFeeCollectionModel_1.default, {
+    foreignKey: {
+        name: "schoolFeeCollectionId",
+        field: "school_fee_collection_id",
+        allowNull: true,
+    },
+    as: "feeHistorySchool",
+});
+schoolFeeCollectionModel_1.default.hasMany(FeeHistoryModel, {
+    foreignKey: {
+        name: "schoolFeeCollectionId",
+        field: "school_fee_collection_id",
+        allowNull: true,
+    },
+    as: "feeHistoryHasSchool",
+});
+FeeHistoryModel.belongsTo(instituteModel_1.default, {
+    foreignKey: {
+        name: "instituteId",
+        field: "institute_id",
+    },
+    as: "feeHistoryInstitute",
+});
+instituteModel_1.default.hasMany(FeeHistoryModel, {
+    foreignKey: "instituteId",
+    as: "instituteHasFeeHistory",
+});
+FeeHistoryModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: "userId",
+        field: "user_id",
+    },
+    as: "feeHistoryUser",
+});
+userModel_1.default.hasMany(FeeHistoryModel, {
+    foreignKey: "userId",
+    as: "userHasFeeHistory",
+});
+FeeHistoryModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: "createdBy",
+        allowNull: true,
+        field: "created_by",
+    },
+    as: "createdByUser",
+});
+FeeHistoryModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: "updatedBy",
+        allowNull: true,
+        field: "updated_by",
+    },
+    as: "updatedByUser",
+});
+FeeHistoryModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: "deletedBy",
+        allowNull: true,
+        field: "deleted_by",
+    },
+    as: "deletedByUser",
+});
+const subjectWiserFeePay = async (instituteId, feeCollectionId, paidFee, userId) => {
+    try {
+        const userInstituteMeta = await userInstituteMetaModel_1.default.findOne({
+            userId,
+            instituteId,
+            status: app_1.USER_INSTITUTE_META_STATUS.ACCEPTED,
+        });
+        if (!userInstituteMeta) {
+            throw new Error(errorMessages_1.USER_INSTITUTE_META_ERROR_MESSAGES.NOT_FOUND);
+        }
+        const subjects = await instituteEntityModel_1.default.findAll({
+            where: {
+                id: { [sequelize_1.Op.in]: userInstituteMeta.entities },
+            },
+            include: [
+                {
+                    association: "entityType",
+                    where: { sequence: app_1.INSTITUTE_ENTITY_TYPE_SEQUENCE.LAST },
+                },
+            ],
+        });
+        const subjectIds = subjects.map((subject) => subject.id);
+        const fees = await userHasSubjectFeeModel_1.default.findAll({
+            where: {
+                subjectId: { [sequelize_1.Op.in]: subjectIds },
+                instituteId,
+            },
+        });
+        const feeCollection = await feesCollectionModel_1.default.findByPk(feeCollectionId);
+        if (!feeCollection) {
+            throw new Error(errorMessages_1.FEESCOLLECTION_ERROR_MESSAGES.NOT_FOUND);
+        }
+        // const totalFeeAmount = Number(fees.reduce((total, fee) => total + fee.fee, 0));
+        const feeDistribution = fees.map((fee) => {
+            const subjectPaidFee = (fee.fee / (feeCollection.feeAmount || 0)) * paidFee;
+            return {
+                subjectId: fee.subjectId,
+                amount: parseFloat(subjectPaidFee.toFixed(2)),
+            };
+        });
+        const feeHistoryEntries = await Promise.all(feeDistribution.map(async (distribution) => {
+            return subjectHasPayFeeHistoryModel_1.default.create({
+                instituteId,
+                userId,
+                subjectId: distribution.subjectId,
+                feeCollectionId,
+                amount: distribution.amount,
+            });
+        }));
+        return feeHistoryEntries;
+    }
+    catch (error) {
+        throw error;
+    }
+};
+const beforeCreateOrUpdateHook = async (feeCollection) => {
+    if (feeCollection.paidFee) {
+        if (feeCollection.paymentType === app_1.PAYMENT_TYPE.CHEQUE) {
+            feeCollection.upiId = null;
+            if (!feeCollection.chequeNo || !feeCollection.bankName) {
+                throw new Error(errorMessages_1.FEESCOLLECTION_ERROR_MESSAGES.FEE_PAID_BY_CHQUE);
+            }
+        }
+        else if (feeCollection.paymentType === app_1.PAYMENT_TYPE.UPI) {
+            feeCollection.chequeNo = null;
+            feeCollection.bankName = null;
+            if (!feeCollection.upiId) {
+                throw new Error(errorMessages_1.FEESCOLLECTION_ERROR_MESSAGES.FEE_PAID_BY_UPI);
+            }
+        }
+        else if (feeCollection.paymentType === app_1.PAYMENT_TYPE.CASH) {
+            feeCollection.bankName = null;
+            feeCollection.chequeNo = null;
+            feeCollection.upiId = null;
+        }
+        else
+            throw new Error(errorMessages_1.FEESCOLLECTION_ERROR_MESSAGES.PAYMENT_TYPE_REQUIRED);
+        if (feeCollection.pdfId) {
+            const pdfUrl = await fileStorageModel_1.default.findByPk(feeCollection.pdfId);
+            if (!pdfUrl)
+                throw new Error(errorMessages_1.FILE_STORAGE_ERROR_MESSAGES.NOT_FOUND);
+        }
+    }
+    if ((!feeCollection.feeTypeId || feeCollection.feeTypeId.length === 0) &&
+        !feeCollection.bankAccountId)
+        await subjectWiserFeePay(feeCollection.instituteId, feeCollection.feeCollectionId, feeCollection.paidFee, feeCollection.userId);
+};
+FeeHistoryModel.beforeCreate(beforeCreateOrUpdateHook);
+exports.default = FeeHistoryModel;

package/dist/models/psql/feeReminderModel.d.ts

@@ -0,0 +1,22 @@
+import { Model } from "sequelize";
+import { IFeeReminderModelAttributes } from "../../interfaces/feeReminderInterface";
+import { TFeeReminderModelCreationAttributes } from "../../types/feeReminderType";
+declare class FeeReminderModel extends Model<IFeeReminderModelAttributes, TFeeReminderModelCreationAttributes> {
+    id: string;
+    userId: string;
+    instituteId: string;
+    sendDate: Date;
+    dueDate: Date;
+    dueAmount: number;
+    templateId: string;
+    batchId?: string;
+    subjectId?: string;
+    feeCollectionId: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default FeeReminderModel;

package/dist/models/psql/feeReminderModel.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+const instituteModel_1 = __importDefault(require("./instituteModel"));
+const userModel_1 = __importDefault(require("./userModel"));
+const feesCollectionModel_1 = __importDefault(require("./feesCollectionModel"));
+const feeReminderSettingModel_1 = __importDefault(require("./feeReminderSettingModel"));
+const errorMessages_1 = require("../../constants/errorMessages");
+const app_1 = require("../../constants/app");
+const userHasBatchModel_1 = __importDefault(require("./userHasBatchModel"));
+const batchModel_1 = __importDefault(require("./batchModel"));
+class FeeReminderModel extends sequelize_1.Model {
+}
+FeeReminderModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+    },
+    sendDate: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: false,
+        defaultValue: sequelize_1.Sequelize.literal("CURRENT_TIMESTAMP"),
+    },
+    dueDate: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: false,
+    },
+    dueAmount: {
+        type: sequelize_1.DataTypes.INTEGER,
+        defaultValue: 0,
+        allowNull: false,
+    },
+    templateId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+    },
+    batchId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+    },
+    subjectId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+    },
+    feeCollectionId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+    },
+}, {
+    modelName: "FeeReminderModel",
+    tableName: "fee_reminders",
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+FeeReminderModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: "userId",
+        field: "user_id",
+    },
+    as: "reminderUser",
+});
+userModel_1.default.hasMany(FeeReminderModel, {
+    foreignKey: "userId",
+    as: "userReminders",
+});
+FeeReminderModel.belongsTo(feeReminderSettingModel_1.default, {
+    foreignKey: {
+        name: "templateId",
+        field: "template_id",
+    },
+    as: "reminderTemplate",
+});
+feeReminderSettingModel_1.default.hasMany(FeeReminderModel, {
+    foreignKey: "templateId",
+    as: "TemplateReminders",
+});
+FeeReminderModel.belongsTo(instituteModel_1.default, {
+    foreignKey: {
+        name: "instituteId",
+        field: "institute_id",
+    },
+    as: "reminderInstitute",
+});
+instituteModel_1.default.hasMany(FeeReminderModel, {
+    foreignKey: "instituteId",
+    as: "instituteReminders",
+});
+FeeReminderModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: "createdBy",
+        allowNull: true,
+        field: "created_by",
+    },
+    as: "createdByUser",
+});
+FeeReminderModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: "updatedBy",
+        allowNull: true,
+        field: "updated_by",
+    },
+    as: "updatedByUser",
+});
+FeeReminderModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: "deletedBy",
+        allowNull: true,
+        field: "deleted_by",
+    },
+    as: "deletedByUser",
+});
+FeeReminderModel.belongsTo(feesCollectionModel_1.default, {
+    foreignKey: {
+        name: "feeCollectionId",
+        field: "fee_collection_id",
+    },
+    as: "feeCollection",
+});
+feesCollectionModel_1.default.hasMany(FeeReminderModel, {
+    foreignKey: "feeCollectionId",
+    as: "feeReminders",
+});
+const beforeCreateHook = async (feeReminder) => {
+    if (feeReminder.userId && feeReminder.batchId && feeReminder.instituteId) {
+        const { batchId, instituteId, userId } = feeReminder;
+        const batchExists = await batchModel_1.default.findOne({
+            where: { id: batchId, instituteId },
+        });
+        if (!batchExists) {
+            throw new Error(errorMessages_1.BATCH_ERROR_MESSAGES.NOT_FOUND);
+        }
+        const userInBatch = await userHasBatchModel_1.default.findOne({
+            where: { userId, batchId },
+        });
+        if (!userInBatch) {
+            throw new Error(errorMessages_1.FEEREMINDER_ERROR_MESSAGES.USER_NOT_IN_BATCH);
+        }
+        if (feeReminder.subjectId) {
+            const validSubject = await userHasBatchModel_1.default.findOne({
+                where: {
+                    userId,
+                    batchId,
+                    subjects: { [sequelize_1.Op.contains]: [feeReminder.subjectId] },
+                },
+            });
+            if (!validSubject) {
+                throw new Error(errorMessages_1.FEEREMINDER_ERROR_MESSAGES.SUBJECT_INVALID);
+            }
+        }
+        if (feeReminder.feeCollectionId) {
+            const validFeeCollection = await feesCollectionModel_1.default.findOne({
+                where: {
+                    userId,
+                    instituteId,
+                    status: { [sequelize_1.Op.ne]: app_1.FEE_PAYMENT_STATUS.COMPLETED },
+                },
+            });
+            if (!validFeeCollection) {
+                throw new Error(errorMessages_1.FEEREMINDER_ERROR_MESSAGES.FEE_COLLECTION_NOT_FOUND);
+            }
+        }
+    }
+};
+const beforeUpdateHook = async (feeReminder) => {
+    if (feeReminder.id) {
+        const existingReminder = await FeeReminderModel.findByPk(feeReminder.id);
+        if (!existingReminder) {
+            throw new Error(errorMessages_1.FEEREMINDER_ERROR_MESSAGES.NOT_FOUND);
+        }
+        const batchId = feeReminder.batchId || existingReminder.batchId;
+        const instituteId = feeReminder.instituteId || existingReminder.instituteId;
+        const userId = feeReminder.userId || existingReminder.userId;
+        const batchExists = await batchModel_1.default.findOne({
+            where: {
+                id: batchId,
+                instituteId,
+            },
+        });
+        if (!batchExists) {
+            throw new Error(errorMessages_1.BATCH_ERROR_MESSAGES.NOT_FOUND);
+        }
+        const userInBatch = await userHasBatchModel_1.default.findOne({
+            where: { userId, batchId },
+        });
+        if (!userInBatch) {
+            throw new Error(errorMessages_1.FEEREMINDER_ERROR_MESSAGES.USER_NOT_IN_BATCH);
+        }
+        if (feeReminder.subjectId) {
+            const validSubject = await userHasBatchModel_1.default.findOne({
+                where: {
+                    userId,
+                    batchId,
+                    subjects: { [sequelize_1.Op.contains]: [feeReminder.subjectId] },
+                },
+            });
+            if (!validSubject) {
+                throw new Error(errorMessages_1.FEEREMINDER_ERROR_MESSAGES.SUBJECT_INVALID);
+            }
+        }
+        if (feeReminder.feeCollectionId) {
+            const validFeeCollection = await feesCollectionModel_1.default.findOne({
+                where: {
+                    userId,
+                    instituteId,
+                    status: { [sequelize_1.Op.ne]: app_1.FEE_PAYMENT_STATUS.COMPLETED },
+                },
+            });
+            if (!validFeeCollection) {
+                throw new Error(errorMessages_1.FEEREMINDER_ERROR_MESSAGES.FEE_COLLECTION_NOT_FOUND);
+            }
+        }
+    }
+    else {
+        throw new Error(errorMessages_1.FEEREMINDER_ERROR_MESSAGES.INVALID_INPUT);
+    }
+};
+FeeReminderModel.beforeBulkCreate(async (feeReminders) => {
+    for (const instance of feeReminders) {
+        await beforeCreateHook(instance);
+    }
+});
+FeeReminderModel.beforeBulkUpdate(async (options) => {
+    await beforeUpdateHook(options.attributes);
+});
+exports.default = FeeReminderModel;

package/dist/models/psql/feeReminderSettingModel.d.ts

@@ -0,0 +1,19 @@
+import { Model } from 'sequelize';
+import { IFeeReminderSettingModelAttributes } from '../../interfaces/feeReminderSettingInterface';
+import { TFeeReminderSettingModelCreationAttributes } from '../../types/feeReminderSettingType';
+import { BOOLEAN_STATUS, FEE_REMINDER_SETTING_STATUS } from '../../constants/app';
+declare class FeeReminderSettingModel extends Model<IFeeReminderSettingModelAttributes, TFeeReminderSettingModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    templateData: string;
+    status: FEE_REMINDER_SETTING_STATUS;
+    typeId: string;
+    default: BOOLEAN_STATUS;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default FeeReminderSettingModel;

package/dist/models/psql/feeReminderSettingModel.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+const instituteModel_1 = __importDefault(require("./instituteModel"));
+const userModel_1 = __importDefault(require("./userModel"));
+const app_1 = require("../../constants/app");
+class FeeReminderSettingModel extends sequelize_1.Model {
+}
+FeeReminderSettingModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+    },
+    templateData: {
+        type: sequelize_1.DataTypes.TEXT,
+        allowNull: false,
+    },
+    status: {
+        type: sequelize_1.DataTypes.ENUM(...Object.values(app_1.FEE_REMINDER_SETTING_STATUS)),
+        allowNull: false,
+        defaultValue: app_1.FEE_REMINDER_SETTING_STATUS.INACTIVE,
+    },
+    default: {
+        type: sequelize_1.DataTypes.ENUM(...Object.values(app_1.BOOLEAN_STATUS)),
+        defaultValue: app_1.BOOLEAN_STATUS.NO,
+        allowNull: false,
+    },
+    typeId: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    // frequency: {
+    //     type: DataTypes.ENUM(...Object.values(FEE_REMINDER_SETTING_FREQUENCY)),
+    //     allowNull: true,
+    //     defaultValue: FEE_REMINDER_SETTING_FREQUENCY.WEEKLY,
+    // },
+    // startDay: {
+    //     type: DataTypes.INTEGER,
+    //     allowNull: true,
+    //     defaultValue: 15,
+    // },
+}, {
+    modelName: 'FeeReminderSettingModel',
+    tableName: 'fee_reminder_settings',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+FeeReminderSettingModel.belongsTo(instituteModel_1.default, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'settingInstitute',
+});
+instituteModel_1.default.hasMany(FeeReminderSettingModel, { foreignKey: 'instituteId', as: 'instituteReminderSettings' });
+FeeReminderSettingModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+FeeReminderSettingModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+FeeReminderSettingModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+exports.default = FeeReminderSettingModel;