dt-common-device 9.1.8 → 9.1.10

package/dist/cronicle/Cronicle.service.js

@@ -44,7 +44,7 @@ class CronicleService {
             });
         }
         catch (error) {
-            (0, config_1.getConfig)().LOGGER.error(`Failed to create device: ${error.message}`);
+            (0, config_1.getConfig)().LOGGER.error(`Failed to create Cronicle job: ${error.message}`);
         }
     }
     async getJob(jobId) {

package/dist/entities/admin/Admin.repository.d.ts

@@ -2,6 +2,7 @@ import { IAccessGroup, IUser, IZone, IZoneAccessGroup } from "./IAdmin";
 export declare class AdminRepository {
     private readonly deviceRepository;
     private readonly postgres;
+    private readonly localDeviceService;
     constructor();
     getZonesByAccessGroupIds(accessGroupIds: string[]): Promise<any[]>;
     getZonesByAccessGroups(accessGroupIds: string[]): Promise<any[]>;
@@ -9,4 +10,5 @@ export declare class AdminRepository {
     getZoneAccessGroupByZoneId(zoneId: string): Promise<IZoneAccessGroup[] | null>;
     getZone(zoneId: string): Promise<IZone | null>;
     getUser(userId: string): Promise<IUser | null>;
+    getZoneByDeviceId(deviceId: string): Promise<IZone | null>;
 }

package/dist/entities/admin/Admin.repository.js

@@ -77,6 +77,7 @@ const utils_1 = require("../../utils");
 const Device_repository_1 = require("../device/local/repository/Device.repository");
 const db_1 = require("../../db/db");
 const interfaces_1 = require("../device/cloud/interfaces");
+const services_1 = require("../device/local/services");
 let AdminRepository = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;
@@ -86,6 +87,7 @@ let AdminRepository = (() => {
         constructor() {
             this.deviceRepository = typedi_1.default.get(Device_repository_1.DeviceRepository);
             this.postgres = (0, db_1.getPostgresClient)();
+            this.localDeviceService = typedi_1.default.get(services_1.LocalDeviceService);
         }
         async getZonesByAccessGroupIds(accessGroupIds) {
             // // Get propertyId from any of the accessGroupIds
@@ -106,10 +108,19 @@ let AdminRepository = (() => {
             //   return JSON.parse(cachedResult);
             // }
             // If not cached, get the result from the database
-            const result = await this.postgres.query(`SELECT "zc".*, "z"."id", "z"."name"
-       FROM "dt_zones_collection_map" "zc"
-       INNER JOIN "dt_zones" "z" ON "zc"."zoneId" = "z"."id"
-       WHERE "zc"."collectionId" = ANY($1)`, [accessGroupIds]);
+            const result = await this.postgres.query(`SELECT 
+        "zc"."id" AS "zoneCollectionMapId",
+        "zc"."collectionId",
+        "zc"."zoneId",
+        "z"."id" AS "zoneId",
+        "z"."name" AS "zoneName",
+        "z"."zoneTypeId",
+        "zt"."name" AS "zoneTypeName"
+      FROM "dt_zones_collection_map" AS "zc"
+      INNER JOIN "dt_zones" AS "z" ON "zc"."zoneId" = "z"."id"
+      LEFT JOIN "dt_zoneTypes" AS "zt" ON "z"."zoneTypeId" = "zt"."id"
+      WHERE "zc"."collectionId" = ANY($1)
+      ORDER BY "zc"."id" ASC`, [accessGroupIds]);
             const response = result.rows;
             const _zones = (nestedZones, allZones = []) => {
                 nestedZones.forEach((z) => {
@@ -167,6 +178,7 @@ let AdminRepository = (() => {
             const _collectionZone = collectionZone.map((e) => {
                 const zones = e.zoneIds;
                 let devices = [];
+                let zonesData = [];
                 zones.forEach((element) => {
                     const device = deviceDetails.filter((d) => d.zoneId == element);
                     // Add collectionId to each device
@@ -175,8 +187,18 @@ let AdminRepository = (() => {
                     });
                     const _devices = devices.concat(device);
                     devices = _devices;
+                    // Create zone data for each zone
+                    const zoneInfo = response.find((r) => r.zoneId === element);
+                    const zoneData = {
+                        zoneId: element,
+                        deviceIds: device?.map((d) => d.deviceId), // Get first device ID if available
+                        zoneName: zoneInfo?.zoneName || "",
+                        zoneType: zoneInfo?.zoneTypeName || null,
+                    };
+                    zonesData.push(zoneData);
                 });
                 e.devices = devices;
+                e.zones = zonesData;
                 e.parentZone = response;
                 return e;
             });
@@ -249,6 +271,7 @@ let AdminRepository = (() => {
                 if (zone.rows.length > 0) {
                     const zoneData = zone.rows[0];
                     const zoneType = await this.postgres.query(`SELECT * FROM "dt_zoneTypes" WHERE "id" = $1`, [zoneData.zoneTypeId]);
+                    zoneData.zoneType = {};
                     zoneData.zoneType = {
                         id: zoneType.rows[0].id,
                         name: zoneType.rows[0].name,
@@ -269,6 +292,16 @@ let AdminRepository = (() => {
             }
             return null;
         }
+        async getZoneByDeviceId(deviceId) {
+            try {
+                const device = await this.localDeviceService.getDevice(deviceId);
+                return await this.getZone(device.zoneId);
+            }
+            catch (error) {
+                console.error("Error in getZoneByDeviceId:", error);
+                throw new Error("Failed to get zone by device ID");
+            }
+        }
     };
     __setFunctionName(_classThis, "AdminRepository");
     (() => {

package/dist/entities/admin/Admin.service.d.ts

@@ -9,4 +9,5 @@ export declare class AdminService {
     getAccessGroupByZoneId(zoneId: string): Promise<IAccessGroup[] | []>;
     getZone(zoneId: string): Promise<IZone | null>;
     getUser(userId: string): Promise<IUser | null>;
+    getZoneByDeviceId(deviceId: string): Promise<IZone | null>;
 }

package/dist/entities/admin/Admin.service.js

@@ -147,6 +147,15 @@ let AdminService = (() => {
                 return null;
             return user;
         }
+        async getZoneByDeviceId(deviceId) {
+            if (!deviceId) {
+                throw new Error("Device ID is required");
+            }
+            const zone = await this.adminRepository.getZoneByDeviceId(deviceId);
+            if (!zone)
+                return null;
+            return zone;
+        }
     };
     __setFunctionName(_classThis, "AdminService");
     (() => {

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

@@ -294,43 +294,52 @@ let LocalDeviceService = (() => {
             }
         }
         async handleOfflineStatus(device, oldStatus, newStatus, source, auditBody, reason, currentTime) {
+            // if deviceProfile is active, only then use baseline for the device, if its calibrating or inactive mark device offline immediately
+            const preferences = await this.localPropertyService.getPropertyPreferences(device.propertyId, ["deviceProfile"]);
+            const deviceProfile = preferences?.settings?.deviceProfile?.value || "calibrating";
             currentTime = currentTime ?? new Date().toISOString();
             const isExistingStatusOnline = oldStatus?.liveStatus === "ONLINE";
             const isExistingStatusOffline = oldStatus?.liveStatus === "OFFLINE";
-            if (isExistingStatusOnline) {
-                // Existing status is Online
-                newStatus.online = true;
-                newStatus.liveStatus = "OFFLINE";
-                newStatus.lastUpdated = currentTime;
-                newStatus.error = {
-                    type: "offline",
-                    message: reason || "Device went offline",
-                    default: {},
-                };
-                await this.deviceRepository.setStatus(device.deviceId, newStatus);
-                await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody, constants_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE);
-            }
-            else if (isExistingStatusOffline) {
-                // Existing status is Offline
-                const timeLapsed = oldStatus?.lastUpdated
-                    ? Date.now() - new Date(oldStatus.lastUpdated).getTime()
-                    : 0;
-                const baselineTime = await this.getDeviceBaseline(device.deviceId);
-                if (timeLapsed > baselineTime) {
-                    // When the time lapsed is higher than the baseline time
-                    newStatus.online = false;
+            if (deviceProfile === "active") {
+                if (isExistingStatusOnline) {
+                    // Existing status is Online
+                    newStatus.online = true;
                     newStatus.liveStatus = "OFFLINE";
                     newStatus.lastUpdated = currentTime;
                     newStatus.error = {
                         type: "offline",
-                        message: reason || "Device has been offline for longer than baseline",
+                        message: reason || "Device went offline",
                         default: {},
                     };
                     await this.deviceRepository.setStatus(device.deviceId, newStatus);
                     await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody, constants_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE);
-                    // Raise issue when the device goes offline if longer than the baseline (OPERATIONAL only)
-                    await this.issueService.createDeviceOfflineIssue(device, source, reason);
                 }
+                else if (isExistingStatusOffline) {
+                    // Existing status is Offline
+                    const timeLapsed = oldStatus?.lastUpdated
+                        ? Date.now() - new Date(oldStatus.lastUpdated).getTime()
+                        : 0;
+                    const baselineTime = await this.getDeviceBaseline(device.deviceId);
+                    if (timeLapsed > baselineTime) {
+                        // When the time lapsed is higher than the baseline time
+                        newStatus.online = false;
+                        newStatus.liveStatus = "OFFLINE";
+                        newStatus.lastUpdated = currentTime;
+                        newStatus.error = {
+                            type: "offline",
+                            message: reason || "Device has been offline for longer than baseline",
+                            default: {},
+                        };
+                        await this.deviceRepository.setStatus(device.deviceId, newStatus);
+                        await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody, constants_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE);
+                        // Raise issue when the device goes offline if longer than the baseline (OPERATIONAL only)
+                        await this.issueService.createDeviceOfflineIssue(device, source, reason);
+                    }
+                }
+            }
+            else {
+                await this.deviceRepository.setStatus(device.deviceId, newStatus);
+                await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody, constants_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE);
             }
         }
         async handleOnlineStatus(device, oldStatus, newStatus, source, auditBody, reason, currentTime) {

package/dist/queue/interfaces/IRateLimitConfig.d.ts

@@ -2,4 +2,5 @@ export interface IRateLimitConfig {
     maxRequests: number;
     windowMs: number;
     provider: string;
+    maxTimeoutWindowMs?: number;
 }

package/dist/queue/utils/rateLimit.utils.js

@@ -37,61 +37,73 @@ class RateLimitUtils {
             maxRequests: 10,
             windowMs: 10000, // 10 seconds
             provider: constants_1.CONNECTION_PROVIDERS.SENSIBO,
+            maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.CLOUDBEDS, {
             maxRequests: 8,
             windowMs: 1000, // 1 second - CloudBed allows 10 requests per second
             provider: constants_1.CONNECTION_PROVIDERS.CLOUDBEDS,
+            maxTimeoutWindowMs: 1800000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.STAYNTOUCH, {
             maxRequests: 10,
             windowMs: 10000, // 10 seconds
             provider: constants_1.CONNECTION_PROVIDERS.STAYNTOUCH,
+            maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.HOTELKEY, {
             maxRequests: 10,
             windowMs: 10000, // 10 seconds
             provider: constants_1.CONNECTION_PROVIDERS.HOTELKEY,
+            maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.TTLOCK, {
             maxRequests: 15,
             windowMs: 60000, // 1 minute
             provider: constants_1.CONNECTION_PROVIDERS.TTLOCK,
+            maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.LOCKLY, {
             maxRequests: 10,
             windowMs: 60000, // 1 minute
             provider: constants_1.CONNECTION_PROVIDERS.LOCKLY,
+            maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.SCHLAGE, {
             maxRequests: 120,
             windowMs: 60000, // 1 minute
             provider: constants_1.CONNECTION_PROVIDERS.SCHLAGE,
+            maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.SMARTTHINGS, {
             maxRequests: 12,
             windowMs: 60000, // 1 minute
             provider: constants_1.CONNECTION_PROVIDERS.SMARTTHINGS,
+            maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.YALEWIFI, {
             maxRequests: 5,
             windowMs: 60000,
             provider: constants_1.CONNECTION_PROVIDERS.YALEWIFI,
+            maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.TUYA, {
             maxRequests: 5,
             windowMs: 1000,
             provider: constants_1.CONNECTION_PROVIDERS.TUYA,
+            maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.SALTOKS, {
             maxRequests: 5,
             windowMs: 60000,
             provider: constants_1.CONNECTION_PROVIDERS.SALTOKS,
+            maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.VERDANT, {
             maxRequests: 5,
             windowMs: 60000,
             provider: constants_1.CONNECTION_PROVIDERS.VERDANT,
+            maxTimeoutWindowMs: 120000,
         });
         return configs;
     }

package/package.json

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