@kipicore/dbcore 1.0.9 → 1.1.0

package/dist/models/psql/feeReminderSettingModel.ts

@@ -1,115 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-import { sequelize } from './index';
-import { IFeeReminderSettingModelAttributes } from '../../interfaces/feeReminderSettingInterface';
-import { TFeeReminderSettingModelCreationAttributes } from '../../types/feeReminderSettingType';
-import InstituteModel from './instituteModel';
-import UserModel from './userModel';
-import { BOOLEAN_STATUS, FEE_REMINDER_SETTING_STATUS } from '../../constants/app';
-
-class FeeReminderSettingModel extends Model<IFeeReminderSettingModelAttributes, TFeeReminderSettingModelCreationAttributes> {
-    declare id: string;
-    declare instituteId: string;
-    declare templateData: string;
-    declare status: FEE_REMINDER_SETTING_STATUS;
-    declare typeId: string;
-    declare default: BOOLEAN_STATUS;
-    // declare frequency: FEE_REMINDER_SETTING_FREQUENCY;
-    // declare startDay: number;
-    // declare dueDate: Date;
-    // declare dueAmount: number;
-
-    declare createdBy: string;
-    declare updatedBy: string;
-    declare deletedBy: string;
-    declare readonly createdAt: Date;
-    declare readonly deletedAt: string;
-    declare readonly updatedAt: Date;
-}
-
-FeeReminderSettingModel.init(
-    {
-        id: {
-            type: DataTypes.UUID,
-            defaultValue: DataTypes.UUIDV4,
-            allowNull: false,
-            primaryKey: true,
-        },
-        instituteId: {
-            type: DataTypes.UUID,
-            allowNull: false,
-        },
-        templateData: {
-            type: DataTypes.TEXT,
-            allowNull: false,
-        },
-        status: {
-            type: DataTypes.ENUM(...Object.values(FEE_REMINDER_SETTING_STATUS)),
-            allowNull: false,
-            defaultValue: FEE_REMINDER_SETTING_STATUS.INACTIVE,
-        },
-        default: {
-            type: DataTypes.ENUM(...Object.values(BOOLEAN_STATUS)),
-            defaultValue: BOOLEAN_STATUS.NO,
-            allowNull: false,
-        },
-        typeId: {
-            type: DataTypes.STRING,
-            allowNull: true,
-        },
-        // frequency: {
-        //     type: DataTypes.ENUM(...Object.values(FEE_REMINDER_SETTING_FREQUENCY)),
-        //     allowNull: true,
-        //     defaultValue: FEE_REMINDER_SETTING_FREQUENCY.WEEKLY,
-        // },
-        // startDay: {
-        //     type: DataTypes.INTEGER,
-        //     allowNull: true,
-        //     defaultValue: 15,
-        // },
-    },
-    {
-        modelName: 'FeeReminderSettingModel',
-        tableName: 'fee_reminder_settings',
-        timestamps: true,
-        sequelize,
-    },
-);
-
-FeeReminderSettingModel.belongsTo(InstituteModel, {
-    foreignKey: {
-        name: 'instituteId',
-        field: 'institute_id',
-    },
-    as: 'settingInstitute',
-});
-
-InstituteModel.hasMany(FeeReminderSettingModel, { foreignKey: 'instituteId', as: 'instituteReminderSettings' });
-
-FeeReminderSettingModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-
-FeeReminderSettingModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-
-FeeReminderSettingModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-
-export default FeeReminderSettingModel;

package/dist/models/psql/feeTypeHasTermsModel.ts

@@ -1,127 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-import { sequelize } from './index';
-import { IFeeTypeHasTermsModelAttributes } from '../../interfaces/feeTypeHasTermsInterface';
-import { TFeeTypeHasTermsModelCreationAttributes } from '../../types/feeTypeHasTermsType';
-import { PAYMENT_TERMS_TYPE } from '../../constants/app';
-import FeeTypeModel from './feeTypeModel';
-import InstituteModel from './instituteModel';
-import UserModel from './userModel';
-
-class FeeTypeHasTermsModel extends Model<IFeeTypeHasTermsModelAttributes, TFeeTypeHasTermsModelCreationAttributes> {
-    declare id: string;
-    declare stdId: string;
-    declare feeTypeId: string;
-    declare frequency: PAYMENT_TERMS_TYPE;
-    declare amount: number;
-    declare date: Date;
-    declare instituteId: string;
-    declare academicCalendarId: string;
-
-    declare createdBy: string;
-    declare updatedBy: string;
-    declare deletedBy: string;
-    declare readonly createdAt: Date;
-    declare readonly deletedAt: string;
-    declare readonly updatedAt: Date;
-}
-
-FeeTypeHasTermsModel.init(
-    {
-        id: {
-            type: DataTypes.UUID,
-            defaultValue: DataTypes.UUIDV4,
-            allowNull: false,
-            primaryKey: true,
-        },
-        instituteId: {
-            type: DataTypes.UUID,
-            field: 'institute_id',
-            allowNull: false,
-        },
-        stdId: {
-            type: DataTypes.UUID,
-            allowNull: false,
-        },
-        feeTypeId: {
-            type: DataTypes.UUID,
-            allowNull: false,
-        },
-        academicCalendarId: {
-            type: DataTypes.UUID,
-            allowNull: true,
-        },
-        amount: {
-            type: DataTypes.INTEGER,
-            allowNull: false,
-        },
-        date: {
-            type: DataTypes.DATE,
-            allowNull: false,
-        },
-        frequency: {
-            type: DataTypes.ENUM,
-            values: Object.values(PAYMENT_TERMS_TYPE),
-            allowNull: false,
-        },
-    },
-    {
-        modelName: 'FeeTypeHasTermsModel',
-        tableName: 'fee_type_has_terms',
-        timestamps: true,
-        sequelize,
-    },
-);
-
-FeeTypeHasTermsModel.belongsTo(FeeTypeModel, {
-    foreignKey: {
-        name: 'feeTypeId',
-    },
-    as: 'termsFeeType',
-});
-
-FeeTypeModel.hasMany(FeeTypeHasTermsModel, {
-    foreignKey: 'feeTypeId',
-    as: 'feeTypeHasTerms',
-});
-
-FeeTypeHasTermsModel.belongsTo(InstituteModel, {
-    foreignKey: {
-        name: 'instituteId',
-        field: 'institute_id',
-    },
-    as: 'instituteFeeTypeTerms',
-});
-
-InstituteModel.hasMany(FeeTypeHasTermsModel, {
-    foreignKey: 'instituteId',
-    as: 'feeTypeHasTermsInstitute',
-});
-
-FeeTypeHasTermsModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-
-FeeTypeHasTermsModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-
-FeeTypeHasTermsModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-
-export default FeeTypeHasTermsModel;

package/dist/models/psql/feeTypeModel.ts

@@ -1,151 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-import { sequelize } from './index';
-import { IFeeTypeModelAttributes } from '../../interfaces/feeTypeInterface';
-import { TFeeTypeModelCreationAttributes } from '../../types/feeTypeType';
-import { BOOLEAN_STATUS, COMMAN_STATUS, FEE_TYPE, FEE_TYPE_FREQUENCY } from '../../constants/app';
-import InstituteModel from './instituteModel';
-import UserModel from './userModel';
-import BankAccountDetailsModel from './bankAccountDetailsModel';
-import TypeManagementModel from './typeManagementModel';
-
-class FeeTypeModel extends Model<IFeeTypeModelAttributes, TFeeTypeModelCreationAttributes> {
-    declare id: string;
-    declare instituteId: string;
-    declare typeManagementId: string;
-    declare frequency: FEE_TYPE_FREQUENCY;
-    declare feeType: FEE_TYPE;
-    declare module: COMMAN_STATUS;
-    declare status: COMMAN_STATUS;
-    declare account: string;
-    declare isDefault: BOOLEAN_STATUS;
-
-    declare createdBy: string;
-    declare updatedBy: string;
-    declare deletedBy: string;
-    declare readonly createdAt: Date;
-    declare readonly deletedAt: string;
-    declare readonly updatedAt: Date;
-}
-
-FeeTypeModel.init(
-    {
-        id: {
-            type: DataTypes.UUID,
-            defaultValue: DataTypes.UUIDV4,
-            allowNull: false,
-            primaryKey: true,
-        },
-        typeManagementId: {
-            type: DataTypes.UUID,
-            field: 'type_management_id',
-            allowNull: false,
-        },
-        instituteId: {
-            type: DataTypes.UUID,
-            field: 'institute_id',
-            allowNull: false,
-        },
-        account: {
-            type: DataTypes.UUID,
-            allowNull: false,
-        },
-        status: {
-            type: DataTypes.ENUM,
-            values: Object.values(COMMAN_STATUS),
-            defaultValue: COMMAN_STATUS.ACTIVE,
-            allowNull: false,
-        },
-        module: {
-            type: DataTypes.ENUM,
-            values: Object.values(COMMAN_STATUS),
-            defaultValue: COMMAN_STATUS.INACTIVE,
-            allowNull: false,
-        },
-        isDefault: {
-            type: DataTypes.ENUM,
-            values: Object.values(BOOLEAN_STATUS),
-            allowNull: false,
-            defaultValue: BOOLEAN_STATUS.NO,
-        },
-        feeType: {
-            type: DataTypes.ENUM,
-            values: Object.values(FEE_TYPE),
-            allowNull: false,
-        },
-        frequency: {
-            type: DataTypes.ENUM,
-            values: Object.values(FEE_TYPE_FREQUENCY),
-            allowNull: false,
-        },
-    },
-    {
-        modelName: 'FeeTypeModel',
-        tableName: 'fee_type',
-        timestamps: true,
-        sequelize,
-    },
-);
-
-FeeTypeModel.belongsTo(BankAccountDetailsModel, {
-    foreignKey: {
-        name: 'account',
-    },
-    as: 'accountFeeType',
-});
-
-BankAccountDetailsModel.hasMany(FeeTypeModel, {
-    foreignKey: 'account',
-    as: 'feeTypeHasAccount',
-});
-TypeManagementModel.hasMany(FeeTypeModel, {
-    foreignKey: 'typeManagementId',
-    as: 'feeTypeTypeManagement',
-});
-FeeTypeModel.belongsTo(TypeManagementModel, {
-    foreignKey: {
-        name: 'typeManagementId',
-    },
-    as: 'typeManagementType',
-});
-
-FeeTypeModel.belongsTo(InstituteModel, {
-    foreignKey: {
-        name: 'instituteId',
-        field: 'institute_id',
-    },
-    as: 'instituteFeeType',
-});
-
-InstituteModel.hasMany(FeeTypeModel, {
-    foreignKey: 'instituteId',
-    as: 'feeTypeInstitute',
-});
-
-FeeTypeModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-
-FeeTypeModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-
-FeeTypeModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-
-export default FeeTypeModel;

package/dist/models/psql/feesCollectionModel.ts

@@ -1,275 +0,0 @@
-import { DataTypes, Model, Op, Sequelize, UpdateOptions } from "sequelize";
-import { sequelize } from "./index";
-import { IFeesCollectionModelAttributes } from "../../interfaces/feesCollectionInterface";
-import { TFeesCollectionModelCreationAttributes } from "../../types/feesCollectionType";
-import { FEE_PAYMENT_STATUS, PAYMENT_TYPE } from "../../constants/app";
-import InstituteModel from "./instituteModel";
-import UserModel from "./userModel";
-import { HTTP_STATUS_CODE } from "../../constants/httpStatusCode";
-import { FEESCOLLECTION_ERROR_MESSAGES } from "../../constants/errorMessages";
-import PaymentTermsModel from "./paymentTermsModel";
-import AcademicCalendarModel from "./academicCalendarModel";
-
-class FeesCollectionModel extends Model<
-  IFeesCollectionModelAttributes,
-  TFeesCollectionModelCreationAttributes
-> {
-  declare id: string;
-  declare date: Date;
-  declare dueDate?: Date;
-  declare feeAmount?: number;
-  declare paidFee?: number;
-  declare discount?: number;
-  declare paymentType?: PAYMENT_TYPE;
-  declare bankName?: string | null;
-  declare chequeNo?: string | null;
-  declare userId: string;
-  declare instituteId: string;
-  declare upiId?: string | null;
-  declare status: FEE_PAYMENT_STATUS;
-  declare academicCalendarId: string;
-  declare isLeft?: boolean;
-
-  declare createdBy: string;
-  declare updatedBy: string;
-  declare deletedBy: string;
-  declare readonly createdAt: Date;
-  declare readonly deletedAt: string;
-  declare readonly updatedAt: Date;
-}
-
-FeesCollectionModel.init(
-  {
-    id: {
-      type: DataTypes.UUID,
-      defaultValue: DataTypes.UUIDV4,
-
-      allowNull: false,
-      primaryKey: true,
-    },
-    date: {
-      type: DataTypes.DATE,
-      defaultValue: Sequelize.literal("CURRENT_TIMESTAMP"),
-      allowNull: true,
-    },
-    dueDate: {
-      type: DataTypes.DATE,
-      allowNull: true,
-    },
-    feeAmount: {
-      type: DataTypes.INTEGER,
-      defaultValue: 0,
-      allowNull: true,
-    },
-    discount: {
-      type: DataTypes.INTEGER,
-      defaultValue: 0,
-      allowNull: true,
-    },
-    paidFee: {
-      type: DataTypes.INTEGER,
-      defaultValue: 0,
-      allowNull: true,
-    },
-    bankName: {
-      type: DataTypes.STRING,
-      allowNull: true,
-    },
-    chequeNo: {
-      type: DataTypes.STRING,
-      allowNull: true,
-    },
-    upiId: {
-      type: DataTypes.STRING,
-      allowNull: true,
-    },
-    status: {
-      type: DataTypes.STRING,
-      allowNull: true,
-      defaultValue: FEE_PAYMENT_STATUS.PENDING,
-    },
-    paymentType: {
-      type: DataTypes.ENUM,
-      values: Object.values(PAYMENT_TYPE),
-      allowNull: true,
-      // defaultValue: PAYMENT_TYPE.CASH,
-    },
-    academicCalendarId: {
-      type: DataTypes.UUID,
-      field: "academic_calendar_id",
-      allowNull: false,
-    },
-    userId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-    },
-    instituteId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-    },
-    isLeft: {
-      type: DataTypes.BOOLEAN,
-      field: "is_left",
-      defaultValue: false,
-      allowNull: true,
-    },
-  },
-  {
-    modelName: "FeesCollectionModel",
-    tableName: "fees_collections",
-    timestamps: true,
-    sequelize,
-  }
-);
-const beforeCreateOrUpdateHook = async (
-  feeCollection: FeesCollectionModel
-): Promise<void> => {
-  let existingRecord: FeesCollectionModel | null = null;
-
-  if ((feeCollection.userId && feeCollection.instituteId) || feeCollection.id) {
-    if (feeCollection.userId && feeCollection.instituteId) {
-      existingRecord = await FeesCollectionModel.findOne({
-        where: {
-          userId: feeCollection.userId,
-          instituteId: feeCollection.instituteId,
-        },
-      });
-    } else {
-      existingRecord = await FeesCollectionModel.findByPk(feeCollection.id);
-    }
-    if (
-      existingRecord?.status === FEE_PAYMENT_STATUS.COMPLETED &&
-      feeCollection.paidFee
-    ) {
-      throw new Error(FEESCOLLECTION_ERROR_MESSAGES.FEE_PAID);
-    }
-  } else {
-    existingRecord = await FeesCollectionModel.findOne({
-      where: {
-        userId: feeCollection.userId,
-        instituteId: feeCollection.instituteId,
-        status: { [Op.ne]: FEE_PAYMENT_STATUS.COMPLETED },
-      },
-    });
-  }
-
-  if (feeCollection.paymentType === PAYMENT_TYPE.CHEQUE) {
-    feeCollection.upiId = null;
-    if (!feeCollection.chequeNo || !feeCollection.bankName) {
-      throw new Error(FEESCOLLECTION_ERROR_MESSAGES.FEE_PAID_BY_CHQUE);
-    }
-  } else if (feeCollection.paymentType === PAYMENT_TYPE.UPI) {
-    feeCollection.chequeNo = null;
-    feeCollection.bankName = null;
-    if (!feeCollection.upiId) {
-      throw new Error(FEESCOLLECTION_ERROR_MESSAGES.FEE_PAID_BY_UPI);
-    }
-  } else if (feeCollection.paymentType === PAYMENT_TYPE.CASH) {
-    feeCollection.bankName = null;
-    feeCollection.chequeNo = null;
-    feeCollection.upiId = null;
-  }
-
-  const discount = feeCollection.discount ?? existingRecord?.discount ?? 0;
-  const paidFee = feeCollection.paidFee ?? existingRecord?.paidFee ?? 0;
-  const feeAmount = feeCollection.feeAmount ?? existingRecord?.feeAmount;
-  if (feeAmount !== 0) {
-    if (feeAmount === discount + paidFee) {
-      feeCollection.status = FEE_PAYMENT_STATUS.COMPLETED;
-    }
-  }
-};
-
-FeesCollectionModel.beforeBulkCreate(async (instances) => {
-  for (const instance of instances) {
-    await beforeCreateOrUpdateHook(instance);
-  }
-});
-FeesCollectionModel.beforeCreate(beforeCreateOrUpdateHook);
-
-FeesCollectionModel.beforeBulkUpdate(async (options: UpdateOptions) => {
-  await beforeCreateOrUpdateHook(options.attributes);
-});
-
-FeesCollectionModel.belongsTo(InstituteModel, {
-  foreignKey: {
-    name: "instituteId",
-    field: "institute_id",
-  },
-  as: "feeCollectionInstitute",
-});
-
-InstituteModel.hasMany(FeesCollectionModel, {
-  foreignKey: "instituteId",
-  as: "instituteHasFeeCollection",
-});
-FeesCollectionModel.belongsTo(UserModel, {
-  foreignKey: {
-    name: "userId",
-    field: "user_id",
-  },
-  as: "feeCollectionUser",
-});
-
-UserModel.hasMany(FeesCollectionModel, {
-  foreignKey: "userId",
-  as: "userHasFeeCollection",
-});
-
-FeesCollectionModel.belongsTo(AcademicCalendarModel, {
-  foreignKey: {
-    name: "academicCalendarId",
-    field: "academic_calendar_id",
-    allowNull: true,
-  },
-  as: "CollectionCalendar",
-});
-AcademicCalendarModel.hasMany(FeesCollectionModel, {
-  foreignKey: {
-    name: "academicCalendarId",
-    field: "academic_calendar_id",
-    allowNull: true,
-  },
-  as: "CollectionHasCalendar",
-});
-
-FeesCollectionModel.belongsTo(UserModel, {
-  foreignKey: {
-    name: "createdBy",
-    allowNull: true,
-    field: "created_by",
-  },
-  as: "createdByUser",
-});
-
-FeesCollectionModel.belongsTo(UserModel, {
-  foreignKey: {
-    name: "updatedBy",
-    allowNull: true,
-    field: "updated_by",
-  },
-  as: "updatedByUser",
-});
-
-FeesCollectionModel.belongsTo(UserModel, {
-  foreignKey: {
-    name: "deletedBy",
-    allowNull: true,
-    field: "deleted_by",
-  },
-  as: "deletedByUser",
-});
-
-PaymentTermsModel.belongsTo(FeesCollectionModel, {
-  foreignKey: {
-    name: "feeCollectionId",
-    field: "fee_collection_id",
-  },
-  as: "feeCollection",
-});
-FeesCollectionModel.hasMany(PaymentTermsModel, {
-  foreignKey: "feeCollectionId",
-  as: "feeCollectionHasPaymentTerms",
-});
-
-export default FeesCollectionModel;