vr-commons 1.0.159 → 1.0.160

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

@@ -1,6 +1,6 @@
 import { Device, UserRole } from "vr-models";
 import { Transaction } from "sequelize";
-import { LockAllDevicesResult, LockDevicesOptions, StockChangeResult } from "./types";
+import { DeviceResetOptions, DeviceResetResult, StockChangeResult } from "./types";
 export declare const stockUtil: {
     /**
      * Increment stock when devices are added/created
@@ -121,9 +121,10 @@ export declare const stockUtil: {
         devices: Device[];
     }>;
     /**
-     * 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
+     * Reset device pairs status based on conditions
+     * - Locks/unlocks both RIDER and PASSENGER devices in each pair together
+     * - Flexible conditions and updates
+     * - Uses batch processing for large datasets
      */
-    lockAllDevices(options?: LockDevicesOptions): Promise<LockAllDevicesResult>;
+    resetAllDevicesStatus(options?: DeviceResetOptions): Promise<DeviceResetResult>;
 };

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

@@ -17,6 +17,155 @@ const extractDedicationFromSerial = (serialNumber) => {
         return "PASSENGER";
     return "N/A";
 };
+// ==================== HELPER FUNCTIONS ====================
+function buildWhereClause(condition) {
+    const parts = [];
+    if (condition.status) {
+        const statuses = Array.isArray(condition.status)
+            ? condition.status
+            : [condition.status];
+        const quoted = statuses.map((s) => `'${s}'`).join(", ");
+        parts.push(`"status" IN (${quoted})`);
+    }
+    if (condition.excludeStatus) {
+        const statuses = Array.isArray(condition.excludeStatus)
+            ? condition.excludeStatus
+            : [condition.excludeStatus];
+        const quoted = statuses.map((s) => `'${s}'`).join(", ");
+        parts.push(`"status" NOT IN (${quoted})`);
+    }
+    if (condition.isPermanentlyUnlocked !== undefined) {
+        parts.push(`"isPermanentlyUnlocked" = ${condition.isPermanentlyUnlocked}`);
+    }
+    if (condition.pairId) {
+        const pairIds = Array.isArray(condition.pairId)
+            ? condition.pairId
+            : [condition.pairId];
+        const quoted = pairIds.map((p) => `'${p}'`).join(", ");
+        parts.push(`"pairId" IN (${quoted})`);
+    }
+    if (condition.excludePairIds) {
+        const pairIds = Array.isArray(condition.excludePairIds)
+            ? condition.excludePairIds
+            : [condition.excludePairIds];
+        const quoted = pairIds.map((p) => `'${p}'`).join(", ");
+        parts.push(`"pairId" NOT IN (${quoted})`);
+    }
+    if (condition.productId) {
+        const productIds = Array.isArray(condition.productId)
+            ? condition.productId
+            : [condition.productId];
+        const quoted = productIds.map((p) => `'${p}'`).join(", ");
+        parts.push(`"productId" IN (${quoted})`);
+    }
+    if (condition.dedicatedUser) {
+        const users = Array.isArray(condition.dedicatedUser)
+            ? condition.dedicatedUser
+            : [condition.dedicatedUser];
+        const quoted = users.map((u) => `'${u}'`).join(", ");
+        parts.push(`"dedicatedUser" IN (${quoted})`);
+    }
+    if (condition.createdBefore) {
+        parts.push(`"createdAt" < '${condition.createdBefore.toISOString()}'`);
+    }
+    if (condition.createdAfter) {
+        parts.push(`"createdAt" > '${condition.createdAfter.toISOString()}'`);
+    }
+    return parts.length > 0 ? parts.join(" AND ") : "1=1";
+}
+function buildSequelizeWhere(condition) {
+    const where = {};
+    if (condition.status) {
+        where.status = {
+            [sequelize_1.Op.in]: Array.isArray(condition.status)
+                ? condition.status
+                : [condition.status],
+        };
+    }
+    if (condition.excludeStatus) {
+        where.status = {
+            ...where.status,
+            [sequelize_1.Op.notIn]: Array.isArray(condition.excludeStatus)
+                ? condition.excludeStatus
+                : [condition.excludeStatus],
+        };
+    }
+    if (condition.isPermanentlyUnlocked !== undefined) {
+        where.isPermanentlyUnlocked = condition.isPermanentlyUnlocked;
+    }
+    if (condition.pairId) {
+        where.pairId = {
+            [sequelize_1.Op.in]: Array.isArray(condition.pairId)
+                ? condition.pairId
+                : [condition.pairId],
+        };
+    }
+    if (condition.excludePairIds) {
+        where.pairId = {
+            [sequelize_1.Op.notIn]: Array.isArray(condition.excludePairIds)
+                ? condition.excludePairIds
+                : [condition.excludePairIds],
+        };
+    }
+    if (condition.productId) {
+        where.productId = {
+            [sequelize_1.Op.in]: Array.isArray(condition.productId)
+                ? condition.productId
+                : [condition.productId],
+        };
+    }
+    if (condition.dedicatedUser) {
+        where.dedicatedUser = {
+            [sequelize_1.Op.in]: Array.isArray(condition.dedicatedUser)
+                ? condition.dedicatedUser
+                : [condition.dedicatedUser],
+        };
+    }
+    if (condition.createdBefore) {
+        where.createdAt = { [sequelize_1.Op.lt]: condition.createdBefore };
+    }
+    if (condition.createdAfter) {
+        where.createdAt = { ...where.createdAt, [sequelize_1.Op.gt]: condition.createdAfter };
+    }
+    return where;
+}
+function buildSetClause(update) {
+    const parts = [];
+    if (update.status !== undefined) {
+        parts.push(`"status" = '${update.status}'`);
+    }
+    if (update.isPermanentlyUnlocked !== undefined) {
+        parts.push(`"isPermanentlyUnlocked" = ${update.isPermanentlyUnlocked}`);
+    }
+    if (update.dedicatedUser !== undefined) {
+        parts.push(`"dedicatedUser" = '${update.dedicatedUser}'`);
+    }
+    if (update.devicePaymentPlanId !== undefined) {
+        parts.push(`"devicePaymentPlanId" = ${update.devicePaymentPlanId === null
+            ? "NULL"
+            : `'${update.devicePaymentPlanId}'`}`);
+    }
+    if (update.activatedAt !== undefined) {
+        parts.push(`"activatedAt" = ${update.activatedAt === null
+            ? "NULL"
+            : `'${update.activatedAt.toISOString()}'`}`);
+    }
+    return parts.length > 0 ? parts.join(", ") : "1=1";
+}
+function buildUpdateObject(update) {
+    const obj = {};
+    if (update.status !== undefined)
+        obj.status = update.status;
+    if (update.isPermanentlyUnlocked !== undefined)
+        obj.isPermanentlyUnlocked = update.isPermanentlyUnlocked;
+    if (update.dedicatedUser !== undefined)
+        obj.dedicatedUser = update.dedicatedUser;
+    if (update.devicePaymentPlanId !== undefined)
+        obj.devicePaymentPlanId = update.devicePaymentPlanId;
+    if (update.activatedAt !== undefined)
+        obj.activatedAt = update.activatedAt;
+    return obj;
+}
 exports.stockUtil = {
     /**
      * Increment stock when devices are added/created
@@ -453,41 +602,48 @@ exports.stockUtil = {
         };
     },
     /**
-     * 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
+     * Reset device pairs status based on conditions
+     * - Locks/unlocks both RIDER and PASSENGER devices in each pair together
+     * - Flexible conditions and updates
+     * - Uses batch processing for large datasets
      */
-    async lockAllDevices(options = {}) {
-        const { actorId = "SYSTEM", actorRole = "SYSTEM", transaction, batchSize = 100, maxRetries = 3, triggeredBy = "manual", } = options;
+    async resetAllDevicesStatus(options = {}) {
+        const { actorId = "SYSTEM", actorRole = "SYSTEM", transaction, batchSize = 100, maxRetries = 3, triggeredBy = "manual", condition = {}, update = {}, } = options;
         const isSystem = actorRole === "SYSTEM" || triggeredBy === "cronjob";
         try {
-            const lockedPairIds = [];
+            const updatedPairIds = [];
             const failedPairIds = [];
             const errors = [];
-            let totalLockedDevices = 0;
+            const allDeviceIds = [];
+            let totalUpdatedDevices = 0;
             let totalProcessedPairs = 0;
             let batchNumber = 0;
             let hasMore = true;
             let offset = 0;
-            console.log(`🔒 Locking ALL device pairs at ${new Date().toISOString()}`);
-            // Log start of job
+            // Build WHERE clause for the query
+            const whereClause = buildWhereClause(condition);
+            // Build UPDATE SET clause
+            const setClause = buildSetClause(update);
+            console.log(`🔄 Resetting device pairs at ${new Date().toISOString()}`);
+            console.log(`📋 WHERE: ${whereClause}`);
+            console.log(`📝 SET: ${setClause}`);
+            // Log start
             if (isSystem) {
-                await (0, systemLog_utils_1.logInfo)(`Lock all device pairs job started`, {
+                await (0, systemLog_utils_1.logInfo)(`Reset device pairs job started`, {
                     category: "CRONJOB",
-                    source: "device-lock.cronjob",
-                    details: { triggeredBy, batchSize, maxRetries },
+                    source: "device-reset.cronjob",
+                    details: { triggeredBy, batchSize, maxRetries, condition, update },
                 });
             }
             else {
-                await (0, systemLog_utils_1.logInfo)(`Lock all device pairs triggered by ${actorRole}`, {
+                await (0, systemLog_utils_1.logInfo)(`Reset device pairs triggered by ${actorRole}`, {
                     category: "DEVICE",
                     userId: actorId || undefined,
                     userRole: actorRole,
-                    source: "device-lock.manual",
-                    details: { triggeredBy, batchSize, maxRetries },
+                    source: "device-reset.manual",
+                    details: { triggeredBy, batchSize, maxRetries, condition, update },
                 });
             }
-            // ✅ Get the sequelize instance from the model
             const sequelizeInstance = vr_models_1.Device.sequelize;
             if (!sequelizeInstance) {
                 throw new Error("Sequelize instance not available");
@@ -496,12 +652,12 @@ exports.stockUtil = {
             while (hasMore) {
                 batchNumber++;
                 offset = (batchNumber - 1) * batchSize;
-                // ✅ Use raw query to get distinct pairIds with both devices
+                // Get distinct pairIds that match the condition
                 const [pairIdsResult] = await sequelizeInstance.query(`
         SELECT "pairId"
         FROM "devices"
-        WHERE "status" != 'disabled'
-          AND "deletedAt" IS NULL
+        WHERE "deletedAt" IS NULL
+          AND ${whereClause}
         GROUP BY "pairId"
         HAVING COUNT(*) = 2
         ORDER BY "pairId" ASC
@@ -522,71 +678,48 @@ exports.stockUtil = {
                 }
                 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 pairLocked = false;
-                    while (!pairLocked && retries < maxRetries) {
+                    let pairUpdated = false;
+                    while (!pairUpdated && retries < maxRetries) {
                         try {
-                            // 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,
+                                    ...buildSequelizeWhere(condition),
                                 },
                                 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;
+                            // Check if update would be a no-op
+                            const shouldUpdate = devices.some((d) => {
+                                const updateObj = buildUpdateObject(update);
+                                return Object.keys(updateObj).some((key) => d[key] !== updateObj[key]);
+                            });
+                            if (!shouldUpdate) {
+                                console.log(`⏭️ Pair ${pairId} already matches target state`);
+                                pairUpdated = true;
                                 break;
                             }
-                            // Lock both devices
                             const deviceIds = devices.map((d) => d.id);
-                            await vr_models_1.Device.update({ status: "locked" }, {
+                            allDeviceIds.push(...deviceIds);
+                            await vr_models_1.Device.update(buildUpdateObject(update), {
                                 where: {
                                     id: { [sequelize_1.Op.in]: deviceIds },
                                 },
                                 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,
-                                });
-                            }
+                            updatedPairIds.push(pairId);
+                            totalUpdatedDevices += devices.length;
+                            pairUpdated = true;
+                            console.log(`✅ Updated pair ${pairId} (${devices.length} devices)`);
                         }
                         catch (err) {
                             retries++;
-                            console.error(`❌ Failed to lock pair ${pairId} (attempt ${retries}/${maxRetries}):`, err instanceof Error ? err.message : "Unknown error");
+                            console.error(`❌ Failed to update pair ${pairId} (attempt ${retries}/${maxRetries}):`, err instanceof Error ? err.message : "Unknown error");
                             if (retries >= maxRetries) {
                                 failedPairIds.push(pairId);
                                 errors.push(`Pair ${pairId}: ${err instanceof Error ? err.message : "Unknown error"}`);
@@ -603,25 +736,56 @@ exports.stockUtil = {
             }
             const result = {
                 success: true,
-                lockedCount: totalLockedDevices,
+                updatedCount: totalUpdatedDevices,
                 failedCount: failedPairIds.length,
                 failedPairIds,
                 errors,
                 totalProcessed: totalProcessedPairs,
                 pairsProcessed: totalProcessedPairs,
-                message: `Successfully locked ${totalLockedDevices} devices (${lockedPairIds.length} pairs) out of ${totalProcessedPairs} pairs processed${failedPairIds.length > 0
+                message: `Successfully updated ${totalUpdatedDevices} devices (${updatedPairIds.length} pairs) out of ${totalProcessedPairs} pairs processed${failedPairIds.length > 0
                     ? `, ${failedPairIds.length} pairs failed`
                     : ""}`,
             };
-            console.log(`✅ Lock all device pairs completed:`, result);
-            // Log completion
+            console.log(`✅ Reset device pairs completed:`, result);
+            // Log single event with summary
+            await (0, eventLog_utils_1.logEvent)({
+                actorId: isSystem ? null : actorId,
+                actorType: isSystem ? "ADMIN" : actorRole,
+                action: "DEVICES_UPDATED",
+                entity: "Device",
+                entityId: null,
+                metadata: {
+                    action: "RESET_DEVICES_STATUS",
+                    triggeredBy: triggeredBy,
+                    condition: condition,
+                    update: update,
+                    summary: {
+                        totalPairsProcessed: result.pairsProcessed,
+                        totalDevicesUpdated: result.updatedCount,
+                        totalPairsUpdated: updatedPairIds.length,
+                        failedPairs: result.failedCount,
+                        failedPairIds: result.failedPairIds,
+                        errors: result.errors,
+                        deviceIds: allDeviceIds.slice(0, 100),
+                    },
+                    batchDetails: {
+                        totalBatches: batchNumber,
+                        batchSize: batchSize,
+                        maxRetries: maxRetries,
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+                deviceSession: null,
+                transaction: transaction,
+            });
+            // Log to system logs
             if (isSystem) {
-                await (0, systemLog_utils_1.logInfo)(`Lock all device pairs job completed`, {
+                await (0, systemLog_utils_1.logInfo)(`Reset device pairs job completed`, {
                     category: "CRONJOB",
-                    source: "device-lock.cronjob",
+                    source: "device-reset.cronjob",
                     details: {
-                        lockedDevices: result.lockedCount,
-                        lockedPairs: lockedPairIds.length,
+                        updatedDevices: result.updatedCount,
+                        updatedPairs: updatedPairIds.length,
                         failedPairs: result.failedCount,
                         totalPairs: result.pairsProcessed,
                         hasErrors: result.errors.length > 0,
@@ -629,14 +793,14 @@ exports.stockUtil = {
                 });
             }
             else {
-                await (0, systemLog_utils_1.logInfo)(`Lock all device pairs completed by ${actorRole}`, {
+                await (0, systemLog_utils_1.logInfo)(`Reset device pairs completed by ${actorRole}`, {
                     category: "DEVICE",
                     userId: actorId || undefined,
                     userRole: actorRole,
-                    source: "device-lock.manual",
+                    source: "device-reset.manual",
                     details: {
-                        lockedDevices: result.lockedCount,
-                        lockedPairs: lockedPairIds.length,
+                        updatedDevices: result.updatedCount,
+                        updatedPairs: updatedPairIds.length,
                         failedPairs: result.failedCount,
                         totalPairs: result.pairsProcessed,
                         hasErrors: result.errors.length > 0,
@@ -644,9 +808,9 @@ exports.stockUtil = {
                 });
             }
             if (result.errors.length > 0) {
-                await (0, systemLog_utils_1.logError)(`Lock all device pairs had ${result.errors.length} failures`, {
+                await (0, systemLog_utils_1.logError)(`Reset device pairs had ${result.errors.length} failures`, {
                     category: isSystem ? "CRONJOB" : "DEVICE",
-                    source: isSystem ? "device-lock.cronjob" : "device-lock.manual",
+                    source: isSystem ? "device-reset.cronjob" : "device-reset.manual",
                     userId: isSystem ? null : actorId || undefined,
                     userRole: isSystem ? null : actorRole,
                     details: {
@@ -658,31 +822,31 @@ exports.stockUtil = {
             return result;
         }
         catch (err) {
-            console.error("❌ Lock all device pairs failed:", err);
+            console.error("❌ Reset device pairs failed:", err);
             const errorMessage = err instanceof Error ? err.message : "Unknown error occurred";
             const result = {
                 success: false,
-                lockedCount: 0,
+                updatedCount: 0,
                 failedCount: 0,
                 failedPairIds: [],
                 errors: [errorMessage],
                 totalProcessed: 0,
                 pairsProcessed: 0,
-                message: `Lock all device pairs job failed: ${errorMessage}`,
+                message: `Reset device pairs job failed: ${errorMessage}`,
             };
             if (isSystem) {
-                await (0, systemLog_utils_1.logError)(`Lock all device pairs job failed`, {
+                await (0, systemLog_utils_1.logError)(`Reset device pairs job failed`, {
                     category: "CRONJOB",
-                    source: "device-lock.cronjob",
+                    source: "device-reset.cronjob",
                     details: { error: errorMessage },
                 });
             }
             else {
-                await (0, systemLog_utils_1.logError)(`Lock all device pairs failed`, {
+                await (0, systemLog_utils_1.logError)(`Reset device pairs failed`, {
                     category: "DEVICE",
                     userId: actorId || undefined,
                     userRole: actorRole,
-                    source: "device-lock.manual",
+                    source: "device-reset.manual",
                     details: { error: errorMessage },
                 });
             }

package/dist/utils/types.d.ts

@@ -35,9 +35,9 @@ export interface StockChangeResult {
     productId: string;
     productName: string;
 }
-export interface LockAllDevicesResult {
+export interface DeviceResetResult {
     success: boolean;
-    lockedCount: number;
+    updatedCount: number;
     failedCount: number;
     failedPairIds: string[];
     errors: string[];
@@ -45,11 +45,29 @@ export interface LockAllDevicesResult {
     totalProcessed: number;
     pairsProcessed: number;
 }
-export interface LockDevicesOptions {
+export interface DeviceResetOptions {
     actorId?: string;
     actorRole?: UserRole | string;
     transaction?: any;
     batchSize?: number;
     maxRetries?: number;
     triggeredBy?: "cronjob" | "manual";
+    condition?: {
+        status?: string | string[];
+        isPermanentlyUnlocked?: boolean;
+        pairId?: string | string[];
+        productId?: string | string[];
+        dedicatedUser?: string | string[];
+        createdBefore?: Date;
+        createdAfter?: Date;
+        excludeStatus?: string | string[];
+        excludePairIds?: string | string[];
+    };
+    update?: {
+        status?: string;
+        isPermanentlyUnlocked?: boolean;
+        dedicatedUser?: string;
+        devicePaymentPlanId?: string | null;
+        activatedAt?: Date | null;
+    };
 }

package/package.json

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