@kipicore/dbcore 1.1.13 → 1.1.14

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

@@ -0,0 +1,143 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index.js';
+import { USER_TYPES, ASSIGN_TYPE, RETURN_STATUS } from '../../constants/app.js';
+import InstituteModel from './instituteModel.js';
+import UserModel from './userModel.js';
+import InventoryModel from './inventoryModel.js';
+class UserHasInventoryModel extends Model {
+}
+UserHasInventoryModel.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userType: {
+        type: DataTypes.ENUM,
+        values: Object.values(USER_TYPES),
+        allowNull: false,
+    },
+    userId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    quantity: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+    },
+    totalReturnQuantity: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    assignType: {
+        type: DataTypes.ENUM,
+        values: Object.values(ASSIGN_TYPE),
+        allowNull: false,
+    },
+    expectedReturnDate: {
+        type: DataTypes.DATE,
+        allowNull: true,
+    },
+    inventoryId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    subjectId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+    },
+    returnStatus: {
+        type: DataTypes.ENUM,
+        values: Object.values(RETURN_STATUS),
+        allowNull: false,
+        defaultValue: RETURN_STATUS.NOT_RETURN,
+    },
+    returnQuantity: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 0,
+    },
+    returnDate: {
+        type: DataTypes.DATE,
+        allowNull: true,
+    },
+    returnDamageQuantity: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 0,
+    },
+    returnLostQuantity: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 0,
+    },
+    penalty: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 0,
+    },
+    returnNote: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+}, {
+    modelName: 'UserHasInventoryModel',
+    tableName: 'user_has_inventory',
+    timestamps: true,
+    sequelize,
+});
+UserHasInventoryModel.belongsTo(InventoryModel, {
+    foreignKey: {
+        name: 'inventoryId',
+        field: 'inventory_id',
+    },
+    as: 'inventory',
+});
+InventoryModel.hasMany(UserHasInventoryModel, { foreignKey: 'inventoryId' });
+UserHasInventoryModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'user',
+});
+UserModel.hasMany(UserHasInventoryModel, { foreignKey: 'userId', as: 'userHasInventory' });
+UserHasInventoryModel.belongsTo(InstituteModel, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'inventoryInstitute',
+});
+InstituteModel.hasMany(UserHasInventoryModel, { foreignKey: 'instituteId' });
+UserHasInventoryModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserHasInventoryModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserHasInventoryModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+export default UserHasInventoryModel;

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

@@ -0,0 +1,25 @@
+import { Model } from 'sequelize';
+import { IUserHasLeaveHistoryModelAttributes } from '../../interfaces/userHasLeaveHistoryInterface.js';
+import { TUserHasLeaveHistoryModelCreationAttributes } from '../../types/userHasLeaveHistoryType.js';
+import { LEAVE, LEAVE_STATUS, LEAVE_TYPE } from '../../constants/app.js';
+declare class UserHasLeaveHistoryModel extends Model<IUserHasLeaveHistoryModelAttributes, TUserHasLeaveHistoryModelCreationAttributes> {
+    id: string;
+    userId: string;
+    instituteId: string;
+    usedLeave: number;
+    leaveType: LEAVE_TYPE;
+    reason?: string;
+    status: LEAVE_STATUS;
+    startTime: Date;
+    endTime: Date;
+    leave: LEAVE;
+    userLeaveRequestId: string;
+    userHasLeaveId: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default UserHasLeaveHistoryModel;

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

@@ -0,0 +1,101 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index.js';
+import InstituteModel from './instituteModel.js';
+import UserModel from './userModel.js';
+import { LEAVE, LEAVE_STATUS, LEAVE_TYPE } from '../../constants/app.js';
+import UserHasLeaveModel from './userHasLeaveModel.js';
+class UserHasLeaveHistoryModel extends Model {
+}
+UserHasLeaveHistoryModel.init({
+    id: {
+        type: DataTypes.UUID,
+        primaryKey: true,
+        defaultValue: DataTypes.UUIDV4,
+    },
+    userId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    userLeaveRequestId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    userHasLeaveId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    usedLeave: {
+        type: DataTypes.FLOAT,
+        defaultValue: 0,
+        allowNull: false,
+    },
+    leaveType: {
+        type: DataTypes.ENUM,
+        values: Object.values(LEAVE_TYPE),
+        allowNull: false,
+    },
+    leave: {
+        type: DataTypes.ENUM,
+        values: Object.values(LEAVE),
+        defaultValue: LEAVE.PAID,
+        allowNull: false,
+    },
+    reason: {
+        type: DataTypes.STRING,
+        allowNull: true,
+    },
+    status: {
+        type: DataTypes.ENUM,
+        values: Object.values(LEAVE_STATUS),
+        defaultValue: LEAVE_STATUS.PENDING,
+        allowNull: false,
+    },
+    startTime: {
+        type: DataTypes.DATE,
+        allowNull: false,
+    },
+    endTime: {
+        type: DataTypes.DATE,
+        allowNull: false,
+    },
+}, {
+    modelName: 'UserHasLeaveHistory',
+    tableName: 'user_has_leave_history',
+    timestamps: true,
+    sequelize,
+});
+UserHasLeaveHistoryModel.belongsTo(UserModel, { foreignKey: 'userId', as: 'user' });
+UserHasLeaveHistoryModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+UserHasLeaveHistoryModel.belongsTo(UserHasLeaveModel, { foreignKey: 'userHasLeaveId', as: 'userHasLeave' });
+UserModel.hasMany(UserHasLeaveHistoryModel, { foreignKey: 'userId', as: 'leaveHistory' });
+InstituteModel.hasMany(UserHasLeaveHistoryModel, { foreignKey: 'instituteId', as: 'leaveHistory' });
+UserHasLeaveModel.belongsTo(UserHasLeaveHistoryModel, { foreignKey: 'userHasLeaveId', as: 'leaveHasUser' });
+UserHasLeaveHistoryModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserHasLeaveHistoryModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserHasLeaveHistoryModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+export default UserHasLeaveHistoryModel;

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

@@ -0,0 +1,21 @@
+import { Model } from 'sequelize';
+import { IUserHasLeaveModelAttributes } from '../../interfaces/userHasLeaveInterface.js';
+import { TUserHasLeaveModelCreationAttributes } from '../../types/userHasLeaveType.js';
+import { LEAVE } from '../../constants/app.js';
+declare class UserHasLeaveModel extends Model<IUserHasLeaveModelAttributes, TUserHasLeaveModelCreationAttributes> {
+    id: string;
+    userId: string;
+    instituteId: string;
+    totalLeave: number;
+    usedLeave: number;
+    leaveId: string;
+    leave: LEAVE;
+    userHasLeaveId: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default UserHasLeaveModel;

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

@@ -0,0 +1,116 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index.js';
+import InstituteModel from './instituteModel.js';
+import UserModel from './userModel.js';
+import MasterLeaveModel from './masterLeaveModel.js';
+import { LEAVE } from '../../constants/app.js';
+class UserHasLeaveModel extends Model {
+}
+UserHasLeaveModel.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    leaveId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    userHasLeaveId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+    },
+    totalLeave: {
+        type: DataTypes.INTEGER,
+        defaultValue: 0,
+        allowNull: true,
+    },
+    leave: {
+        type: DataTypes.ENUM,
+        values: Object.values(LEAVE),
+        defaultValue: LEAVE.PAID,
+        allowNull: false,
+    },
+    usedLeave: {
+        type: DataTypes.FLOAT,
+        defaultValue: 0,
+        allowNull: false,
+    },
+}, {
+    modelName: 'UserHasLeaveModel',
+    tableName: 'user_has_leave',
+    timestamps: true,
+    sequelize,
+});
+UserHasLeaveModel.belongsTo(UserModel, {
+    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, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'leaveInstitute',
+});
+UserHasLeaveModel.belongsTo(MasterLeaveModel, {
+    foreignKey: {
+        name: 'leaveId',
+        field: 'leave_id',
+    },
+    as: 'leaveDetails',
+});
+MasterLeaveModel.hasMany(UserHasLeaveModel, {
+    foreignKey: {
+        name: 'leaveId',
+        field: 'leave_id',
+    },
+    as: 'associatedUserLeaves',
+});
+UserModel.hasMany(UserHasLeaveModel, {
+    foreignKey: 'userId',
+    as: 'userHasLeaves',
+});
+InstituteModel.hasMany(UserHasLeaveModel, {
+    foreignKey: 'instituteId',
+    as: 'instituteLeaveRecords',
+});
+UserHasLeaveModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserHasLeaveModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserHasLeaveModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+export default UserHasLeaveModel;

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

@@ -0,0 +1,19 @@
+import { Model } from 'sequelize';
+import { IUserHasOfferModelAttributes } from '../../interfaces/userHasOfferInterface.js';
+import { TUserHasOfferModelCreationAttributes } from '../../types/userHasOffer.js';
+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/esm/models/psql/userHasOfferModel.js

@@ -0,0 +1,149 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index.js';
+import InstituteModel from './instituteModel.js';
+import UserModel from './userModel.js';
+import FeesCollectionModel from './feesCollectionModel.js';
+import OfferModel from './offerModel.js';
+import CourseModel from './courseModel.js';
+// 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 Model {
+}
+UserHasOfferModel.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    offerId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    courseId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+    },
+    feeCollectionId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+    },
+    discountAmount: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+    },
+}, {
+    modelName: 'UserHasOfferModel',
+    tableName: 'user_has_offers',
+    timestamps: true,
+    sequelize,
+});
+UserHasOfferModel.belongsTo(InstituteModel, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'userHasOfferInstitute',
+});
+InstituteModel.hasMany(UserHasOfferModel, { foreignKey: 'instituteId' });
+UserHasOfferModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserHasOfferModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserHasOfferModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+UserHasOfferModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'offerUser',
+});
+UserModel.hasMany(UserHasOfferModel, { foreignKey: 'userId', as: 'userHasOffer' });
+UserHasOfferModel.belongsTo(FeesCollectionModel, {
+    foreignKey: {
+        name: 'feeCollectionId',
+        field: 'fee_collection_id',
+    },
+    as: 'offerFeeCollection',
+});
+FeesCollectionModel.hasMany(UserHasOfferModel, { foreignKey: 'feeCollectionId', as: 'feeCollectionUserHasOffer' });
+UserHasOfferModel.belongsTo(OfferModel, {
+    foreignKey: {
+        name: 'offerId',
+        field: 'offer_id',
+    },
+    as: 'offerHasUserHasOffer',
+});
+OfferModel.hasMany(UserHasOfferModel, { foreignKey: 'offerId', as: 'userHasOfferOffer' });
+UserHasOfferModel.belongsTo(CourseModel, {
+    foreignKey: {
+        name: 'courseId',
+        field: 'course_id',
+    },
+    as: 'courseHasUserHasOffer',
+});
+CourseModel.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);
+//     }
+// });
+export default UserHasOfferModel;

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

@@ -0,0 +1,23 @@
+import { Model } from 'sequelize';
+import { USER_HAS_PARENT_STATUS } from '../../constants/app.js';
+import { IUserHasParentAttributes } from '../../interfaces/userHasParentInterface.js';
+import { TUserHasParentCreationAttributes } from '../../types/userHasParentType.js';
+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;