vr-commons 1.0.158 → 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 devices regardless of payment plan status
-     * Uses batch processing for large datasets
-     * If no transaction is provided, runs without transaction
+     * 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,166 +602,219 @@ exports.stockUtil = {
         };
     },
     /**
-     * Lock ALL devices regardless of payment plan status
-     * Uses batch processing for large datasets
-     * If no transaction is provided, runs without transaction
+     * 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";
-        const isAdmin = !isSystem;
         try {
-            const lockedDeviceIds = [];
-            const failedDeviceIds = [];
+            const updatedPairIds = [];
+            const failedPairIds = [];
             const errors = [];
-            let totalLocked = 0;
-            let totalProcessed = 0;
+            const allDeviceIds = [];
+            let totalUpdatedDevices = 0;
+            let totalProcessedPairs = 0;
             let batchNumber = 0;
             let hasMore = true;
-            console.log(`🔒 Locking ALL devices at ${new Date().toISOString()}`);
-            // Log start of job
+            let offset = 0;
+            // 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 devices 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 devices 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 },
                 });
             }
+            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;
+                // Get distinct pairIds that match the condition
+                const [pairIdsResult] = await sequelizeInstance.query(`
+        SELECT "pairId"
+        FROM "devices"
+        WHERE "deletedAt" IS NULL
+          AND ${whereClause}
+        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})`);
+                for (const pairId of pairIds) {
                     let retries = 0;
-                    let locked = false;
-                    while (!locked && retries < maxRetries) {
+                    let pairUpdated = false;
+                    while (!pairUpdated && retries < maxRetries) {
                         try {
-                            // Skip if already locked
-                            if (device.status === "locked") {
-                                console.log(`🔒 Device ${device.serialNumber} already locked`);
-                                locked = true;
+                            const devices = await vr_models_1.Device.findAll({
+                                where: {
+                                    pairId: pairId,
+                                    deletedAt: null,
+                                    ...buildSequelizeWhere(condition),
+                                },
+                                transaction: transaction,
+                            });
+                            if (devices.length !== 2) {
+                                throw new Error(`Incomplete pair ${pairId}: expected 2 devices, found ${devices.length}`);
+                            }
+                            // 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 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,
+                            const deviceIds = devices.map((d) => d.id);
+                            allDeviceIds.push(...deviceIds);
+                            await vr_models_1.Device.update(buildUpdateObject(update), {
+                                where: {
+                                    id: { [sequelize_1.Op.in]: deviceIds },
                                 },
-                                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 device ${device.serialNumber} (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) {
-                                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,
+                updatedCount: totalUpdatedDevices,
+                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 updated ${totalUpdatedDevices} devices (${updatedPairIds.length} pairs) out of ${totalProcessedPairs} pairs processed${failedPairIds.length > 0
+                    ? `, ${failedPairIds.length} pairs failed`
+                    : ""}`,
             };
-            console.log(`✅ Lock all devices 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 devices job completed`, {
+                await (0, systemLog_utils_1.logInfo)(`Reset device pairs job completed`, {
                     category: "CRONJOB",
-                    source: "device-lock.cronjob",
+                    source: "device-reset.cronjob",
                     details: {
-                        lockedCount: result.lockedCount,
-                        failedCount: result.failedCount,
-                        totalProcessed: result.totalProcessed,
+                        updatedDevices: result.updatedCount,
+                        updatedPairs: updatedPairIds.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)(`Reset device pairs completed by ${actorRole}`, {
                     category: "DEVICE",
                     userId: actorId || undefined,
                     userRole: actorRole,
-                    source: "device-lock.manual",
+                    source: "device-reset.manual",
                     details: {
-                        lockedCount: result.lockedCount,
-                        failedCount: result.failedCount,
-                        totalProcessed: result.totalProcessed,
+                        updatedDevices: result.updatedCount,
+                        updatedPairs: updatedPairIds.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)(`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: {
-                        failedCount: result.failedCount,
-                        failedDeviceIds: result.failedDeviceIds,
+                        failedPairs: result.failedPairIds,
                         errors: result.errors,
                     },
                 });
@@ -620,31 +822,31 @@ exports.stockUtil = {
             return result;
         }
         catch (err) {
-            console.error("❌ Lock all devices 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,
-                failedDeviceIds: [],
+                failedPairIds: [],
                 errors: [errorMessage],
                 totalProcessed: 0,
-                message: `Lock all devices job failed: ${errorMessage}`,
+                pairsProcessed: 0,
+                message: `Reset 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)(`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 devices 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,20 +35,39 @@ export interface StockChangeResult {
     productId: string;
     productName: string;
 }
-export interface LockAllDevicesResult {
+export interface DeviceResetResult {
     success: boolean;
-    lockedCount: number;
+    updatedCount: number;
     failedCount: number;
-    failedDeviceIds: string[];
+    failedPairIds: string[];
     errors: string[];
     message: string;
     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.158",
+  "version": "1.0.160",
   "description": "Shared functions package",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",