dt-common-device 9.2.4 → 9.2.6

package/dist/audit/ExcludeAudits.js

@@ -7,6 +7,11 @@ exports.excludeEvents = [
     "rpa.accessibility.enabled",
     "alert.create.skipped",
     "heartbeat.lock.local_codes",
+    "device.event.unhandled",
+    "schedule.accessmodes.assign.success",
+    "pms.webhook.received",
+    "schedule.sendcode.initiate",
+    "schedule.sendcode.success",
     "device.state.changed",
     "lock.code.set.success",
     "lock.unlocked_non_business_hour.alert",

package/dist/audit/PushAudit.js

@@ -10,8 +10,7 @@ const typedi_1 = __importDefault(require("typedi"));
 const ExcludeAudits_1 = require("./ExcludeAudits");
 async function pushAudit(data) {
     const audit = await typedi_1.default.get(AuditUtils_1.AuditUtils).buildAuditProperties(data.auditData);
-    if (ExcludeAudits_1.excludeEvents.includes(data.auditType) &&
-        !ExcludeAudits_1.propertyIdsToPush.includes(data.auditData.propertyId)) {
+    if (ExcludeAudits_1.excludeEvents.includes(data.auditType)) {
         console.log("Audit event excluded:", data.auditType);
     }
     else {

package/dist/chronicle/Cronicle.service.d.ts

@@ -1,9 +1,13 @@
 import { ICronicle } from "./ICronicle.interface";
 export declare class CronicleService {
-    private cronicleEndpoint;
-    private cronicleApiKey;
+    private readonly cronicleEndpoint;
+    private readonly cronicleApiKey;
     constructor();
     registerJob(payload: ICronicle): Promise<void>;
     getJob(jobId: string): Promise<any>;
+    getSchedules(filter: {
+        offset: number;
+        limit: number;
+    }): Promise<any>;
     deleteJob(jobId: string): Promise<void>;
 }

package/dist/chronicle/Cronicle.service.js

@@ -12,12 +12,12 @@ class CronicleService {
         this.cronicleApiKey = process.env.CRONICLE_API_KEY || "";
     }
     async registerJob(payload) {
-        const { name, apiUrl, method, schedule, cronJobId, target } = payload;
+        const { name, apiUrl, method, schedule, cronJobId, target, category } = payload;
         try {
             await axios_1.default.post(`${this.cronicleEndpoint}/create_event/v1`, {
                 id: cronJobId,
                 title: name,
-                category: "general",
+                category: category ?? "general",
                 plugin: "urlplug",
                 timeZone: "UTC",
                 enabled: 1,
@@ -48,6 +48,8 @@ class CronicleService {
     }
     async getJob(jobId) {
         try {
+            (0, config_1.getConfig)().LOGGER.info(`Getting job: ${jobId}`);
+            (0, config_1.getConfig)().LOGGER.info(`Cronicle endpoint: ${this.cronicleEndpoint}/get_event/v1`);
             const res = await axios_1.default.post(`${this.cronicleEndpoint}/get_event/v1`, {
                 id: jobId,
                 api_key: this.cronicleApiKey,
@@ -55,6 +57,21 @@ class CronicleService {
             return res.data;
         }
         catch (error) {
+            (0, config_1.getConfig)().LOGGER.error(`Failed to get job: ${error.message}`);
+            return;
+        }
+    }
+    async getSchedules(filter) {
+        try {
+            const res = await axios_1.default.post(`${this.cronicleEndpoint}/get_schedule/v1`, {
+                api_key: this.cronicleApiKey,
+                offset: filter.offset ?? 0,
+                limit: filter.limit ?? 100,
+            });
+            return res.data;
+        }
+        catch (error) {
+            (0, config_1.getConfig)().LOGGER.error(`Failed to get schedules: ${error.message}`);
             return;
         }
     }

package/dist/chronicle/ICronicle.interface.d.ts

@@ -1,6 +1,7 @@
 export interface ICronicle {
     name: string;
     cronJobId: string;
+    category?: "heartbeat" | "replenish_codes" | "sync_reservations" | "delete_reservations" | "deliver_codes" | "daily_summary" | "battery_report";
     apiUrl: string;
     method: "POST";
     target: string;

package/dist/entities/accessGroup/AccessGroup.repository.d.ts

@@ -1,5 +1,6 @@
+import { IAccessGroup } from "./IAccessGroup";
 export declare class AccessGroupRepository {
     private readonly postgres;
     constructor();
-    getAccessGroup(accessGroupId: string): Promise<any>;
+    getAccessGroup(accessGroupId: string): Promise<IAccessGroup | null>;
 }

package/dist/entities/accessGroup/AccessGroup.repository.js

@@ -56,7 +56,10 @@ let AccessGroupRepository = (() => {
       WHERE "id" = $1
     `;
             const result = await this.postgres.query(query, [accessGroupId]);
-            return result.rows[0];
+            if (result.rows.length > 0) {
+                return result.rows[0];
+            }
+            return null;
         }
     };
     __setFunctionName(_classThis, "AccessGroupRepository");

package/dist/entities/accessGroup/AccessGroup.service.d.ts

@@ -1,5 +1,6 @@
+import { IAccessGroup } from "./IAccessGroup";
 export declare class AccessGroupService {
     private readonly accessGroupRepository;
     constructor();
-    getAccessGroup(accessGroupId: string): Promise<any>;
+    getAccessGroup(accessGroupId: string): Promise<IAccessGroup | null>;
 }

package/dist/entities/accessGroup/AccessGroup.service.js

@@ -87,7 +87,10 @@ let AccessGroupService = (() => {
             if (!accessGroupId) {
                 throw new Error("Access Group ID is required");
             }
-            return await this.accessGroupRepository.getAccessGroup(accessGroupId);
+            const accessGroup = await this.accessGroupRepository.getAccessGroup(accessGroupId);
+            if (!accessGroup)
+                return null;
+            return accessGroup;
         }
     };
     __setFunctionName(_classThis, "AccessGroupService");
@@ -101,5 +104,3 @@ let AccessGroupService = (() => {
     return AccessGroupService = _classThis;
 })();
 exports.AccessGroupService = AccessGroupService;
-// Accessgroup.getAccessGroup(accessGroupId)
-// GetAccessGroup()

package/dist/entities/device/local/services/Device.service.js

@@ -437,6 +437,16 @@ let LocalDeviceService = (() => {
                     // Raise issue when the level is below threshold
                     await this.issueService.createDeviceBatteryIssue(device, batteryLevel, propertyThreshold, issue_types_1.IssuePriority.CRITICAL, source);
                 }
+                else if (batteryLevel >= propertyThreshold) {
+                    // Resolve issue when the level is above threshold
+                    await this.issueService.performIssueAction({
+                        entityId: deviceId,
+                        entityType: issue_types_1.EntityType.DEVICE,
+                        type: issue_types_1.IssueType.BATTERY_LOW,
+                        propertyId: device.propertyId,
+                        zoneId: device.zoneId,
+                    }, "resolve", source);
+                }
                 // }
             }
         }

package/dist/entities/guest/Guest.repository.d.ts

@@ -2,5 +2,5 @@ import { IGuest } from "./IGuest";
 export declare class GuestRepository {
     private readonly pmsPostgres;
     constructor();
-    getGuest(guestId: string): Promise<IGuest>;
+    getGuest(guestId: string): Promise<IGuest | null>;
 }

package/dist/entities/guest/Guest.repository.js

@@ -52,8 +52,11 @@ let GuestRepository = (() => {
         }
         async getGuest(guestId) {
             try {
-                const guest = await this.pmsPostgres.query(`SELECT * FROM dt_guests WHERE "id" = $1`, [guestId]);
-                return guest.rows[0];
+                const guest = await this.pmsPostgres.query(`SELECT * FROM dt_guest WHERE "id" = $1`, [guestId]);
+                if (guest.rows.length > 0) {
+                    return guest.rows[0];
+                }
+                return null;
             }
             catch (error) {
                 console.error("Error in getGuest:", error);

package/dist/entities/guest/Guest.service.d.ts

@@ -2,5 +2,5 @@ import { IGuest } from "./IGuest";
 export declare class GuestService {
     private readonly guestRepository;
     constructor();
-    getGuest(guestId: string): Promise<IGuest>;
+    getGuest(guestId: string): Promise<IGuest | null>;
 }

package/dist/entities/guest/Guest.service.js

@@ -88,7 +88,10 @@ let GuestService = (() => {
             if (!guestId) {
                 throw new Error("Guest ID is required");
             }
-            return await this.guestRepository.getGuest(guestId);
+            const guest = await this.guestRepository.getGuest(guestId);
+            if (!guest)
+                return null;
+            return guest;
         }
     };
     __setFunctionName(_classThis, "GuestService");

package/dist/entities/schedules/Schedule.repository.d.ts

@@ -2,5 +2,5 @@ import { ISchedule } from "./ISchedule";
 export declare class ScheduleRepository {
     private readonly pmsPostgres;
     constructor();
-    getSchedule(scheduleId: string): Promise<ISchedule>;
+    getSchedule(scheduleId: string): Promise<ISchedule | null>;
 }

package/dist/entities/schedules/Schedule.repository.js

@@ -52,8 +52,11 @@ let ScheduleRepository = (() => {
         }
         async getSchedule(scheduleId) {
             try {
-                const schedule = await this.pmsPostgres.query(`SELECT * FROM dt_schedules WHERE "id" = $1`, [scheduleId]);
-                return schedule.rows[0];
+                const schedule = await this.pmsPostgres.query(`SELECT * FROM dt_schedule WHERE "id" = $1`, [scheduleId]);
+                if (schedule.rows.length > 0) {
+                    return schedule.rows[0];
+                }
+                return null;
             }
             catch (error) {
                 console.error("Error in getSchedule:", error);

package/dist/entities/schedules/Schedule.service.d.ts

@@ -2,5 +2,5 @@ import { ISchedule } from "./ISchedule";
 export declare class ScheduleService {
     private readonly scheduleRepository;
     constructor();
-    getSchedule(scheduleId: string): Promise<ISchedule>;
+    getSchedule(scheduleId: string): Promise<ISchedule | null>;
 }

package/dist/entities/schedules/Schedule.service.js

@@ -88,7 +88,10 @@ let ScheduleService = (() => {
             if (!scheduleId) {
                 throw new Error("Schedule ID is required");
             }
-            return await this.scheduleRepository.getSchedule(scheduleId);
+            const schedule = await this.scheduleRepository.getSchedule(scheduleId);
+            if (!schedule)
+                return null;
+            return schedule;
         }
     };
     __setFunctionName(_classThis, "ScheduleService");

package/dist/entities/user/User.repository.js

@@ -52,7 +52,10 @@ let UserRepository = (() => {
         }
         async getUser(userId) {
             const user = await this.postgres.query(`SELECT * FROM dt_users WHERE "id" = $1`, [userId]);
-            return user.rows[0];
+            if (user.rows.length > 0) {
+                return user.rows[0];
+            }
+            return null;
         }
     };
     __setFunctionName(_classThis, "UserRepository");

package/dist/entities/user/User.service.d.ts

@@ -2,5 +2,5 @@ import { IUser } from "./IUser";
 export declare class UserService {
     private readonly userRepository;
     constructor();
-    getUser(userId: string): Promise<IUser>;
+    getUser(userId: string): Promise<IUser | null>;
 }

package/dist/entities/user/User.service.js

@@ -87,7 +87,10 @@ let UserService = (() => {
             if (!userId) {
                 throw new Error("User ID is required");
             }
-            return await this.userRepository.getUser(userId);
+            const user = await this.userRepository.getUser(userId);
+            if (!user)
+                return null;
+            return user;
         }
     };
     __setFunctionName(_classThis, "UserService");

package/dist/entities/zone/Zone.service.js

@@ -88,7 +88,10 @@ let ZoneService = (() => {
             if (!zoneId) {
                 throw new Error("Zone ID is required");
             }
-            return await this.zoneRepository.getZone(zoneId);
+            const zone = await this.zoneRepository.getZone(zoneId);
+            if (!zone)
+                return null;
+            return zone;
         }
     };
     __setFunctionName(_classThis, "ZoneService");

package/dist/issues/Issue.service.js

@@ -710,18 +710,13 @@ let IssueService = (() => {
                     throw new Error(`Multiple issues found matching the query. Please provide more specific criteria.`);
                 }
                 const issue = issues[0];
-                // Check if issue can be cancelled/closed/resolved
-                if (issue.status === issue_types_1.IssueStatus.CANCELLED) {
-                    throw new Error("Issue is already cancelled");
-                }
-                if (issue.status === issue_types_1.IssueStatus.CLOSED) {
-                    throw new Error("Issue is already closed");
-                }
-                if (issue.status === issue_types_1.IssueStatus.RESOLVED) {
-                    throw new Error("Issue is already resolved");
-                }
-                if (issue.status === issue_types_1.IssueStatus.IGNORED) {
-                    throw new Error("Issue is already ignored");
+                if ([
+                    issue_types_1.IssueStatus.CANCELLED,
+                    issue_types_1.IssueStatus.CLOSED,
+                    issue_types_1.IssueStatus.RESOLVED,
+                    issue_types_1.IssueStatus.IGNORED,
+                ].includes(issue.status)) {
+                    throw new Error(`Issue is already ${issue.status}ed`);
                 }
                 // Determine the new status based on the action
                 let newStatus;

package/dist/queue/entities/HybridHttpQueue.js

@@ -72,6 +72,7 @@ let HybridHttpQueue = (() => {
                 const earliestRequest = recentRequests[0];
                 const nextAvailableTime = earliestRequest + windowMs;
                 delay = Math.max(nextAvailableTime - now, 1000); // At least 1s delay
+                console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Rate limit exceeded, calculated delay: ${delay}ms for job`);
             }
             // Create job data
             const jobData = {
@@ -82,26 +83,57 @@ let HybridHttpQueue = (() => {
                 options,
                 timestamp: Date.now(),
             };
+            console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Adding job to queue - ${method} ${url} -> ${provider} [${connectionId}], delay: ${delay}ms`);
             // Add job to BullMQ queue with delay
             const jobId = await queueUtils_1.QueueUtils.addJobToQueue(queueKey, jobData, delay, this.queues);
+            console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Job added to queue - JobId: ${jobId}, QueueKey: ${queueKey}`);
             // Initialize worker if not exists
+            console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Initializing worker for queue: ${queueKey}`);
             queueUtils_1.QueueUtils.getOrCreateWorker(queueKey, this.workers, this.processHttpRequest.bind(this), this.jobResults);
+            // Verify worker was created
+            if (this.workers.has(queueKey)) {
+                console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Worker confirmed for queue: ${queueKey}`);
+            }
+            else {
+                console.log(`[${new Date().toISOString()}] [HybridHttpQueue] WARNING: Worker NOT found for queue: ${queueKey}`);
+            }
             (0, config_1.getConfig)().LOGGER.info(`Request queued: ${method} ${url} -> ${provider} [${connectionId}]. Job ID: ${jobId}, Delay: ${delay}ms`);
             // Wait for job completion and return result
-            // Pass the delay so timeout calculation accounts for it
-            return queueUtils_1.QueueUtils.waitForJobCompletion(jobId, queueKey, this.jobResults, delay);
+            // Simple: delay + windowMs + HTTP buffer timeout
+            return queueUtils_1.QueueUtils.waitForJobCompletion(jobId, queueKey, delay, windowMs);
         }
         async processHttpRequest(job) {
-            const { connectionId, provider, url, method, options } = job.data;
-            // Check rate limit before processing
-            const allowed = await rateLimit_utils_1.RateLimitUtils.isRateLimitAllowed(connectionId, provider, this.rateLimitConfigs);
-            if (!allowed) {
-                // This shouldn't happen since we calculate delay, but handle it gracefully
-                (0, config_1.getConfig)().LOGGER.warn(`Job ${job.id} still rate limited after delay, waiting for window to expire...`);
-                await queueUtils_1.QueueUtils.waitForRateLimitExpiry(connectionId, provider, this.rateLimitConfigs);
+            // Log immediately when worker picks up the job
+            const startTime = Date.now();
+            console.log(`[${new Date().toISOString()}] [Worker] processHttpRequest CALLED - JobId: ${job?.id}, QueueName: ${job?.queueName}, JobName: ${job?.name}, JobData: ${JSON.stringify(job?.data || {})}`);
+            try {
+                if (!job?.data) {
+                    throw new Error(`Job ${job?.id} has no data`);
+                }
+                const { connectionId, provider, url, method, options } = job.data;
+                if (!connectionId || !provider || !url || !method) {
+                    throw new Error(`Missing required job data fields. ConnectionId: ${connectionId}, Provider: ${provider}, URL: ${url}, Method: ${method}`);
+                }
+                console.log(`[${new Date().toISOString()}] [Worker] Processing job - JobId: ${job.id}, ${method} ${url} -> ${provider} [${connectionId}]`);
+                // Check rate limit before processing
+                const allowed = await rateLimit_utils_1.RateLimitUtils.isRateLimitAllowed(connectionId, provider, this.rateLimitConfigs);
+                if (!allowed) {
+                    // This shouldn't happen since we calculate delay, but handle it gracefully
+                    console.log(`[${new Date().toISOString()}] [Worker] Job ${job.id} still rate limited, waiting for window to expire...`);
+                    (0, config_1.getConfig)().LOGGER.warn(`Job ${job.id} still rate limited after delay, waiting for window to expire...`);
+                    await queueUtils_1.QueueUtils.waitForRateLimitExpiry(connectionId, provider, this.rateLimitConfigs);
+                    console.log(`[${new Date().toISOString()}] [Worker] Rate limit wait completed for job ${job.id}, proceeding with HTTP request`);
+                }
+                // Execute the HTTP request
+                console.log(`[${new Date().toISOString()}] [Worker] Executing HTTP request for job ${job.id}`);
+                const result = await queueUtils_1.QueueUtils.executeHttpRequest(url, method, options, connectionId, provider);
+                console.log(`[${new Date().toISOString()}] [Worker] HTTP request completed successfully for job ${job.id}`);
+                return result;
+            }
+            catch (error) {
+                console.log(`[${new Date().toISOString()}] [Worker] ERROR in processHttpRequest for job ${job?.id}: ${error.message}, Stack: ${error.stack}`);
+                throw error;
             }
-            // Execute the HTTP request
-            return queueUtils_1.QueueUtils.executeHttpRequest(url, method, options, connectionId, provider);
         }
         async request(options) {
             const { method, url, body, params, headers, queueOptions } = options;

package/dist/queue/utils/queueUtils.d.ts

@@ -8,5 +8,5 @@ export declare class QueueUtils {
     static waitForRateLimitExpiry(connectionId: string, provider: string, rateLimitConfigs: Map<string, IRateLimitConfig>): Promise<void>;
     static executeHttpRequest(url: string, method: string, options: HttpCallOption, connectionId: string, provider: string): Promise<any>;
     static addJobToQueue(queueKey: string, jobData: any, delay: number, queues: Map<string, any>): Promise<string>;
-    static waitForJobCompletion(jobId: string, queueKey: string, jobResults: Map<string, any>, jobDelay?: number): Promise<any>;
+    static waitForJobCompletion(jobId: string, queueKey: string, jobDelay?: number, windowMs?: number): Promise<any>;
 }