@kipicore/dbcore 1.1.13 → 1.1.15

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

@@ -0,0 +1,150 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index.js';
+import { USER_PAYOUT_TYPE, USER_TYPES } from '../../constants/app.js';
+import UserModel from './userModel.js';
+import InstituteModel from './instituteModel.js';
+import UserPayoutModel from './userPayoutModel.js';
+class UserPayoutHistoryModel extends Model {
+}
+UserPayoutHistoryModel.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        field: 'user_id',
+    },
+    userType: {
+        type: DataTypes.ENUM,
+        values: Object.values(USER_TYPES),
+        allowNull: false,
+        field: 'user_type',
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        field: 'institute_id',
+    },
+    userPayoutId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        field: 'user_payout_id',
+    },
+    paidAmount: {
+        type: DataTypes.FLOAT,
+        allowNull: false,
+        field: 'paid_amount',
+    },
+    payableAmount: {
+        type: DataTypes.FLOAT,
+        allowNull: false,
+        field: 'payable_amount',
+    },
+    bonusAmount: {
+        type: DataTypes.FLOAT,
+        allowNull: true,
+        defaultValue: 0,
+        field: 'bonus_amount',
+    },
+    overtimeAmount: {
+        type: DataTypes.FLOAT,
+        allowNull: true,
+        defaultValue: 0,
+        field: 'overtime_amount',
+    },
+    payoutDate: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        field: 'payout_date',
+    },
+    payoutStartTime: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        field: 'payout_start_time',
+    },
+    payoutEndTime: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        field: 'payout_end_time',
+    },
+    payoutType: {
+        type: DataTypes.ENUM,
+        values: Object.values(USER_PAYOUT_TYPE),
+        allowNull: false,
+        field: 'payout_type',
+    },
+    description: {
+        type: DataTypes.STRING,
+        allowNull: true,
+    },
+}, {
+    modelName: 'UserPayoutHistoryModel',
+    tableName: 'user_payout_history',
+    timestamps: true,
+    sequelize,
+});
+UserPayoutHistoryModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserPayoutHistoryModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserPayoutHistoryModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+UserPayoutHistoryModel.belongsTo(InstituteModel, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'institute',
+});
+InstituteModel.hasMany(UserPayoutHistoryModel, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'instituteHasPayoutHistoryList',
+});
+UserPayoutHistoryModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'userId',
+    },
+    as: 'user',
+});
+UserModel.hasMany(UserPayoutHistoryModel, {
+    foreignKey: {
+        name: 'userId',
+    },
+    as: 'userHasPayoutHistoryList',
+});
+UserPayoutHistoryModel.belongsTo(UserPayoutModel, {
+    foreignKey: {
+        name: 'userPayoutId',
+    },
+    as: 'userPayout',
+});
+UserPayoutModel.hasMany(UserPayoutHistoryModel, {
+    foreignKey: {
+        name: 'userPayoutId',
+    },
+    as: 'userPayoutHistoryList',
+});
+export default UserPayoutHistoryModel;

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

@@ -0,0 +1,20 @@
+import { Model } from 'sequelize';
+import { IUserPayoutModelAttributes } from '../../interfaces/userPayoutInterface.js';
+import { TUserPayoutModelCreationAttributes } from '../../types/userPayoutType.js';
+import { USER_PAYOUT_TYPE, USER_TYPES } from '../../constants/app.js';
+declare class UserPayoutModel extends Model<IUserPayoutModelAttributes, TUserPayoutModelCreationAttributes> {
+    id: string;
+    userId: string;
+    userType: USER_TYPES;
+    instituteId: string;
+    totalPayableAmount: number;
+    totalPaidAmount: number;
+    type: USER_PAYOUT_TYPE;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: Date;
+    readonly updatedAt: Date;
+}
+export default UserPayoutModel;

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

@@ -0,0 +1,296 @@
+import { DataTypes, Model, Op, Sequelize } from 'sequelize';
+import { sequelize } from './index.js';
+import { ATTENDANCE_STATUS, SIXTY, USER_PAYOUT_TYPE, USER_TYPES } from '../../constants/app.js';
+import UserModel from './userModel.js';
+import InstituteModel from './instituteModel.js';
+import { endOfMonth, format, startOfMonth, startOfToday, subMonths } from 'date-fns';
+import { getUniqueArrayByFields } from '../../helpers/utils.js';
+import SubjectHasPayFeeHistory from './subjectHasPayFeeHistoryModel.js';
+import LectureModel from './lectureModel.js';
+import AttendanceModel from '../mongodb/attendanceModel.js';
+import UserPayoutDetailsModel from './userPayoutDetailsModel.js';
+class UserPayoutModel extends Model {
+}
+UserPayoutModel.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        field: 'user_id',
+    },
+    userType: {
+        type: DataTypes.ENUM,
+        values: Object.values(USER_TYPES),
+        allowNull: false,
+        field: 'user_type',
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        field: 'institute_id',
+    },
+    totalPayableAmount: {
+        type: DataTypes.FLOAT,
+        allowNull: true,
+        defaultValue: 0,
+        field: 'total_payable_amount',
+    },
+    totalPaidAmount: {
+        type: DataTypes.FLOAT,
+        allowNull: true,
+        defaultValue: 0,
+        field: 'total_paid_amount',
+    },
+    type: {
+        type: DataTypes.ENUM,
+        values: Object.values(USER_PAYOUT_TYPE),
+        allowNull: false,
+    },
+    lastCalculatedAt: {
+        type: DataTypes.DATE,
+        defaultValue: startOfToday(),
+        field: 'last_calculated_at',
+    },
+}, {
+    modelName: 'UserPayoutModel',
+    tableName: 'user_payouts',
+    timestamps: true,
+    sequelize,
+});
+UserPayoutModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserPayoutModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserPayoutModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+UserPayoutModel.belongsTo(InstituteModel, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'institute',
+});
+InstituteModel.hasMany(UserPayoutModel, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'instituteHasPayoutList',
+});
+UserPayoutModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'userId',
+    },
+    as: 'user',
+});
+UserModel.hasMany(UserPayoutModel, {
+    foreignKey: {
+        name: 'userId',
+    },
+    as: 'userHasPayoutList',
+});
+const afterCreateOrUpdateHook = async (userPayout, user = null, transaction, filterOptions = {}) => {
+    try {
+        if (!userPayout.userPayoutDetailsList || !userPayout.userPayoutDetailsList.length)
+            return userPayout;
+        userPayout.userPayoutDetailsList = getUniqueArrayByFields(userPayout.userPayoutDetailsList, ['subjectId']);
+        const options = {
+            transaction,
+        };
+        if (user)
+            options.userId = user.id;
+        const now = new Date();
+        const previousMonthDate = subMonths(now, 1);
+        let startOfPreviousMonth = startOfMonth(previousMonthDate).toISOString();
+        let endOfPreviousMonth = endOfMonth(previousMonthDate).toISOString();
+        if (filterOptions.include) {
+            filterOptions.include = !Array.isArray(filterOptions.include) ? [filterOptions.include] : filterOptions.include;
+            const historyListInclude = filterOptions.include.find((include) => include.as === 'userPayoutHistoryList');
+            let where = {};
+            if (historyListInclude && historyListInclude.where && historyListInclude.where[Op.and]) {
+                where = historyListInclude.where[Op.and].pop();
+            }
+            if (where.payout_start_time && where.payout_end_time) {
+                startOfPreviousMonth = where.payout_start_time[Op.gte];
+                endOfPreviousMonth = where.payout_end_time[Op.lte];
+            }
+        }
+        const attendanceWhereAnd = [{ date: { $gte: startOfPreviousMonth } }, { date: { $lte: endOfPreviousMonth } }];
+        const exsitUserPayout = (await UserPayoutModel.findOne({
+            where: { id: userPayout.id },
+            include: [{ association: 'userPayoutDetailsList' }],
+            transaction,
+        }));
+        if (!exsitUserPayout)
+            return userPayout;
+        if (userPayout.type === USER_PAYOUT_TYPE.PERCENTAGE) {
+            let feeTotalBySubjectList = await SubjectHasPayFeeHistory.findAll({
+                where: {
+                    instituteId: exsitUserPayout.instituteId,
+                    subjectId: {
+                        [Op.in]: userPayout.userPayoutDetailsList.map(userPayoutDetails => userPayoutDetails.subjectId),
+                    },
+                },
+                attributes: [
+                    ['subject_id', 'subjectId'],
+                    [Sequelize.fn('sum', Sequelize.col('amount')), 'amount'],
+                ],
+                group: ['subject_id', 'created_at'],
+                raw: true,
+            });
+            feeTotalBySubjectList = JSON.parse(JSON.stringify(feeTotalBySubjectList));
+            userPayout.userPayoutDetailsList = userPayout.userPayoutDetailsList.map(oneUserPayoutDetails => {
+                oneUserPayoutDetails.payableAmount = feeTotalBySubjectList
+                    .filter(feeTotalBySubject => feeTotalBySubject.subjectId === oneUserPayoutDetails.subjectId)
+                    .reduce((sum, record) => {
+                    if (oneUserPayoutDetails.percentage) {
+                        const amount = ((record.amount || 0) * oneUserPayoutDetails.percentage) / 100;
+                        return sum + parseFloat(amount.toFixed(2)); // Add fixed precision and convert back to number
+                    }
+                    return sum;
+                }, 0);
+                return oneUserPayoutDetails;
+            });
+        }
+        if (userPayout.type === USER_PAYOUT_TYPE.HOURLY) {
+            let lectureList = (await LectureModel.findAll({
+                where: {
+                    instituteId: exsitUserPayout.instituteId,
+                    subject: {
+                        [Op.in]: userPayout.userPayoutDetailsList.map(userPayoutDetails => userPayoutDetails.subjectId),
+                    },
+                    [Op.or]: [{ primaryUserId: exsitUserPayout.userId }, { secondaryUserId: exsitUserPayout.userId }],
+                },
+                include: [{ association: 'workingDay' }],
+            }));
+            lectureList = JSON.parse(JSON.stringify(lectureList));
+            const currentMonthAttendenceList = await AttendanceModel.find({
+                $and: attendanceWhereAnd,
+                userType: userPayout.userType,
+                'users.userId': userPayout.userId,
+                'users.status': { $ne: ATTENDANCE_STATUS.ABSENT },
+            });
+            userPayout.userPayoutDetailsList = userPayout.userPayoutDetailsList.map(oneUserPayoutDetails => {
+                let totalMinutes = 0;
+                currentMonthAttendenceList.forEach(attendance => {
+                    const dayName = format(attendance.date, 'EEEE');
+                    const attendanceDayLectureBySubjectList = lectureList.filter(lecture => {
+                        return lecture.workingDay.dayName === dayName && lecture.subject === oneUserPayoutDetails.subjectId;
+                    });
+                    if (attendanceDayLectureBySubjectList.length) {
+                        totalMinutes += attendanceDayLectureBySubjectList.reduce((sum, record) => {
+                            return sum + record.slotDuration;
+                        }, 0);
+                    }
+                });
+                oneUserPayoutDetails.payableAmount = ((oneUserPayoutDetails.amountPerHour || 0) / SIXTY) * totalMinutes;
+                return oneUserPayoutDetails;
+            });
+        }
+        const userPayoutDetailsList = [];
+        for (let userPayoutDetails of userPayout.userPayoutDetailsList) {
+            userPayoutDetails.userPayoutId = exsitUserPayout.id;
+            userPayoutDetails.userId = exsitUserPayout.userId;
+            userPayoutDetails.instituteId = exsitUserPayout.instituteId;
+            userPayoutDetails.type = exsitUserPayout.type;
+            const found = exsitUserPayout.userPayoutDetailsList.find(exsitUserPayoutDetails => userPayoutDetails.userPayoutId === exsitUserPayout.id &&
+                userPayoutDetails.instituteId === exsitUserPayoutDetails.instituteId &&
+                userPayoutDetails.userId === exsitUserPayoutDetails.userId &&
+                userPayoutDetails.type === exsitUserPayoutDetails.type &&
+                userPayoutDetails.subjectId === exsitUserPayoutDetails.subjectId &&
+                userPayoutDetails.batchId === exsitUserPayoutDetails.batchId);
+            if (found) {
+                await UserPayoutDetailsModel.update(userPayoutDetails, {
+                    where: { id: found.id },
+                    ...options,
+                });
+            }
+            else {
+                userPayoutDetails = (await UserPayoutDetailsModel.create(userPayoutDetails, options));
+            }
+            userPayoutDetailsList.push(userPayoutDetails);
+        }
+        if (userPayoutDetailsList.length) {
+            await UserPayoutDetailsModel.destroy({
+                where: {
+                    id: {
+                        [Op.notIn]: userPayoutDetailsList.map(userPayoutDetails => userPayoutDetails.id),
+                    },
+                    userPayoutId: exsitUserPayout.id,
+                },
+                ...options,
+            });
+        }
+        const totalPayableAmount = userPayoutDetailsList.reduce((sum, record) => {
+            return sum + record.payableAmount || 0;
+        }, 0);
+        //this is updatating payble amount so comment it .
+        // await this.update({ id: exsitUserPayout.id }, { totalPayableAmount, lastCalculatedAt: startOfToday() }, options);
+        userPayout.userPayoutDetailsList = userPayoutDetailsList;
+        userPayout.totalPayableAmount = totalPayableAmount;
+        return userPayout;
+    }
+    catch (err) {
+        throw err;
+    }
+};
+const afterFindHook = async (userPayoutList, options = {}) => {
+    const afterFindHookTransaction = await sequelize.transaction();
+    try {
+        const syncUserPayoutList = JSON.parse(JSON.stringify(userPayoutList));
+        if (!syncUserPayoutList.length) {
+            await afterFindHookTransaction.commit();
+            return userPayoutList;
+        }
+        const updatedData = [];
+        for (let syncUserPayout of syncUserPayoutList) {
+            syncUserPayout = await afterCreateOrUpdateHook(JSON.parse(JSON.stringify(syncUserPayout)), undefined, afterFindHookTransaction, options);
+            updatedData.push(syncUserPayout);
+        }
+        userPayoutList = userPayoutList.map((userPayout) => {
+            const found = updatedData.find(one => one.id === userPayout.id);
+            if (found) {
+                userPayout.totalPayableAmount = found.totalPayableAmount;
+                userPayout.userPayoutDetailsList = found.userPayoutDetailsList;
+            }
+            return userPayout;
+        });
+        await afterFindHookTransaction.commit();
+        return userPayoutList;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (err) {
+        await afterFindHookTransaction.rollback();
+        return userPayoutList;
+    }
+};
+UserPayoutModel.addHook('afterFind', async (result, options) => {
+    if (options.syncUserPayoutLastCalculatedAt && Array.isArray(result)) {
+        result = (await afterFindHook(result, options));
+    }
+    else if (options.syncUserPayoutLastCalculatedAt && result) {
+        result = (await afterFindHook([result], options)).pop();
+    }
+});
+export default UserPayoutModel;

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

@@ -0,0 +1,19 @@
+import { Model } from 'sequelize';
+import { IUserProjectAssessmentOptionModelAttributes } from '../../interfaces/userProjectAssessmentOptionInterface.js';
+import { TUserProjectAssessmentOptionModelCreationAttributes } from '../../types/userProjectAssessmentOptionType.js';
+import { PROJECT_ASSESSMENT_OPTION_STATUS } from '../../constants/app.js';
+declare class UserProjectAssessmentOptionModel extends Model<IUserProjectAssessmentOptionModelAttributes, TUserProjectAssessmentOptionModelCreationAttributes> {
+    id: string;
+    assessmentProjectId: string;
+    projectOptionId: string;
+    userId: string;
+    status: PROJECT_ASSESSMENT_OPTION_STATUS;
+    note: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default UserProjectAssessmentOptionModel;

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

@@ -0,0 +1,121 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index.js';
+import UserModel from './userModel.js';
+import { PROJECT_ASSESSMENT_OPTION_STATUS } from '../../constants/app.js';
+import BatchSubjectProjectAssessmentModel from './batchSubjectProjectAssessmentModel.js';
+import ProjectAssessmentOptionModel from './projectAssessmentOptionModel.js';
+class UserProjectAssessmentOptionModel extends Model {
+}
+UserProjectAssessmentOptionModel.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    assessmentProjectId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        field: 'assessment_project_id',
+    },
+    projectOptionId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+        field: 'project_option_id',
+    },
+    userId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        field: 'user_id',
+    },
+    status: {
+        type: DataTypes.ENUM(...Object.values(PROJECT_ASSESSMENT_OPTION_STATUS)),
+        allowNull: false,
+        defaultValue: PROJECT_ASSESSMENT_OPTION_STATUS.PENDING,
+    },
+    note: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+    },
+}, {
+    modelName: 'UserProjectAssessmentOptionModel',
+    tableName: 'user_project_assessment_options',
+    sequelize,
+    indexes: [
+        {
+            name: 'user_project_assessments_unique_key',
+            unique: true,
+            fields: ['user_id', 'assessment_project_id'],
+            // eslint-disable-next-line camelcase
+            where: { deleted_at: null },
+        },
+    ],
+});
+// Associations
+UserProjectAssessmentOptionModel.belongsTo(BatchSubjectProjectAssessmentModel, {
+    foreignKey: {
+        name: 'assessmentProjectId',
+        field: 'assessment_project_id',
+    },
+    as: 'assessmentProject',
+});
+BatchSubjectProjectAssessmentModel.hasMany(UserProjectAssessmentOptionModel, {
+    foreignKey: {
+        name: 'assessmentProjectId',
+        field: 'assessment_project_id',
+    },
+    as: 'assessmentProjectUserList',
+});
+UserProjectAssessmentOptionModel.belongsTo(ProjectAssessmentOptionModel, {
+    foreignKey: {
+        name: 'projectOptionId',
+        field: 'project_option_id',
+    },
+    as: 'assessmentProjectOption',
+});
+ProjectAssessmentOptionModel.hasMany(UserProjectAssessmentOptionModel, {
+    foreignKey: {
+        name: 'projectOptionId',
+        field: 'project_option_id',
+    },
+    as: 'assessmentProjectOptionUserList',
+});
+UserProjectAssessmentOptionModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'user',
+});
+UserModel.hasMany(UserProjectAssessmentOptionModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'userProjectAssessmentOptionList',
+});
+UserProjectAssessmentOptionModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserProjectAssessmentOptionModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserProjectAssessmentOptionModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+export default UserProjectAssessmentOptionModel;

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

@@ -0,0 +1,17 @@
+import { Model } from 'sequelize';
+import { IUserRequiredStepsAttributes } from '../../interfaces/userRequiredStepsInterface.js';
+import { APP_TYPE } from '../../constants/app.js';
+declare class UserRequiredSteps extends Model<IUserRequiredStepsAttributes> implements IUserRequiredStepsAttributes {
+    id: string;
+    userId: string;
+    stepNumber: number;
+    isCompleted: boolean;
+    appType: APP_TYPE;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+}
+export default UserRequiredSteps;

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

@@ -0,0 +1,73 @@
+import { Model, DataTypes } from 'sequelize';
+import { sequelize } from './index.js';
+import UserModel from './userModel.js';
+class UserRequiredSteps extends Model {
+}
+UserRequiredSteps.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        field: 'user_id',
+    },
+    stepNumber: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        field: 'step_number',
+    },
+    isCompleted: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+        field: 'is_completed',
+    },
+    appType: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        field: 'app_type',
+    },
+}, {
+    sequelize,
+    tableName: 'user_required_steps',
+    modelName: 'UserRequiredSteps',
+    timestamps: true,
+    underscored: true,
+});
+UserRequiredSteps.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserRequiredSteps.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserRequiredSteps.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+UserModel.hasMany(UserRequiredSteps, {
+    foreignKey: 'userId',
+    as: 'userHasRequiredSteps',
+});
+UserRequiredSteps.belongsTo(UserModel, {
+    foreignKey: 'userId',
+    as: 'requiredStepsUser',
+});
+export default UserRequiredSteps;