@kipicore/dbcore 1.1.30 → 1.1.33

package/dist/models/psql/testimonialModel.js

@@ -6,13 +6,107 @@ 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 errorMessages_1 = require("../../constants/errorMessages");
 const utils_1 = require("../../helpers/utils");
-const instituteEntityModel_1 = __importDefault(require("./instituteEntityModel"));
 const userInstituteMetaModel_1 = __importDefault(require("../mongodb/userInstituteMetaModel"));
 class TestimonialModel extends sequelize_1.Model {
+    static associate(models) {
+        const { UserModel, InstituteModel } = models;
+        TestimonialModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'createdBy',
+                allowNull: true,
+                field: 'created_by',
+            },
+            as: 'createdByUser',
+        });
+        TestimonialModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'updatedBy',
+                allowNull: true,
+                field: 'updated_by',
+            },
+            as: 'updatedByUser',
+        });
+        TestimonialModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'deletedBy',
+                allowNull: true,
+                field: 'deleted_by',
+            },
+            as: 'deletedByUser',
+        });
+        TestimonialModel.belongsTo(InstituteModel, {
+            foreignKey: 'instituteId',
+            as: 'testimonialInstitute',
+        });
+        InstituteModel.hasMany(TestimonialModel, {
+            foreignKey: 'instituteId',
+            as: 'instituteHasTestimonials',
+        });
+        TestimonialModel.belongsTo(UserModel, {
+            foreignKey: 'userId',
+            as: 'testimonialUser',
+        });
+        UserModel.hasMany(TestimonialModel, {
+            foreignKey: 'userId',
+            as: 'userHasTestimonials',
+        });
+    }
+    static addHooks(models) {
+        const { InstituteModel, UserModel, InstituteEntityModel } = models;
+        const beforeCreateOrUpdateHook = async (testimonial) => {
+            if (testimonial.instituteId) {
+                const institute = await InstituteModel.findByPk(testimonial.instituteId);
+                if (!institute) {
+                    throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+                }
+            }
+            let user = null;
+            if (testimonial.userId) {
+                user = await UserModel.findByPk(testimonial.userId);
+                if (!user) {
+                    throw new Error(errorMessages_1.USER_ERROR_MESSAGES.NOT_FOUND);
+                }
+                testimonial.userType = user.type;
+            }
+            testimonial.class = `${(0, utils_1.fromSnakeCaseToNormalText)(testimonial.userType)}`;
+            if (testimonial.userId && testimonial.instituteId && testimonial.userType !== app_1.USER_TYPES.PARENTS) {
+                const meta = await userInstituteMetaModel_1.default.findOne({
+                    userId: testimonial.userId,
+                    instituteId: testimonial.instituteId,
+                    status: app_1.USER_INSTITUTE_META_STATUS.ACCEPTED,
+                });
+                if (!meta) {
+                    throw new Error(errorMessages_1.USER_INSTITUTE_META_ERROR_MESSAGES.NOT_FOUND);
+                }
+                testimonial.userType = meta.userType;
+                let stdDataList = await InstituteEntityModel.findAll({
+                    where: {
+                        id: { [sequelize_1.Op.in]: meta.entities },
+                    },
+                    include: {
+                        association: 'entityType',
+                        required: true,
+                        where: {
+                            [sequelize_1.Op.or]: [
+                                { title: { [sequelize_1.Op.iLike]: 'STANDARD' } },
+                                { title: { [sequelize_1.Op.iLike]: 'MEDIUM' } },
+                            ],
+                        },
+                    },
+                });
+                stdDataList = JSON.parse(JSON.stringify(stdDataList));
+                const className = stdDataList.find((item) => item.entityType?.title === 'STANDARD')?.title || null;
+                const mediumName = stdDataList.find((item) => item.entityType?.title === 'MEDIUM')?.title || null;
+                testimonial.class = `${(0, utils_1.capitalizeFirst)(mediumName.substring(0, 3))} Medium ${(0, utils_1.capitalizeFirst)(className)}`;
+            }
+        };
+        TestimonialModel.beforeCreate(beforeCreateOrUpdateHook);
+        TestimonialModel.beforeBulkUpdate(async (options) => {
+            await beforeCreateOrUpdateHook(options.attributes);
+        });
+    }
 }
 TestimonialModel.init({
     id: {
@@ -60,101 +154,4 @@ TestimonialModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-// Associations
-TestimonialModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-TestimonialModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-TestimonialModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-TestimonialModel.belongsTo(instituteModel_1.default, {
-    foreignKey: 'instituteId',
-    as: 'testimonialInstitute',
-});
-instituteModel_1.default.hasMany(TestimonialModel, {
-    foreignKey: 'instituteId',
-    as: 'instituteHasTestimonials',
-});
-TestimonialModel.belongsTo(userModel_1.default, {
-    foreignKey: 'userId',
-    as: 'testimonialUser',
-});
-userModel_1.default.hasMany(TestimonialModel, {
-    foreignKey: 'userId',
-    as: 'userHasTestimonials',
-});
-const beforeCreateOrUpdateHook = async (testimonial) => {
-    if (testimonial.instituteId) {
-        const institute = await instituteModel_1.default.findByPk(testimonial.instituteId);
-        if (!institute) {
-            throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
-        }
-    }
-    let user = null;
-    if (testimonial.userId) {
-        user = await userModel_1.default.findByPk(testimonial.userId);
-        if (!user) {
-            throw new Error(errorMessages_1.USER_ERROR_MESSAGES.NOT_FOUND);
-        }
-        testimonial.userType = user.type;
-    }
-    testimonial.class = `${(0, utils_1.fromSnakeCaseToNormalText)(testimonial.userType)}`;
-    if (testimonial.userId && testimonial.instituteId && testimonial.userType !== app_1.USER_TYPES.PARENTS) {
-        const meta = await userInstituteMetaModel_1.default.findOne({
-            userId: testimonial.userId,
-            instituteId: testimonial.instituteId,
-            status: app_1.USER_INSTITUTE_META_STATUS.ACCEPTED,
-        });
-        if (!meta) {
-            throw new Error(errorMessages_1.USER_INSTITUTE_META_ERROR_MESSAGES.NOT_FOUND);
-        }
-        testimonial.userType = meta.userType;
-        let stdDataList = await instituteEntityModel_1.default.findAll({
-            where: {
-                id: { [sequelize_1.Op.in]: meta.entities },
-            },
-            include: {
-                association: 'entityType',
-                required: true,
-                where: {
-                    [sequelize_1.Op.or]: [
-                        { title: { [sequelize_1.Op.iLike]: 'STANDARD' } },
-                        { title: { [sequelize_1.Op.iLike]: 'MEDIUM' } },
-                        // { title: { [Op.iLike]: 'BOARD' } },
-                        // { title: { [Op.iLike]: 'STREAM' } },
-                        // { title: { [Op.iLike]: 'SUBJECT' } },
-                    ],
-                },
-            },
-        });
-        stdDataList = JSON.parse(JSON.stringify(stdDataList));
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const className = stdDataList.find((item) => item.entityType?.title === 'STANDARD')?.title || null;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const mediumName = stdDataList.find((item) => item.entityType?.title === 'MEDIUM')?.title || null;
-        testimonial.class = `${(0, utils_1.capitalizeFirst)(mediumName.substring(0, 3))} Medium ${(0, utils_1.capitalizeFirst)(className)}`;
-    }
-};
-TestimonialModel.beforeCreate(beforeCreateOrUpdateHook);
-TestimonialModel.beforeBulkUpdate(async (options) => {
-    await beforeCreateOrUpdateHook(options.attributes);
-});
 exports.default = TestimonialModel;

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

@@ -16,5 +16,7 @@ declare class ToDoModel extends Model<IToDoModelAttributes, TToDoModelCreationAt
     readonly createdAt: Date;
     readonly updatedAt: Date;
     readonly deletedAt?: Date;
+    static associate(models: any): void;
+    static addHooks(models: any): void;
 }
 export default ToDoModel;

package/dist/models/psql/toDoModel.js

@@ -1,15 +1,74 @@
 "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 userModel_1 = __importDefault(require("./userModel"));
-const instituteModel_1 = __importDefault(require("./instituteModel"));
 const errorMessages_1 = require("../../constants/errorMessages");
 class ToDoModel extends sequelize_1.Model {
+    static associate(models) {
+        const { UserModel, InstituteModel } = models;
+        ToDoModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'createdBy',
+                allowNull: true,
+                field: 'created_by',
+            },
+            as: 'createdByUser',
+        });
+        ToDoModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'updatedBy',
+                allowNull: true,
+                field: 'updated_by',
+            },
+            as: 'updatedByUser',
+        });
+        ToDoModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'deletedBy',
+                allowNull: true,
+                field: 'deleted_by',
+            },
+            as: 'deletedByUser',
+        });
+        ToDoModel.belongsTo(InstituteModel, {
+            foreignKey: 'instituteId',
+            as: 'toDoInstitute',
+        });
+        InstituteModel.hasMany(ToDoModel, {
+            foreignKey: 'instituteId',
+            as: 'instituteHasToDos',
+        });
+        ToDoModel.belongsTo(UserModel, {
+            foreignKey: 'userId',
+            as: 'toDoUser',
+        });
+        UserModel.hasMany(ToDoModel, {
+            foreignKey: 'userId',
+            as: 'userHasToDos',
+        });
+    }
+    static addHooks(models) {
+        const { InstituteModel, UserModel } = models;
+        const beforeCreateOrUpdateHook = async (toDo) => {
+            if (toDo.instituteId) {
+                const institute = await InstituteModel.findByPk(toDo.instituteId);
+                if (!institute) {
+                    throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+                }
+            }
+            if (toDo.userId) {
+                const user = await UserModel.findByPk(toDo.userId);
+                if (!user) {
+                    throw new Error(errorMessages_1.USER_ERROR_MESSAGES.NOT_FOUND);
+                }
+            }
+        };
+        ToDoModel.beforeCreate(beforeCreateOrUpdateHook);
+        ToDoModel.beforeBulkUpdate(async (options) => {
+            await beforeCreateOrUpdateHook(options.attributes);
+        });
+    }
 }
 ToDoModel.init({
     id: {
@@ -54,63 +113,4 @@ ToDoModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-// Associations
-ToDoModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-ToDoModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-ToDoModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-ToDoModel.belongsTo(instituteModel_1.default, {
-    foreignKey: 'instituteId',
-    as: 'toDoInstitute',
-});
-instituteModel_1.default.hasMany(ToDoModel, {
-    foreignKey: 'instituteId',
-    as: 'instituteHasToDos',
-});
-ToDoModel.belongsTo(userModel_1.default, {
-    foreignKey: 'userId',
-    as: 'toDoUser',
-});
-userModel_1.default.hasMany(ToDoModel, {
-    foreignKey: 'userId',
-    as: 'userHasToDos',
-});
-const beforeCreateOrUpdateHook = async (toDo) => {
-    if (toDo.instituteId) {
-        const institute = await instituteModel_1.default.findByPk(toDo.instituteId);
-        if (!institute) {
-            throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
-        }
-    }
-    if (toDo.userId) {
-        const user = await userModel_1.default.findByPk(toDo.userId);
-        if (!user) {
-            throw new Error(errorMessages_1.USER_ERROR_MESSAGES.NOT_FOUND);
-        }
-    }
-};
-ToDoModel.beforeCreate(beforeCreateOrUpdateHook);
-ToDoModel.beforeBulkUpdate(async (options) => {
-    await beforeCreateOrUpdateHook(options.attributes);
-});
 exports.default = ToDoModel;

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

@@ -18,5 +18,6 @@ declare class TripModel extends Model<ITripModelAttributes, TTripModelCreationAt
     readonly createdAt: Date;
     readonly updatedAt: Date;
     readonly deletedAt?: Date;
+    static associate(models: any): void;
 }
 export default TripModel;

package/dist/models/psql/tripModel.js

@@ -1,15 +1,60 @@
 "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 userModel_1 = __importDefault(require("./userModel"));
-const instituteModel_1 = __importDefault(require("./instituteModel"));
-const vehicleModel_1 = __importDefault(require("./vehicleModel"));
 class TripModel extends sequelize_1.Model {
+    static associate(models) {
+        const { UserModel, VehicleModel, InstituteModel } = models;
+        TripModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'createdBy',
+                allowNull: true,
+                field: 'created_by',
+            },
+            as: 'createdByUser',
+        });
+        TripModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'updatedBy',
+                allowNull: true,
+                field: 'updated_by',
+            },
+            as: 'updatedByUser',
+        });
+        TripModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'deletedBy',
+                allowNull: true,
+                field: 'deleted_by',
+            },
+            as: 'deletedByUser',
+        });
+        TripModel.belongsTo(VehicleModel, {
+            foreignKey: 'vehicleId',
+            as: 'tripVehicle',
+        });
+        VehicleModel.hasMany(TripModel, {
+            foreignKey: 'vehicleId',
+            as: 'tripHasVehicle',
+        });
+        TripModel.belongsTo(InstituteModel, {
+            foreignKey: 'instituteId',
+            as: 'tripInstitute',
+        });
+        InstituteModel.hasMany(TripModel, {
+            foreignKey: 'instituteId',
+            as: 'instituteHasTrips',
+        });
+        TripModel.belongsTo(UserModel, {
+            foreignKey: 'driverId',
+            as: 'driver',
+        });
+        UserModel.hasMany(TripModel, {
+            foreignKey: 'driverId',
+            as: 'tripHasDriver',
+        });
+    }
 }
 TripModel.init({
     id: {
@@ -62,53 +107,4 @@ TripModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-// Associations
-TripModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-TripModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-TripModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-TripModel.belongsTo(vehicleModel_1.default, {
-    foreignKey: 'vehicleId',
-    as: 'tripVehicle',
-});
-vehicleModel_1.default.hasMany(TripModel, {
-    foreignKey: 'vehicleId',
-    as: 'tripHasVehicle',
-});
-TripModel.belongsTo(instituteModel_1.default, {
-    foreignKey: 'instituteId',
-    as: 'tripInstitute',
-});
-instituteModel_1.default.hasMany(TripModel, {
-    foreignKey: 'instituteId',
-    as: 'instituteHasTrips',
-});
-TripModel.belongsTo(userModel_1.default, {
-    foreignKey: 'driverId',
-    as: 'driver',
-});
-userModel_1.default.hasMany(TripModel, {
-    foreignKey: 'driverId',
-    as: 'tripHasDriver',
-});
 exports.default = TripModel;

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

@@ -16,5 +16,7 @@ declare class TypeManagementModel extends Model<ITypeManagementModelAttributes,
     readonly createdAt: Date;
     readonly deletedAt: string;
     readonly updatedAt: Date;
+    static associate(models: any): void;
+    static addHooks(models: any): void;
 }
 export default TypeManagementModel;

package/dist/models/psql/typeManagementModel.js

@@ -1,15 +1,79 @@
 "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 instituteModel_1 = __importDefault(require("./instituteModel"));
-const userModel_1 = __importDefault(require("./userModel"));
 const errorMessages_1 = require("../../constants/errorMessages");
 class TypeManagementModel extends sequelize_1.Model {
+    static associate(models) {
+        const { UserModel, InstituteModel } = models;
+        TypeManagementModel.belongsTo(InstituteModel, {
+            foreignKey: {
+                name: 'instituteId',
+                field: 'institute_id',
+            },
+            as: 'institute',
+        });
+        InstituteModel.hasMany(TypeManagementModel, {
+            foreignKey: 'instituteId',
+            as: 'typeManagements',
+        });
+        TypeManagementModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'createdBy',
+                allowNull: true,
+                field: 'created_by',
+            },
+            as: 'createdByUser',
+        });
+        TypeManagementModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'updatedBy',
+                allowNull: true,
+                field: 'updated_by',
+            },
+            as: 'updatedByUser',
+        });
+        TypeManagementModel.belongsTo(UserModel, {
+            foreignKey: {
+                name: 'deletedBy',
+                allowNull: true,
+                field: 'deleted_by',
+            },
+            as: 'deletedByUser',
+        });
+    }
+    static addHooks(models) {
+        const beforeCreateOrUpdateHook = async (type) => {
+            const { InstituteModel } = models;
+            if (type.instituteId) {
+                const institute = await InstituteModel.findByPk(type.instituteId);
+                if (!institute) {
+                    throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+                }
+            }
+            if (type.title && type.instituteId && type.type) {
+                const typeExist = await TypeManagementModel.findOne({
+                    where: {
+                        title: type.title,
+                        instituteId: type.instituteId,
+                        type: type.type,
+                    },
+                });
+                if (typeExist)
+                    throw new Error(errorMessages_1.TYPE_MANAGEMENT_ERROR_MESSAGES.TYPE_ALREADY_EXISTS);
+            }
+        };
+        TypeManagementModel.beforeCreate(beforeCreateOrUpdateHook);
+        TypeManagementModel.beforeBulkUpdate(async (options) => {
+            await beforeCreateOrUpdateHook(options.attributes);
+        });
+        TypeManagementModel.beforeBulkCreate(async (instances) => {
+            for (const instance of instances) {
+                await beforeCreateOrUpdateHook(instance);
+            }
+        });
+    }
 }
 TypeManagementModel.init({
     id: {
@@ -55,68 +119,4 @@ TypeManagementModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-const beforeCreateOrUpdateHook = async (type) => {
-    if (type.instituteId) {
-        const institute = await instituteModel_1.default.findByPk(type.instituteId);
-        if (!institute) {
-            throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
-        }
-    }
-    if (type.title && type.instituteId && type.type) {
-        const typeExit = await TypeManagementModel.findOne({
-            where: {
-                title: type.title,
-                instituteId: type.instituteId,
-                type: type.type,
-            },
-        });
-        if (typeExit)
-            throw new Error(errorMessages_1.TYPE_MANAGEMENT_ERROR_MESSAGES.TYPE_ALREADY_EXISTS);
-    }
-};
-TypeManagementModel.beforeCreate(beforeCreateOrUpdateHook);
-TypeManagementModel.beforeBulkUpdate(async (options) => {
-    await beforeCreateOrUpdateHook(options.attributes);
-});
-TypeManagementModel.beforeBulkCreate(async (instances) => {
-    for (const instance of instances) {
-        await beforeCreateOrUpdateHook(instance);
-    }
-});
-// TypeManagementModel belongs to InstituteModel
-TypeManagementModel.belongsTo(instituteModel_1.default, {
-    foreignKey: {
-        name: 'instituteId',
-        field: 'institute_id',
-    },
-    as: 'institute',
-});
-instituteModel_1.default.hasMany(TypeManagementModel, {
-    foreignKey: 'instituteId',
-    as: 'typeManagements',
-});
-TypeManagementModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-TypeManagementModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-TypeManagementModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
 exports.default = TypeManagementModel;

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

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