@kipicore/dbcore 1.1.5 → 1.1.6

package/dist/models/mongodb/attendanceModel.d.ts

@@ -1,4 +1,4 @@
-import { Model } from "mongoose";
-import { IAttendanceModelAttributes } from "../../interfaces/attendanceInterface.js";
+import { Model } from 'mongoose';
+import { IAttendanceModelAttributes } from '../../interfaces/attendanceInterface.js';
 declare const AttendanceModel: Model<IAttendanceModelAttributes>;
 export default AttendanceModel;

package/dist/models/mongodb/attendanceModel.js

@@ -104,7 +104,7 @@ const attendanceModelSchema = new mongoose_1.Schema({
     versionKey: false,
     virtuals: true,
 });
-attendanceModelSchema.pre("save", async function (next) {
+attendanceModelSchema.pre('save', async function (next) {
     const attendance = this;
     try {
         if (attendance.instituteId) {
@@ -126,12 +126,12 @@ attendanceModelSchema.pre("save", async function (next) {
             const userHasBatchList = await userHasBatchModel_js_1.default.findAll({
                 where: {
                     userId: {
-                        [sequelize_1.Op.in]: attendance.users.map((user) => user.userId),
+                        [sequelize_1.Op.in]: attendance.users.map(user => user.userId),
                     },
                 },
                 include: [
-                    { association: "batch", where: batchWhere },
-                    { association: "user", where: { type: attendance.userType } },
+                    { association: 'batch', where: batchWhere },
+                    { association: 'user', where: { type: attendance.userType } },
                 ],
             });
             for (const user of attendance.users) {
@@ -142,8 +142,7 @@ attendanceModelSchema.pre("save", async function (next) {
                 if (attendance.type === app_js_1.ATTENDANCE_TYPE.BATCH) {
                     if (!attendance.batchId)
                         throw new Error(errorMessages_js_1.ATTENDANCE_ERROR_MESSAGES.USER_BATCH_NOT_FOUND);
-                    const userHasbatch = userHasBatchList.find((userBatch) => userBatch.batchId === attendance.batchId &&
-                        userBatch.userId === user.userId);
+                    const userHasbatch = userHasBatchList.find(userBatch => userBatch.batchId === attendance.batchId && userBatch.userId === user.userId);
                     if (!userHasbatch || !userHasbatch.batch)
                         throw new Error(errorMessages_js_1.ATTENDANCE_ERROR_MESSAGES.USER_HAS_BATCH_NOT_FOUND);
                     startTime = userHasbatch.batch.startTime;
@@ -172,7 +171,7 @@ attendanceModelSchema.index({
     batchId: 1,
     userType: 1,
     instituteId: 1,
-    "users.userId": 1,
+    'users.userId': 1,
 });
-const AttendanceModel = mongoose_1.default.model("attendance", attendanceModelSchema);
+const AttendanceModel = mongoose_1.default.model('attendance', attendanceModelSchema);
 exports.default = AttendanceModel;

package/dist/models/mongodb/eventModel.d.ts

@@ -1,4 +1,4 @@
-import { Model } from "mongoose";
-import { IEventModelAttributes } from "../../interfaces/eventInterface.js";
+import { Model } from 'mongoose';
+import { IEventModelAttributes } from '../../interfaces/eventInterface.js';
 declare const EventModel: Model<IEventModelAttributes>;
 export default EventModel;

package/dist/models/mongodb/eventModel.js

@@ -120,7 +120,7 @@ const eventModelSchema = new mongoose_1.Schema({
     timestamps: true,
     versionKey: false,
 });
-eventModelSchema.pre("save", async function (next) {
+eventModelSchema.pre('save', async function (next) {
     const event = this;
     try {
         // If type is BATCH, ensure instituteId and batches exist
@@ -155,9 +155,9 @@ eventModelSchema.pre("save", async function (next) {
         return next(error);
     }
 });
-eventModelSchema.index({ instituteId: 1, status: 1, "batches.batchId": 1 });
+eventModelSchema.index({ instituteId: 1, status: 1, 'batches.batchId': 1 });
 eventModelSchema.index({ instituteId: 1, status: 1, batches: 1 });
-const EventModel = mongoose_1.default.model("event", eventModelSchema);
+const EventModel = mongoose_1.default.model('event', eventModelSchema);
 // (async () => {
 //     await EventModel.syncIndexes();
 // })(); // Rebuilds indexes in DB based on schema

package/dist/models/mongodb/examGroupModel.d.ts

@@ -1,4 +1,4 @@
-import { Model } from "mongoose";
-import { IExamGroupModelAttributes } from "../../interfaces/examGroupInterface.js";
+import { Model } from 'mongoose';
+import { IExamGroupModelAttributes } from '../../interfaces/examGroupInterface.js';
 declare const ExamGroupModel: Model<IExamGroupModelAttributes>;
 export default ExamGroupModel;

package/dist/models/mongodb/examGroupModel.js

@@ -168,7 +168,7 @@ const createOrUpdateHook = async (examGroup) => {
             examGroup.subjects = [];
         }
         if (examGroup.standardByDays) {
-            examGroup.standardByDays = examGroup.standardByDays.filter((standardByDays) => examGroup.standards.includes(standardByDays.standardId));
+            examGroup.standardByDays = examGroup.standardByDays.filter(standardByDays => examGroup.standards.includes(standardByDays.standardId));
             const userInstituteMeta = await userInstituteMetaModel_js_1.default.findOne({
                 userId: examGroup.instituteId,
                 instituteId: examGroup.instituteId,
@@ -178,10 +178,10 @@ const createOrUpdateHook = async (examGroup) => {
                     entityId: { [sequelize_1.Op.in]: userInstituteMeta?.entities },
                 },
             });
-            subjectList = subjectList.filter((subject) => examGroup.standards.includes(subject.entityId));
-            subjectList = subjectList.filter((subject) => userInstituteMeta?.entities?.includes(subject.id));
-            examGroup.subjects = subjectList.map((subject) => subject.id);
-            const subjectListByStandardId = (0, utils_js_1.groupByFieldOrFields)(subjectList, "entityId");
+            subjectList = subjectList.filter(subject => examGroup.standards.includes(subject.entityId));
+            subjectList = subjectList.filter(subject => userInstituteMeta?.entities?.includes(subject.id));
+            examGroup.subjects = subjectList.map(subject => subject.id);
+            const subjectListByStandardId = (0, utils_js_1.groupByFieldOrFields)(subjectList, 'entityId');
             const dateList = [];
             let startDate = examGroup.startDate;
             while (new Date(startDate).getTime() < new Date(examGroup.endDate).getTime()) {
@@ -193,31 +193,27 @@ const createOrUpdateHook = async (examGroup) => {
                     continue;
                 // const standardSubjectList = subjectListByStandardId[standard].map((entity: { id: string }) => entity.id);
                 // const batches = await this.batchService.findAll({ subjects: { [Op.overlap]: standardSubjectList } });
-                const existStandardByDays = examGroup.standardByDays.find((standardByDays) => standardByDays.standardId === standard);
-                const existStandardByDaysIndex = examGroup.standardByDays.findIndex((standardByDays) => standardByDays.standardId === standard);
+                const existStandardByDays = examGroup.standardByDays.find(standardByDays => standardByDays.standardId === standard);
+                const existStandardByDaysIndex = examGroup.standardByDays.findIndex(standardByDays => standardByDays.standardId === standard);
                 let standardByDays = {
                     standardId: standard,
                     // batches: batches.map(batch => batch.id),
                     // subjects: standardSubjectList,
                     days: [],
                 };
-                dateList.forEach((date) => {
+                dateList.forEach(date => {
                     const dayObject = {
                         date,
-                        note: "",
-                        subjectId: "",
+                        note: '',
+                        subjectId: '',
                         isHoliday: false,
                     };
                     if (existStandardByDays) {
-                        existStandardByDays.days = existStandardByDays.days.filter((day) => {
-                            return dateList
-                                .map((date) => new Date(date).getTime())
-                                .includes(new Date(day.date).getTime());
+                        existStandardByDays.days = existStandardByDays.days.filter(day => {
+                            return dateList.map(date => new Date(date).getTime()).includes(new Date(day.date).getTime());
                         });
-                        const existDate = existStandardByDays.days.find((day) => {
-                            return dateList
-                                .map((date) => new Date(date).getTime())
-                                .includes(new Date(day.date).getTime());
+                        const existDate = existStandardByDays.days.find(day => {
+                            return dateList.map(date => new Date(date).getTime()).includes(new Date(day.date).getTime());
                         });
                         if (!existDate)
                             existStandardByDays.days.push(dayObject);
@@ -227,9 +223,8 @@ const createOrUpdateHook = async (examGroup) => {
                     }
                 });
                 if (existStandardByDays) {
-                    examGroup.standardByDays[existStandardByDaysIndex] =
-                        existStandardByDays;
-                    const isNotValidHoliday = examGroup.standardByDays[existStandardByDaysIndex].days.some((day) => day.isHoliday && day.subjectId.length > 1);
+                    examGroup.standardByDays[existStandardByDaysIndex] = existStandardByDays;
+                    const isNotValidHoliday = examGroup.standardByDays[existStandardByDaysIndex].days.some(day => day.isHoliday && day.subjectId.length > 1);
                     if (isNotValidHoliday)
                         throw new Error(errorMessages_js_1.EXAM_GROUP_ERROR_MESSAGES.INVALID_HOLIDAY);
                     standardByDays = { ...existStandardByDays };
@@ -244,14 +239,13 @@ const createOrUpdateHook = async (examGroup) => {
                 // }
             }
             //*********** days array remove duplicate date from date if multiple date empty ********///
-            examGroup.standardByDays = examGroup.standardByDays.map((standard) => ({
+            examGroup.standardByDays = examGroup.standardByDays.map(standard => ({
                 ...standard,
                 days: standard.days.reduce((acc, day) => {
-                    const existingIndex = acc.findIndex((d) => new Date(d.date).getTime() === new Date(day.date).getTime());
+                    const existingIndex = acc.findIndex(d => new Date(d.date).getTime() === new Date(day.date).getTime());
                     if (Object.keys(day.examDetails || {}).length > 0) {
                         // If an empty object exists for this date, remove it
-                        if (existingIndex !== -1 &&
-                            Object.keys(acc[existingIndex].examDetails || {}).length === 0) {
+                        if (existingIndex !== -1 && Object.keys(acc[existingIndex].examDetails || {}).length === 0) {
                             acc.splice(existingIndex, 1);
                         }
                         acc.push(day);
@@ -269,7 +263,7 @@ const createOrUpdateHook = async (examGroup) => {
         throw err;
     }
 };
-examGroupModelSchema.pre("save", async function (next) {
+examGroupModelSchema.pre('save', async function (next) {
     const subjectIndex = this;
     try {
         await createOrUpdateHook(subjectIndex);
@@ -279,7 +273,7 @@ examGroupModelSchema.pre("save", async function (next) {
         throw error;
     }
 });
-examGroupModelSchema.pre("updateMany", async function (next) {
+examGroupModelSchema.pre('updateMany', async function (next) {
     const subjectIndex = this.getUpdate();
     try {
         await createOrUpdateHook(subjectIndex);
@@ -289,5 +283,5 @@ examGroupModelSchema.pre("updateMany", async function (next) {
         throw error;
     }
 });
-const ExamGroupModel = mongoose_1.default.model("exam_groups", examGroupModelSchema);
+const ExamGroupModel = mongoose_1.default.model('exam_groups', examGroupModelSchema);
 exports.default = ExamGroupModel;

package/dist/models/mongodb/examHasAnswerSheetModel.d.ts

@@ -1,4 +1,4 @@
-import { Model } from "mongoose";
-import { IExamHasAnswerSheetModelAttributes } from "../../interfaces/examHasAnswerSheetInterface.js";
+import { Model } from 'mongoose';
+import { IExamHasAnswerSheetModelAttributes } from '../../interfaces/examHasAnswerSheetInterface.js';
 declare const ExamHasAnswerSheetModel: Model<IExamHasAnswerSheetModelAttributes>;
 export default ExamHasAnswerSheetModel;

package/dist/models/mongodb/examHasAnswerSheetModel.js

@@ -64,13 +64,12 @@ const AnswerSheetQuestionSchema = new mongoose_1.Schema({
         default: app_js_1.EXAM_ANSWER_SHEET_QUESTION_RESULT.NOT_ATTENDED,
         required: false,
     },
-}, { _id: false } // Prevent creation of an automatic `_id` field for subdocuments
-);
+}, { _id: false });
 // Define the main schema for IExamHasAnswerSheetModelAttributes
 const examHasAnswerSheetSchema = new mongoose_1.Schema({
     examId: {
         type: mongoose_1.default.Schema.Types.ObjectId,
-        ref: "exams",
+        ref: 'exams',
         required: true,
     },
     questions: {
@@ -114,7 +113,7 @@ const examHasAnswerSheetSchema = new mongoose_1.Schema({
     },
     studentExamIp: {
         type: String,
-        default: "",
+        default: '',
         required: false,
     },
 }, {
@@ -122,12 +121,12 @@ const examHasAnswerSheetSchema = new mongoose_1.Schema({
     versionKey: false,
 });
 // Add a pre-save hook to validate examId existence
-examHasAnswerSheetSchema.pre("save", async function (next) {
+examHasAnswerSheetSchema.pre('save', async function (next) {
     const examExists = await examModel_js_1.default.findOne({ where: { id: this.examId } });
     if (!examExists) {
         return next(new Error(errorMessages_js_1.EXAM_ERROR_MESSAGES.NOT_FOUND));
     }
     next();
 });
-const ExamHasAnswerSheetModel = mongoose_1.default.model("exam_answer_sheets", examHasAnswerSheetSchema);
+const ExamHasAnswerSheetModel = mongoose_1.default.model('exam_answer_sheets', examHasAnswerSheetSchema);
 exports.default = ExamHasAnswerSheetModel;

package/dist/models/mongodb/examModel.d.ts

@@ -1,4 +1,4 @@
-import { Model } from "mongoose";
-import { IExamModelAttributes } from "../../interfaces/examInterface.js";
+import { Model } from 'mongoose';
+import { IExamModelAttributes } from '../../interfaces/examInterface.js';
 declare const ExamModel: Model<IExamModelAttributes>;
 export default ExamModel;

package/dist/models/mongodb/examModel.js

@@ -67,8 +67,7 @@ const ExamHasBatchSchema = new mongoose_1.Schema({
         type: Boolean,
         default: false,
     },
-}, { _id: false } // Prevent creation of an automatic `_id` field for subdocuments
-);
+}, { _id: false });
 const examModelSchema = new mongoose_1.Schema({
     title: {
         type: String,
@@ -191,7 +190,7 @@ const examModelSchema = new mongoose_1.Schema({
     timestamps: true,
     versionKey: false,
 });
-examModelSchema.pre("save", async function (next) {
+examModelSchema.pre('save', async function (next) {
     const exam = this;
     try {
         if (exam.batches && exam.batches.length && exam.subject) {
@@ -203,7 +202,7 @@ examModelSchema.pre("save", async function (next) {
                 return next(new Error(errorMessages_js_1.BATCH_ERROR_MESSAGES.INVALID_SELECTED));
             }
             where = {
-                id: { [sequelize_1.Op.in]: exam.batches.map((batch) => batch.batchId) },
+                id: { [sequelize_1.Op.in]: exam.batches.map(batch => batch.batchId) },
                 subjects: { [sequelize_1.Op.overlap]: [exam.subject] },
             };
             const batchesList = await batchModel_js_1.default.findAll({ where });
@@ -212,12 +211,10 @@ examModelSchema.pre("save", async function (next) {
             }
             if (exam.mode === app_js_1.EXAM_MODE.OFFLINE && !exam.groupId) {
                 where = {
-                    id: { [sequelize_1.Op.in]: exam.batches.map((batch) => batch.classroomId) },
+                    id: { [sequelize_1.Op.in]: exam.batches.map(batch => batch.classroomId) },
                 };
                 const classroomCount = await classRoomModel_js_1.default.count({ where });
-                const classroomDataount = [
-                    ...new Set(exam.batches.map((val) => val.classroomId)),
-                ].length;
+                const classroomDataount = [...new Set(exam.batches.map(val => val.classroomId))].length;
                 if (classroomCount !== classroomDataount) {
                     return next(new Error(errorMessages_js_1.CLASSROOM_ERROR_MESSAGES.INVALID_SELECTED));
                 }
@@ -254,13 +251,13 @@ examModelSchema.pre("save", async function (next) {
 });
 examModelSchema.index({
     instituteId: 1,
-    "batches.batchId": 1,
+    'batches.batchId': 1,
     scheduleDate: 1,
     subject: 1,
     status: 1,
     mode: 1,
 });
-const ExamModel = mongoose_1.default.model("exams", examModelSchema);
+const ExamModel = mongoose_1.default.model('exams', examModelSchema);
 // (async () => {
 //     await ExamModel.syncIndexes();
 // })(); // Rebuilds indexes in DB based on schema

package/dist/models/mongodb/holidayModel.d.ts

@@ -1,4 +1,4 @@
-import { Model } from "mongoose";
-import { IHolidayModelAttributes } from "../../interfaces/holidayInterface.js";
+import { Model } from 'mongoose';
+import { IHolidayModelAttributes } from '../../interfaces/holidayInterface.js';
 declare const HolidayModel: Model<IHolidayModelAttributes>;
 export default HolidayModel;

package/dist/models/mongodb/holidayModel.js

@@ -124,14 +124,12 @@ const holidayModelSchema = new mongoose_1.Schema({
     timestamps: true,
     versionKey: false,
 });
-holidayModelSchema.pre("save", async function (next) {
+holidayModelSchema.pre('save', async function (next) {
     const holiday = this;
     try {
         // If type is BATCH, ensure instituteId and batches exist
         if (holiday.type === app_js_1.ACADEMIC_CALENDARS_TYPE.BATCH) {
-            if (!holiday.instituteId ||
-                !holiday.batches ||
-                holiday.batches.length === 0) {
+            if (!holiday.instituteId || !holiday.batches || holiday.batches.length === 0) {
                 return next(new Error(errorMessages_js_1.BATCH_ERROR_MESSAGES.INSTITUTED_BATCHES_REQUIRED));
             }
         }
@@ -163,9 +161,9 @@ holidayModelSchema.pre("save", async function (next) {
         return next(error);
     }
 });
-holidayModelSchema.index({ instituteId: 1, status: 1, "batches.batchId": 1 });
+holidayModelSchema.index({ instituteId: 1, status: 1, 'batches.batchId': 1 });
 holidayModelSchema.index({ instituteId: 1, status: 1, batches: 1 });
-const HolidayModel = mongoose_1.default.model("holiday", holidayModelSchema);
+const HolidayModel = mongoose_1.default.model('holiday', holidayModelSchema);
 // (async () => {
 //     await HolidayModel.syncIndexes();
 // })(); // Rebuilds indexes in DB based on schema

package/dist/models/mongodb/inquiryModel.d.ts

@@ -1,4 +1,4 @@
-import { Model } from "mongoose";
-import { IInquiryModelAttributes } from "../../interfaces/inquiryInterface.js";
+import { Model } from 'mongoose';
+import { IInquiryModelAttributes } from '../../interfaces/inquiryInterface.js';
 declare const InquiryModel: Model<IInquiryModelAttributes>;
 export default InquiryModel;

package/dist/models/mongodb/inquiryModel.js

@@ -112,8 +112,7 @@ const AddressSchema = new mongoose_1.Schema({
         type: Number,
         required: false,
     },
-}, { _id: false } // Prevent creation of an automatic `_id` field for subdocuments
-);
+}, { _id: false });
 const InquirySchema = new mongoose_1.Schema({
     instituteId: { type: String, required: false },
     basicInformation: { type: BasicInformationSchema, required: true },
@@ -154,7 +153,7 @@ const InquirySchema = new mongoose_1.Schema({
     timestamps: true,
     versionKey: false,
 });
-InquirySchema.pre("save", async function (next) {
+InquirySchema.pre('save', async function (next) {
     const inquiry = this;
     try {
         if (inquiry.academicInformation.batchType) {
@@ -182,5 +181,5 @@ InquirySchema.pre("save", async function (next) {
         return next(error);
     }
 });
-const InquiryModel = mongoose_1.default.model("inquiry", InquirySchema);
+const InquiryModel = mongoose_1.default.model('inquiry', InquirySchema);
 exports.default = InquiryModel;

package/dist/models/mongodb/plugin/transformIdInResponsePlugin.d.ts

@@ -1,3 +1,3 @@
-import { Schema } from "mongoose";
+import { Schema } from 'mongoose';
 declare const transformIdInResponsePlugin: (schema: Schema) => void;
 export default transformIdInResponsePlugin;

package/dist/models/mongodb/plugin/transformIdInResponsePlugin.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const mongoose_1 = __importDefault(require("mongoose"));
 const transformNestedDocs = (doc) => {
-    if (!doc || typeof doc !== "object") {
+    if (!doc || typeof doc !== 'object') {
         return doc; // Skip non-object or null values
     }
     if (Array.isArray(doc)) {
@@ -19,9 +19,7 @@ const transformNestedDocs = (doc) => {
     }
     // Recursively process nested objects
     for (const key of Object.keys(doc)) {
-        if (!mongoose_1.default.Types.ObjectId.isValid(doc[key]) &&
-            doc[key] &&
-            typeof doc[key] === "object") {
+        if (!mongoose_1.default.Types.ObjectId.isValid(doc[key]) && doc[key] && typeof doc[key] === 'object') {
             doc[key] = transformNestedDocs(doc[key]);
         }
     }
@@ -29,7 +27,7 @@ const transformNestedDocs = (doc) => {
 };
 const transformIdInResponsePlugin = (schema) => {
     // Apply `toJSON` and `toObject` transformations
-    schema.set("toJSON", {
+    schema.set('toJSON', {
         virtuals: true,
         transform: (_, ret) => {
             if (ret._id !== undefined) {
@@ -39,7 +37,7 @@ const transformIdInResponsePlugin = (schema) => {
             }
         },
     });
-    schema.set("toObject", {
+    schema.set('toObject', {
         virtuals: true,
         transform: (_, ret) => {
             if (ret._id !== undefined) {

package/dist/models/mongodb/schoolFeeModel.d.ts

@@ -1,4 +1,4 @@
-import { Model } from "mongoose";
-import { ISchoolFeeModelAttributes } from "../../interfaces/schoolFeeInterface.js";
+import { Model } from 'mongoose';
+import { ISchoolFeeModelAttributes } from '../../interfaces/schoolFeeInterface.js';
 declare const SchoolFeeModel: Model<ISchoolFeeModelAttributes>;
 export default SchoolFeeModel;

package/dist/models/mongodb/schoolFeeModel.js

@@ -118,11 +118,11 @@ const schoolFeeSchema = new mongoose_1.Schema({
     timestamps: true,
     versionKey: false,
 });
-schoolFeeSchema.pre("save", async function (next) {
+schoolFeeSchema.pre('save', async function (next) {
     const schoolFee = this;
     try {
         if (!schoolFee.fees || schoolFee.fees.length === 0) {
-            return next(new Error("Fees array cannot be empty."));
+            return next(new Error('Fees array cannot be empty.'));
         }
         if (schoolFee.instituteId) {
             const institute = await instituteModel_js_1.default.findByPk(schoolFee.instituteId);
@@ -174,5 +174,5 @@ schoolFeeSchema.pre("save", async function (next) {
         return next(error);
     }
 });
-const SchoolFeeModel = mongoose_1.default.model("schoolFee", schoolFeeSchema);
+const SchoolFeeModel = mongoose_1.default.model('schoolFee', schoolFeeSchema);
 exports.default = SchoolFeeModel;

package/dist/models/mongodb/subjectIndexModel.d.ts

@@ -1,4 +1,4 @@
-import { Model } from "mongoose";
-import { ISubjectIndexModelAttributes } from "../../interfaces/subjectIndexInterface.js";
+import { Model } from 'mongoose';
+import { ISubjectIndexModelAttributes } from '../../interfaces/subjectIndexInterface.js';
 declare const SubjectIndexModel: Model<ISubjectIndexModelAttributes>;
 export default SubjectIndexModel;