vr-commons 1.0.155 → 1.0.157

package/dist/utils/admin.device.utils.d.ts

@@ -1,6 +1,23 @@
 import { Device, UserRole } from "vr-models";
 import { Transaction } from "sequelize";
 import { StockChangeResult } from "./types";
+export interface LockAllDevicesResult {
+    success: boolean;
+    lockedCount: number;
+    failedCount: number;
+    failedDeviceIds: string[];
+    errors: string[];
+    message: string;
+    totalProcessed: number;
+}
+export interface LockDevicesOptions {
+    actorId?: string;
+    actorRole?: UserRole | string;
+    transaction?: any;
+    batchSize?: number;
+    maxRetries?: number;
+    triggeredBy?: "cronjob" | "manual";
+}
 export declare const stockUtil: {
     /**
      * Increment stock when devices are added/created
@@ -120,4 +137,10 @@ export declare const stockUtil: {
         message: string;
         devices: Device[];
     }>;
+    /**
+     * Lock ALL devices regardless of payment plan status
+     * Uses batch processing for large datasets
+     * If no transaction is provided, runs without transaction
+     */
+    lockAllDevices(options?: LockDevicesOptions): Promise<LockAllDevicesResult>;
 };

package/dist/utils/admin.device.utils.js

@@ -6,6 +6,7 @@ const vr_models_1 = require("vr-models");
 const sequelize_1 = require("sequelize");
 const eventLog_utils_1 = require("./eventLog.utils");
 const admin_devices_validations_1 = require("../validations/admin.devices.validations");
+const systemLog_utils_1 = require("./systemLog.utils");
 /**
  * Extract dedication from serial number
  */
@@ -451,4 +452,203 @@ exports.stockUtil = {
             devices: updatedDevices,
         };
     },
+    /**
+     * Lock ALL devices regardless of payment plan status
+     * Uses batch processing for large datasets
+     * If no transaction is provided, runs without transaction
+     */
+    async lockAllDevices(options = {}) {
+        const { actorId = "SYSTEM", actorRole = "SYSTEM", transaction, batchSize = 100, maxRetries = 3, triggeredBy = "manual", } = options;
+        const isSystem = actorRole === "SYSTEM" || triggeredBy === "cronjob";
+        const isAdmin = !isSystem;
+        try {
+            const lockedDeviceIds = [];
+            const failedDeviceIds = [];
+            const errors = [];
+            let totalLocked = 0;
+            let totalProcessed = 0;
+            let batchNumber = 0;
+            let hasMore = true;
+            console.log(`🔒 Locking ALL devices at ${new Date().toISOString()}`);
+            // Log start of job
+            if (isSystem) {
+                await (0, systemLog_utils_1.logInfo)(`Lock all devices job started`, {
+                    category: "CRONJOB",
+                    source: "device-lock.cronjob",
+                    details: { triggeredBy, batchSize, maxRetries },
+                });
+            }
+            else {
+                await (0, systemLog_utils_1.logInfo)(`Lock all devices triggered by ${actorRole}`, {
+                    category: "DEVICE",
+                    userId: actorId || undefined,
+                    userRole: actorRole,
+                    source: "device-lock.manual",
+                    details: { triggeredBy, batchSize, maxRetries },
+                });
+            }
+            // Process in batches
+            while (hasMore) {
+                batchNumber++;
+                const offset = (batchNumber - 1) * batchSize;
+                // Get devices for current batch (ALL devices except disabled)
+                const devices = await vr_models_1.Device.findAll({
+                    where: {
+                        status: { [sequelize_1.Op.ne]: "disabled" },
+                        deletedAt: null,
+                    },
+                    limit: batchSize,
+                    offset: offset,
+                    transaction: transaction, // Use transaction if provided, otherwise undefined
+                });
+                if (devices.length === 0) {
+                    hasMore = false;
+                    break;
+                }
+                totalProcessed += devices.length;
+                console.log(`📦 Batch ${batchNumber}: Processing ${devices.length} devices (Total: ${totalProcessed})`);
+                // Process each device with retry logic
+                for (const device of devices) {
+                    let retries = 0;
+                    let locked = false;
+                    while (!locked && retries < maxRetries) {
+                        try {
+                            // Skip if already locked
+                            if (device.status === "locked") {
+                                console.log(`🔒 Device ${device.serialNumber} already locked`);
+                                locked = true;
+                                break;
+                            }
+                            // Lock the device
+                            await device.update({ status: "locked" }, { transaction: transaction } // Use transaction if provided
+                            );
+                            lockedDeviceIds.push(device.id);
+                            totalLocked++;
+                            locked = true;
+                            console.log(`🔒 Locked device ${device.serialNumber} (${device.id})`);
+                            // Log event for each lock
+                            await (0, eventLog_utils_1.logEvent)({
+                                actorId: isSystem ? null : actorId,
+                                actorType: isSystem ? "ADMIN" : actorRole,
+                                action: "DEVICES_LOCKED",
+                                entity: "Device",
+                                entityId: device.id,
+                                metadata: {
+                                    serialNumber: device.serialNumber,
+                                    pairId: device.pairId,
+                                    productId: device.productId,
+                                    lockedAt: new Date().toISOString(),
+                                    reason: "Scheduled lock all devices",
+                                    triggeredBy: triggeredBy,
+                                    batchNumber,
+                                    previousStatus: device.status,
+                                },
+                                deviceSession: null,
+                                transaction: transaction,
+                            });
+                        }
+                        catch (err) {
+                            retries++;
+                            console.error(`❌ Failed to lock device ${device.serialNumber} (attempt ${retries}/${maxRetries}):`, err instanceof Error ? err.message : "Unknown error");
+                            if (retries >= maxRetries) {
+                                failedDeviceIds.push(device.id);
+                                errors.push(`Device ${device.serialNumber} (${device.id}): ${err instanceof Error ? err.message : "Unknown error"}`);
+                            }
+                            else {
+                                // Wait before retry (exponential backoff)
+                                await new Promise((resolve) => setTimeout(resolve, retries * 1000));
+                            }
+                        }
+                    }
+                }
+                // If we got fewer devices than batch size, we're done
+                if (devices.length < batchSize) {
+                    hasMore = false;
+                }
+            }
+            const result = {
+                success: true,
+                lockedCount: totalLocked,
+                failedCount: failedDeviceIds.length,
+                failedDeviceIds,
+                errors,
+                totalProcessed,
+                message: `Successfully locked ${totalLocked} devices out of ${totalProcessed} processed${failedDeviceIds.length > 0 ? `, ${failedDeviceIds.length} failed` : ""}`,
+            };
+            console.log(`✅ Lock all devices completed:`, result);
+            // Log completion
+            if (isSystem) {
+                await (0, systemLog_utils_1.logInfo)(`Lock all devices job completed`, {
+                    category: "CRONJOB",
+                    source: "device-lock.cronjob",
+                    details: {
+                        lockedCount: result.lockedCount,
+                        failedCount: result.failedCount,
+                        totalProcessed: result.totalProcessed,
+                        hasErrors: result.errors.length > 0,
+                    },
+                });
+            }
+            else {
+                await (0, systemLog_utils_1.logInfo)(`Lock all devices completed by ${actorRole}`, {
+                    category: "DEVICE",
+                    userId: actorId || undefined,
+                    userRole: actorRole,
+                    source: "device-lock.manual",
+                    details: {
+                        lockedCount: result.lockedCount,
+                        failedCount: result.failedCount,
+                        totalProcessed: result.totalProcessed,
+                        hasErrors: result.errors.length > 0,
+                    },
+                });
+            }
+            // Log errors if any
+            if (result.errors.length > 0) {
+                await (0, systemLog_utils_1.logError)(`Lock all devices had ${result.errors.length} failures`, {
+                    category: isSystem ? "CRONJOB" : "DEVICE",
+                    source: isSystem ? "device-lock.cronjob" : "device-lock.manual",
+                    userId: isSystem ? null : actorId || undefined,
+                    userRole: isSystem ? null : actorRole,
+                    details: {
+                        failedCount: result.failedCount,
+                        failedDeviceIds: result.failedDeviceIds,
+                        errors: result.errors,
+                    },
+                });
+            }
+            return result;
+        }
+        catch (err) {
+            console.error("❌ Lock all devices failed:", err);
+            const errorMessage = err instanceof Error ? err.message : "Unknown error occurred";
+            const result = {
+                success: false,
+                lockedCount: 0,
+                failedCount: 0,
+                failedDeviceIds: [],
+                errors: [errorMessage],
+                totalProcessed: 0,
+                message: `Lock all devices job failed: ${errorMessage}`,
+            };
+            // Log failure
+            if (isSystem) {
+                await (0, systemLog_utils_1.logError)(`Lock all devices job failed`, {
+                    category: "CRONJOB",
+                    source: "device-lock.cronjob",
+                    details: { error: errorMessage },
+                });
+            }
+            else {
+                await (0, systemLog_utils_1.logError)(`Lock all devices failed`, {
+                    category: "DEVICE",
+                    userId: actorId || undefined,
+                    userRole: actorRole,
+                    source: "device-lock.manual",
+                    details: { error: errorMessage },
+                });
+            }
+            return result;
+        }
+    },
 };

package/dist/utils/index.d.ts

@@ -15,3 +15,4 @@ export { DPP_OperationsUtil } from "./admin.devicePayment.utils";
 export { PendingRegistration, VerificationMethod, ConfirmResponse, UploadResult, StockChangeResult, } from "./types";
 export { formatDeviceSession, formatEventLog, formatEventLogs, buildEventLogWhereClause, buildSearchConditions, buildUserSearchConditions, } from "./eventlogs.admin.utils";
 export { extractDedicatedUserFromSerial } from "./deviceUtils";
+export { logApi, logAuth, logCronjob, logDebug, logDevice, logError, logInfo, logPayment, logSecurity, logSystem, logWarning, } from "./systemLog.utils";

package/dist/utils/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateContactValue = exports.detectContactType = exports.sendVerificationCode = exports.sendSMS = exports.sendEmail = exports.getVerificationMethod = exports.getOTPExpiry = exports.generateOTP = exports.createDeviceSession = exports.suspensionUtil = exports.banUtil = exports.hasHigherAuthority = exports.getModeratableRoles = exports.canModerateUser = exports.canModerate = exports.softDeleteUser = exports.hashPassword = exports.validatePassword = exports.validateUniqueFields = exports.generateJacketId = exports.getSortOrder = exports.generateEventSearchConditions = exports.generateUserSearchConditions = exports.findSecurityClearanceByRole = exports.getUsersByRole = exports.getUserById = exports.isAccountAccessible = exports.canModifyAccount = exports.hasAllPermissions = exports.hasAnyPermission = exports.hasPermission = exports.hasRole = exports.formatUserListResponse = exports.formatUserProfile = exports.sendErrorResponse = exports.sendSuccessResponse = exports.logEvent = exports.formatTimeRemaining = exports.getTokenTimeRemaining = exports.generateToken = exports.shouldRefreshToken = exports.verifyToken = exports.generateRiderToken = exports.generatePassengerToken = exports.generateAdminToken = exports.checkSuspensionStatus = exports.checkIsUserBannedOrSuspended = exports.checkBanStatus = exports.hasActiveDependencies = exports.checkAccountDependencies = void 0;
-exports.extractDedicatedUserFromSerial = exports.buildUserSearchConditions = exports.buildSearchConditions = exports.buildEventLogWhereClause = exports.formatEventLogs = exports.formatEventLog = exports.formatDeviceSession = exports.DPP_OperationsUtil = exports.cloudinaryUtil = exports.stockUtil = exports.hierarchicalView = exports.validateHierarchy = exports.isSuperiorOrEqual = exports.isSuperior = exports.isSubordinateOrEqual = exports.isSubordinate = exports.isRankEqual = exports.getUserLevel = void 0;
+exports.logWarning = exports.logSystem = exports.logSecurity = exports.logPayment = exports.logInfo = exports.logError = exports.logDevice = exports.logDebug = exports.logCronjob = exports.logAuth = exports.logApi = exports.extractDedicatedUserFromSerial = exports.buildUserSearchConditions = exports.buildSearchConditions = exports.buildEventLogWhereClause = exports.formatEventLogs = exports.formatEventLog = exports.formatDeviceSession = exports.DPP_OperationsUtil = exports.cloudinaryUtil = exports.stockUtil = exports.hierarchicalView = exports.validateHierarchy = exports.isSuperiorOrEqual = exports.isSuperior = exports.isSubordinateOrEqual = exports.isSubordinate = exports.isRankEqual = exports.getUserLevel = void 0;
 var account_utils_1 = require("./account.utils");
 Object.defineProperty(exports, "checkAccountDependencies", { enumerable: true, get: function () { return account_utils_1.checkAccountDependencies; } });
 Object.defineProperty(exports, "hasActiveDependencies", { enumerable: true, get: function () { return account_utils_1.hasActiveDependencies; } });
@@ -93,3 +93,15 @@ Object.defineProperty(exports, "buildSearchConditions", { enumerable: true, get:
 Object.defineProperty(exports, "buildUserSearchConditions", { enumerable: true, get: function () { return eventlogs_admin_utils_1.buildUserSearchConditions; } });
 var deviceUtils_1 = require("./deviceUtils");
 Object.defineProperty(exports, "extractDedicatedUserFromSerial", { enumerable: true, get: function () { return deviceUtils_1.extractDedicatedUserFromSerial; } });
+var systemLog_utils_1 = require("./systemLog.utils");
+Object.defineProperty(exports, "logApi", { enumerable: true, get: function () { return systemLog_utils_1.logApi; } });
+Object.defineProperty(exports, "logAuth", { enumerable: true, get: function () { return systemLog_utils_1.logAuth; } });
+Object.defineProperty(exports, "logCronjob", { enumerable: true, get: function () { return systemLog_utils_1.logCronjob; } });
+Object.defineProperty(exports, "logDebug", { enumerable: true, get: function () { return systemLog_utils_1.logDebug; } });
+Object.defineProperty(exports, "logDevice", { enumerable: true, get: function () { return systemLog_utils_1.logDevice; } });
+Object.defineProperty(exports, "logError", { enumerable: true, get: function () { return systemLog_utils_1.logError; } });
+Object.defineProperty(exports, "logInfo", { enumerable: true, get: function () { return systemLog_utils_1.logInfo; } });
+Object.defineProperty(exports, "logPayment", { enumerable: true, get: function () { return systemLog_utils_1.logPayment; } });
+Object.defineProperty(exports, "logSecurity", { enumerable: true, get: function () { return systemLog_utils_1.logSecurity; } });
+Object.defineProperty(exports, "logSystem", { enumerable: true, get: function () { return systemLog_utils_1.logSystem; } });
+Object.defineProperty(exports, "logWarning", { enumerable: true, get: function () { return systemLog_utils_1.logWarning; } });

package/dist/utils/systemLog.utils.d.ts

@@ -0,0 +1,60 @@
+import { LogLevel, LogCategory, UserRole } from "vr-models";
+import { Transaction } from "sequelize";
+export interface SystemLogInput {
+    level?: LogLevel;
+    category?: LogCategory;
+    message: string;
+    details?: Record<string, any> | null;
+    source?: string | null;
+    userId?: string | null;
+    userRole?: UserRole | null;
+    ipAddress?: string | null;
+    userAgent?: string | null;
+    timestamp?: Date;
+    transaction?: Transaction;
+}
+/**
+ * Create a system log entry
+ * Uses the static methods from SystemLog model
+ */
+export declare const logSystem: ({ level, category, message, details, source, userId, userRole, ipAddress, userAgent, timestamp, transaction, }: SystemLogInput) => Promise<void>;
+/**
+ * Log an error
+ */
+export declare const logError: (message: string, options?: Omit<SystemLogInput, "level" | "message">) => Promise<void>;
+/**
+ * Log a warning
+ */
+export declare const logWarning: (message: string, options?: Omit<SystemLogInput, "level" | "message">) => Promise<void>;
+/**
+ * Log an info message
+ */
+export declare const logInfo: (message: string, options?: Omit<SystemLogInput, "level" | "message">) => Promise<void>;
+/**
+ * Log debug info
+ */
+export declare const logDebug: (message: string, options?: Omit<SystemLogInput, "level" | "message">) => Promise<void>;
+/**
+ * Log a cronjob event
+ */
+export declare const logCronjob: (message: string, options?: Omit<SystemLogInput, "level" | "category" | "message">) => Promise<void>;
+/**
+ * Log a payment event
+ */
+export declare const logPayment: (message: string, options?: Omit<SystemLogInput, "level" | "category" | "message">) => Promise<void>;
+/**
+ * Log a device event
+ */
+export declare const logDevice: (message: string, options?: Omit<SystemLogInput, "level" | "category" | "message">) => Promise<void>;
+/**
+ * Log an auth event
+ */
+export declare const logAuth: (message: string, options?: Omit<SystemLogInput, "level" | "category" | "message">) => Promise<void>;
+/**
+ * Log a security event
+ */
+export declare const logSecurity: (message: string, options?: Omit<SystemLogInput, "level" | "category" | "message">) => Promise<void>;
+/**
+ * Log an API request
+ */
+export declare const logApi: (message: string, options?: Omit<SystemLogInput, "level" | "category" | "message">) => Promise<void>;

package/dist/utils/systemLog.utils.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logApi = exports.logSecurity = exports.logAuth = exports.logDevice = exports.logPayment = exports.logCronjob = exports.logDebug = exports.logInfo = exports.logWarning = exports.logError = exports.logSystem = void 0;
+// src/utils/systemLog.utils.ts
+const vr_models_1 = require("vr-models");
+/**
+ * Create a system log entry
+ * Uses the static methods from SystemLog model
+ */
+const logSystem = async ({ level = "INFO", category = "SYSTEM", message, details = null, source = null, userId = null, userRole = null, ipAddress = null, userAgent = null, timestamp, transaction, }) => {
+    try {
+        const logData = {
+            level,
+            category,
+            message,
+            details,
+            source,
+            userId,
+            userRole,
+            ipAddress,
+            userAgent,
+            timestamp,
+        };
+        // Create log entry with optional transaction
+        await vr_models_1.SystemLog.create(logData, { transaction });
+    }
+    catch (err) {
+        console.error("❌ Failed to create system log:", err);
+        // Don't throw - system logging should not break the main operation
+    }
+};
+exports.logSystem = logSystem;
+/**
+ * Log an error
+ */
+const logError = async (message, options = {}) => {
+    await (0, exports.logSystem)({
+        level: "ERROR",
+        message,
+        ...options,
+    });
+};
+exports.logError = logError;
+/**
+ * Log a warning
+ */
+const logWarning = async (message, options = {}) => {
+    await (0, exports.logSystem)({
+        level: "WARNING",
+        message,
+        ...options,
+    });
+};
+exports.logWarning = logWarning;
+/**
+ * Log an info message
+ */
+const logInfo = async (message, options = {}) => {
+    await (0, exports.logSystem)({
+        level: "INFO",
+        message,
+        ...options,
+    });
+};
+exports.logInfo = logInfo;
+/**
+ * Log debug info
+ */
+const logDebug = async (message, options = {}) => {
+    await (0, exports.logSystem)({
+        level: "DEBUG",
+        message,
+        ...options,
+    });
+};
+exports.logDebug = logDebug;
+/**
+ * Log a cronjob event
+ */
+const logCronjob = async (message, options = {}) => {
+    await (0, exports.logSystem)({
+        level: "INFO",
+        category: "CRONJOB",
+        message,
+        ...options,
+    });
+};
+exports.logCronjob = logCronjob;
+/**
+ * Log a payment event
+ */
+const logPayment = async (message, options = {}) => {
+    await (0, exports.logSystem)({
+        level: "INFO",
+        category: "PAYMENT",
+        message,
+        ...options,
+    });
+};
+exports.logPayment = logPayment;
+/**
+ * Log a device event
+ */
+const logDevice = async (message, options = {}) => {
+    await (0, exports.logSystem)({
+        level: "INFO",
+        category: "DEVICE",
+        message,
+        ...options,
+    });
+};
+exports.logDevice = logDevice;
+/**
+ * Log an auth event
+ */
+const logAuth = async (message, options = {}) => {
+    await (0, exports.logSystem)({
+        level: "INFO",
+        category: "AUTH",
+        message,
+        ...options,
+    });
+};
+exports.logAuth = logAuth;
+/**
+ * Log a security event
+ */
+const logSecurity = async (message, options = {}) => {
+    await (0, exports.logSystem)({
+        level: "INFO",
+        category: "SECURITY",
+        message,
+        ...options,
+    });
+};
+exports.logSecurity = logSecurity;
+/**
+ * Log an API request
+ */
+const logApi = async (message, options = {}) => {
+    await (0, exports.logSystem)({
+        level: "INFO",
+        category: "API",
+        message,
+        ...options,
+    });
+};
+exports.logApi = logApi;