dt-common-device 7.6.11 → 7.6.13

package/dist/pms/webhookQueue/services/WebhookQueueService.d.ts

@@ -12,5 +12,32 @@ export declare class WebhookQueueService implements IWebhookQueue {
      * Creates queue if it doesn't exist
      */
     addWebhookToQueue(propertyId: string, pmsType: string, webhookData: any, options?: IWebhookQueueOptions): Promise<string>;
+    /**
+     * Mark a webhook job as completed (processed successfully)
+     */
+    markWebhookCompleted(propertyId: string, pmsType: string, jobId: string): Promise<void>;
+    /**
+     * Mark a webhook job as failed
+     */
+    markWebhookFailed(propertyId: string, pmsType: string, jobId: string, error?: string): Promise<void>;
+    /**
+     * Poll available webhook from ANY available webhook queue in Redis
+     * This method will discover all queues in Redis and filter only webhook queues
+     */
+    pollWebhookFromQueues(): Promise<{
+        jobId: string;
+        data: any;
+        propertyId: string;
+        pmsType: string;
+        queueName: string;
+    } | null>;
+    /**
+     * Get all available webhook queue names from Redis
+     */
+    getAllQueueNames(): Promise<string[]>;
+    /**
+     * Get total waiting count across all webhook queues
+     */
+    getTotalWaitingCount(): Promise<number>;
     static getOrCreateQueue(queueKey: string, queues: Map<string, any>): any;
 }

package/dist/pms/webhookQueue/services/WebhookQueueService.js

@@ -78,6 +78,151 @@ let WebhookQueueService = (() => {
             });
             return job.id;
         }
+        /**
+         * Mark a webhook job as completed (processed successfully)
+         */
+        async markWebhookCompleted(propertyId, pmsType, jobId) {
+            const queueName = this.generateQueueName(propertyId, pmsType);
+            if (!this.webhookQueues.has(queueName)) {
+                throw new Error(`Queue ${queueName} does not exist`);
+            }
+            const queue = this.webhookQueues.get(queueName);
+            const job = await queue.getJob(jobId);
+            if (job) {
+                // Mark job as completed - it will be removed after TTL
+                await job.complete();
+            }
+        }
+        /**
+         * Mark a webhook job as failed
+         */
+        async markWebhookFailed(propertyId, pmsType, jobId, error) {
+            const queueName = this.generateQueueName(propertyId, pmsType);
+            if (!this.webhookQueues.has(queueName)) {
+                throw new Error(`Queue ${queueName} does not exist`);
+            }
+            const queue = this.webhookQueues.get(queueName);
+            const job = await queue.getJob(jobId);
+            if (job) {
+                // Mark job as failed - it will be removed after TTL
+                await job.fail(new Error(error || "Job processing failed"));
+            }
+        }
+        /**
+         * Poll available webhook from ANY available webhook queue in Redis
+         * This method will discover all queues in Redis and filter only webhook queues
+         */
+        async pollWebhookFromQueues() {
+            try {
+                // Get all queue names from Redis (not just local Map)
+                const redisClient = (0, redis_1.getRedisClient)();
+                const queueKeys = await redisClient.keys("bull:*:id");
+                // Filter only webhook queues (PropertyId_pmsType_webhook pattern)
+                const webhookQueueKeys = queueKeys
+                    .map((key) => key.replace("bull:", "").replace(":id", ""))
+                    .filter((queueName) => {
+                    const parts = queueName.split("_");
+                    return parts.length === 3 && parts[2] === "webhook";
+                });
+                // Check each webhook queue for waiting jobs
+                for (const queueName of webhookQueueKeys) {
+                    try {
+                        // Create queue instance if not exists locally
+                        if (!this.webhookQueues.has(queueName)) {
+                            const { Queue } = require("bullmq");
+                            const queue = new Queue(queueName, {
+                                connection: (0, redis_1.getRedisClient)(),
+                            });
+                            this.webhookQueues.set(queueName, queue);
+                        }
+                        const queue = this.webhookQueues.get(queueName);
+                        // Use takeNextJob instead of getWaiting + moveToActive
+                        const job = await queue.takeNextJob();
+                        if (job) {
+                            // Extract propertyId and pmsType from queue name
+                            const parts = queueName.split("_");
+                            const propertyId = parts[0];
+                            const pmsType = parts[1];
+                            return {
+                                jobId: job.id,
+                                data: job.data,
+                                propertyId,
+                                pmsType,
+                                queueName,
+                            };
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Error checking queue ${queueName}:`, error);
+                        continue; // Try next queue
+                    }
+                }
+                return null; // No jobs available in any webhook queue
+            }
+            catch (error) {
+                console.error("Error discovering queues from Redis:", error);
+                return null;
+            }
+        }
+        /**
+         * Get all available webhook queue names from Redis
+         */
+        async getAllQueueNames() {
+            try {
+                const redisClient = (0, redis_1.getRedisClient)();
+                const queueKeys = await redisClient.keys("bull:*:id");
+                // Filter only webhook queues (PropertyId_pmsType_webhook pattern)
+                return queueKeys
+                    .map((key) => key.replace("bull:", "").replace(":id", ""))
+                    .filter((queueName) => {
+                    const parts = queueName.split("_");
+                    return parts.length === 3 && parts[2] === "webhook";
+                });
+            }
+            catch (error) {
+                console.error("Error getting queue names from Redis:", error);
+                return [];
+            }
+        }
+        /**
+         * Get total waiting count across all webhook queues
+         */
+        async getTotalWaitingCount() {
+            try {
+                const redisClient = (0, redis_1.getRedisClient)();
+                const queueKeys = await redisClient.keys("bull:*:id");
+                let totalCount = 0;
+                // Filter only webhook queues and count waiting jobs
+                for (const key of queueKeys) {
+                    const queueName = key.replace("bull:", "").replace(":id", "");
+                    const parts = queueName.split("_");
+                    // Only count webhook queues
+                    if (parts.length === 3 && parts[2] === "webhook") {
+                        try {
+                            // Create queue instance if not exists locally
+                            if (!this.webhookQueues.has(queueName)) {
+                                const { Queue } = require("bullmq");
+                                const queue = new Queue(queueName, {
+                                    connection: (0, redis_1.getRedisClient)(),
+                                });
+                                this.webhookQueues.set(queueName, queue);
+                            }
+                            const queue = this.webhookQueues.get(queueName);
+                            const waitingJobs = await queue.getWaiting();
+                            totalCount += waitingJobs.length;
+                        }
+                        catch (error) {
+                            console.error(`Error getting count for queue ${queueName}:`, error);
+                        }
+                    }
+                }
+                return totalCount;
+            }
+            catch (error) {
+                console.error("Error getting total waiting count:", error);
+                return 0;
+            }
+        }
         static getOrCreateQueue(queueKey, queues) {
             return (queues.get(queueKey) ??
                 queues

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-common-device",
-  "version": "7.6.11",
+  "version": "7.6.13",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [