cloud-ide-model-schema 1.1.107 → 1.1.109

package/lib/schema/index.d.ts

@@ -6,3 +6,4 @@ export * from "./accounts";
 export * from "./frontdesk";
 export * from "./admission";
 export * from "./notifications";
+export * from "./system";

package/lib/schema/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./accounts"), exports);
 __exportStar(require("./frontdesk"), exports);
 __exportStar(require("./admission"), exports);
 __exportStar(require("./notifications"), exports);
+__exportStar(require("./system"), exports);

package/lib/schema/notifications/notification_log.js

@@ -4,13 +4,6 @@ exports.CNotificationLog = void 0;
 var mongoose_1 = require("mongoose");
 /* SCHEMA START */
 var notification_log = new mongoose_1.Schema({
-    nlog_notification_id: {
-        type: mongoose_1.default.Schema.Types.ObjectId,
-        ref: "notification",
-        required: true,
-        index: true,
-        comment: "Reference to notification"
-    },
     nlog_id_user: {
         type: mongoose_1.default.Schema.Types.ObjectId,
         ref: "auth_user_mst",
@@ -84,7 +77,6 @@ var notification_log = new mongoose_1.Schema({
     collection: 'notification_logs'
 });
 // Indexes
-notification_log.index({ nlog_notification_id: 1, nlog_event_type: 1 });
 notification_log.index({ nlog_id_user: 1, nlog_event_timestamp: -1 });
 notification_log.index({ nlog_channel: 1, nlog_channel_status: 1 });
 notification_log.index({ nlog_event_type: 1, nlog_event_timestamp: -1 });

package/lib/schema/notifications/notification_preference.js

@@ -4,7 +4,7 @@ exports.CNotificationPreference = void 0;
 var mongoose_1 = require("mongoose");
 /* SCHEMA START */
 var notification_preference = new mongoose_1.Schema({
-    npref_user_id: {
+    npref_id_user: {
         type: mongoose_1.default.Schema.Types.ObjectId,
         ref: "auth_user_mst",
         required: true,
@@ -117,6 +117,6 @@ var notification_preference = new mongoose_1.Schema({
     collection: 'notification_preferences'
 });
 // Unique index on user_id
-notification_preference.index({ npref_user_id: 1 }, { unique: true });
+notification_preference.index({ npref_id_user: 1 }, { unique: true });
 var CNotificationPreference = mongoose_1.default.model("notification_preference", notification_preference);
 exports.CNotificationPreference = CNotificationPreference;

package/lib/schema/system/api_keys.d.ts

@@ -0,0 +1,26 @@
+import mongoose from "mongoose";
+export interface IApiKey {
+    _id?: string;
+    akey_name: string;
+    akey_api_key: string;
+    akey_api_secret?: string;
+    akey_permissions: string[];
+    akey_rate_limit?: {
+        requests_per_minute?: number;
+        requests_per_hour?: number;
+        requests_per_day?: number;
+    };
+    akey_expiry_date?: Date;
+    akey_last_used?: Date;
+    akey_status: 'active' | 'revoked' | 'expired';
+    akey_created_by?: string;
+    akey_created_at?: Date;
+    akey_updated_at?: Date;
+    akey_isactive?: boolean;
+}
+declare const CApiKey: mongoose.Model<IApiKey, {}, {}, {}, mongoose.Document<unknown, {}, IApiKey, {}> & IApiKey & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CApiKey };

package/lib/schema/system/api_keys.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CApiKey = void 0;
+var mongoose_1 = require("mongoose");
+var api_keys = new mongoose_1.Schema({
+    akey_name: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true
+    },
+    akey_api_key: {
+        type: String,
+        required: true,
+        maxlength: 500,
+        unique: true
+    },
+    akey_api_secret: {
+        type: String,
+        maxlength: 500
+    },
+    akey_permissions: {
+        type: [String],
+        default: []
+    },
+    akey_rate_limit: {
+        requests_per_minute: {
+            type: Number,
+            min: 0
+        },
+        requests_per_hour: {
+            type: Number,
+            min: 0
+        },
+        requests_per_day: {
+            type: Number,
+            min: 0
+        }
+    },
+    akey_expiry_date: {
+        type: Date
+    },
+    akey_last_used: {
+        type: Date
+    },
+    akey_status: {
+        type: String,
+        required: true,
+        enum: ['active', 'revoked', 'expired'],
+        default: 'active',
+        index: true
+    },
+    akey_created_by: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst"
+    },
+    akey_created_at: {
+        type: Date,
+        default: Date.now
+    },
+    akey_updated_at: {
+        type: Date,
+        default: Date.now
+    },
+    akey_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'api_keys', timestamps: { createdAt: 'akey_created_at', updatedAt: 'akey_updated_at' } });
+// Indexes
+api_keys.index({ akey_name: 1 });
+api_keys.index({ akey_status: 1 });
+api_keys.index({ akey_api_key: 1 });
+var CApiKey = mongoose_1.default.model("api_keys", api_keys);
+exports.CApiKey = CApiKey;

package/lib/schema/system/backup_jobs.d.ts

@@ -0,0 +1,39 @@
+import mongoose from "mongoose";
+export interface IBackupJob {
+    _id?: string;
+    bjob_name: string;
+    bjob_backup_type: 'full' | 'incremental' | 'differential' | 'file';
+    bjob_schedule: {
+        frequency: 'daily' | 'weekly' | 'monthly' | 'hourly' | 'manual';
+        time?: string;
+        day_of_week?: number;
+        day_of_month?: number;
+    };
+    bjob_status: 'active' | 'paused' | 'disabled';
+    bjob_last_run?: Date;
+    bjob_next_run?: Date;
+    bjob_retention_days: number;
+    bjob_encryption_enabled: boolean;
+    bjob_compression_enabled: boolean;
+    bjob_storage_location: 'local' | 'cloud' | 'both';
+    bjob_cloud_provider?: 'aws' | 'azure' | 'gcp';
+    bjob_cloud_config?: {
+        bucket_name?: string;
+        region?: string;
+        access_key?: string;
+    };
+    bjob_include_collections?: string[];
+    bjob_exclude_collections?: string[];
+    bjob_include_files?: boolean;
+    bjob_file_paths?: string[];
+    bjob_created_by?: string;
+    bjob_created_at?: Date;
+    bjob_updated_at?: Date;
+    bjob_isactive?: boolean;
+}
+declare const CBackupJob: mongoose.Model<IBackupJob, {}, {}, {}, mongoose.Document<unknown, {}, IBackupJob, {}> & IBackupJob & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CBackupJob };

package/lib/schema/system/backup_jobs.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CBackupJob = void 0;
+var mongoose_1 = require("mongoose");
+var backup_jobs = new mongoose_1.Schema({
+    bjob_name: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true,
+        unique: true
+    },
+    bjob_backup_type: {
+        type: String,
+        required: true,
+        enum: ['full', 'incremental', 'differential', 'file'],
+        trim: true
+    },
+    bjob_schedule: {
+        frequency: {
+            type: String,
+            required: true,
+            enum: ['daily', 'weekly', 'monthly', 'hourly', 'manual']
+        },
+        time: {
+            type: String,
+            maxlength: 5
+        },
+        day_of_week: {
+            type: Number,
+            min: 0,
+            max: 6
+        },
+        day_of_month: {
+            type: Number,
+            min: 1,
+            max: 31
+        }
+    },
+    bjob_status: {
+        type: String,
+        required: true,
+        enum: ['active', 'paused', 'disabled'],
+        default: 'active'
+    },
+    bjob_last_run: {
+        type: Date
+    },
+    bjob_next_run: {
+        type: Date
+    },
+    bjob_retention_days: {
+        type: Number,
+        required: true,
+        default: 30,
+        min: 1
+    },
+    bjob_encryption_enabled: {
+        type: Boolean,
+        default: false
+    },
+    bjob_compression_enabled: {
+        type: Boolean,
+        default: true
+    },
+    bjob_storage_location: {
+        type: String,
+        required: true,
+        enum: ['local', 'cloud', 'both'],
+        default: 'local'
+    },
+    bjob_cloud_provider: {
+        type: String,
+        enum: ['aws', 'azure', 'gcp']
+    },
+    bjob_cloud_config: {
+        type: Object
+    },
+    bjob_include_collections: {
+        type: [String]
+    },
+    bjob_exclude_collections: {
+        type: [String]
+    },
+    bjob_include_files: {
+        type: Boolean,
+        default: false
+    },
+    bjob_file_paths: {
+        type: [String]
+    },
+    bjob_created_by: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst"
+    },
+    bjob_created_at: {
+        type: Date,
+        default: Date.now
+    },
+    bjob_updated_at: {
+        type: Date,
+        default: Date.now
+    },
+    bjob_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'backup_jobs', timestamps: { createdAt: 'bjob_created_at', updatedAt: 'bjob_updated_at' } });
+// Indexes
+backup_jobs.index({ bjob_name: 1 });
+backup_jobs.index({ bjob_status: 1 });
+backup_jobs.index({ bjob_next_run: 1 });
+var CBackupJob = mongoose_1.default.model("backup_jobs", backup_jobs);
+exports.CBackupJob = CBackupJob;

package/lib/schema/system/backup_policies.d.ts

@@ -0,0 +1,23 @@
+import mongoose from "mongoose";
+export interface IBackupPolicy {
+    _id?: string;
+    bpol_name: string;
+    bpol_retention_days: number;
+    bpol_backup_frequency: 'hourly' | 'daily' | 'weekly' | 'monthly';
+    bpol_encryption_enabled: boolean;
+    bpol_compression_enabled: boolean;
+    bpol_auto_cleanup: boolean;
+    bpol_notification_enabled: boolean;
+    bpol_notification_emails?: string[];
+    bpol_description?: string;
+    bpol_created_by?: string;
+    bpol_created_at?: Date;
+    bpol_updated_at?: Date;
+    bpol_isactive?: boolean;
+}
+declare const CBackupPolicy: mongoose.Model<IBackupPolicy, {}, {}, {}, mongoose.Document<unknown, {}, IBackupPolicy, {}> & IBackupPolicy & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CBackupPolicy };

package/lib/schema/system/backup_policies.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CBackupPolicy = void 0;
+var mongoose_1 = require("mongoose");
+var backup_policies = new mongoose_1.Schema({
+    bpol_name: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true,
+        unique: true
+    },
+    bpol_retention_days: {
+        type: Number,
+        required: true,
+        default: 30,
+        min: 1
+    },
+    bpol_backup_frequency: {
+        type: String,
+        required: true,
+        enum: ['hourly', 'daily', 'weekly', 'monthly']
+    },
+    bpol_encryption_enabled: {
+        type: Boolean,
+        default: false
+    },
+    bpol_compression_enabled: {
+        type: Boolean,
+        default: true
+    },
+    bpol_auto_cleanup: {
+        type: Boolean,
+        default: true
+    },
+    bpol_notification_enabled: {
+        type: Boolean,
+        default: true
+    },
+    bpol_notification_emails: {
+        type: [String]
+    },
+    bpol_description: {
+        type: String,
+        maxlength: 500
+    },
+    bpol_created_by: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst"
+    },
+    bpol_created_at: {
+        type: Date,
+        default: Date.now
+    },
+    bpol_updated_at: {
+        type: Date,
+        default: Date.now
+    },
+    bpol_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'backup_policies', timestamps: { createdAt: 'bpol_created_at', updatedAt: 'bpol_updated_at' } });
+// Indexes
+backup_policies.index({ bpol_name: 1 });
+backup_policies.index({ bpol_isactive: 1 });
+var CBackupPolicy = mongoose_1.default.model("backup_policies", backup_policies);
+exports.CBackupPolicy = CBackupPolicy;

package/lib/schema/system/backup_records.d.ts

@@ -0,0 +1,29 @@
+import mongoose from "mongoose";
+export interface IBackupRecord {
+    _id?: string;
+    brec_backup_job_id: string;
+    brec_backup_type: 'full' | 'incremental' | 'differential' | 'file';
+    brec_backup_path: string;
+    brec_file_name: string;
+    brec_size: number;
+    brec_status: 'in_progress' | 'completed' | 'failed' | 'cancelled';
+    brec_verification_status: 'pending' | 'verified' | 'failed';
+    brec_started_at?: Date;
+    brec_completed_at?: Date;
+    brec_duration?: number;
+    brec_error_message?: string;
+    brec_metadata?: {
+        collections_backed_up?: string[];
+        collections_count?: number;
+        files_backed_up?: number;
+        compression_ratio?: number;
+    };
+    brec_created_at?: Date;
+    brec_isactive?: boolean;
+}
+declare const CBackupRecord: mongoose.Model<IBackupRecord, {}, {}, {}, mongoose.Document<unknown, {}, IBackupRecord, {}> & IBackupRecord & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CBackupRecord };

package/lib/schema/system/backup_records.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CBackupRecord = void 0;
+var mongoose_1 = require("mongoose");
+var backup_records = new mongoose_1.Schema({
+    brec_backup_job_id: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "backup_jobs",
+        required: true,
+        index: true
+    },
+    brec_backup_type: {
+        type: String,
+        required: true,
+        enum: ['full', 'incremental', 'differential', 'file']
+    },
+    brec_backup_path: {
+        type: String,
+        required: true,
+        maxlength: 500
+    },
+    brec_file_name: {
+        type: String,
+        required: true,
+        maxlength: 255
+    },
+    brec_size: {
+        type: Number,
+        required: true,
+        min: 0
+    },
+    brec_status: {
+        type: String,
+        required: true,
+        enum: ['in_progress', 'completed', 'failed', 'cancelled'],
+        default: 'in_progress',
+        index: true
+    },
+    brec_verification_status: {
+        type: String,
+        required: true,
+        enum: ['pending', 'verified', 'failed'],
+        default: 'pending'
+    },
+    brec_started_at: {
+        type: Date,
+        default: Date.now
+    },
+    brec_completed_at: {
+        type: Date
+    },
+    brec_duration: {
+        type: Number,
+        min: 0
+    },
+    brec_error_message: {
+        type: String,
+        maxlength: 1000
+    },
+    brec_metadata: {
+        type: Object
+    },
+    brec_created_at: {
+        type: Date,
+        default: Date.now,
+        index: true
+    },
+    brec_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'backup_records', timestamps: { createdAt: 'brec_created_at' } });
+// Indexes
+backup_records.index({ brec_backup_job_id: 1, brec_created_at: -1 });
+backup_records.index({ brec_status: 1 });
+backup_records.index({ brec_verification_status: 1 });
+var CBackupRecord = mongoose_1.default.model("backup_records", backup_records);
+exports.CBackupRecord = CBackupRecord;

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

@@ -0,0 +1,12 @@
+export { CBackupJob, IBackupJob } from './backup_jobs';
+export { CBackupRecord, IBackupRecord } from './backup_records';
+export { CRecoveryOperation, IRecoveryOperation } from './recovery_operations';
+export { CBackupPolicy, IBackupPolicy } from './backup_policies';
+export { CIntegration, IIntegration } from './integrations';
+export { CApiKey, IApiKey } from './api_keys';
+export { CWebhook, IWebhook } from './webhooks';
+export { CIntegrationLog, IIntegrationLog } from './integration_logs';
+export { CSubscriptionPlan, ISubscriptionPlan } from './subscription_plans';
+export { CSubscriptionFeature, ISubscriptionFeature } from './subscription_features';
+export { CSubscription, ISubscription } from './subscriptions';
+export { CSubscriptionPayment, ISubscriptionPayment } from './subscription_payments';

package/lib/schema/system/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSubscriptionPayment = exports.CSubscription = exports.CSubscriptionFeature = exports.CSubscriptionPlan = exports.CIntegrationLog = exports.CWebhook = exports.CApiKey = exports.CIntegration = exports.CBackupPolicy = exports.CRecoveryOperation = exports.CBackupRecord = exports.CBackupJob = void 0;
+// System Module Schemas
+var backup_jobs_1 = require("./backup_jobs");
+Object.defineProperty(exports, "CBackupJob", { enumerable: true, get: function () { return backup_jobs_1.CBackupJob; } });
+var backup_records_1 = require("./backup_records");
+Object.defineProperty(exports, "CBackupRecord", { enumerable: true, get: function () { return backup_records_1.CBackupRecord; } });
+var recovery_operations_1 = require("./recovery_operations");
+Object.defineProperty(exports, "CRecoveryOperation", { enumerable: true, get: function () { return recovery_operations_1.CRecoveryOperation; } });
+var backup_policies_1 = require("./backup_policies");
+Object.defineProperty(exports, "CBackupPolicy", { enumerable: true, get: function () { return backup_policies_1.CBackupPolicy; } });
+var integrations_1 = require("./integrations");
+Object.defineProperty(exports, "CIntegration", { enumerable: true, get: function () { return integrations_1.CIntegration; } });
+var api_keys_1 = require("./api_keys");
+Object.defineProperty(exports, "CApiKey", { enumerable: true, get: function () { return api_keys_1.CApiKey; } });
+var webhooks_1 = require("./webhooks");
+Object.defineProperty(exports, "CWebhook", { enumerable: true, get: function () { return webhooks_1.CWebhook; } });
+var integration_logs_1 = require("./integration_logs");
+Object.defineProperty(exports, "CIntegrationLog", { enumerable: true, get: function () { return integration_logs_1.CIntegrationLog; } });
+var subscription_plans_1 = require("./subscription_plans");
+Object.defineProperty(exports, "CSubscriptionPlan", { enumerable: true, get: function () { return subscription_plans_1.CSubscriptionPlan; } });
+var subscription_features_1 = require("./subscription_features");
+Object.defineProperty(exports, "CSubscriptionFeature", { enumerable: true, get: function () { return subscription_features_1.CSubscriptionFeature; } });
+var subscriptions_1 = require("./subscriptions");
+Object.defineProperty(exports, "CSubscription", { enumerable: true, get: function () { return subscriptions_1.CSubscription; } });
+var subscription_payments_1 = require("./subscription_payments");
+Object.defineProperty(exports, "CSubscriptionPayment", { enumerable: true, get: function () { return subscription_payments_1.CSubscriptionPayment; } });

package/lib/schema/system/integration_logs.d.ts

@@ -0,0 +1,21 @@
+import mongoose from "mongoose";
+export interface IIntegrationLog {
+    _id?: string;
+    ilog_integration_id?: string;
+    ilog_operation: string;
+    ilog_status: 'success' | 'failed' | 'pending';
+    ilog_request_data?: any;
+    ilog_response_data?: any;
+    ilog_error_message?: string;
+    ilog_error_code?: string;
+    ilog_duration?: number;
+    ilog_retry_count?: number;
+    ilog_created_at?: Date;
+    ilog_isactive?: boolean;
+}
+declare const CIntegrationLog: mongoose.Model<IIntegrationLog, {}, {}, {}, mongoose.Document<unknown, {}, IIntegrationLog, {}> & IIntegrationLog & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CIntegrationLog };

package/lib/schema/system/integration_logs.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CIntegrationLog = void 0;
+var mongoose_1 = require("mongoose");
+var integration_logs = new mongoose_1.Schema({
+    ilog_integration_id: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "integrations",
+        index: true
+    },
+    ilog_operation: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        index: true
+    },
+    ilog_status: {
+        type: String,
+        required: true,
+        enum: ['success', 'failed', 'pending'],
+        default: 'pending',
+        index: true
+    },
+    ilog_request_data: {
+        type: Object
+    },
+    ilog_response_data: {
+        type: Object
+    },
+    ilog_error_message: {
+        type: String,
+        maxlength: 1000
+    },
+    ilog_error_code: {
+        type: String,
+        maxlength: 50
+    },
+    ilog_duration: {
+        type: Number,
+        min: 0
+    },
+    ilog_retry_count: {
+        type: Number,
+        default: 0,
+        min: 0
+    },
+    ilog_created_at: {
+        type: Date,
+        default: Date.now,
+        index: true
+    },
+    ilog_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'integration_logs', timestamps: { createdAt: 'ilog_created_at' } });
+// Indexes
+integration_logs.index({ ilog_integration_id: 1, ilog_created_at: -1 });
+integration_logs.index({ ilog_status: 1 });
+integration_logs.index({ ilog_operation: 1 });
+var CIntegrationLog = mongoose_1.default.model("integration_logs", integration_logs);
+exports.CIntegrationLog = CIntegrationLog;

package/lib/schema/system/integrations.d.ts

@@ -0,0 +1,31 @@
+import mongoose from "mongoose";
+export interface IIntegration {
+    _id?: string;
+    intg_name: string;
+    intg_type: 'payment_gateway' | 'shipping_carrier' | 'accounting_software' | 'ecommerce_platform' | 'sms_gateway' | 'email_service' | 'bank' | 'tax_service' | 'custom';
+    intg_provider: string;
+    intg_api_key?: string;
+    intg_api_secret?: string;
+    intg_merchant_id?: string;
+    intg_status: 'active' | 'inactive' | 'testing';
+    intg_configuration?: {
+        endpoint?: string;
+        webhook_url?: string;
+        timeout?: number;
+        retry_count?: number;
+        [key: string]: any;
+    };
+    intg_test_mode: boolean;
+    intg_last_sync?: Date;
+    intg_sync_frequency?: 'realtime' | 'hourly' | 'daily' | 'manual';
+    intg_created_by?: string;
+    intg_created_at?: Date;
+    intg_updated_at?: Date;
+    intg_isactive?: boolean;
+}
+declare const CIntegration: mongoose.Model<IIntegration, {}, {}, {}, mongoose.Document<unknown, {}, IIntegration, {}> & IIntegration & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CIntegration };