@kipicore/dbcore 1.1.32 → 1.1.33

package/dist/models/psql/facilityModel.js

@@ -3,15 +3,77 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FacilityModel = void 0;
 const sequelize_1 = require("sequelize");
 const index_1 = require("./index");
 const instituteModel_1 = __importDefault(require("./instituteModel"));
-const userModel_1 = __importDefault(require("./userModel"));
 const errorMessages_1 = require("../../constants/errorMessages");
 const typeManagementModel_1 = __importDefault(require("./typeManagementModel"));
 const app_1 = require("../../constants/app");
 class FacilityModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, TypeManagementModel, UserModel } = models;
+        FacilityModel.belongsTo(InstituteModel, {
+            foreignKey: { name: 'instituteId', field: 'institute_id' },
+            as: 'facilityInstitute',
+        });
+        InstituteModel.hasMany(FacilityModel, {
+            foreignKey: 'instituteId',
+            as: 'instituteHasFacilities',
+        });
+        FacilityModel.belongsTo(TypeManagementModel, {
+            foreignKey: { name: 'typeManagementId', field: 'type_management_id' },
+            as: 'facilityType',
+        });
+        TypeManagementModel.hasMany(FacilityModel, {
+            foreignKey: 'typeManagementId',
+            as: 'instituteHasFacilitiesType',
+        });
+        FacilityModel.belongsTo(UserModel, {
+            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+            as: 'createdByUser',
+        });
+        FacilityModel.belongsTo(UserModel, {
+            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+            as: 'updatedByUser',
+        });
+        FacilityModel.belongsTo(UserModel, {
+            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+            as: 'deletedByUser',
+        });
+    }
+    static addHooks() {
+        const beforeCreateOrUpdateHook = async (facility) => {
+            if (facility.instituteId) {
+                const institute = await instituteModel_1.default.findByPk(facility.instituteId);
+                if (!institute)
+                    throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+            }
+            if (facility.typeManagementId) {
+                const type = await typeManagementModel_1.default.findOne({
+                    where: {
+                        id: facility.typeManagementId,
+                        type: app_1.TYPE_MANAGEMENT_TYPE.FACILITY,
+                    },
+                });
+                if (!type)
+                    throw new Error(errorMessages_1.TYPE_MANAGEMENT_ERROR_MESSAGES.NOT_FOUND);
+            }
+        };
+        FacilityModel.beforeCreate(beforeCreateOrUpdateHook);
+        FacilityModel.beforeBulkUpdate(async (options) => {
+            if (options.attributes) {
+                await beforeCreateOrUpdateHook(options.attributes);
+            }
+        });
+        FacilityModel.beforeBulkCreate(async (instances) => {
+            for (const instance of instances) {
+                await beforeCreateOrUpdateHook(instance);
+            }
+        });
+    }
 }
+exports.FacilityModel = FacilityModel;
 FacilityModel.init({
     id: {
         type: sequelize_1.DataTypes.UUID,
@@ -45,76 +107,4 @@ FacilityModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-const beforeCreateOrUpdateHook = async (facilities) => {
-    if (facilities.instituteId) {
-        const institute = await instituteModel_1.default.findByPk(facilities.instituteId);
-        if (!institute)
-            throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
-    }
-    if (facilities.typeManagementId) {
-        const type = await typeManagementModel_1.default.findOne({
-            where: {
-                id: facilities.typeManagementId,
-                type: app_1.TYPE_MANAGEMENT_TYPE.FACILITY,
-            },
-        });
-        if (!type)
-            throw new Error(errorMessages_1.TYPE_MANAGEMENT_ERROR_MESSAGES.NOT_FOUND);
-    }
-};
-FacilityModel.beforeCreate(beforeCreateOrUpdateHook);
-FacilityModel.beforeBulkUpdate(async (options) => {
-    await beforeCreateOrUpdateHook(options.attributes);
-});
-FacilityModel.beforeBulkCreate(async (instances) => {
-    for (const instance of instances) {
-        await beforeCreateOrUpdateHook(instance);
-    }
-});
-FacilityModel.belongsTo(instituteModel_1.default, {
-    foreignKey: {
-        name: 'instituteId',
-        field: 'institute_id',
-    },
-    as: 'facilityInstitute',
-});
-instituteModel_1.default.hasMany(FacilityModel, {
-    foreignKey: 'instituteId',
-    as: 'instituteHasFacilities',
-});
-FacilityModel.belongsTo(typeManagementModel_1.default, {
-    foreignKey: {
-        name: 'typeManagementId',
-        field: 'type_management_id',
-    },
-    as: 'facilityType',
-});
-typeManagementModel_1.default.hasMany(FacilityModel, {
-    foreignKey: 'typeManagementId',
-    as: 'instituteHasFacilitiesType',
-});
-FacilityModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-FacilityModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-FacilityModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
 exports.default = FacilityModel;

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

@@ -2,7 +2,7 @@ import { Model } from 'sequelize';
 import { APP_TYPE, COMMAN_STATUS } from '../../constants/app';
 import { IFeatureActionAttributes } from '../../interfaces/featureActionInterface';
 import { TFeatureActionCreationAttributes } from '../../types/featureActionType';
-declare class FeatureActionModel extends Model<IFeatureActionAttributes, TFeatureActionCreationAttributes> {
+export declare class FeatureActionModel extends Model<IFeatureActionAttributes, TFeatureActionCreationAttributes> {
     id: string;
     name: string;
     status: COMMAN_STATUS;
@@ -16,7 +16,8 @@ declare class FeatureActionModel extends Model<IFeatureActionAttributes, TFeatur
     updatedBy: string;
     deletedBy: string;
     readonly createdAt: Date;
-    readonly deletedAt: string;
     readonly updatedAt: Date;
+    readonly deletedAt: string;
+    static associate(models: any): void;
 }
 export default FeatureActionModel;

package/dist/models/psql/featureActionModel.js

@@ -1,15 +1,31 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureActionModel = void 0;
 const sequelize_1 = require("sequelize");
 const index_1 = require("./index");
 const app_1 = require("../../constants/app");
-const userModel_1 = __importDefault(require("./userModel"));
-const roleModel_1 = __importDefault(require("./roleModel"));
 class FeatureActionModel extends sequelize_1.Model {
+    static associate(models) {
+        const { UserModel, RoleModel } = models;
+        FeatureActionModel.belongsTo(UserModel, {
+            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+            as: 'createdByUser',
+        });
+        FeatureActionModel.belongsTo(UserModel, {
+            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+            as: 'updatedByUser',
+        });
+        FeatureActionModel.belongsTo(UserModel, {
+            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+            as: 'deletedByUser',
+        });
+        FeatureActionModel.belongsTo(RoleModel, {
+            foreignKey: { name: 'roleId', field: 'role_id' },
+            as: 'role',
+        });
+    }
 }
+exports.FeatureActionModel = FeatureActionModel;
 FeatureActionModel.init({
     id: {
         type: sequelize_1.DataTypes.UUID,
@@ -61,35 +77,4 @@ FeatureActionModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-FeatureActionModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-FeatureActionModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-FeatureActionModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-FeatureActionModel.belongsTo(roleModel_1.default, {
-    foreignKey: {
-        name: 'roleId',
-        field: 'roleId',
-    },
-    as: 'role',
-});
 exports.default = FeatureActionModel;

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

@@ -2,7 +2,7 @@ import { Model } from 'sequelize';
 import { IFeeHistoryDetailsModelAttributes } from '../../interfaces/feeHistoryDetailsInterface';
 import { TFeeHistoryDetailsModelCreationAttributes } from '../../types/feeHistoryDetailsType';
 import { PAYMENT_TYPE } from '../../constants/app';
-declare class FeeHistoryDetailsModel extends Model<IFeeHistoryDetailsModelAttributes, TFeeHistoryDetailsModelCreationAttributes> {
+export declare class FeeHistoryDetailsModel extends Model<IFeeHistoryDetailsModelAttributes, TFeeHistoryDetailsModelCreationAttributes> {
     id: string;
     instituteId: string;
     userFeeTypeByAccountId: string;
@@ -22,5 +22,6 @@ declare class FeeHistoryDetailsModel extends Model<IFeeHistoryDetailsModelAttrib
     readonly createdAt: Date;
     readonly updatedAt: Date;
     readonly deletedAt?: Date;
+    static associate(models: any): void;
 }
 export default FeeHistoryDetailsModel;

package/dist/models/psql/feeHistoryDetailsModel.js

@@ -1,18 +1,74 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeeHistoryDetailsModel = void 0;
 const sequelize_1 = require("sequelize");
 const index_1 = require("./index");
-const userModel_1 = __importDefault(require("./userModel"));
-const instituteModel_1 = __importDefault(require("./instituteModel"));
-const schoolFeeCollectionModel_1 = __importDefault(require("./schoolFeeCollectionModel"));
-const userFeeTypeByAccountModel_1 = __importDefault(require("./userFeeTypeByAccountModel"));
-const feeHistoryModel_1 = __importDefault(require("./feeHistoryModel"));
-const feeTypeModel_1 = __importDefault(require("./feeTypeModel"));
 class FeeHistoryDetailsModel extends sequelize_1.Model {
+    static associate(models) {
+        const { UserModel, InstituteModel, SchoolFeeCollectionModel, UserFeeTypeByAccountModel, FeeHistoryModel, FeeTypeModel, } = models;
+        FeeHistoryDetailsModel.belongsTo(UserModel, {
+            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+            as: 'createdByUser',
+        });
+        FeeHistoryDetailsModel.belongsTo(UserModel, {
+            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+            as: 'updatedByUser',
+        });
+        FeeHistoryDetailsModel.belongsTo(UserModel, {
+            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+            as: 'deletedByUser',
+        });
+        FeeHistoryDetailsModel.belongsTo(InstituteModel, {
+            foreignKey: 'instituteId',
+            as: 'feeHistoryDetailsInstitute',
+        });
+        InstituteModel.hasMany(FeeHistoryDetailsModel, {
+            foreignKey: 'instituteId',
+            as: 'instituteHasFeeHistoryDetails',
+        });
+        FeeHistoryDetailsModel.belongsTo(UserModel, {
+            foreignKey: 'userId',
+            as: 'feeHistoryDetailsUser',
+        });
+        UserModel.hasMany(FeeHistoryDetailsModel, {
+            foreignKey: 'userId',
+            as: 'userHasFeeHistoryDetails',
+        });
+        FeeHistoryDetailsModel.belongsTo(SchoolFeeCollectionModel, {
+            foreignKey: { name: 'schoolFeeCollectionId', field: 'school_fee_collection_id', allowNull: true },
+            as: 'feeHistoryDetailsSchool',
+        });
+        SchoolFeeCollectionModel.hasMany(FeeHistoryDetailsModel, {
+            foreignKey: { name: 'schoolFeeCollectionId', field: 'school_fee_collection_id', allowNull: true },
+            as: 'feeHistoryDetailsHasSchool',
+        });
+        FeeHistoryDetailsModel.belongsTo(UserFeeTypeByAccountModel, {
+            foreignKey: 'userFeeTypeByAccountId',
+            as: 'feeHistoryDetailsFeeType',
+        });
+        UserFeeTypeByAccountModel.hasMany(FeeHistoryDetailsModel, {
+            foreignKey: 'userFeeTypeByAccountId',
+            as: 'userFeeTypeFeeHistoryDetails',
+        });
+        FeeHistoryDetailsModel.belongsTo(FeeHistoryModel, {
+            foreignKey: { name: 'feeHistoryId', field: 'fee_history_id', allowNull: true },
+            as: 'detailsFeeHistory',
+        });
+        FeeHistoryModel.hasMany(FeeHistoryDetailsModel, {
+            foreignKey: { name: 'feeHistoryId', field: 'fee_history_id', allowNull: true },
+            as: 'feeHistoryHasDetails',
+        });
+        FeeHistoryDetailsModel.belongsTo(FeeTypeModel, {
+            foreignKey: { name: 'feeTypeId', field: 'fee_type_id', allowNull: true },
+            as: 'feeHistoryDetailsType',
+        });
+        FeeTypeModel.hasMany(FeeHistoryDetailsModel, {
+            foreignKey: { name: 'feeTypeId', field: 'fee_type_id', allowNull: true },
+            as: 'feeHistoryDetailsHasType',
+        });
+    }
 }
+exports.FeeHistoryDetailsModel = FeeHistoryDetailsModel;
 FeeHistoryDetailsModel.init({
     id: {
         type: sequelize_1.DataTypes.UUID,
@@ -86,101 +142,4 @@ FeeHistoryDetailsModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-// Associations
-FeeHistoryDetailsModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-FeeHistoryDetailsModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-FeeHistoryDetailsModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-FeeHistoryDetailsModel.belongsTo(instituteModel_1.default, {
-    foreignKey: 'instituteId',
-    as: 'feeHistoryDetailsInstitute',
-});
-instituteModel_1.default.hasMany(FeeHistoryDetailsModel, {
-    foreignKey: 'instituteId',
-    as: 'instituteHasFeeHistoryDetails',
-});
-FeeHistoryDetailsModel.belongsTo(userModel_1.default, {
-    foreignKey: 'userId',
-    as: 'feeHistoryDetailsUser',
-});
-userModel_1.default.hasMany(FeeHistoryDetailsModel, {
-    foreignKey: 'userId',
-    as: 'userHasFeeHistoryDetails',
-});
-FeeHistoryDetailsModel.belongsTo(schoolFeeCollectionModel_1.default, {
-    foreignKey: {
-        name: 'schoolFeeCollectionId',
-        field: 'school_fee_collection_id',
-        allowNull: true,
-    },
-    as: 'feeHistoryDetailsSchool',
-});
-schoolFeeCollectionModel_1.default.hasMany(FeeHistoryDetailsModel, {
-    foreignKey: {
-        name: 'schoolFeeCollectionId',
-        field: 'school_fee_collection_id',
-        allowNull: true,
-    },
-    as: 'feeHistoryDetailsHasSchool',
-});
-FeeHistoryDetailsModel.belongsTo(userFeeTypeByAccountModel_1.default, {
-    foreignKey: 'userFeeTypeByAccountId',
-    as: 'feeHistoryDetailsFeeType',
-});
-userFeeTypeByAccountModel_1.default.hasMany(FeeHistoryDetailsModel, {
-    foreignKey: 'userFeeTypeByAccountId',
-    as: 'userFeeTypeFeeHistoryDetails',
-});
-FeeHistoryDetailsModel.belongsTo(feeHistoryModel_1.default, {
-    foreignKey: {
-        name: 'feeHistoryId',
-        field: 'fee_history_id',
-        allowNull: true,
-    },
-    as: 'detailsFeeHistory',
-});
-feeHistoryModel_1.default.hasMany(FeeHistoryDetailsModel, {
-    foreignKey: {
-        name: 'feeHistoryId',
-        field: 'fee_history_id',
-        allowNull: true,
-    },
-    as: 'feeHistoryHasDetails',
-});
-FeeHistoryDetailsModel.belongsTo(feeTypeModel_1.default, {
-    foreignKey: {
-        name: 'feeTypeId',
-        field: 'fee_type_id',
-        allowNull: true,
-    },
-    as: 'feeHistoryDetailsType',
-});
-feeTypeModel_1.default.hasMany(FeeHistoryDetailsModel, {
-    foreignKey: {
-        name: 'feeTypeId',
-        field: 'fee_type_id',
-        allowNull: true,
-    },
-    as: 'feeHistoryDetailsHasType',
-});
 exports.default = FeeHistoryDetailsModel;

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

@@ -2,7 +2,7 @@ import { Model } from 'sequelize';
 import { IFeeHistoryModelAttributes } from '../../interfaces/feeHistoryInterface';
 import { TFeeHistoryModelCreationAttributes } from '../../types/feeHistoryType';
 import { FEE_HISTORY_STATUS, PAYMENT_TYPE } from '../../constants/app';
-declare class FeeHistoryModel extends Model<IFeeHistoryModelAttributes, TFeeHistoryModelCreationAttributes> {
+export declare class FeeHistoryModel extends Model<IFeeHistoryModelAttributes, TFeeHistoryModelCreationAttributes> {
     id: string;
     instituteId: string;
     userId: string;
@@ -24,7 +24,9 @@ declare class FeeHistoryModel extends Model<IFeeHistoryModelAttributes, TFeeHist
     updatedBy: string;
     deletedBy: string;
     readonly createdAt: Date;
-    readonly deletedAt: string;
     readonly updatedAt: Date;
+    readonly deletedAt: string;
+    static associate(models: any): void;
+    static addHooks(models: any): void;
 }
 export default FeeHistoryModel;