cloud-ide-model-schema 1.1.141 → 1.1.142

package/lib/config/database.js

@@ -47,6 +47,7 @@ var MAX_RETRY_ATTEMPTS = 10;
 var INITIAL_RETRY_DELAY = 1000; // 1 second
 var MAX_RETRY_DELAY = 30000; // 30 seconds
 var retryTimeout = null;
+var alertEmailSent = false; // Track if alert email has been sent
 /**
  * Check if MongoDB is already connected
  */
@@ -72,6 +73,7 @@ function setupConnectionListeners() {
         console.log('✅ MongoDB connected successfully');
         connectionRetryCount = 0; // Reset retry count on success
         isConnecting = false;
+        alertEmailSent = false; // Reset alert flag on successful connection
     });
     // Connection error
     mongoose.connection.on('error', function (error) {
@@ -115,9 +117,25 @@ function attemptReconnection() {
         clearTimeout(retryTimeout);
         retryTimeout = null;
     }
-    // Check retry limit
+    // Check retry limit - but allow reset after a longer delay
     if (connectionRetryCount >= MAX_RETRY_ATTEMPTS) {
-        console.error("\u274C MongoDB reconnection failed after ".concat(MAX_RETRY_ATTEMPTS, " attempts. Server will continue running but database operations may fail."));
+        // Send alert email if not already sent
+        if (!alertEmailSent) {
+            sendMongoDBConnectionAlert();
+            alertEmailSent = true;
+        }
+        // After max attempts, wait longer before allowing another attempt
+        // This prevents infinite retries but allows recovery if MongoDB becomes available
+        var longDelay = MAX_RETRY_DELAY * 2; // 60 seconds
+        console.log("\u23F3 MongoDB reconnection paused after ".concat(MAX_RETRY_ATTEMPTS, " attempts. Will retry in ").concat(longDelay, "ms..."));
+        retryTimeout = setTimeout(function () {
+            retryTimeout = null;
+            connectionRetryCount = 0; // Reset retry count to allow fresh attempt
+            console.log('🔄 Resetting retry count. Attempting fresh MongoDB connection...');
+            connectDB().catch(function () {
+                // If it fails, start retry cycle again
+            });
+        }, longDelay);
         return;
     }
     // Calculate exponential backoff delay
@@ -129,10 +147,12 @@ function attemptReconnection() {
             switch (_a.label) {
                 case 0:
                     retryTimeout = null;
+                    if (!(!isConnected() && !isConnecting)) return [3 /*break*/, 2];
                     return [4 /*yield*/, connectDB()];
                 case 1:
                     _a.sent(); // Recursive call
-                    return [2 /*return*/];
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
             }
         });
     }); }, delay);
@@ -143,7 +163,7 @@ function attemptReconnection() {
  */
 function connectDB() {
     return __awaiter(this, void 0, void 0, function () {
-        var mongoUri, options, connectPromise, timeoutPromise, error_1, errorMessage;
+        var mongoUri, closeError_1, options, error_1, errorMessage, closeError_2;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -151,10 +171,23 @@ function connectDB() {
                     if (isConnected()) {
                         return [2 /*return*/];
                     }
-                    // If already connecting, wait for it
-                    if (isConnecting || isConnectingState()) {
+                    if (!(isConnecting || isConnectingState())) return [3 /*break*/, 2];
+                    // Wait 2 seconds and check if connection succeeded
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 2000); })];
+                case 1:
+                    // Wait 2 seconds and check if connection succeeded
+                    _a.sent();
+                    // If connected now, return
+                    if (isConnected()) {
                         return [2 /*return*/];
                     }
+                    // If still connecting after wait, allow new attempt (might be stuck)
+                    if (isConnecting || isConnectingState()) {
+                        console.warn('⚠️ Previous connection attempt seems stuck. Starting fresh connection attempt...');
+                        isConnecting = false; // Reset flag to allow new attempt
+                    }
+                    _a.label = 2;
+                case 2:
                     // Setup event listeners (idempotent)
                     setupConnectionListeners();
                     mongoUri = process.env.MONGODB_URI;
@@ -164,13 +197,25 @@ function connectDB() {
                         return [2 /*return*/];
                     }
                     isConnecting = true;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 9, , 15]);
+                    if (!(mongoose.connection.readyState !== 0)) return [3 /*break*/, 7];
+                    _a.label = 4;
+                case 4:
+                    _a.trys.push([4, 6, , 7]);
+                    return [4 /*yield*/, mongoose.connection.close()];
+                case 5:
+                    _a.sent();
+                    return [3 /*break*/, 7];
+                case 6:
+                    closeError_1 = _a.sent();
+                    return [3 /*break*/, 7];
+                case 7:
                     options = {
-                        connectTimeoutMS: 15000, // Increased timeout
-                        socketTimeoutMS: 45000, // Increased socket timeout
-                        serverSelectionTimeoutMS: 15000, // Timeout for server selection
+                        connectTimeoutMS: 15000, // 15 second timeout
+                        socketTimeoutMS: 45000, // 45 second socket timeout
+                        serverSelectionTimeoutMS: 15000, // 15 second server selection timeout
                         heartbeatFrequencyMS: 10000, // Heartbeat frequency
                         retryWrites: true,
                         retryReads: true,
@@ -179,35 +224,121 @@ function connectDB() {
                         maxPoolSize: 10, // Maximum number of connections in the pool
                         minPoolSize: 2, // Minimum number of connections in the pool
                     };
-                    connectPromise = mongoose.connect(mongoUri, options);
-                    timeoutPromise = new Promise(function (_, reject) {
-                        setTimeout(function () {
-                            reject(new Error('Connection timeout'));
-                        }, 20000); // 20 second timeout
-                    });
-                    return [4 /*yield*/, Promise.race([connectPromise, timeoutPromise])];
-                case 2:
+                    // Attempt connection
+                    return [4 /*yield*/, mongoose.connect(mongoUri, options)];
+                case 8:
+                    // Attempt connection
                     _a.sent();
                     // If we get here, connection was successful
                     console.log('✅ Connected to MongoDB');
-                    connectionRetryCount = 0; // Reset retry count
+                    connectionRetryCount = 0; // Reset retry count on success
                     isConnecting = false;
-                    return [3 /*break*/, 4];
-                case 3:
+                    return [3 /*break*/, 15];
+                case 9:
                     error_1 = _a.sent();
                     isConnecting = false;
                     errorMessage = (error_1 === null || error_1 === void 0 ? void 0 : error_1.message) || 'Unknown error';
                     console.error("\u274C MongoDB connection failed: ".concat(errorMessage));
+                    _a.label = 10;
+                case 10:
+                    _a.trys.push([10, 13, , 14]);
+                    if (!(mongoose.connection.readyState !== 0)) return [3 /*break*/, 12];
+                    return [4 /*yield*/, mongoose.connection.close()];
+                case 11:
+                    _a.sent();
+                    _a.label = 12;
+                case 12: return [3 /*break*/, 14];
+                case 13:
+                    closeError_2 = _a.sent();
+                    return [3 /*break*/, 14];
+                case 14:
                     // Only attempt retry if we haven't exceeded max attempts
                     if (connectionRetryCount < MAX_RETRY_ATTEMPTS) {
                         attemptReconnection();
                     }
                     else {
-                        console.error("\u274C MongoDB connection failed after ".concat(MAX_RETRY_ATTEMPTS, " attempts. Server will continue running but database operations may fail."));
-                        console.error('⚠️ To retry connection, restart the server or wait for automatic reconnection.');
+                        // Send alert email if we've reached max attempts and haven't sent it yet
+                        if (!alertEmailSent) {
+                            sendMongoDBConnectionAlert();
+                            alertEmailSent = true;
+                        }
+                        // After max attempts, schedule a longer wait before retrying
+                        attemptReconnection(); // This will handle the long delay
+                    }
+                    return [3 /*break*/, 15];
+                case 15: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Send email alert to Cloud IDE team about MongoDB connection failure
+ * This function works without requiring MongoDB connection
+ */
+function sendMongoDBConnectionAlert() {
+    return __awaiter(this, void 0, void 0, function () {
+        var recipientEmail, serverName, mongoUri, subject, body, emailGatewayUrl, emailGatewayApiKey, senderEmail, axios, emailPayload, emailError_1, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 7, , 8]);
+                    recipientEmail = process.env.CLOUD_IDE_ALERT_EMAIL || process.env.SYSTEM_ALERT_EMAIL;
+                    if (!recipientEmail) {
+                        console.warn('⚠️ MongoDB alert email not sent: CLOUD_IDE_ALERT_EMAIL or SYSTEM_ALERT_EMAIL not configured');
+                        return [2 /*return*/];
                     }
+                    serverName = process.env.SERVER_NAME || process.env.NODE_ENV || 'Unknown';
+                    mongoUri = process.env.MONGODB_URI ?
+                        process.env.MONGODB_URI.replace(/\/\/([^:]+):([^@]+)@/, '//***:***@') : // Mask credentials
+                        'Not configured';
+                    subject = "\uD83D\uDEA8 MongoDB Connection Failure Alert - ".concat(serverName);
+                    body = "\nMongoDB Connection Failure Alert\n\nSystem Information:\n- Server: ".concat(serverName, "\n- Environment: ").concat(process.env.NODE_ENV || 'Unknown', "\n- Timestamp: ").concat(new Date().toISOString(), "\n- MongoDB URI: ").concat(mongoUri, "\n\nConnection Status:\n- Retry Attempts: ").concat(connectionRetryCount, "/").concat(MAX_RETRY_ATTEMPTS, "\n- Connection State: ").concat(mongoose.connection.readyState === 0 ? 'Disconnected' :
+                        mongoose.connection.readyState === 1 ? 'Connected' :
+                            mongoose.connection.readyState === 2 ? 'Connecting' : 'Unknown', "\n\nAction Required:\nThe system has failed to connect to MongoDB after ").concat(MAX_RETRY_ATTEMPTS, " retry attempts. \nPlease check:\n1. MongoDB server status\n2. Network connectivity\n3. MongoDB URI configuration\n4. Firewall rules\n5. MongoDB authentication credentials\n\nThe system will continue to retry connection automatically, but database operations may fail until connection is restored.\n\nThis is an automated alert from Cloud IDE System Monitoring.\n        ").trim();
+                    emailGatewayUrl = process.env.EMAIL_GATEWAY_URL;
+                    emailGatewayApiKey = process.env.EMAIL_GATEWAY_API_KEY;
+                    senderEmail = process.env.EMAIL_SENDER || process.env.SYSTEM_EMAIL || 'noreply@cloudide.com';
+                    if (!(emailGatewayUrl && emailGatewayApiKey)) return [3 /*break*/, 5];
+                    axios = require('axios');
+                    emailPayload = {
+                        to: recipientEmail,
+                        from: senderEmail,
+                        subject: subject,
+                        body: body,
+                        html: body.replace(/\n/g, '<br>') // Convert newlines to HTML breaks
+                    };
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, axios.post(emailGatewayUrl, emailPayload, {
+                            headers: {
+                                'Content-Type': 'application/json',
+                                'Authorization': "Bearer ".concat(emailGatewayApiKey),
+                                'X-API-Key': emailGatewayApiKey
+                            },
+                            timeout: 10000 // 10 second timeout
+                        })];
+                case 2:
+                    _a.sent();
+                    console.log("\uD83D\uDCE7 MongoDB connection failure alert email sent to ".concat(recipientEmail));
+                    return [3 /*break*/, 4];
+                case 3:
+                    emailError_1 = _a.sent();
+                    console.error('❌ Failed to send alert email via gateway:', (emailError_1 === null || emailError_1 === void 0 ? void 0 : emailError_1.message) || emailError_1);
                     return [3 /*break*/, 4];
-                case 4: return [2 /*return*/];
+                case 4: return [3 /*break*/, 6];
+                case 5:
+                    console.warn('⚠️ Alert email not sent: EMAIL_GATEWAY_URL and EMAIL_GATEWAY_API_KEY not configured');
+                    console.warn('⚠️ Please configure email gateway environment variables for MongoDB connection failure alerts');
+                    console.warn("\u26A0\uFE0F Alert details would have been sent to: ".concat(recipientEmail));
+                    _a.label = 6;
+                case 6: return [3 /*break*/, 8];
+                case 7:
+                    error_2 = _a.sent();
+                    // Don't throw - this is a non-critical operation
+                    console.error('❌ Failed to send MongoDB connection alert email:', (error_2 === null || error_2 === void 0 ? void 0 : error_2.message) || error_2);
+                    return [3 /*break*/, 8];
+                case 8: return [2 /*return*/];
             }
         });
     });

package/lib/schema/admission/admission_application_main.js

@@ -99,6 +99,50 @@ var admission_application_main = new mongoose_1.Schema({
         ref: "core_file_manager",
         comment: "Student photo file manager ID"
     },
+    admap_identification_status_id_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_general_master",
+        comment: "Student identification status (Alive, Passed Away, etc.) - Reference to core_general_master with type 'IDENTIFICATION_STATUS'"
+    },
+    admap_is_rte_scheme: {
+        type: Boolean,
+        default: false,
+        comment: "Is student under Right to Education (RTE) scheme - if true, RTE details will be required"
+    },
+    admap_grn: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "General Registration Number assigned by authority (CBSE, State Board, etc.)"
+    },
+    admap_grn_authority_id_edbrd: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_education_board",
+        comment: "Education board/authority that assigned GRN - Reference to core_education_board"
+    },
+    admap_handicap_certificate_id_cyfm: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_file_manager",
+        comment: "Handicap certificate file manager ID"
+    },
+    admap_handicap_certificate_number: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "Handicap certificate number"
+    },
+    admap_handicap_percentage: {
+        type: Number,
+        min: 0,
+        max: 100,
+        comment: "Handicap percentage (0-100)"
+    },
+    admap_accessibility_requirements: {
+        type: String,
+        maxlength: 1000,
+        trim: true,
+        comment: "Accessibility requirements and special accommodations needed"
+    },
     // SECTION 2: CONTACT & ADDRESS INFORMATION
     admap_primary_email: {
         type: String,

package/lib/schema/admission/admission_family_members.js

@@ -249,6 +249,11 @@ var admission_family_members = new mongoose_1.Schema({
         trim: true,
         comment: "Additional remarks/notes"
     },
+    admfm_identification_status_id_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'core_general_master',
+        comment: "Identification status for father/guardian (Alive, Passed Away, etc.) - Reference to core_general_master with type 'IDENTIFICATION_STATUS'"
+    },
     admfm_isactive: {
         type: Boolean,
         default: true,

package/lib/schema/admission/admission_rte_details.d.ts

@@ -0,0 +1,45 @@
+import mongoose from "mongoose";
+declare const CAdmissionRteDetails: mongoose.Model<{
+    [x: string]: unknown;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    [x: string]: unknown;
+}, {}> & {
+    [x: string]: unknown;
+} & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    [x: string]: unknown;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    [x: string]: unknown;
+}>, {}> & mongoose.FlatRecord<{
+    [x: string]: unknown;
+}> & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}>>;
+declare const CAdmissionEntityAccessPassManagementAdmrte: mongoose.Model<{
+    [x: string]: unknown;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    [x: string]: unknown;
+}, {}> & {
+    [x: string]: unknown;
+} & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    [x: string]: unknown;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    [x: string]: unknown;
+}>, {}> & mongoose.FlatRecord<{
+    [x: string]: unknown;
+}> & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}>>;
+export { CAdmissionEntityAccessPassManagementAdmrte, // collection
+CAdmissionRteDetails };

package/lib/schema/admission/admission_rte_details.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAdmissionRteDetails = exports.CAdmissionEntityAccessPassManagementAdmrte = void 0;
+var mongoose_1 = require("mongoose");
+/**
+ * Admission RTE (Right to Education) Details Schema
+ *
+ * Purpose: Store comprehensive RTE scheme details for admission applications
+ * Prefix: admrte_ (admission RTE)
+ *
+ * BUSINESS LOGIC:
+ * 1. Separate table for RTE details to allow future integration with multiple tables
+ * 2. One RTE details record per admission (when RTE scheme is applicable)
+ * 3. Stores certificates, income details, caste information, BPL card details
+ * 4. Reference fields for future extensibility to connect with student master and other tables
+ * 5. Entity-based access control
+ */
+/* SCHEMA START */
+var admission_rte_details = new mongoose_1.Schema({
+    admrte_admission_id_admap: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'admission_application_main',
+        required: true,
+        comment: "Reference to admission application (primary reference)"
+    },
+    admrte_reference_table: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "Reference table name for future extensibility (e.g., 'admission_application_main', 'student_master')"
+    },
+    admrte_reference_id: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        comment: "Reference ID for future extensibility (reference to other tables)"
+    },
+    admrte_rte_certificate_number: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "RTE certificate number"
+    },
+    admrte_rte_certificate_date: {
+        type: Date,
+        comment: "RTE certificate issue date"
+    },
+    admrte_rte_category_id_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'core_general_master',
+        comment: "RTE category (Economically Weaker Section, Disadvantaged Group, etc.) - Reference to core_general_master with type 'RTE_CATEGORY'"
+    },
+    admrte_income_certificate_number: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "Income certificate number"
+    },
+    admrte_income_certificate_date: {
+        type: Date,
+        comment: "Income certificate date"
+    },
+    admrte_income_certificate_id_cyfm: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'core_file_manager',
+        comment: "Income certificate file manager ID"
+    },
+    admrte_caste_certificate_number: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "Caste certificate number"
+    },
+    admrte_caste_certificate_date: {
+        type: Date,
+        comment: "Caste certificate date"
+    },
+    admrte_caste_certificate_id_cyfm: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'core_file_manager',
+        comment: "Caste certificate file manager ID"
+    },
+    admrte_caste_category_id_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'core_general_master',
+        comment: "Caste category (General, OBC, SC, ST, etc.) - Reference to core_general_master with type 'CASTE_CATEGORY'"
+    },
+    admrte_bpl_card_number: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "BPL (Below Poverty Line) card number"
+    },
+    admrte_bpl_card_id_cyfm: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'core_file_manager',
+        comment: "BPL card file manager ID"
+    },
+    admrte_annual_income: {
+        type: Number,
+        min: 0,
+        comment: "Annual family income"
+    },
+    admrte_annual_income_currency_id_syic: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'core_iso_currency',
+        comment: "Currency reference for annual income"
+    },
+    admrte_rte_quota_percentage: {
+        type: Number,
+        min: 0,
+        max: 100,
+        comment: "RTE quota percentage (0-100)"
+    },
+    admrte_remarks: {
+        type: String,
+        maxlength: 1000,
+        trim: true,
+        comment: "Additional remarks/notes"
+    },
+    admrte_isactive: {
+        type: Boolean,
+        default: true,
+        comment: "Is active"
+    }
+}, {
+    collection: 'admission_rte_details'
+});
+// Indexes for better performance
+admission_rte_details.index({ admrte_admission_id_admap: 1 });
+admission_rte_details.index({ admrte_reference_table: 1, admrte_reference_id: 1 });
+admission_rte_details.index({ admrte_isactive: 1 });
+var CAdmissionRteDetails = mongoose_1.default.model("admission_rte_details", admission_rte_details);
+exports.CAdmissionRteDetails = CAdmissionRteDetails;
+// Access pass for entity-based access control
+var admission_entity_access_pass_management_admrte = new mongoose_1.Schema({
+    admepm_user_id_user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'auth_user_mst',
+        comment: "User who has access"
+    },
+    admepm_entity_id_syen: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'core_system_entity',
+        comment: "Entity context"
+    },
+    admepm_access_pass_to: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'admission_rte_details',
+        comment: "RTE details record access"
+    },
+    admepm_is_owner: {
+        type: Boolean,
+        default: true,
+        comment: "Is owner of record"
+    },
+    admepm_can_edit: {
+        type: Boolean,
+        default: true,
+        comment: "Can edit permission"
+    },
+    admepm_can_view: {
+        type: Boolean,
+        default: true,
+        comment: "Can view permission"
+    },
+    admepm_isactive: {
+        type: Boolean,
+        default: true,
+        comment: "Is access active"
+    },
+    admepm_actions_allowed: {
+        type: Object,
+        default: {},
+        comment: "Specific actions allowed"
+    }
+}, { collection: 'admission_entity_access_pass_management_admrte' });
+var CAdmissionEntityAccessPassManagementAdmrte = mongoose_1.default.model("admission_entity_access_pass_management_admrte", admission_entity_access_pass_management_admrte);
+exports.CAdmissionEntityAccessPassManagementAdmrte = CAdmissionEntityAccessPassManagementAdmrte;

package/lib/schema/admission/admission_vital_information.d.ts

@@ -0,0 +1,45 @@
+import mongoose from "mongoose";
+declare const CAdmissionVitalInformation: mongoose.Model<{
+    [x: string]: unknown;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    [x: string]: unknown;
+}, {}> & {
+    [x: string]: unknown;
+} & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    [x: string]: unknown;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    [x: string]: unknown;
+}>, {}> & mongoose.FlatRecord<{
+    [x: string]: unknown;
+}> & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}>>;
+declare const CAdmissionEntityAccessPassManagementAdmvi: mongoose.Model<{
+    [x: string]: unknown;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    [x: string]: unknown;
+}, {}> & {
+    [x: string]: unknown;
+} & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    [x: string]: unknown;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    [x: string]: unknown;
+}>, {}> & mongoose.FlatRecord<{
+    [x: string]: unknown;
+}> & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}>>;
+export { CAdmissionEntityAccessPassManagementAdmvi, // collection
+CAdmissionVitalInformation };

package/lib/schema/admission/admission_vital_information.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAdmissionVitalInformation = exports.CAdmissionEntityAccessPassManagementAdmvi = void 0;
+var mongoose_1 = require("mongoose");
+/**
+ * Admission Vital Information Schema
+ *
+ * Purpose: Store flexible vital information for admission applications with timestamps
+ * Prefix: admvi_ (admission vital information)
+ *
+ * BUSINESS LOGIC:
+ * 1. Multiple vital information entries per admission (height, weight, blood pressure, etc.)
+ * 2. Flexible structure - vital types configurable via general master
+ * 3. Each entry has capture date and user for audit trail
+ * 4. Supports various units of measurement (configurable via general master)
+ * 5. Entity-based access control
+ */
+/* SCHEMA START */
+var admission_vital_information = new mongoose_1.Schema({
+    admvi_admission_id_admap: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'admission_application_main',
+        required: true,
+        comment: "Reference to admission application"
+    },
+    admvi_vital_type_id_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'core_general_master',
+        required: true,
+        comment: "Vital information type (Height, Weight, Blood Pressure, etc.) - Reference to core_general_master with type 'VITAL_INFORMATION_TYPE'"
+    },
+    admvi_value: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        required: true,
+        comment: "Vital information value (stored as string to support various data types)"
+    },
+    admvi_unit_id_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'core_general_master',
+        comment: "Unit of measurement (cm, kg, mmHg, bpm, etc.) - Reference to core_general_master with type 'VITAL_INFORMATION_UNIT'"
+    },
+    admvi_captured_date: {
+        type: Date,
+        required: true,
+        default: Date.now,
+        comment: "Date when vital information was captured"
+    },
+    admvi_captured_by_user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'auth_user_mst',
+        comment: "User who captured the vital information"
+    },
+    admvi_remarks: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Additional remarks/notes about the vital information"
+    },
+    admvi_isactive: {
+        type: Boolean,
+        default: true,
+        comment: "Is active"
+    }
+}, {
+    collection: 'admission_vital_information'
+});
+// Indexes for better performance
+admission_vital_information.index({ admvi_admission_id_admap: 1 });
+admission_vital_information.index({ admvi_vital_type_id_sygms: 1 });
+admission_vital_information.index({ admvi_captured_date: 1 });
+admission_vital_information.index({ admvi_isactive: 1 });
+var CAdmissionVitalInformation = mongoose_1.default.model("admission_vital_information", admission_vital_information);
+exports.CAdmissionVitalInformation = CAdmissionVitalInformation;
+// Access pass for entity-based access control
+var admission_entity_access_pass_management_admvi = new mongoose_1.Schema({
+    admepm_user_id_user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'auth_user_mst',
+        comment: "User who has access"
+    },
+    admepm_entity_id_syen: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'core_system_entity',
+        comment: "Entity context"
+    },
+    admepm_access_pass_to: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'admission_vital_information',
+        comment: "Vital information record access"
+    },
+    admepm_is_owner: {
+        type: Boolean,
+        default: true,
+        comment: "Is owner of record"
+    },
+    admepm_can_edit: {
+        type: Boolean,
+        default: true,
+        comment: "Can edit permission"
+    },
+    admepm_can_view: {
+        type: Boolean,
+        default: true,
+        comment: "Can view permission"
+    },
+    admepm_isactive: {
+        type: Boolean,
+        default: true,
+        comment: "Is access active"
+    },
+    admepm_actions_allowed: {
+        type: Object,
+        default: {},
+        comment: "Specific actions allowed"
+    }
+}, { collection: 'admission_entity_access_pass_management_admvi' });
+var CAdmissionEntityAccessPassManagementAdmvi = mongoose_1.default.model("admission_entity_access_pass_management_admvi", admission_entity_access_pass_management_admvi);
+exports.CAdmissionEntityAccessPassManagementAdmvi = CAdmissionEntityAccessPassManagementAdmvi;

package/lib/schema/admission/index.d.ts

@@ -5,3 +5,5 @@ export * from "./admission_document_uploads";
 export * from "./admission_contact_addresses";
 export * from "./admission_family_members";
 export * from "./admission_fee_snapshot";
+export * from "./admission_rte_details";
+export * from "./admission_vital_information";

package/lib/schema/admission/index.js

@@ -21,3 +21,5 @@ __exportStar(require("./admission_document_uploads"), exports);
 __exportStar(require("./admission_contact_addresses"), exports);
 __exportStar(require("./admission_family_members"), exports);
 __exportStar(require("./admission_fee_snapshot"), exports);
+__exportStar(require("./admission_rte_details"), exports);
+__exportStar(require("./admission_vital_information"), exports);

package/lib/schema/email/email_log.js

@@ -35,7 +35,28 @@ var email_log = new mongoose_1.Schema({
         type: String,
         trim: true,
         default: 'created',
-        enum: ['created', 'sent', 'not_sent']
+        enum: ['created', 'pending', 'queued', 'sent', 'delivered', 'failed', 'not_sent', 'bounced'],
+        comment: "Email delivery status"
+    },
+    elog_response_data: {
+        type: String,
+        comment: "Vendor response data (JSON string)"
+    },
+    elog_error_message: {
+        type: String,
+        maxlength: 1000,
+        trim: true,
+        comment: "Error message if email failed"
+    },
+    elog_retry_count: {
+        type: Number,
+        default: 0,
+        min: 0,
+        comment: "Number of retry attempts"
+    },
+    elog_delivered_at: {
+        type: Date,
+        comment: "Timestamp when email was delivered"
     },
     elog_timestamp: {
         type: Date,

package/lib/schema/email/email_reference.js

@@ -12,18 +12,38 @@ var email_reference = new mongoose_1.Schema({
     eref_sender_id_elst: {
         type: mongoose_1.default.Schema.Types.ObjectId,
         require: true,
-        ref: "email_vendor"
+        ref: "email_list",
+        comment: "Reference to email_list (fixed: was incorrectly referencing email_vendor)"
     },
     eref_receiver_id_elst: {
         type: mongoose_1.default.Schema.Types.ObjectId,
         require: true,
-        ref: "email_vendor"
+        ref: "email_list",
+        comment: "Reference to email_list"
     },
     eref_var: {
         type: Array,
         required: true,
         trim: true,
-        default: []
+        default: [],
+        comment: "Array of template variables"
+    },
+    eref_description: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Email reference description"
+    },
+    eref_category: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "Email reference category"
+    },
+    eref_default_variables: {
+        type: [String],
+        default: [],
+        comment: "Default variables expected for this reference"
     },
     eref_isactive: {
         type: Boolean,

package/lib/schema/email/email_subscription_vendor.js

@@ -17,7 +17,13 @@ var email_subscription_vendor = new mongoose_1.Schema({
     esub_end_dtm: {
         type: Date,
         required: true,
-        default: new Date()
+        default: new Date(),
+        validate: {
+            validator: function (value) {
+                return !this.esub_start_dtm || value > this.esub_start_dtm;
+            },
+            message: 'End date must be after start date'
+        }
     },
     esub_timestamp: {
         type: Date,
@@ -45,6 +51,15 @@ var email_subscription_vendor = new mongoose_1.Schema({
         minvalue: 0,
         default: 0,
     },
+    esub_alert_sent: {
+        type: Boolean,
+        default: false,
+        comment: "Whether alert has been sent for limit"
+    },
+    esub_last_alert_at: {
+        type: Date,
+        comment: "Timestamp of last alert sent"
+    },
     esub_status: {
         type: String,
         required: true,

package/lib/schema/email/email_templete.js

@@ -23,11 +23,46 @@ var email_templete = new mongoose_1.Schema({
         maxlength: 384000,
         required: true
     },
+    etmp_variables: {
+        type: [String],
+        default: [],
+        comment: "Template variables detected in body (e.g., {{user_name}})"
+    },
+    etmp_category: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "Template category for organization"
+    },
+    etmp_description: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Template description"
+    },
     etmp_isactive: {
         type: Boolean,
         required: true,
         default: true
+    },
+    etmp_created_at: {
+        type: Date,
+        default: Date.now,
+        comment: "Creation timestamp"
+    },
+    etmp_updated_at: {
+        type: Date,
+        default: Date.now,
+        comment: "Last update timestamp"
     }
-}, { collection: 'email_templete' });
+}, {
+    collection: 'email_templete',
+    timestamps: { createdAt: 'etmp_created_at', updatedAt: 'etmp_updated_at' }
+});
+// Indexes for better query performance
+email_templete.index({ etmp_id_eref: 1 });
+email_templete.index({ etmp_isactive: 1 });
+email_templete.index({ etmp_category: 1 });
+email_templete.index({ etmp_created_at: -1 });
 var CEmailTemplete = mongoose_1.default.model("email_templete", email_templete);
 exports.CEmailTemplete = CEmailTemplete;

package/package.json

@@ -9,7 +9,7 @@
     "typescript": "^5.8.3"
   },
   "name": "cloud-ide-model-schema",
-  "version": "1.1.141",
+  "version": "1.1.142",
   "description": "Pachage for schema management of Cloud IDEsys LMS",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",