@kipicore/dbcore 1.1.17 → 1.1.20

package/dist/models/psql/userHasLeaveModel.js

@@ -0,0 +1,121 @@
+"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 masterLeaveModel_1 = __importDefault(require("./masterLeaveModel"));
+const app_1 = require("../../constants/app");
+class UserHasLeaveModel extends sequelize_1.Model {
+}
+UserHasLeaveModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+    },
+    leaveId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+    },
+    userHasLeaveId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+    },
+    totalLeave: {
+        type: sequelize_1.DataTypes.INTEGER,
+        defaultValue: 0,
+        allowNull: true,
+    },
+    leave: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: Object.values(app_1.LEAVE),
+        defaultValue: app_1.LEAVE.PAID,
+        allowNull: false,
+    },
+    usedLeave: {
+        type: sequelize_1.DataTypes.FLOAT,
+        defaultValue: 0,
+        allowNull: false,
+    },
+}, {
+    modelName: 'UserHasLeaveModel',
+    tableName: 'user_has_leave',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+UserHasLeaveModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'leaveUser',
+});
+UserHasLeaveModel.belongsTo(UserHasLeaveModel, { foreignKey: 'userHasLeaveId', as: 'parentLeave' });
+UserHasLeaveModel.hasMany(UserHasLeaveModel, { foreignKey: 'userHasLeaveId', as: 'childLeaves' });
+UserHasLeaveModel.belongsTo(instituteModel_1.default, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'leaveInstitute',
+});
+UserHasLeaveModel.belongsTo(masterLeaveModel_1.default, {
+    foreignKey: {
+        name: 'leaveId',
+        field: 'leave_id',
+    },
+    as: 'leaveDetails',
+});
+masterLeaveModel_1.default.hasMany(UserHasLeaveModel, {
+    foreignKey: {
+        name: 'leaveId',
+        field: 'leave_id',
+    },
+    as: 'associatedUserLeaves',
+});
+userModel_1.default.hasMany(UserHasLeaveModel, {
+    foreignKey: 'userId',
+    as: 'userHasLeaves',
+});
+instituteModel_1.default.hasMany(UserHasLeaveModel, {
+    foreignKey: 'instituteId',
+    as: 'instituteLeaveRecords',
+});
+UserHasLeaveModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserHasLeaveModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserHasLeaveModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+exports.default = UserHasLeaveModel;

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

@@ -0,0 +1,19 @@
+import { Model } from 'sequelize';
+import { IUserHasOfferModelAttributes } from '../../interfaces/userHasOfferInterface';
+import { TUserHasOfferModelCreationAttributes } from '../../types/userHasOffer';
+declare class UserHasOfferModel extends Model<IUserHasOfferModelAttributes, TUserHasOfferModelCreationAttributes> {
+    id: string;
+    userId: string;
+    instituteId: string;
+    feeCollectionId: string;
+    courseId: string;
+    offerId: string;
+    discountAmount: number;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default UserHasOfferModel;

package/dist/models/psql/userHasOfferModel.js

@@ -0,0 +1,154 @@
+"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 offerModel_1 = __importDefault(require("./offerModel"));
+const courseModel_1 = __importDefault(require("./courseModel"));
+// const instituteService = container.resolve<IInstituteService>(InstituteService);
+// const userService = container.resolve<IUserService>(UserService);
+// const feesCollectionCollectionService = container.resolve<IFeesCollectionService>(FeesCollectionService);
+// const offerService = container.resolve<IOfferService>(OfferService);
+class UserHasOfferModel extends sequelize_1.Model {
+}
+UserHasOfferModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+    },
+    offerId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+    },
+    courseId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+    },
+    feeCollectionId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+    },
+    discountAmount: {
+        type: sequelize_1.DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+    },
+}, {
+    modelName: 'UserHasOfferModel',
+    tableName: 'user_has_offers',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+UserHasOfferModel.belongsTo(instituteModel_1.default, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'userHasOfferInstitute',
+});
+instituteModel_1.default.hasMany(UserHasOfferModel, { foreignKey: 'instituteId' });
+UserHasOfferModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserHasOfferModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserHasOfferModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+UserHasOfferModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'offerUser',
+});
+userModel_1.default.hasMany(UserHasOfferModel, { foreignKey: 'userId', as: 'userHasOffer' });
+UserHasOfferModel.belongsTo(feesCollectionModel_1.default, {
+    foreignKey: {
+        name: 'feeCollectionId',
+        field: 'fee_collection_id',
+    },
+    as: 'offerFeeCollection',
+});
+feesCollectionModel_1.default.hasMany(UserHasOfferModel, { foreignKey: 'feeCollectionId', as: 'feeCollectionUserHasOffer' });
+UserHasOfferModel.belongsTo(offerModel_1.default, {
+    foreignKey: {
+        name: 'offerId',
+        field: 'offer_id',
+    },
+    as: 'offerHasUserHasOffer',
+});
+offerModel_1.default.hasMany(UserHasOfferModel, { foreignKey: 'offerId', as: 'userHasOfferOffer' });
+UserHasOfferModel.belongsTo(courseModel_1.default, {
+    foreignKey: {
+        name: 'courseId',
+        field: 'course_id',
+    },
+    as: 'courseHasUserHasOffer',
+});
+courseModel_1.default.hasMany(UserHasOfferModel, { foreignKey: 'courseId', as: 'userOfferHasCourse' });
+// const beforeCreateOrUpdateHook = async (userOffer: UserHasOfferModel) => {
+//     if (userOffer.instituteId) {
+//         const institute = await instituteService.findByPk(userOffer.instituteId);
+//         if (!institute) {
+//             throw new Error(INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+//         }
+//     }
+//     if (userOffer.userId) {
+//         const user = await userService.findByPk(userOffer.userId);
+//         if (!user) {
+//             throw new Error(USER_ERROR_MESSAGES.NOT_FOUND);
+//         }
+//     }
+//     if (userOffer.feeCollectionId) {
+//         const feeCollection = await feesCollectionCollectionService.findByPk(userOffer.feeCollectionId);
+//         if (!feeCollection) {
+//             throw new Error(FEESCOLLECTION_ERROR_MESSAGES.NOT_FOUND);
+//         }
+//     }
+//     if (userOffer.offerId) {
+//         const offer = await offerService.findByPk(userOffer.offerId);
+//         if (!offer) {
+//             throw new Error(OFFER_ERROR_MESSAGES.NOT_FOUND);
+//         }
+//     }
+// };
+// UserHasOfferModel.beforeCreate(beforeCreateOrUpdateHook);
+// UserHasOfferModel.beforeUpdate(beforeCreateOrUpdateHook);
+// UserHasOfferModel.beforeBulkCreate(async instances => {
+//     for (const instance of instances) {
+//         await beforeCreateOrUpdateHook(instance);
+//     }
+// });
+exports.default = UserHasOfferModel;

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

@@ -0,0 +1,23 @@
+import { Model } from 'sequelize';
+import { USER_HAS_PARENT_STATUS } from '../../constants/app';
+import { IUserHasParentAttributes } from '../../interfaces/userHasParentInterface';
+import { TUserHasParentCreationAttributes } from '../../types/userHasParentType';
+declare class UserHasParentModel extends Model<IUserHasParentAttributes, TUserHasParentCreationAttributes> {
+    id: string;
+    status: USER_HAS_PARENT_STATUS;
+    userId: string;
+    parentId: string;
+    instituteAccess: string[];
+    unverifiedInstitute: string[];
+    isPrimaryParent: boolean;
+    isGuardianParent: boolean;
+    isDeleted: boolean;
+    securityCode: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default UserHasParentModel;

package/dist/models/psql/userHasParentModel.js

@@ -0,0 +1,135 @@
+"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"));
+class UserHasParentModel extends sequelize_1.Model {
+}
+UserHasParentModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'user_id',
+        allowNull: false,
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING(30),
+        allowNull: false,
+        defaultValue: app_1.USER_HAS_PARENT_STATUS.PENDING,
+    },
+    securityCode: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    parentId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'parent_id',
+        allowNull: false,
+    },
+    instituteAccess: {
+        type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.STRING),
+        field: 'institute_access',
+        defaultValue: [],
+        allowNull: true,
+    },
+    unverifiedInstitute: {
+        type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.STRING),
+        field: 'unverified_institute',
+        defaultValue: [],
+        allowNull: true,
+    },
+    isPrimaryParent: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        field: 'is_primary_parent',
+        allowNull: false,
+        defaultValue: false,
+    },
+    isGuardianParent: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        field: 'is_guardian_parent',
+        allowNull: false,
+        defaultValue: false,
+    },
+    isDeleted: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        field: 'is_deleted',
+        allowNull: false,
+        defaultValue: false,
+    },
+}, {
+    modelName: 'UserHasParentModel',
+    tableName: 'user_has_parents',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+userModel_1.default.hasMany(UserHasParentModel, {
+    foreignKey: {
+        name: 'userId',
+        allowNull: false,
+        field: 'userId',
+    },
+    as: 'parents',
+});
+userModel_1.default.hasMany(UserHasParentModel, {
+    foreignKey: {
+        name: 'parentId',
+        allowNull: false,
+        field: 'parentId',
+    },
+    as: 'users',
+});
+UserHasParentModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'parentId',
+        allowNull: false,
+        field: 'parent_id',
+    },
+    as: 'parent',
+});
+UserHasParentModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'userId',
+        allowNull: false,
+        field: 'user_id',
+    },
+    as: 'user',
+});
+UserHasParentModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserHasParentModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserHasParentModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+UserHasParentModel.addHook('beforeFind', options => {
+    if (!Object.prototype.hasOwnProperty.call(options.where, 'isDeleted')) {
+        options.where = { ...options.where, isDeleted: false };
+    }
+});
+exports.default = UserHasParentModel;

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

@@ -0,0 +1,18 @@
+import { Model } from 'sequelize';
+import { COMMAN_STATUS } from '../../constants/app';
+import { IUserHasRoleAttributes } from '../../interfaces/userHasRoleInterface';
+import { TUserHasRoleCreationAttributes } from '../../types/userHasRoleType';
+declare class UserHasRoleModel extends Model<IUserHasRoleAttributes, TUserHasRoleCreationAttributes> {
+    id: string;
+    status: COMMAN_STATUS;
+    userId: string;
+    roleId: string;
+    instituteId: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default UserHasRoleModel;

package/dist/models/psql/userHasRoleModel.js

@@ -0,0 +1,97 @@
+"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 roleModel_1 = __importDefault(require("./roleModel"));
+const instituteModel_1 = __importDefault(require("./instituteModel"));
+class UserHasRoleModel extends sequelize_1.Model {
+}
+UserHasRoleModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'user_id',
+        allowNull: false,
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING(30),
+        allowNull: false,
+        defaultValue: app_1.COMMAN_STATUS.ACTIVE,
+    },
+    roleId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'role_id',
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'institute_id',
+        allowNull: true,
+    },
+}, {
+    modelName: 'UserHasRoleModel',
+    tableName: 'user_has_roles',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+// UserModel.belongsToMany(RoleModel, { foreignKey: 'userId', through: 'UserHasRoleModel' });
+// RoleModel.belongsToMany(UserModel, { foreignKey: 'roleId', through: 'UserHasRoleModel' });
+UserHasRoleModel.belongsTo(instituteModel_1.default, {
+    foreignKey: {
+        name: 'instituteId',
+        allowNull: true,
+        field: 'institute_id',
+    },
+    as: 'institute',
+});
+UserHasRoleModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'userId',
+        allowNull: false,
+        field: 'user_id',
+    },
+    as: 'user',
+});
+UserHasRoleModel.belongsTo(roleModel_1.default, {
+    foreignKey: {
+        name: 'roleId',
+        allowNull: false,
+        field: 'role_id',
+    },
+    as: 'role',
+});
+UserHasRoleModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserHasRoleModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserHasRoleModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+exports.default = UserHasRoleModel;

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

@@ -0,0 +1,17 @@
+import { Model } from 'sequelize';
+import { IUserHasRollNumberModelAttributes } from '../../interfaces/userHasRollNumberInterface';
+import { TUserHasRoleCreationAttributes } from '../../types/userHasRoleType';
+declare class UserHasRollNumberModel extends Model<IUserHasRollNumberModelAttributes, TUserHasRoleCreationAttributes> {
+    id: string;
+    userId: string;
+    instituteId: string;
+    batchId: string;
+    rollNumber: number;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default UserHasRollNumberModel;

package/dist/models/psql/userHasRollNumberModel.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 batchModel_1 = __importDefault(require("./batchModel"));
+class UserHasRollNumberModel extends sequelize_1.Model {
+}
+UserHasRollNumberModel.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,
+    },
+    batchId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+    },
+    rollNumber: {
+        type: sequelize_1.DataTypes.INTEGER,
+        allowNull: false,
+    },
+}, {
+    modelName: 'UserHasRollNumberModel',
+    tableName: 'user_has_roll_number',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+UserHasRollNumberModel.belongsTo(instituteModel_1.default, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'rollNumberHasInstitute',
+});
+instituteModel_1.default.hasMany(UserHasRollNumberModel, { foreignKey: 'instituteId', as: 'instituteHasRollNumber' });
+UserHasRollNumberModel.belongsTo(batchModel_1.default, {
+    foreignKey: {
+        name: 'batchId',
+        field: 'batch_id',
+    },
+    as: 'rollNumberHasBatch',
+});
+batchModel_1.default.hasMany(UserHasRollNumberModel, { foreignKey: 'batchId', as: 'batchHasRollNumber' });
+UserHasRollNumberModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserHasRollNumberModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserHasRollNumberModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+UserHasRollNumberModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'userRollNumber',
+});
+userModel_1.default.hasMany(UserHasRollNumberModel, { foreignKey: 'userId', as: 'rollNumberHasUser' });
+exports.default = UserHasRollNumberModel;