@kipicore/dbcore 1.0.6 → 1.0.8

package/dist/models/psql/tripModel.ts

@@ -0,0 +1,141 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index';
+import { ITripModelAttributes } from '../../interfaces/tripInterface';
+import { TTripModelCreationAttributes } from '../../types/tripType';
+import { TRIP_TYPE } from '../../constants/app';
+import UserModel from './userModel';
+import InstituteModel from './instituteModel';
+import VehicleModel from './vehicleModel';
+
+class TripModel extends Model<ITripModelAttributes, TTripModelCreationAttributes> {
+    declare id: string;
+    declare tripType: TRIP_TYPE;
+    declare vehicleId: string;
+    declare driverId: string;
+    declare shiftId: string[];
+    declare area: string[];
+    declare instituteId: string;
+    declare departure: Date;
+    declare arrival: Date;
+
+    declare createdBy: string;
+    declare updatedBy: string;
+    declare deletedBy: string;
+    declare readonly createdAt: Date;
+    declare readonly updatedAt: Date;
+    declare readonly deletedAt?: Date;
+}
+
+TripModel.init(
+    {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            allowNull: false,
+            primaryKey: true,
+        },
+        tripType: {
+            type: DataTypes.ENUM,
+            allowNull: false,
+            values: Object.values(TRIP_TYPE),
+        },
+        vehicleId: {
+            type: DataTypes.UUID,
+            field: 'vehicle_id',
+            allowNull: true,
+        },
+        driverId: {
+            type: DataTypes.UUID,
+            field: 'driver_id',
+            allowNull: true,
+        },
+        shiftId: {
+            type: DataTypes.ARRAY(DataTypes.UUID),
+            defaultValue: [],
+            allowNull: true,
+        },
+        area: {
+            type: DataTypes.ARRAY(DataTypes.STRING),
+            defaultValue: [],
+            allowNull: true,
+        },
+        departure: {
+            type: DataTypes.DATE,
+            allowNull: false,
+        },
+        arrival: {
+            type: DataTypes.DATE,
+            allowNull: false,
+        },
+        instituteId: {
+            type: DataTypes.UUID,
+            field: 'institute_id',
+            allowNull: true,
+        },
+    },
+    {
+        modelName: 'TripModel',
+        tableName: 'trips',
+        timestamps: true,
+        sequelize,
+    },
+);
+
+// Associations
+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',
+});
+
+export default TripModel;

package/dist/models/psql/typeManagementModel.ts

@@ -0,0 +1,155 @@
+import { DataTypes, Model, UpdateOptions } from "sequelize";
+import { sequelize } from "./index";
+import { ITypeManagementModelAttributes } from "../../interfaces/typeManagementInterface";
+import { TTypeManagementModelCreationAttributes } from "../../types/typeManagementType";
+import { COMMAN_STATUS, TYPE_MANAGEMENT_TYPE } from "../../constants/app";
+import InstituteModel from "./instituteModel";
+import UserModel from "./userModel";
+import {
+  INSTITUTE_ERROR_MESSAGES,
+  TYPE_MANAGEMENT_ERROR_MESSAGES,
+} from "../../constants/errorMessages";
+
+class TypeManagementModel extends Model<
+  ITypeManagementModelAttributes,
+  TTypeManagementModelCreationAttributes
+> {
+  declare id: string;
+  declare title: string;
+  declare instituteId: string;
+  declare status?: COMMAN_STATUS;
+  declare type: TYPE_MANAGEMENT_TYPE;
+  declare isInstituteDefault: boolean;
+  declare isDefault: boolean;
+
+  declare createdBy: string;
+  declare updatedBy: string;
+  declare deletedBy: string;
+  declare readonly createdAt: Date;
+  declare readonly deletedAt: string;
+  declare readonly updatedAt: Date;
+}
+
+TypeManagementModel.init(
+  {
+    id: {
+      type: DataTypes.UUID,
+      defaultValue: DataTypes.UUIDV4,
+      allowNull: false,
+      primaryKey: true,
+    },
+    title: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    instituteId: {
+      type: DataTypes.UUID,
+      field: "institute_id",
+      allowNull: true,
+    },
+    status: {
+      type: DataTypes.ENUM,
+      values: Object.values(COMMAN_STATUS),
+      defaultValue: COMMAN_STATUS.ACTIVE,
+      allowNull: false,
+    },
+    type: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    isInstituteDefault: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      field: "is_institute_default",
+      defaultValue: false,
+    },
+    isDefault: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      field: "is_default",
+      defaultValue: false,
+    },
+  },
+  {
+    modelName: "TypeManagementModel",
+    tableName: "type_management",
+    timestamps: true,
+    sequelize,
+  }
+);
+
+const beforeCreateOrUpdateHook = async (
+  type: TypeManagementModel
+): Promise<void> => {
+  if (type.instituteId) {
+    const institute = await InstituteModel.findByPk(type.instituteId);
+    if (!institute) {
+      throw new Error(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(TYPE_MANAGEMENT_ERROR_MESSAGES.TYPE_ALREADY_EXISTS);
+  }
+};
+TypeManagementModel.beforeCreate(beforeCreateOrUpdateHook);
+
+TypeManagementModel.beforeBulkUpdate(async (options: UpdateOptions) => {
+  await beforeCreateOrUpdateHook(options.attributes);
+});
+
+TypeManagementModel.beforeBulkCreate(async (instances) => {
+  for (const instance of instances) {
+    await beforeCreateOrUpdateHook(instance);
+  }
+});
+
+// TypeManagementModel belongs to InstituteModel
+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",
+});
+
+export default TypeManagementModel;

package/dist/models/psql/userBookAssessmentModel.ts

@@ -0,0 +1,168 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index';
+import { IUserBookAssessmentModelAttributes } from '../../interfaces/userBookAssessmentInterface';
+import { TUserBookAssessmentModelCreationAttributes } from '../../types/userBookAssessmentType';
+import UserModel from './userModel';
+import BatchSubjectBookAssessmentModel from './batchSubjectBookAssessmentModel';
+import { USER_BOOK_ASSESSMENT_STATUS } from '../../constants/app';
+import BatchModel from './batchModel';
+import BookAssessmentDateModel from './bookAssessmentDateModel';
+
+class UserBookAssessmentModel extends Model<IUserBookAssessmentModelAttributes, TUserBookAssessmentModelCreationAttributes> {
+    declare id: string;
+    declare assessmentBookId: string;
+    declare assessmentDateId: string;
+    declare batchId: string;
+    declare userId: string;
+    declare status: USER_BOOK_ASSESSMENT_STATUS;
+
+    declare createdBy: string;
+    declare updatedBy: string;
+    declare deletedBy: string;
+    declare readonly createdAt: Date;
+    declare readonly deletedAt: string;
+    declare readonly updatedAt: Date;
+}
+
+UserBookAssessmentModel.init(
+    {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            allowNull: false,
+            primaryKey: true,
+        },
+        assessmentBookId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+            field: 'assessment_book_id',
+        },
+        assessmentDateId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+            field: 'assessment_date_id',
+        },
+        batchId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+            field: 'batch_id',
+        },
+        userId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+            field: 'user_id',
+        },
+        status: {
+            type: DataTypes.ENUM(...Object.values(USER_BOOK_ASSESSMENT_STATUS)),
+            defaultValue: USER_BOOK_ASSESSMENT_STATUS.PENDING,
+        },
+    },
+    {
+        modelName: 'UserBookAssessmentModel',
+        tableName: 'user_book_assessments',
+        sequelize,
+        indexes: [
+            {
+                name: 'composite_unique_key',
+                unique: true,
+                fields: ['assessment_book_id', 'assessment_date_id', 'batch_id', 'user_id'],
+                // eslint-disable-next-line camelcase
+                where: { deleted_at: null },
+            },
+        ],
+    },
+);
+
+// Associations
+UserBookAssessmentModel.belongsTo(BatchSubjectBookAssessmentModel, {
+    foreignKey: {
+        name: 'assessmentBookId',
+        field: 'assessment_book_id',
+    },
+    as: 'assessmentBook',
+});
+
+BatchSubjectBookAssessmentModel.hasMany(UserBookAssessmentModel, {
+    foreignKey: {
+        name: 'assessmentBookId',
+        field: 'assessment_book_id',
+    },
+    as: 'subjectBookAssessmentUserList',
+});
+
+UserBookAssessmentModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'user',
+});
+
+UserModel.hasMany(UserBookAssessmentModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'userBookAssessmentList',
+});
+
+UserBookAssessmentModel.belongsTo(BatchModel, {
+    foreignKey: {
+        name: 'batchId',
+        field: 'batch_id',
+    },
+    as: 'batch',
+});
+
+BatchModel.hasMany(UserBookAssessmentModel, {
+    foreignKey: {
+        name: 'batchId',
+        field: 'batch_id',
+    },
+    as: 'batchUserBookAssessmentList',
+});
+
+UserBookAssessmentModel.belongsTo(BookAssessmentDateModel, {
+    foreignKey: {
+        name: 'assessmentDateId',
+        field: 'assessment_date_id',
+    },
+    as: 'assessmentDate',
+});
+
+BookAssessmentDateModel.hasMany(UserBookAssessmentModel, {
+    foreignKey: {
+        name: 'assessmentDateId',
+        field: 'assessment_date_id',
+    },
+    as: 'assessmentDateUserList',
+});
+
+UserBookAssessmentModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+
+UserBookAssessmentModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+
+UserBookAssessmentModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+
+export default UserBookAssessmentModel;

package/dist/models/psql/userFeeTypeByAccountModel.ts

@@ -0,0 +1,205 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index';
+import { IUserFeeTypeByAccountModelAttributes } from '../../interfaces/userFeeTypeByAccountInterface';
+import { TUserFeeTypeByAccountModelCreationAttributes } from '../../types/userFeeTypeByAccountType';
+import UserModel from './userModel';
+import InstituteModel from './instituteModel';
+import AcademicCalendarModel from './academicCalendarModel';
+import SchoolFeeCollectionModel from './schoolFeeCollectionModel';
+import BankAccountDetailsModel from './bankAccountDetailsModel';
+
+class UserFeeTypeByAccountModel extends Model<IUserFeeTypeByAccountModelAttributes, TUserFeeTypeByAccountModelCreationAttributes> {
+    declare id: string;
+    declare userId: string;
+    declare instituteId: string;
+    declare bankAccountId: string;
+    declare feeCollectionId: string;
+    declare amount: number;
+    declare discount: number;
+    declare perviousFeeCollectionId: string;
+    declare academicCalendarId: string;
+    declare paidAmount: number;
+
+    declare createdBy: string;
+    declare updatedBy: string;
+    declare deletedBy: string;
+    declare readonly createdAt: Date;
+    declare readonly deletedAt: string;
+    declare readonly updatedAt: Date;
+}
+
+UserFeeTypeByAccountModel.init(
+    {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            allowNull: false,
+            primaryKey: true,
+        },
+        userId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+        },
+        instituteId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+        },
+        bankAccountId: {
+            type: DataTypes.UUID,
+            field: 'bank_account_id',
+            allowNull: false,
+        },
+        feeCollectionId: {
+            type: DataTypes.UUID,
+            field: 'fee_collection_id',
+            allowNull: false,
+        },
+        amount: {
+            type: DataTypes.INTEGER,
+            allowNull: false,
+        },
+        discount: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+        },
+        perviousFeeCollectionId: {
+            type: DataTypes.UUID,
+            field: 'pervious_fee_collection_id',
+            allowNull: true,
+        },
+        academicCalendarId: {
+            type: DataTypes.UUID,
+            field: 'academic_calendar_id',
+            allowNull: false,
+        },
+        paidAmount: {
+            type: DataTypes.INTEGER,
+            field: 'paid_amount',
+            allowNull: false,
+        },
+    },
+    {
+        modelName: 'UserFeeTypeByAccountModel',
+        tableName: 'user_fee_type_by_account',
+        timestamps: true,
+        sequelize,
+    },
+);
+
+UserFeeTypeByAccountModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserFeeTypeByAccountModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserFeeTypeByAccountModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+UserFeeTypeByAccountModel.belongsTo(InstituteModel, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'userAccountInstituted',
+});
+InstituteModel.hasMany(UserFeeTypeByAccountModel, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'institutedHasUserAccount',
+});
+UserFeeTypeByAccountModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'accountUser',
+});
+UserModel.hasMany(UserFeeTypeByAccountModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'userHasAccount',
+});
+UserFeeTypeByAccountModel.belongsTo(BankAccountDetailsModel, {
+    foreignKey: {
+        name: 'bankAccountId',
+        field: 'bank_account_id',
+    },
+    as: 'accountBank',
+});
+BankAccountDetailsModel.hasMany(UserFeeTypeByAccountModel, {
+    foreignKey: {
+        name: 'bankAccountId',
+        field: 'bank_account_id',
+    },
+    as: 'bankHasAccount',
+});
+UserFeeTypeByAccountModel.belongsTo(AcademicCalendarModel, {
+    foreignKey: {
+        name: 'academicCalendarId',
+        field: 'academic_calendar_id',
+        allowNull: true,
+    },
+    as: 'accountAcademicCalendar',
+});
+AcademicCalendarModel.hasMany(UserFeeTypeByAccountModel, {
+    foreignKey: {
+        name: 'academicCalendarId',
+        field: 'academic_calendar_id',
+        allowNull: true,
+    },
+    as: 'accountHasAcademicCalendar',
+});
+UserFeeTypeByAccountModel.belongsTo(SchoolFeeCollectionModel, {
+    foreignKey: {
+        name: 'perviousFeeCollectionId',
+        field: 'previous_fee_collection_id',
+        allowNull: true,
+    },
+    as: 'accountPreviousCollection',
+});
+SchoolFeeCollectionModel.hasMany(UserFeeTypeByAccountModel, {
+    foreignKey: {
+        name: 'perviousFeeCollectionId',
+        field: 'previous_fee_collection_id',
+        allowNull: true,
+    },
+    as: 'previousCollectionHasAccount',
+});
+UserFeeTypeByAccountModel.belongsTo(SchoolFeeCollectionModel, {
+    foreignKey: {
+        name: 'feeCollectionId',
+        field: 'fee_collection_id',
+        allowNull: true,
+    },
+    as: 'accountFeeCollection',
+});
+SchoolFeeCollectionModel.hasMany(UserFeeTypeByAccountModel, {
+    foreignKey: {
+        name: 'feeCollectionId',
+        field: 'fee_collection_id',
+        allowNull: true,
+    },
+    as: 'accountHasFeeCollection',
+});
+
+export default UserFeeTypeByAccountModel;