@kipicore/dbcore 1.1.30 → 1.1.33

package/dist/models/psql/feeReminderModel.js

@@ -1,19 +1,157 @@
 "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 {
+    static associate(models) {
+        const { UserModel, InstituteModel, FeesCollectionModel, FeeReminderSettingModel, } = models;
+        FeeReminderModel.belongsTo(UserModel, {
+            foreignKey: { name: 'userId', field: 'user_id' },
+            as: 'reminderUser',
+        });
+        UserModel.hasMany(FeeReminderModel, {
+            foreignKey: 'userId',
+            as: 'userReminders',
+        });
+        FeeReminderModel.belongsTo(FeeReminderSettingModel, {
+            foreignKey: { name: 'templateId', field: 'template_id' },
+            as: 'reminderTemplate',
+        });
+        FeeReminderSettingModel.hasMany(FeeReminderModel, {
+            foreignKey: 'templateId',
+            as: 'TemplateReminders',
+        });
+        FeeReminderModel.belongsTo(InstituteModel, {
+            foreignKey: { name: 'instituteId', field: 'institute_id' },
+            as: 'reminderInstitute',
+        });
+        InstituteModel.hasMany(FeeReminderModel, {
+            foreignKey: 'instituteId',
+            as: 'instituteReminders',
+        });
+        FeeReminderModel.belongsTo(UserModel, {
+            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+            as: 'createdByUser',
+        });
+        FeeReminderModel.belongsTo(UserModel, {
+            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+            as: 'updatedByUser',
+        });
+        FeeReminderModel.belongsTo(UserModel, {
+            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+            as: 'deletedByUser',
+        });
+        FeeReminderModel.belongsTo(FeesCollectionModel, {
+            foreignKey: { name: 'feeCollectionId', field: 'fee_collection_id' },
+            as: 'feeCollection',
+        });
+        FeesCollectionModel.hasMany(FeeReminderModel, {
+            foreignKey: 'feeCollectionId',
+            as: 'feeReminders',
+        });
+    }
+    static addHooks(models) {
+        const { BatchModel, UserHasBatchModel, FeesCollectionModel } = models;
+        const beforeCreateHook = async (feeReminder) => {
+            if (feeReminder.userId && feeReminder.batchId && feeReminder.instituteId) {
+                const { batchId, instituteId, userId } = feeReminder;
+                const batchExists = await BatchModel.findOne({
+                    where: { id: batchId, instituteId },
+                });
+                if (!batchExists) {
+                    throw new Error(errorMessages_1.BATCH_ERROR_MESSAGES.NOT_FOUND);
+                }
+                const userInBatch = await UserHasBatchModel.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.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.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) {
+                throw new Error(errorMessages_1.FEEREMINDER_ERROR_MESSAGES.INVALID_INPUT);
+            }
+            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.findOne({
+                where: { id: batchId, instituteId },
+            });
+            if (!batchExists) {
+                throw new Error(errorMessages_1.BATCH_ERROR_MESSAGES.NOT_FOUND);
+            }
+            const userInBatch = await UserHasBatchModel.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.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.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);
+                }
+            }
+        };
+        FeeReminderModel.beforeBulkCreate(async (feeReminders) => {
+            for (const instance of feeReminders) {
+                await beforeCreateHook(instance);
+            }
+        });
+        FeeReminderModel.beforeBulkUpdate(async (options) => {
+            await beforeUpdateHook(options.attributes);
+        });
+    }
 }
 FeeReminderModel.init({
     id: {
@@ -66,174 +204,4 @@ FeeReminderModel.init({
     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

@@ -15,5 +15,6 @@ declare class FeeReminderSettingModel extends Model<IFeeReminderSettingModelAttr
     readonly createdAt: Date;
     readonly deletedAt: string;
     readonly updatedAt: Date;
+    static associate(models: any): void;
 }
 export default FeeReminderSettingModel;

package/dist/models/psql/feeReminderSettingModel.js

@@ -1,14 +1,32 @@
 "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 {
+    static associate(models) {
+        const { InstituteModel, UserModel } = models;
+        FeeReminderSettingModel.belongsTo(InstituteModel, {
+            foreignKey: { name: 'instituteId', field: 'institute_id' },
+            as: 'settingInstitute',
+        });
+        InstituteModel.hasMany(FeeReminderSettingModel, {
+            foreignKey: 'instituteId',
+            as: 'instituteReminderSettings',
+        });
+        FeeReminderSettingModel.belongsTo(UserModel, {
+            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+            as: 'createdByUser',
+        });
+        FeeReminderSettingModel.belongsTo(UserModel, {
+            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+            as: 'updatedByUser',
+        });
+        FeeReminderSettingModel.belongsTo(UserModel, {
+            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+            as: 'deletedByUser',
+        });
+    }
 }
 FeeReminderSettingModel.init({
     id: {
@@ -39,52 +57,10 @@ FeeReminderSettingModel.init({
         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;

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

@@ -17,5 +17,6 @@ declare class FeeTypeHasTermsModel extends Model<IFeeTypeHasTermsModelAttributes
     readonly createdAt: Date;
     readonly deletedAt: string;
     readonly updatedAt: Date;
+    static associate(models: any): void;
 }
 export default FeeTypeHasTermsModel;

package/dist/models/psql/feeTypeHasTermsModel.js

@@ -1,15 +1,57 @@
 "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 app_1 = require("../../constants/app");
-const feeTypeModel_1 = __importDefault(require("./feeTypeModel"));
-const instituteModel_1 = __importDefault(require("./instituteModel"));
-const userModel_1 = __importDefault(require("./userModel"));
 class FeeTypeHasTermsModel extends sequelize_1.Model {
+    static associate(models) {
+        const { FeeTypeModel, InstituteModel, UserModel } = models;
+        FeeTypeHasTermsModel.belongsTo(FeeTypeModel, {
+            foreignKey: {
+                name: 'feeTypeId',
+            },
+            as: 'termsFeeType',
+        });
+        FeeTypeModel.hasMany(FeeTypeHasTermsModel, {
+            foreignKey: 'feeTypeId',
+            as: 'feeTypeHasTerms',
+        });
+        FeeTypeHasTermsModel.belongsTo(InstituteModel, {
+            foreignKey: {
+                name: 'instituteId',
+                field: 'institute_id',
+            },
+            as: 'instituteFeeTypeTerms',
+        });
+        InstituteModel.hasMany(FeeTypeHasTermsModel, {
+            foreignKey: 'instituteId',
+            as: 'feeTypeHasTermsInstitute',
+        });
+        FeeTypeHasTermsModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'createdBy',
+                allowNull: true,
+                field: 'created_by',
+            },
+            as: 'createdByUser',
+        });
+        FeeTypeHasTermsModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'updatedBy',
+                allowNull: true,
+                field: 'updated_by',
+            },
+            as: 'updatedByUser',
+        });
+        FeeTypeHasTermsModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'deletedBy',
+                allowNull: true,
+                field: 'deleted_by',
+            },
+            as: 'deletedByUser',
+        });
+    }
 }
 FeeTypeHasTermsModel.init({
     id: {
@@ -54,49 +96,4 @@ FeeTypeHasTermsModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-FeeTypeHasTermsModel.belongsTo(feeTypeModel_1.default, {
-    foreignKey: {
-        name: 'feeTypeId',
-    },
-    as: 'termsFeeType',
-});
-feeTypeModel_1.default.hasMany(FeeTypeHasTermsModel, {
-    foreignKey: 'feeTypeId',
-    as: 'feeTypeHasTerms',
-});
-FeeTypeHasTermsModel.belongsTo(instituteModel_1.default, {
-    foreignKey: {
-        name: 'instituteId',
-        field: 'institute_id',
-    },
-    as: 'instituteFeeTypeTerms',
-});
-instituteModel_1.default.hasMany(FeeTypeHasTermsModel, {
-    foreignKey: 'instituteId',
-    as: 'feeTypeHasTermsInstitute',
-});
-FeeTypeHasTermsModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-FeeTypeHasTermsModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-FeeTypeHasTermsModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
 exports.default = FeeTypeHasTermsModel;

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

@@ -18,5 +18,6 @@ declare class FeeTypeModel extends Model<IFeeTypeModelAttributes, TFeeTypeModelC
     readonly createdAt: Date;
     readonly deletedAt: string;
     readonly updatedAt: Date;
+    static associate(models: any): void;
 }
 export default FeeTypeModel;