vr-commons 1.0.158 → 1.0.159

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

@@ -121,9 +121,9 @@ export declare const stockUtil: {
         devices: Device[];
     }>;
     /**
-     * Lock ALL devices regardless of payment plan status
+     * Lock ALL device pairs regardless of payment plan status
+     * Locks both RIDER and PASSENGER devices in each pair together
      * 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

@@ -453,33 +453,33 @@ exports.stockUtil = {
         };
     },
     /**
-     * Lock ALL devices regardless of payment plan status
+     * Lock ALL device pairs regardless of payment plan status
+     * Locks both RIDER and PASSENGER devices in each pair together
      * 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 lockedPairIds = [];
+            const failedPairIds = [];
             const errors = [];
-            let totalLocked = 0;
-            let totalProcessed = 0;
+            let totalLockedDevices = 0;
+            let totalProcessedPairs = 0;
             let batchNumber = 0;
             let hasMore = true;
-            console.log(`🔒 Locking ALL devices at ${new Date().toISOString()}`);
+            let offset = 0;
+            console.log(`🔒 Locking ALL device pairs at ${new Date().toISOString()}`);
             // Log start of job
             if (isSystem) {
-                await (0, systemLog_utils_1.logInfo)(`Lock all devices job started`, {
+                await (0, systemLog_utils_1.logInfo)(`Lock all device pairs 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}`, {
+                await (0, systemLog_utils_1.logInfo)(`Lock all device pairs triggered by ${actorRole}`, {
                     category: "DEVICE",
                     userId: actorId || undefined,
                     userRole: actorRole,
@@ -487,132 +487,170 @@ exports.stockUtil = {
                     details: { triggeredBy, batchSize, maxRetries },
                 });
             }
+            // ✅ Get the sequelize instance from the model
+            const sequelizeInstance = vr_models_1.Device.sequelize;
+            if (!sequelizeInstance) {
+                throw new Error("Sequelize instance not available");
+            }
             // 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,
+                offset = (batchNumber - 1) * batchSize;
+                // ✅ Use raw query to get distinct pairIds with both devices
+                const [pairIdsResult] = await sequelizeInstance.query(`
+        SELECT "pairId"
+        FROM "devices"
+        WHERE "status" != 'disabled'
+          AND "deletedAt" IS NULL
+        GROUP BY "pairId"
+        HAVING COUNT(*) = 2
+        ORDER BY "pairId" ASC
+        LIMIT :limit
+        OFFSET :offset
+        `, {
+                    replacements: {
+                        limit: batchSize,
+                        offset: offset,
                     },
-                    limit: batchSize,
-                    offset: offset,
-                    transaction: transaction, // Use transaction if provided, otherwise undefined
+                    type: "SELECT",
+                    transaction: transaction,
                 });
-                if (devices.length === 0) {
+                const pairIds = pairIdsResult.map((p) => p.pairId);
+                if (pairIds.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) {
+                totalProcessedPairs += pairIds.length;
+                console.log(`📦 Batch ${batchNumber}: Processing ${pairIds.length} pairs (Total: ${totalProcessedPairs})`);
+                // Process each pair
+                for (const pairId of pairIds) {
                     let retries = 0;
-                    let locked = false;
-                    while (!locked && retries < maxRetries) {
+                    let pairLocked = false;
+                    while (!pairLocked && retries < maxRetries) {
                         try {
-                            // Skip if already locked
-                            if (device.status === "locked") {
-                                console.log(`🔒 Device ${device.serialNumber} already locked`);
-                                locked = true;
+                            // Get both devices in the pair
+                            const devices = await vr_models_1.Device.findAll({
+                                where: {
+                                    pairId: pairId,
+                                    status: { [sequelize_1.Op.ne]: "disabled" },
+                                    deletedAt: null,
+                                },
+                                transaction: transaction,
+                            });
+                            if (devices.length !== 2) {
+                                throw new Error(`Incomplete pair ${pairId}: expected 2 devices, found ${devices.length}`);
+                            }
+                            // Check if both devices are already locked
+                            const allLocked = devices.every((d) => d.status === "locked");
+                            if (allLocked) {
+                                console.log(`🔒 Pair ${pairId} already fully locked`);
+                                pairLocked = 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,
+                            // Lock both devices
+                            const deviceIds = devices.map((d) => d.id);
+                            await vr_models_1.Device.update({ status: "locked" }, {
+                                where: {
+                                    id: { [sequelize_1.Op.in]: deviceIds },
                                 },
-                                deviceSession: null,
                                 transaction: transaction,
                             });
+                            lockedPairIds.push(pairId);
+                            totalLockedDevices += devices.length;
+                            pairLocked = true;
+                            console.log(`🔒 Locked pair ${pairId} (${devices.length} devices)`);
+                            // Log event for each device in the pair
+                            for (const device of devices) {
+                                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,
+                                        dedicatedUser: device.dedicatedUser,
+                                        productId: device.productId,
+                                        lockedAt: new Date().toISOString(),
+                                        reason: "Scheduled lock all devices",
+                                        triggeredBy: triggeredBy,
+                                        batchNumber,
+                                        previousStatus: device.status,
+                                        isPartOfPair: true,
+                                    },
+                                    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");
+                            console.error(`❌ Failed to lock pair ${pairId} (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"}`);
+                                failedPairIds.push(pairId);
+                                errors.push(`Pair ${pairId}: ${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) {
+                if (pairIds.length < batchSize) {
                     hasMore = false;
                 }
             }
             const result = {
                 success: true,
-                lockedCount: totalLocked,
-                failedCount: failedDeviceIds.length,
-                failedDeviceIds,
+                lockedCount: totalLockedDevices,
+                failedCount: failedPairIds.length,
+                failedPairIds,
                 errors,
-                totalProcessed,
-                message: `Successfully locked ${totalLocked} devices out of ${totalProcessed} processed${failedDeviceIds.length > 0 ? `, ${failedDeviceIds.length} failed` : ""}`,
+                totalProcessed: totalProcessedPairs,
+                pairsProcessed: totalProcessedPairs,
+                message: `Successfully locked ${totalLockedDevices} devices (${lockedPairIds.length} pairs) out of ${totalProcessedPairs} pairs processed${failedPairIds.length > 0
+                    ? `, ${failedPairIds.length} pairs failed`
+                    : ""}`,
             };
-            console.log(`✅ Lock all devices completed:`, result);
+            console.log(`✅ Lock all device pairs completed:`, result);
             // Log completion
             if (isSystem) {
-                await (0, systemLog_utils_1.logInfo)(`Lock all devices job completed`, {
+                await (0, systemLog_utils_1.logInfo)(`Lock all device pairs job completed`, {
                     category: "CRONJOB",
                     source: "device-lock.cronjob",
                     details: {
-                        lockedCount: result.lockedCount,
-                        failedCount: result.failedCount,
-                        totalProcessed: result.totalProcessed,
+                        lockedDevices: result.lockedCount,
+                        lockedPairs: lockedPairIds.length,
+                        failedPairs: result.failedCount,
+                        totalPairs: result.pairsProcessed,
                         hasErrors: result.errors.length > 0,
                     },
                 });
             }
             else {
-                await (0, systemLog_utils_1.logInfo)(`Lock all devices completed by ${actorRole}`, {
+                await (0, systemLog_utils_1.logInfo)(`Lock all device pairs completed by ${actorRole}`, {
                     category: "DEVICE",
                     userId: actorId || undefined,
                     userRole: actorRole,
                     source: "device-lock.manual",
                     details: {
-                        lockedCount: result.lockedCount,
-                        failedCount: result.failedCount,
-                        totalProcessed: result.totalProcessed,
+                        lockedDevices: result.lockedCount,
+                        lockedPairs: lockedPairIds.length,
+                        failedPairs: result.failedCount,
+                        totalPairs: result.pairsProcessed,
                         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`, {
+                await (0, systemLog_utils_1.logError)(`Lock all device pairs 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,
+                        failedPairs: result.failedPairIds,
                         errors: result.errors,
                     },
                 });
@@ -620,27 +658,27 @@ exports.stockUtil = {
             return result;
         }
         catch (err) {
-            console.error("❌ Lock all devices failed:", err);
+            console.error("❌ Lock all device pairs failed:", err);
             const errorMessage = err instanceof Error ? err.message : "Unknown error occurred";
             const result = {
                 success: false,
                 lockedCount: 0,
                 failedCount: 0,
-                failedDeviceIds: [],
+                failedPairIds: [],
                 errors: [errorMessage],
                 totalProcessed: 0,
-                message: `Lock all devices job failed: ${errorMessage}`,
+                pairsProcessed: 0,
+                message: `Lock all device pairs job failed: ${errorMessage}`,
             };
-            // Log failure
             if (isSystem) {
-                await (0, systemLog_utils_1.logError)(`Lock all devices job failed`, {
+                await (0, systemLog_utils_1.logError)(`Lock all device pairs job failed`, {
                     category: "CRONJOB",
                     source: "device-lock.cronjob",
                     details: { error: errorMessage },
                 });
             }
             else {
-                await (0, systemLog_utils_1.logError)(`Lock all devices failed`, {
+                await (0, systemLog_utils_1.logError)(`Lock all device pairs failed`, {
                     category: "DEVICE",
                     userId: actorId || undefined,
                     userRole: actorRole,

package/dist/utils/types.d.ts

@@ -39,10 +39,11 @@ export interface LockAllDevicesResult {
     success: boolean;
     lockedCount: number;
     failedCount: number;
-    failedDeviceIds: string[];
+    failedPairIds: string[];
     errors: string[];
     message: string;
     totalProcessed: number;
+    pairsProcessed: number;
 }
 export interface LockDevicesOptions {
     actorId?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vr-commons",
-  "version": "1.0.158",
+  "version": "1.0.159",
   "description": "Shared functions package",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",