@kipicore/dbcore 1.0.3

package/dist/models/mongodb/examGroupModel.js

@@ -0,0 +1,293 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importStar(require("mongoose"));
+const app_1 = require("../../constants/app");
+const errorMessages_1 = require("../../constants/errorMessages");
+const instituteModel_1 = __importDefault(require("../psql/instituteModel"));
+const instituteEntityModel_1 = __importDefault(require("../psql/instituteEntityModel"));
+const sequelize_1 = require("sequelize");
+const userInstituteMetaModel_1 = __importDefault(require("./userInstituteMetaModel"));
+const utils_1 = require("../../helpers/utils");
+const date_fns_1 = require("date-fns");
+const examGroupDaysSchema = new mongoose_1.Schema({
+    date: {
+        type: Date,
+        required: true,
+    },
+    note: {
+        type: String,
+        required: false,
+    },
+    subjectId: {
+        type: String,
+        required: false,
+    },
+    examId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        required: false,
+    },
+    isHoliday: {
+        type: Boolean,
+        required: true,
+        default: false,
+    },
+    examDetails: {
+        type: mongoose_1.default.Schema.Types.Mixed,
+    },
+}, { _id: false });
+const examGroupStandardByDaysSchema = new mongoose_1.Schema({
+    standardId: {
+        type: String,
+        required: true,
+    },
+    // batches: {
+    //     type: [String],
+    //     default: [],
+    // },
+    // subjects: {
+    //     type: [String],
+    //     default: [],
+    // },
+    days: {
+        type: [examGroupDaysSchema],
+        required: true,
+    },
+    isMarksAdded: {
+        type: Boolean,
+        default: false,
+    },
+    result: {
+        type: String,
+        enum: app_1.EXAM_GROUP_STANDARD_RESULT,
+        default: app_1.EXAM_GROUP_STANDARD_RESULT.PENDING,
+    },
+}, { _id: false });
+const examGroupModelSchema = new mongoose_1.Schema({
+    title: {
+        type: String,
+        required: true,
+    },
+    subTitle: {
+        type: String,
+        required: false,
+    },
+    instituteId: {
+        type: String,
+        required: true,
+    },
+    startDate: {
+        type: Date,
+        required: true,
+    },
+    endDate: {
+        type: Date,
+        required: true,
+    },
+    standards: {
+        type: [String],
+        default: [],
+        required: true,
+    },
+    subjects: {
+        type: [String],
+        default: [],
+        required: true,
+    },
+    standardByDays: {
+        type: [examGroupStandardByDaysSchema],
+        required: true,
+    },
+    status: {
+        type: String,
+        enum: app_1.EXAM_GROUP_STATUS,
+        default: app_1.EXAM_GROUP_STATUS.PENDING,
+    },
+}, {
+    timestamps: true,
+    versionKey: false,
+});
+const createOrUpdateHook = async (examGroup) => {
+    try {
+        if (examGroup.instituteId) {
+            const institute = await instituteModel_1.default.findOne({
+                where: {
+                    id: examGroup.instituteId,
+                },
+            });
+            if (!institute)
+                throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+        }
+        if (examGroup.standards) {
+            examGroup.standards = [...new Set(examGroup.standards)];
+            const standardCount = await instituteEntityModel_1.default.count({
+                where: {
+                    id: { [sequelize_1.Op.in]: examGroup.standards },
+                },
+            });
+            if (standardCount !== examGroup.standards.length)
+                throw new Error(errorMessages_1.INSTITUTE_ENTITY_TYPE_ERROR_MESSAGES.NOT_FOUND);
+        }
+        if (examGroup.isNew) {
+            examGroup.standardByDays = examGroup.standardByDays = [];
+            examGroup.subjects = [];
+        }
+        if (examGroup.standardByDays) {
+            examGroup.standardByDays = examGroup.standardByDays.filter((standardByDays) => examGroup.standards.includes(standardByDays.standardId));
+            const userInstituteMeta = await userInstituteMetaModel_1.default.findOne({
+                userId: examGroup.instituteId,
+                instituteId: examGroup.instituteId,
+            });
+            let subjectList = await instituteEntityModel_1.default.findAll({
+                where: {
+                    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_1.groupByFieldOrFields)(subjectList, "entityId");
+            const dateList = [];
+            let startDate = examGroup.startDate;
+            while (new Date(startDate).getTime() < new Date(examGroup.endDate).getTime()) {
+                dateList.push(startDate);
+                startDate = (0, date_fns_1.addDays)(startDate, 1);
+            }
+            for (const standard of examGroup.standards) {
+                if (!subjectListByStandardId[standard])
+                    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);
+                let standardByDays = {
+                    standardId: standard,
+                    // batches: batches.map(batch => batch.id),
+                    // subjects: standardSubjectList,
+                    days: [],
+                };
+                dateList.forEach((date) => {
+                    const dayObject = {
+                        date,
+                        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());
+                        });
+                        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);
+                    }
+                    else {
+                        standardByDays.days.push(dayObject);
+                    }
+                });
+                if (existStandardByDays) {
+                    examGroup.standardByDays[existStandardByDaysIndex] =
+                        existStandardByDays;
+                    const isNotValidHoliday = examGroup.standardByDays[existStandardByDaysIndex].days.some((day) => day.isHoliday && day.subjectId.length > 1);
+                    if (isNotValidHoliday)
+                        throw new Error(errorMessages_1.EXAM_GROUP_ERROR_MESSAGES.INVALID_HOLIDAY);
+                    standardByDays = { ...existStandardByDays };
+                }
+                else {
+                    examGroup.standardByDays.push(standardByDays);
+                }
+                /**************** Remove if want validate all subject exam created when status publish **************/
+                // if (examGroup.status === EXAM_GROUP_STATUS.PUBLISHED) {
+                //     const isAllSubjectExamCreated = standardByDays.days.every(day => standardSubjectList.includes(day.subjectId as string));
+                //     if (!isAllSubjectExamCreated) throw new Error(EXAM_GROUP_ERROR_MESSAGES.ALL_SUBJECT_EXAM_NOT_CREATED);
+                // }
+            }
+            //*********** days array remove duplicate date from date if multiple date empty ********///
+            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());
+                    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) {
+                            acc.splice(existingIndex, 1);
+                        }
+                        acc.push(day);
+                    }
+                    else if (existingIndex === -1) {
+                        // Push empty examDetails object only if there's no existing entry
+                        acc.push(day);
+                    }
+                    return acc;
+                }, []),
+            }));
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+};
+examGroupModelSchema.pre("save", async function (next) {
+    const subjectIndex = this;
+    try {
+        await createOrUpdateHook(subjectIndex);
+        next();
+    }
+    catch (error) {
+        throw error;
+    }
+});
+examGroupModelSchema.pre("updateMany", async function (next) {
+    const subjectIndex = this.getUpdate();
+    try {
+        await createOrUpdateHook(subjectIndex);
+        next();
+    }
+    catch (error) {
+        throw error;
+    }
+});
+const ExamGroupModel = mongoose_1.default.model("exam_groups", examGroupModelSchema);
+exports.default = ExamGroupModel;

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

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

package/dist/models/mongodb/examHasAnswerSheetModel.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importStar(require("mongoose"));
+const app_1 = require("../../constants/app");
+const examModel_1 = __importDefault(require("./examModel"));
+const errorMessages_1 = require("../../constants/errorMessages");
+// Define the schema for IAnswerSheetQuestion
+const AnswerSheetQuestionSchema = new mongoose_1.Schema({
+    index: {
+        type: Number,
+        required: true,
+    },
+    options: {
+        type: [String],
+        required: false,
+    },
+    selectedOptions: {
+        type: [String],
+        required: false,
+    },
+    validOptions: {
+        type: [String],
+        required: false,
+    },
+    result: {
+        type: String,
+        enum: Object.values(app_1.EXAM_ANSWER_SHEET_QUESTION_RESULT),
+        default: app_1.EXAM_ANSWER_SHEET_QUESTION_RESULT.NOT_ATTENDED,
+        required: false,
+    },
+}, { _id: false } // Prevent creation of an automatic `_id` field for subdocuments
+);
+// Define the main schema for IExamHasAnswerSheetModelAttributes
+const examHasAnswerSheetSchema = new mongoose_1.Schema({
+    examId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "exams",
+        required: true,
+    },
+    questions: {
+        type: [AnswerSheetQuestionSchema],
+        default: [],
+        required: true,
+    },
+    userId: {
+        type: String,
+        required: true,
+    },
+    userType: {
+        type: String,
+        enum: Object.values(app_1.USER_TYPES),
+        required: true,
+    },
+    type: {
+        type: String,
+        enum: Object.values(app_1.EXAM_ANSWER_SHEET_RESULT_TYPE),
+        required: true,
+    },
+    status: {
+        type: String,
+        enum: Object.values(app_1.EXAM_ANSWER_SHEET_STATUS),
+        default: app_1.EXAM_ANSWER_SHEET_STATUS.PENDING,
+        required: true,
+    },
+    obtainedMarks: {
+        type: Number,
+        required: false,
+    },
+    resultStatus: {
+        type: String,
+        enum: Object.values(app_1.EXAM_ANSWER_SHEET_RESULT_STATUS),
+        required: false,
+    },
+    isInProgress: {
+        type: Boolean,
+        default: false,
+        required: false,
+    },
+    studentExamIp: {
+        type: String,
+        default: "",
+        required: false,
+    },
+}, {
+    timestamps: true,
+    versionKey: false,
+});
+// Add a pre-save hook to validate examId existence
+examHasAnswerSheetSchema.pre("save", async function (next) {
+    const examExists = await examModel_1.default.findOne({ where: { id: this.examId } });
+    if (!examExists) {
+        return next(new Error(errorMessages_1.EXAM_ERROR_MESSAGES.NOT_FOUND));
+    }
+    next();
+});
+const ExamHasAnswerSheetModel = mongoose_1.default.model("exam_answer_sheets", examHasAnswerSheetSchema);
+exports.default = ExamHasAnswerSheetModel;

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

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

package/dist/models/mongodb/examModel.js

@@ -0,0 +1,267 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importStar(require("mongoose"));
+const app_1 = require("../../constants/app");
+const sequelize_1 = require("sequelize");
+const errorMessages_1 = require("../../constants/errorMessages");
+const instituteEntityModel_1 = __importDefault(require("../psql/instituteEntityModel"));
+const classRoomModel_1 = __importDefault(require("../psql/classRoomModel"));
+const instituteModel_1 = __importDefault(require("../psql/instituteModel"));
+const fileStorageModel_1 = __importDefault(require("../psql/fileStorageModel"));
+const typeManagementModel_1 = __importDefault(require("../psql/typeManagementModel"));
+const batchModel_1 = __importDefault(require("../psql/batchModel"));
+const ExamHasBatchSchema = new mongoose_1.Schema({
+    batchId: {
+        type: String,
+        required: true,
+    },
+    classroomId: {
+        type: String,
+        required: false,
+    },
+    startTime: {
+        type: Date,
+        required: true,
+    },
+    endTime: {
+        type: Date,
+        required: true,
+    },
+    isMarksAdded: {
+        type: Boolean,
+        default: false,
+    },
+}, { _id: false } // Prevent creation of an automatic `_id` field for subdocuments
+);
+const examModelSchema = new mongoose_1.Schema({
+    title: {
+        type: String,
+        required: true,
+    },
+    subTitle: {
+        type: String,
+        required: false,
+    },
+    description: {
+        type: String,
+        required: false,
+    },
+    subject: {
+        type: String,
+        required: true,
+    },
+    batches: {
+        type: [ExamHasBatchSchema],
+        required: true,
+    },
+    mode: {
+        type: String,
+        enum: Object.values(app_1.EXAM_MODE),
+        required: true,
+    },
+    type: {
+        type: String,
+        required: true,
+    },
+    scheduleDate: {
+        type: Date,
+        required: true,
+    },
+    maxMarks: {
+        type: Number,
+        required: true,
+    },
+    passingMarks: {
+        type: Number,
+        required: true,
+    },
+    status: {
+        type: String,
+        enum: Object.values(app_1.EXAM_STATUS),
+        default: app_1.EXAM_STATUS.PENDING,
+        required: false,
+    },
+    nagativeMarksPerQuestion: {
+        type: Number,
+        required: false,
+    },
+    marksPerQuestion: {
+        type: Number,
+        required: false,
+    },
+    instituteId: {
+        type: String,
+        required: false,
+    },
+    fileId: {
+        type: String,
+        required: false,
+    },
+    // fileUrl: {
+    //     type: String,
+    //     required: false,
+    // },
+    totalQuestions: {
+        type: Number,
+        required: false,
+    },
+    mcqOptions: {
+        type: [String],
+        required: false,
+    },
+    ansSelectionType: {
+        type: String,
+        enum: Object.values(app_1.EXAM_ANSWER_SELECTION_TYPE),
+        required: false,
+    },
+    validAnsType: {
+        type: String,
+        enum: Object.values(app_1.EXAM_VALID_ANSWER_TYPE),
+        required: false,
+    },
+    standard: {
+        type: String,
+        required: false,
+    },
+    groupId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        required: false,
+    },
+    isPublished: {
+        type: Boolean,
+        default: true,
+    },
+    createdBy: {
+        type: String,
+        required: false,
+    },
+    updatedBy: {
+        type: String,
+        required: false,
+    },
+    deletedBy: {
+        type: String,
+        required: false,
+    },
+    isMarksAdded: {
+        type: Boolean,
+        default: false,
+    },
+    plannerSyncStatus: {
+        type: String,
+        default: app_1.PLANNER_SYNC_STATUS.PENDING,
+    },
+}, {
+    timestamps: true,
+    versionKey: false,
+});
+examModelSchema.pre("save", async function (next) {
+    const exam = this;
+    try {
+        if (exam.batches && exam.batches.length && exam.subject) {
+            let where = {
+                id: exam.subject,
+            };
+            const subject = await instituteEntityModel_1.default.findOne({ where });
+            if (!subject) {
+                return next(new Error(errorMessages_1.BATCH_ERROR_MESSAGES.INVALID_SELECTED));
+            }
+            where = {
+                id: { [sequelize_1.Op.in]: exam.batches.map((batch) => batch.batchId) },
+                subjects: { [sequelize_1.Op.overlap]: [exam.subject] },
+            };
+            const batchesList = await batchModel_1.default.findAll({ where });
+            if (batchesList.length !== exam.batches.length) {
+                return next(new Error(errorMessages_1.BATCH_ERROR_MESSAGES.INVALID_SELECTED));
+            }
+            if (exam.mode === app_1.EXAM_MODE.OFFLINE && !exam.groupId) {
+                where = {
+                    id: { [sequelize_1.Op.in]: exam.batches.map((batch) => batch.classroomId) },
+                };
+                const classroomCount = await classRoomModel_1.default.count({ where });
+                const classroomDataount = [
+                    ...new Set(exam.batches.map((val) => val.classroomId)),
+                ].length;
+                if (classroomCount !== classroomDataount) {
+                    return next(new Error(errorMessages_1.CLASSROOM_ERROR_MESSAGES.INVALID_SELECTED));
+                }
+            }
+        }
+        if (exam.instituteId) {
+            const institute = await instituteModel_1.default.findByPk(exam.instituteId);
+            if (!institute) {
+                return next(new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND));
+            }
+        }
+        if (exam.fileId) {
+            const file = await fileStorageModel_1.default.findByPk(exam.fileId);
+            if (!file) {
+                return next(new Error(errorMessages_1.FILE_STORAGE_ERROR_MESSAGES.NOT_FOUND));
+            }
+        }
+        if (exam.type) {
+            const type = await typeManagementModel_1.default.findOne({
+                where: {
+                    id: exam.type,
+                    type: app_1.TYPE_MANAGEMENT_TYPE.EXAM,
+                },
+            });
+            if (!type) {
+                return next(new Error(errorMessages_1.TYPE_MANAGEMENT_ERROR_MESSAGES.NOT_FOUND));
+            }
+        }
+        next(); // Proceed with the save operation
+    }
+    catch (error) {
+        return next(error); // Handle any errors that occur during the validation
+    }
+});
+examModelSchema.index({
+    instituteId: 1,
+    "batches.batchId": 1,
+    scheduleDate: 1,
+    subject: 1,
+    status: 1,
+    mode: 1,
+});
+const ExamModel = mongoose_1.default.model("exams", examModelSchema);
+// (async () => {
+//     await ExamModel.syncIndexes();
+// })(); // Rebuilds indexes in DB based on schema
+exports.default = ExamModel;