@kipicore/dbcore 1.0.8 → 1.0.10

package/dist/models/mongodb/dashboardManagementModel.js

@@ -0,0 +1,111 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importStar(require("mongoose"));
+const app_1 = require("../../constants/app");
+const DashboardManagementSchema = new mongoose_1.Schema({
+    sequenceNumber: {
+        type: Number,
+        required: true,
+    },
+    moduleName: {
+        type: String,
+        required: false,
+    },
+    webConfig: {
+        type: String,
+        required: true,
+    },
+    mobileConfig: {
+        type: String,
+        required: true,
+    },
+    webStatus: {
+        type: String,
+        enum: Object.values(app_1.COMMAN_STATUS),
+        default: app_1.COMMAN_STATUS.ACTIVE,
+        required: false,
+    },
+    mobileStatus: {
+        type: String,
+        enum: Object.values(app_1.COMMAN_STATUS),
+        default: app_1.COMMAN_STATUS.ACTIVE,
+        required: false,
+    },
+}, { _id: false });
+const DashboardManagementModelSchema = new mongoose_1.Schema({
+    isDefault: {
+        type: Boolean,
+        required: true,
+    },
+    instituteId: {
+        type: String,
+        required: false,
+    },
+    userId: {
+        type: String,
+        required: false,
+    },
+    userType: {
+        type: String,
+        enum: Object.values(app_1.USER_TYPES),
+        required: false,
+    },
+    moduleList: {
+        type: [DashboardManagementSchema],
+        required: true,
+    },
+    createdBy: {
+        type: String,
+        required: false,
+    },
+    updatedBy: {
+        type: String,
+        required: false,
+    },
+    deletedBy: {
+        type: String,
+        required: false,
+    },
+}, {
+    timestamps: true,
+    versionKey: false,
+});
+// DashboardManagementModelSchema.index({
+//     instituteId: 1,
+//     user:1
+// });
+const DashboardManagement = mongoose_1.default.model('dashboard_management', DashboardManagementModelSchema);
+exports.default = DashboardManagement;

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

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

package/dist/models/mongodb/eventModel.js

@@ -0,0 +1,164 @@
+"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 batchModel_1 = __importDefault(require("../psql/batchModel"));
+const EventHasBatchSchema = new mongoose_1.Schema({
+    batchId: {
+        type: String,
+        required: true,
+    },
+    subjectId: {
+        type: String,
+        required: false,
+    },
+    lectureId: {
+        type: String,
+        required: false,
+    },
+}, { _id: false });
+const eventModelSchema = new mongoose_1.Schema({
+    title: {
+        type: String,
+        required: true,
+    },
+    subTitle: {
+        type: String,
+        required: false,
+    },
+    description: {
+        type: String,
+        required: false,
+    },
+    // subject: {
+    //     type: String,
+    //     required: false,
+    // },
+    batches: {
+        type: [EventHasBatchSchema],
+        required: false,
+    },
+    type: {
+        type: String,
+        enum: Object.values(app_1.ACADEMIC_CALENDARS_TYPE),
+        default: app_1.ACADEMIC_CALENDARS_TYPE.INSTITUTE,
+        required: true,
+    },
+    startTime: {
+        type: Date,
+        required: true,
+    },
+    endTime: {
+        type: Date,
+        required: true,
+    },
+    status: {
+        type: String,
+        enum: Object.values(app_1.COMMAN_STATUS),
+        default: app_1.COMMAN_STATUS.INACTIVE,
+        required: true,
+    },
+    instituteId: {
+        type: String,
+        required: false,
+    },
+    createdBy: {
+        type: String,
+        required: false,
+    },
+    updatedBy: {
+        type: String,
+        required: false,
+    },
+    deletedBy: {
+        type: String,
+        required: false,
+    },
+    plannerSyncStatus: {
+        type: String,
+        default: app_1.PLANNER_SYNC_STATUS.PENDING,
+    },
+}, {
+    timestamps: true,
+    versionKey: false,
+});
+eventModelSchema.pre("save", async function (next) {
+    const event = this;
+    try {
+        // If type is BATCH, ensure instituteId and batches exist
+        if (event.type === app_1.ACADEMIC_CALENDARS_TYPE.BATCH) {
+            if (!event.instituteId || !event.batches || event.batches.length === 0) {
+                return next(new Error(errorMessages_1.BATCH_ERROR_MESSAGES.INSTITUTED_BATCHES_REQUIRED));
+            }
+        }
+        for (const batch of event.batches || []) {
+            // Validate subjectId if provided
+            if (batch.subjectId) {
+                const subject = await instituteModel_1.default.findOne({
+                    where: { id: batch.subjectId },
+                });
+                if (!subject) {
+                    return next(new Error(errorMessages_1.BATCH_ERROR_MESSAGES.INVALID_SELECTED));
+                }
+            }
+            // Validate batchId if provided
+            if (batch.batchId) {
+                const batchExists = await batchModel_1.default.findOne({
+                    where: { id: batch.batchId },
+                });
+                if (!batchExists) {
+                    return next(new Error(errorMessages_1.BATCH_ERROR_MESSAGES.INVALID_SELECTED));
+                }
+            }
+        }
+        next();
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+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);
+// (async () => {
+//     await EventModel.syncIndexes();
+// })(); // Rebuilds indexes in DB based on schema
+exports.default = EventModel;

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

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

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;