@kipicore/dbcore 1.0.9 → 1.0.10

package/dist/models/mongodb/feeReminderTypeModel.ts

@@ -1,48 +0,0 @@
-import mongoose, { Model, Schema } from 'mongoose';
-import { IFeeReminderTypeModelAttributes } from '../../interfaces/feeReminderTypeInterface';
-import { FEE_REMINDER_SETTING_FREQUENCY, FEE_REMINDER_SETTING_TYPE } from '../../constants/app';
-
-const feeReminderTypeModelSchema: Schema<IFeeReminderTypeModelAttributes> = new Schema<IFeeReminderTypeModelAttributes>(
-    {
-        type: {
-            type: String,
-            enum: Object.values(FEE_REMINDER_SETTING_TYPE),
-            required: true,
-        },
-        day: {
-            type: Number,
-            required: true,
-        },
-        frequency: {
-            type: String,
-            enum: Object.values(FEE_REMINDER_SETTING_FREQUENCY),
-        },
-        instituteId: {
-            type: String,
-            required: true,
-        },
-        createdBy: {
-            type: String,
-            required: false,
-        },
-        updatedBy: {
-            type: String,
-            required: false,
-        },
-        deletedBy: {
-            type: String,
-            required: false,
-        },
-    },
-    {
-        timestamps: true,
-        versionKey: false,
-    },
-);
-
-const FeeReminderTypeModel: Model<IFeeReminderTypeModelAttributes> = mongoose.model<IFeeReminderTypeModelAttributes>(
-    'feeReminderType',
-    feeReminderTypeModelSchema,
-);
-
-export default FeeReminderTypeModel;

package/dist/models/mongodb/feedBackModel.ts

@@ -1,87 +0,0 @@
-import mongoose, { Model, Schema } from 'mongoose';
-import { FEED_BACK_STATUS, FEED_BACK_TYPE } from '../../constants/app';
-import { IConversation, IFeedBackModelAttributes } from '../../interfaces/feedBackInterface';
-
-const ConversationSchema: Schema<IConversation> = new Schema<IConversation>(
-    {
-        userId: {
-            type: String,
-            required: true,
-        },
-        comment: {
-            type: String,
-            required: true,
-        },
-        parentCommentId: {
-            type: String,
-            required: false,
-        },
-        createdAt: {
-            type: Date,
-            // default: Date.now,
-        },
-        updatedAt: {
-            type: Date,
-        },
-    },
-    { _id: true },
-);
-
-const FeedBackSchema: Schema<IFeedBackModelAttributes> = new Schema<IFeedBackModelAttributes>(
-    {
-        subject: {
-            type: String,
-            required: true,
-        },
-        description: {
-            type: String,
-            required: false,
-        },
-        type: {
-            type: String,
-            enum: Object.values(FEED_BACK_TYPE),
-            required: true,
-        },
-        status: {
-            type: String,
-            enum: Object.values(FEED_BACK_STATUS),
-            required: true,
-        },
-        conversation: {
-            type: [ConversationSchema],
-            required: false,
-        },
-        instituteId: {
-            type: String,
-            required: false,
-        },
-        serialNo: {
-            type: String,
-            required: false,
-        },
-        publicToAll: {
-            type: Boolean,
-            default: false,
-        },
-        createdBy: {
-            type: String,
-            required: false,
-        },
-        updatedBy: {
-            type: String,
-            required: false,
-        },
-        deletedBy: {
-            type: String,
-            required: false,
-        },
-    },
-    {
-        timestamps: true,
-        versionKey: false,
-    },
-);
-
-const FeedBackModel: Model<IFeedBackModelAttributes> = mongoose.model<IFeedBackModelAttributes>('feedBack', FeedBackSchema);
-
-export default FeedBackModel;

package/dist/models/mongodb/generateIdCardModel.ts

@@ -1,29 +0,0 @@
-import mongoose, { Schema, Model } from 'mongoose';
-import { IGenarateIdCardModelAttributes } from '../../interfaces/generateIdCardInterface';
-
-const GenerateIdCardSchema: Schema<IGenarateIdCardModelAttributes> = new Schema<IGenarateIdCardModelAttributes>(
-    {
-        templateName: {
-            type: String,
-            required: false,
-        },
-        content: {
-            type: String,
-            required: false,
-        },
-        instituteId: {
-            type: String,
-            required: false,
-        },
-    },
-    {
-        timestamps: true,
-        versionKey: false,
-    },
-);
-
-const GenerateIdCardModel: Model<IGenarateIdCardModelAttributes> = mongoose.model<IGenarateIdCardModelAttributes>(
-    'generate_idcard',
-    GenerateIdCardSchema,
-);
-export default GenerateIdCardModel;

package/dist/models/mongodb/holidayModel.ts

@@ -1,164 +0,0 @@
-import mongoose, { CallbackError, Model, Schema } from "mongoose";
-import {
-  IHolidayModelAttributes,
-  IHolidayHasBatch,
-} from "../../interfaces/holidayInterface";
-import {
-  ACADEMIC_CALENDARS_TYPE,
-  COMMAN_STATUS,
-  PLANNER_SYNC_STATUS,
-} from "../../constants/app";
-import { BATCH_ERROR_MESSAGES } from "../../constants/errorMessages";
-import InstituteEntityModel from "../psql/instituteEntityModel";
-import BatchModel from "../psql/batchModel";
-
-const HolidayHasBatchSchema: Schema<IHolidayHasBatch> =
-  new Schema<IHolidayHasBatch>(
-    {
-      batchId: {
-        type: String,
-        required: true,
-      },
-      subjectId: {
-        type: String,
-        required: false,
-      },
-      lectureId: {
-        type: String,
-        required: false,
-      },
-    },
-    { _id: false }
-  );
-
-const holidayModelSchema: Schema<IHolidayModelAttributes> =
-  new Schema<IHolidayModelAttributes>(
-    {
-      title: {
-        type: String,
-        required: true,
-      },
-      subTitle: {
-        type: String,
-        required: false,
-      },
-      description: {
-        type: String,
-        required: false,
-      },
-      // subject: {
-      //     type: String,
-      //     required: false,
-      // },
-      batches: {
-        type: [HolidayHasBatchSchema],
-        required: false,
-      },
-      type: {
-        type: String,
-        enum: Object.values(ACADEMIC_CALENDARS_TYPE),
-        default: ACADEMIC_CALENDARS_TYPE.INSTITUTE,
-        required: true,
-      },
-      status: {
-        type: String,
-        enum: Object.values(COMMAN_STATUS),
-        default: COMMAN_STATUS.INACTIVE,
-        required: true,
-      },
-      instituteId: {
-        type: String,
-        required: false,
-      },
-      typeManagementId: {
-        type: String,
-        required: false,
-      },
-      startTime: {
-        type: Date,
-        required: true,
-      },
-      endTime: {
-        type: Date,
-        required: true,
-      },
-      createdBy: {
-        type: String,
-        required: false,
-      },
-      updatedBy: {
-        type: String,
-        required: false,
-      },
-      deletedBy: {
-        type: String,
-        required: false,
-      },
-      plannerSyncStatus: {
-        type: String,
-        default: PLANNER_SYNC_STATUS.PENDING,
-      },
-    },
-    {
-      timestamps: true,
-      versionKey: false,
-    }
-  );
-
-holidayModelSchema.pre("save", async function (next) {
-  const holiday = this as IHolidayModelAttributes;
-
-  try {
-    // If type is BATCH, ensure instituteId and batches exist
-    if (holiday.type === ACADEMIC_CALENDARS_TYPE.BATCH) {
-      if (
-        !holiday.instituteId ||
-        !holiday.batches ||
-        holiday.batches.length === 0
-      ) {
-        return next(
-          new Error(BATCH_ERROR_MESSAGES.INSTITUTED_BATCHES_REQUIRED)
-        );
-      }
-    }
-
-    for (const batch of holiday.batches || []) {
-      // Validate subjectId if provided
-      if (batch.subjectId) {
-        const subject = await InstituteEntityModel.findOne({
-          where: {
-            id: batch.subjectId,
-          },
-        });
-        if (!subject) {
-          return next(new Error(BATCH_ERROR_MESSAGES.INVALID_SELECTED));
-        }
-      }
-
-      // Validate batchId if provided
-      if (batch.batchId) {
-        const batchExists = await BatchModel.findOne({
-          where: { id: batch.batchId },
-        });
-        if (!batchExists) {
-          return next(new Error(BATCH_ERROR_MESSAGES.INVALID_SELECTED));
-        }
-      }
-    }
-
-    next();
-  } catch (error: unknown) {
-    return next(error as CallbackError);
-  }
-});
-
-holidayModelSchema.index({ instituteId: 1, status: 1, "batches.batchId": 1 });
-holidayModelSchema.index({ instituteId: 1, status: 1, batches: 1 });
-
-const HolidayModel: Model<IHolidayModelAttributes> =
-  mongoose.model<IHolidayModelAttributes>("holiday", holidayModelSchema);
-// (async () => {
-//     await HolidayModel.syncIndexes();
-// })(); // Rebuilds indexes in DB based on schema
-
-export default HolidayModel;

package/dist/models/mongodb/index.ts

@@ -1,21 +0,0 @@
-import mongoose from 'mongoose';
-import { ENV_VARIABLE } from '../../configs/env';
-import transformIdIdQueryPlugin from './plugin/transformIdInQueryPlugin';
-import transformIdInResponsePlugin from './plugin/transformIdInResponsePlugin';
-import { addDefaultAttributesPlugin } from './plugin/addDefaultAttributesPlugin';
-
-mongoose.plugin(transformIdIdQueryPlugin);
-mongoose.plugin(transformIdInResponsePlugin);
-mongoose.plugin(addDefaultAttributesPlugin);
-
-const connectMongoDb = async () => {
-    try {
-        await mongoose.connect(ENV_VARIABLE.MONGO_DB_CONNECTION_URL, {
-            dbName: ENV_VARIABLE.MONGO_DB_NAME,
-        });
-    } catch (err) {
-        console.log('error while connect monngodb : ' + err);
-    }
-};
-
-export default connectMongoDb;

package/dist/models/mongodb/informationSupportModel.ts

@@ -1,76 +0,0 @@
-import mongoose, { Model, Schema } from 'mongoose';
-import { IDescription, IInformationSupportModelAttributes } from '../../interfaces/informationSupportInterface';
-import { LANGUAGES } from '../../constants/app';
-// import AutoIncrementFactory from 'mongoose-sequence';
-
-// const AutoIncrement = AutoIncrementFactory(mongoose);
-
-const descriptionSchema: Schema<IDescription> = new Schema<IDescription>(
-    {
-        videoId: {
-            type: [String],
-            default: [],
-        },
-        videoUrl: {
-            type: [String],
-            default: [],
-        },
-        description: {
-            type: String,
-            required: true,
-        },
-        language: {
-            type: String,
-            enum: Object.values(LANGUAGES),
-            required: true,
-        },
-    },
-    { _id: false }, // disable _id for subdocs if not needed
-);
-
-const informationSupportSchema: Schema<IInformationSupportModelAttributes> = new Schema<IInformationSupportModelAttributes>(
-    {
-        title: {
-            type: String,
-            required: true,
-        },
-        number: {
-            type: Number,
-            required: false, // This will be auto-incremented on server side
-        },
-        information: {
-            type: [descriptionSchema],
-            default: [],
-            required: false,
-        },
-        createdBy: {
-            type: String,
-            required: false,
-        },
-        updatedBy: {
-            type: String,
-            required: false,
-        },
-        deletedBy: {
-            type: String,
-            required: false,
-        },
-    },
-    {
-        timestamps: true,
-        versionKey: false,
-    },
-);
-// informationSupportSchema.plugin(AutoIncrement, {
-//     // eslint-disable-next-line camelcase
-//     inc_field: 'number',
-//     // eslint-disable-next-line camelcase
-//     start_seq: 1, // optional: where numbering should start
-// });
-
-const InformationSupportModel: Model<IInformationSupportModelAttributes> = mongoose.model<IInformationSupportModelAttributes>(
-    'informationSupport',
-    informationSupportSchema,
-);
-
-export default InformationSupportModel;

package/dist/models/mongodb/inquiryModel.ts

@@ -1,196 +0,0 @@
-import mongoose, { Model, Schema } from "mongoose";
-import {
-  APP_TYPE,
-  INQUIRY_REFERRED_BY,
-  INQUIRY_STATUS,
-  TYPE_MANAGEMENT_TYPE,
-  USER_TYPES,
-} from "../../constants/app";
-import {
-  IBasicInformation,
-  IAcademicInformation,
-  IGuardianInformation,
-  IInquiryModelAttributes,
-  ILastSchool,
-} from "../../interfaces/inquiryInterface";
-import { CallbackError } from "mongoose";
-import {
-  INSTITUTE_ENTITY_ERROR_MESSAGES,
-  INSTITUTE_ERROR_MESSAGES,
-  TYPE_MANAGEMENT_ERROR_MESSAGES,
-} from "../../constants/errorMessages";
-import { Op } from "sequelize";
-import { IAddressSchema } from "../../interfaces/userDetailsInterface";
-import TypeManagementModel from "../psql/typeManagementModel";
-import InstituteModel from "../psql/instituteModel";
-import InstituteEntityModel from "../psql/instituteEntityModel";
-
-const BasicInformationSchema: Schema<IBasicInformation> =
-  new Schema<IBasicInformation>(
-    {
-      firstName: { type: String, required: true },
-      lastName: { type: String, required: true },
-      middleName: { type: String, required: false },
-      birthPlace: { type: String, required: false },
-      email: { type: String, required: true },
-      mobile: { type: String, required: true },
-      gender: { type: String, required: true },
-      dob: { type: Date, required: true },
-      address1: { type: String, required: false },
-    },
-    { _id: false }
-  );
-
-const AcademicInformationSchema: Schema<IAcademicInformation> =
-  new Schema<IAcademicInformation>(
-    {
-      entities: { type: [String], required: true },
-      batchType: { type: String, required: false },
-      admissionType: { type: String, required: false },
-    },
-    { _id: false }
-  );
-const LastSchoolSchema: Schema<ILastSchool> = new Schema<ILastSchool>(
-  {
-    name: { type: String, required: false },
-    address1: { type: String, required: false },
-    reason: { type: String, required: false },
-    uidNo: { type: String, required: false },
-    haveLeavingCertificate: { type: Boolean, required: false },
-    result: { type: Number, required: false },
-  },
-  { _id: false }
-);
-
-const GuardianInformationSchema: Schema<IGuardianInformation> =
-  new Schema<IGuardianInformation>(
-    {
-      firstName: { type: String, required: true },
-      lastName: { type: String, required: true },
-      middleName: { type: String, required: false },
-      mobile: { type: String, required: true },
-      relation: { type: String, required: false },
-      email: { type: String, required: false },
-      guardianQualification: { type: String, required: true },
-      guardianOccupation: { type: String, required: true },
-      guardianOccupationDetails: { type: String, required: false },
-      motherName: { type: String, required: false },
-    },
-    { _id: false }
-  );
-const AddressSchema: Schema<IAddressSchema> = new Schema<IAddressSchema>(
-  {
-    pinCode: {
-      type: String,
-      required: false,
-    },
-    address1: {
-      type: String,
-      required: false,
-    },
-    address2: {
-      type: String,
-      required: false,
-    },
-    district: {
-      type: String,
-      required: false,
-    },
-    area: {
-      type: String,
-      required: false,
-    },
-    state: {
-      type: Number,
-      required: false,
-    },
-    country: {
-      type: Number,
-      required: false,
-    },
-    city: {
-      type: Number,
-      required: false,
-    },
-  },
-  { _id: false } // Prevent creation of an automatic `_id` field for subdocuments
-);
-
-const InquirySchema: Schema<IInquiryModelAttributes> =
-  new Schema<IInquiryModelAttributes>(
-    {
-      instituteId: { type: String, required: false },
-      basicInformation: { type: BasicInformationSchema, required: true },
-      academicInformation: { type: AcademicInformationSchema, required: true },
-      guardianInformation: { type: GuardianInformationSchema, required: true },
-      lastSchoolInformation: { type: LastSchoolSchema, required: true },
-      address: { type: AddressSchema, required: false },
-      referredBy: {
-        type: String,
-        enum: Object.values(INQUIRY_REFERRED_BY),
-        required: true,
-      },
-      others: {
-        type: String,
-        required: false,
-      },
-      inquiryStatus: {
-        type: String,
-        enum: Object.values(INQUIRY_STATUS),
-        default: INQUIRY_STATUS.NOT_ENROLL,
-        required: true,
-      },
-      appType: {
-        type: String,
-        enum: Object.values(APP_TYPE),
-        required: true,
-      },
-      userType: {
-        type: String,
-        enum: Object.values(USER_TYPES),
-        default: USER_TYPES.STUDENT,
-        required: true,
-      },
-      createdBy: { type: String, required: false },
-      updatedBy: { type: String, required: false },
-      deletedBy: { type: String, required: false },
-    },
-    {
-      timestamps: true,
-      versionKey: false,
-    }
-  );
-InquirySchema.pre("save", async function (next) {
-  const inquiry = this as IInquiryModelAttributes;
-
-  try {
-    if (inquiry.academicInformation.batchType) {
-      const batchType = await TypeManagementModel.findByPk(
-        inquiry.academicInformation.batchType
-      );
-      if (!batchType || batchType.type !== TYPE_MANAGEMENT_TYPE.BATCH)
-        throw new Error(TYPE_MANAGEMENT_ERROR_MESSAGES.NOT_FOUND);
-    }
-    if (inquiry.instituteId) {
-      const institute = await InstituteModel.findByPk(inquiry.instituteId);
-      if (!institute) {
-        throw new Error(INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
-      }
-    }
-    if (inquiry.academicInformation.entities) {
-      const entitiesList = await InstituteEntityModel.findAll({
-        where: { id: { [Op.in]: inquiry.academicInformation.entities } },
-      });
-      if (!entitiesList || entitiesList.length === 0) {
-        throw new Error(INSTITUTE_ENTITY_ERROR_MESSAGES.INVALID_TYPE);
-      }
-    }
-    next();
-  } catch (error: unknown) {
-    return next(error as CallbackError);
-  }
-});
-const InquiryModel: Model<IInquiryModelAttributes> =
-  mongoose.model<IInquiryModelAttributes>("inquiry", InquirySchema);
-
-export default InquiryModel;