dt-common-device 5.0.5 → 5.1.0

package/dist/alerts/Alert.model.d.ts

@@ -18,7 +18,7 @@ interface IAlertModel extends Model<IAlertDocument, {}, IAlertMethods> {
     findSnoozed(includeDeleted?: boolean): Promise<IAlertDocument[]>;
     findExpiredSnooze(includeDeleted?: boolean): Promise<IAlertDocument[]>;
 }
-declare const AlertSchema: mongoose.Schema<IAlertDocument, IAlertModel, IAlertMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IAlertDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IAlertDocument>, {}> & Omit<mongoose.FlatRecord<IAlertDocument> & Required<{
+declare const AlertSchema: mongoose.Schema<IAlertDocument, IAlertModel, IAlertMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IAlertDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IAlertDocument>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & Omit<mongoose.FlatRecord<IAlertDocument> & Required<{
     _id: string;
 }> & {
     __v: number;

package/dist/audit/AuditUtils.d.ts

@@ -16,7 +16,7 @@ export declare class AuditUtils {
      */
     private calculateScheduleDuration;
     private getPropertyName;
-    private getPropertyIdFromDevice;
+    private getFieldFromDevice;
     private getUserName;
     private getGuestName;
     private getDeviceName;

package/dist/audit/AuditUtils.js

@@ -139,17 +139,22 @@ let AuditUtils = (() => {
             if (propertyId && !propertyName)
                 audit.propertyName = await this.getPropertyName(propertyId);
             if (!propertyId && deviceId) {
-                audit.propertyId = await this.getPropertyIdFromDevice(deviceId);
+                audit.propertyId = await this.getFieldFromDevice(deviceId, "propertyId");
                 audit.propertyName = await this.getPropertyName(audit.propertyId);
             }
+            if (zoneId && !zoneName)
+                audit.zoneName = await this.getZoneName(zoneId);
+            if (!zoneId && deviceId) {
+                audit.zoneId = await this.getFieldFromDevice(deviceId, "zoneId");
+                audit.zoneName = await this.getZoneName(audit.zoneId);
+            }
             if (userId && !userName)
                 audit.userName = await this.getUserName(userId);
             if (guestId && !guestName)
                 audit.guestName = await this.getGuestName(guestId);
-            if (deviceId && !deviceName)
+            if (deviceId && !deviceName) {
                 audit.deviceName = await this.getDeviceName(deviceId);
-            if (zoneId && !zoneName)
-                audit.zoneName = await this.getZoneName(zoneId);
+            }
             if (accessGroupId && !accessGroupName)
                 audit.accessGroupName = await this.getAccessGroupName(accessGroupId);
             if (scheduleId) {
@@ -189,17 +194,17 @@ let AuditUtils = (() => {
                 return property?.name || "";
             });
         }
-        async getPropertyIdFromDevice(deviceId) {
+        async getFieldFromDevice(deviceId, field) {
             const redisKey = `device:${deviceId}`;
             const redisDevice = await this.redisUtils.hget(redisKey, "device");
             if (redisDevice) {
-                return JSON.parse(redisDevice).propertyId;
+                return redisDevice[field];
             }
             else {
                 const device = await typedi_1.default.get(services_1.LocalDeviceService).getDevice(deviceId);
                 await this.redisUtils.hset(redisKey, "device", JSON.stringify(device));
                 await this.redisUtils.expire(redisKey, this.CACHE_TTL);
-                return device.propertyId;
+                return device[field];
             }
         }
         async getUserName(userId) {
@@ -217,7 +222,7 @@ let AuditUtils = (() => {
         async getDeviceName(deviceId) {
             return this.getCachedEntityData("device", deviceId, async () => {
                 const device = await typedi_1.default.get(services_1.LocalDeviceService).querySelect({ deviceId }, ["name"]);
-                return device?.name || "";
+                return device[0]?.name || "";
             });
         }
         async getZoneName(zoneId) {

package/dist/config/config.js

@@ -32,33 +32,33 @@ let db_keys = null;
 let sourceKey = null;
 async function initialize(cfg) {
     // Check if required env variables are set
-    checkRequiredEnv(constants_1.CONFIG_KEYS.REQUIRED.env);
+    checkRequiredEnv(constants_1.REQUIRED.env);
     // Initialize config
     config = { ...cfg };
     if (cfg.SOURCE === "ADMIN_SERVICE") {
         sourceKey = "ADMIN";
         db_keys = constants_1.CONFIG_KEYS.ADMIN.db_keys;
-        await validateAdminConfig(cfg);
+        await validateServiceConfig(cfg);
     }
     if (cfg.SOURCE === "ACCESS_SERVICE") {
         sourceKey = "ACCESS";
         db_keys = constants_1.CONFIG_KEYS.ACCESS.db_keys;
-        await validateAccessConfig(cfg);
+        await validateServiceConfig(cfg);
     }
     if (cfg.SOURCE === "SCHEDULE_SERVICE") {
         sourceKey = "SCHEDULE";
         db_keys = constants_1.CONFIG_KEYS.SCHEDULE.db_keys;
-        await validateScheduleConfig(cfg);
+        await validateServiceConfig(cfg);
     }
     if (cfg.SOURCE === "ENERGY_SERVICE") {
         sourceKey = "ENERGY";
         db_keys = constants_1.CONFIG_KEYS.ENERGY.db_keys;
-        await validateEnergyConfig(cfg);
+        await validateServiceConfig(cfg);
     }
     if (cfg.SOURCE === "REMOTE_SERVICE") {
         sourceKey = "REMOTE";
         db_keys = constants_1.CONFIG_KEYS.REMOTE.db_keys;
-        await validateRemoteConfig(cfg);
+        await validateServiceConfig(cfg);
     }
     // Connect to databases
     try {
@@ -82,7 +82,7 @@ async function initialize(cfg) {
     }
     // Initialize audit
     ensureAuditInitialized();
-    console.log("dt-common-device: Initialization completed successfully");
+    cfg.LOGGER.info("dt-common-device: Initialization completed successfully");
 }
 async function validateInternalEventHandler(cfg) {
     // Initialize internal event subscription if handler is provided
@@ -99,33 +99,9 @@ async function validateInternalEventHandler(cfg) {
         }
     }
 }
-async function validateAdminConfig(cfg) {
-    checkRequiredEnv(constants_1.CONFIG_KEYS.ADMIN.env);
-    if (constants_1.CONFIG_KEYS.ADMIN.INTERNAL_EVENT_HANDLER) {
-        await validateInternalEventHandler(cfg);
-    }
-}
-async function validateAccessConfig(cfg) {
-    checkRequiredEnv(constants_1.CONFIG_KEYS.ACCESS.env);
-    if (constants_1.CONFIG_KEYS.ACCESS.INTERNAL_EVENT_HANDLER) {
-        await validateInternalEventHandler(cfg);
-    }
-}
-async function validateEnergyConfig(cfg) {
-    checkRequiredEnv(constants_1.CONFIG_KEYS.ENERGY.env);
-    if (constants_1.CONFIG_KEYS.ENERGY.INTERNAL_EVENT_HANDLER) {
-        await validateInternalEventHandler(cfg);
-    }
-}
-async function validateRemoteConfig(cfg) {
-    checkRequiredEnv(constants_1.CONFIG_KEYS.REMOTE.env);
-    if (constants_1.CONFIG_KEYS.REMOTE.INTERNAL_EVENT_HANDLER) {
-        await validateInternalEventHandler(cfg);
-    }
-}
-async function validateScheduleConfig(cfg) {
-    checkRequiredEnv(constants_1.CONFIG_KEYS.SCHEDULE.env);
-    if (constants_1.CONFIG_KEYS.SCHEDULE.INTERNAL_EVENT_HANDLER) {
+async function validateServiceConfig(cfg) {
+    checkRequiredEnv(constants_1.CONFIG_KEYS[sourceKey].env);
+    if (constants_1.CONFIG_KEYS[sourceKey].INTERNAL_EVENT_HANDLER) {
         await validateInternalEventHandler(cfg);
     }
 }

package/dist/config/constants.d.ts

@@ -1,7 +1,7 @@
+export declare const REQUIRED: {
+    env: string[];
+};
 export declare const CONFIG_KEYS: {
-    REQUIRED: {
-        env: string[];
-    };
     ACCESS: {
         env: string[];
         INTERNAL_EVENT_HANDLER: boolean;

package/dist/config/constants.js

@@ -1,22 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONFIG_KEYS = void 0;
+exports.CONFIG_KEYS = exports.REQUIRED = void 0;
+exports.REQUIRED = {
+    env: [
+        "AWS_SECRET_ACCESS_KEY",
+        "AWS_REGION",
+        "AWS_ACCESS_KEY_ID",
+        "EVENT_BUS_NAME",
+        "REDIS_HOST",
+        "REDIS_PORT",
+        "POSTHOG_API_KEY",
+        "POSTHOG_HOST",
+        "DEVICE_SERVICE",
+        "DT_API_KEY",
+    ],
+};
 exports.CONFIG_KEYS = {
-    REQUIRED: {
-        env: [
-            "AWS_SECRET_ACCESS_KEY",
-            "AWS_REGION",
-            "AWS_ACCESS_KEY_ID",
-            "EVENT_BUS_NAME",
-            "MONGODB_URI",
-            "REDIS_HOST",
-            "REDIS_PORT",
-            "POSTHOG_API_KEY",
-            "POSTHOG_HOST",
-            "DEVICE_SERVICE",
-            "DT_API_KEY",
-        ],
-    },
     ACCESS: {
         env: ["ADMIN_DB_URI", "PMS_DB_URI", "AWS_SQS_URL", "ADMIN_SERVICE"],
         INTERNAL_EVENT_HANDLER: true,

package/dist/constants/Event.d.ts

@@ -1,43 +1,55 @@
 export declare const DT_EVENT_TYPES: {
     DEVICE: {
         CREATE: {
+            ATTEMPT: string;
             SUCCESS: string;
             FAILED: string;
         };
         UPDATE: {
+            ATTEMPT: string;
             SUCCESS: string;
             FAILED: string;
         };
         DELETE: {
+            ATTEMPT: string;
+            SUCCESS: string;
+            FAILED: string;
+        };
+        ZONE: {
+            UPDATE: {
+                ATTEMPT: string;
+                SUCCESS: string;
+                FAILED: string;
+            };
+        };
+        REFRESH: {
+            ATTEMPT: string;
             SUCCESS: string;
             FAILED: string;
         };
         STATE: {
-            SET: string;
-            UNKNOWN: string;
-            UPDATED: string;
             CHANGED: string;
         };
         STATUS: {
-            SET: string;
             ONLINE: string;
             OFFLINE: string;
             UNKNOWN: string;
-            UPDATED: string;
-            CHANGED: string;
         };
         BATTERY: {
-            SET: string;
-            UNKNOWN: string;
-            LOW: string;
-            CRITICAL: string;
+            REPLACED: string;
+            LEVEL: {
+                UNKNOWN: string;
+                NORMAL: string;
+                LOW: string;
+                CRITICAL: string;
+                UPDATED: string;
+            };
+        };
+        METADATA: {
             UPDATED: string;
-            CHANGED: string;
         };
-        META_DATA: {
-            SET: string;
+        NAME: {
             UPDATED: string;
-            CHANGED: string;
         };
         EVENT: {
             RECEIVED: string;
@@ -45,6 +57,7 @@ export declare const DT_EVENT_TYPES: {
             UNREGISTERED: string;
             PROCESSED: string;
             UNPROCESSED: string;
+            UNHANDLED: string;
         };
         WEBHOOK: {
             RECEIVED: string;
@@ -52,38 +65,91 @@ export declare const DT_EVENT_TYPES: {
             UNREGISTERED: string;
             PROCESSED: string;
             UNPROCESSED: string;
+            UNHANDLED: string;
         };
     };
     CONNECTION: {
         CREATE: {
+            ATTEMPT: string;
             SUCCESS: string;
             FAILED: string;
         };
         UPDATE: {
+            ATTEMPT: string;
             SUCCESS: string;
             FAILED: string;
         };
         DELETE: {
+            ATTEMPT: string;
+            SUCCESS: string;
+            FAILED: string;
+        };
+        TOKEN_REFRESH: {
+            ATTEMPT: string;
             SUCCESS: string;
             FAILED: string;
         };
     };
     PROPERTY: {
         CREATE: {
+            ATTEMPT: string;
             SUCCESS: string;
             FAILED: string;
         };
         UPDATE: {
+            ATTEMPT: string;
             SUCCESS: string;
             FAILED: string;
         };
         DELETE: {
+            ATTEMPT: string;
             SUCCESS: string;
             FAILED: string;
         };
         PREFERENCES: {
             UPDATED: string;
+        };
+        PROFILE: {
+            UPDATED: string;
+        };
+        USER: {
+            ATTEMPT: string;
             CREATED: string;
+            UPDATED: string;
+        };
+    };
+    ACCESS_GROUP: {
+        CREATE: {
+            ATTEMPT: string;
+            SUCCESS: string;
+            FAILED: string;
+        };
+        UPDATE: {
+            ATTEMPT: string;
+            SUCCESS: string;
+            FAILED: string;
+        };
+        DELETE: {
+            ATTEMPT: string;
+            SUCCESS: string;
+            FAILED: string;
+        };
+    };
+    ZONE: {
+        CREATE: {
+            ATTEMPT: string;
+            SUCCESS: string;
+            FAILED: string;
+        };
+        UPDATE: {
+            ATTEMPT: string;
+            SUCCESS: string;
+            FAILED: string;
+        };
+        DELETE: {
+            ATTEMPT: string;
+            SUCCESS: string;
+            FAILED: string;
         };
     };
 };

package/dist/constants/Event.js

@@ -4,43 +4,55 @@ exports.DT_EVENT_TYPES = void 0;
 exports.DT_EVENT_TYPES = {
     DEVICE: {
         CREATE: {
+            ATTEMPT: "device.create.attempt",
             SUCCESS: "device.create.success",
             FAILED: "device.create.failed",
         },
         UPDATE: {
+            ATTEMPT: "device.update.attempt",
             SUCCESS: "device.update.success",
             FAILED: "device.update.failed",
         },
         DELETE: {
+            ATTEMPT: "device.delete.attempt",
             SUCCESS: "device.delete.success",
             FAILED: "device.delete.failed",
         },
+        ZONE: {
+            UPDATE: {
+                ATTEMPT: "device.zone.update.attempt",
+                SUCCESS: "device.zone.update.success",
+                FAILED: "device.zone.update.failed",
+            },
+        },
+        REFRESH: {
+            ATTEMPT: "device.refresh.attempt",
+            SUCCESS: "device.refresh.success",
+            FAILED: "device.refresh.failed",
+        },
         STATE: {
-            SET: "device.state.set",
-            UNKNOWN: "device.state.unknown",
-            UPDATED: "device.state.updated",
             CHANGED: "device.state.changed",
         },
         STATUS: {
-            SET: "device.status.set",
             ONLINE: "device.status.online",
             OFFLINE: "device.status.offline",
             UNKNOWN: "device.status.unknown",
-            UPDATED: "device.status.updated",
-            CHANGED: "device.status.changed",
         },
         BATTERY: {
-            SET: "device.battery.set",
-            UNKNOWN: "device.battery.unknown",
-            LOW: "device.battery.low",
-            CRITICAL: "device.battery.critical",
-            UPDATED: "device.battery.updated",
-            CHANGED: "device.battery.changed",
-        },
-        META_DATA: {
-            SET: "device.metaData.set",
-            UPDATED: "device.metaData.updated",
-            CHANGED: "device.metaData.changed",
+            REPLACED: "device.battery.replaced",
+            LEVEL: {
+                UNKNOWN: "device.battery.level.unknown",
+                NORMAL: "device.battery.level.normal",
+                LOW: "device.battery.level.low",
+                CRITICAL: "device.battery.level.critical",
+                UPDATED: "device.battery.level.updated",
+            },
+        },
+        METADATA: {
+            UPDATED: "device.metadata.updated",
+        },
+        NAME: {
+            UPDATED: "device.name.updated",
         },
         EVENT: {
             RECEIVED: "device.event.received",
@@ -48,6 +60,7 @@ exports.DT_EVENT_TYPES = {
             UNREGISTERED: "device.event.unregistered",
             PROCESSED: "device.event.processed",
             UNPROCESSED: "device.event.unprocessed",
+            UNHANDLED: "device.event.unhandled",
         },
         WEBHOOK: {
             RECEIVED: "device.webhook.received",
@@ -55,38 +68,91 @@ exports.DT_EVENT_TYPES = {
             UNREGISTERED: "device.webhook.unregistered",
             PROCESSED: "device.webhook.processed",
             UNPROCESSED: "device.webhook.unprocessed",
+            UNHANDLED: "device.webhook.unhandled",
         },
     },
     CONNECTION: {
         CREATE: {
+            ATTEMPT: "connection.create.attempt",
             SUCCESS: "connection.create.success",
             FAILED: "connection.create.failed",
         },
         UPDATE: {
+            ATTEMPT: "connection.update.attempt",
             SUCCESS: "connection.update.success",
             FAILED: "connection.update.failed",
         },
         DELETE: {
+            ATTEMPT: "connection.delete.attempt",
             SUCCESS: "connection.delete.success",
             FAILED: "connection.delete.failed",
         },
+        TOKEN_REFRESH: {
+            ATTEMPT: "connection.token.refresh.attempt",
+            SUCCESS: "connection.token.refresh.success",
+            FAILED: "connection.token.refresh.failed",
+        },
     },
     PROPERTY: {
         CREATE: {
+            ATTEMPT: "property.create.attempt",
             SUCCESS: "property.create.success",
             FAILED: "property.create.failed",
         },
         UPDATE: {
+            ATTEMPT: "property.update.attempt",
             SUCCESS: "property.update.success",
             FAILED: "property.update.failed",
         },
         DELETE: {
+            ATTEMPT: "property.delete.attempt",
             SUCCESS: "property.delete.success",
             FAILED: "property.delete.failed",
         },
         PREFERENCES: {
             UPDATED: "property.preferences.updated",
-            CREATED: "property.preferences.created",
+        },
+        PROFILE: {
+            UPDATED: "property.profile.updated",
+        },
+        USER: {
+            ATTEMPT: "property.user.attempt",
+            CREATED: "property.user.created",
+            UPDATED: "property.user.updated",
+        },
+    },
+    ACCESS_GROUP: {
+        CREATE: {
+            ATTEMPT: "accessgroup.create.attempt",
+            SUCCESS: "accessgroup.create.success",
+            FAILED: "accessgroup.create.failed",
+        },
+        UPDATE: {
+            ATTEMPT: "accessgroup.update.attempt",
+            SUCCESS: "accessgroup.update.success",
+            FAILED: "accessgroup.update.failed",
+        },
+        DELETE: {
+            ATTEMPT: "accessgroup.delete.attempt",
+            SUCCESS: "accessgroup.delete.success",
+            FAILED: "accessgroup.delete.failed",
+        },
+    },
+    ZONE: {
+        CREATE: {
+            ATTEMPT: "zone.create.attempt",
+            SUCCESS: "zone.create.success",
+            FAILED: "zone.create.failed",
+        },
+        UPDATE: {
+            ATTEMPT: "zone.update.attempt",
+            SUCCESS: "zone.update.success",
+            FAILED: "zone.update.failed",
+        },
+        DELETE: {
+            ATTEMPT: "zone.delete.attempt",
+            SUCCESS: "zone.delete.success",
+            FAILED: "zone.delete.failed",
         },
     },
 };

package/dist/entities/device/local/repository/Device.repository.js

@@ -144,7 +144,6 @@ let DeviceRepository = (() => {
         async getState(deviceId) {
             try {
                 const response = await this.axiosInstance.get(`/devices/${deviceId}/state`);
-                console.log("GetState response:------------", response.data);
                 return response.data;
             }
             catch (error) {
@@ -183,18 +182,14 @@ let DeviceRepository = (() => {
             }
         }
         async setStatusMany(query, newStatus) {
-            console.log("SetStatusMany query:------------", query);
-            console.log("SetStatusMany newStatus:------------", newStatus);
             try {
                 const response = await this.axiosInstance.put(`/devices/statusMany`, {
                     query,
                     status: newStatus,
                 });
-                console.log("SetStatusMany response:------------", response);
                 return response.data;
             }
             catch (error) {
-                console.log("SetStatusMany error:------------", error);
                 (0, config_1.getConfig)().LOGGER.error(`Failed to set status for multiple devices: ${error.message}`);
                 throw new Error(`Failed to set status for multiple devices: ${error.message}`);
             }

package/dist/entities/device/local/services/Device.service.d.ts

@@ -17,7 +17,7 @@ export declare class LocalDeviceService {
     updateDevices(query: any, updateData: any): Promise<any>;
     deleteDevice(deviceId: string, auditBody: IAuditProperties): Promise<any>;
     getState(deviceId: string): Promise<any>;
-    setState(deviceId: string, newState: any, auditProperties: IAuditProperties): Promise<void>;
+    setState(deviceId: string, newState: any, auditProperties: IAuditProperties, eventType?: string): Promise<void>;
     getStatus(deviceId: string): Promise<Record<string, any>>;
     setStatus(deviceId: string, newStatus: IStatus, source: Source, auditBody: IAuditProperties, reason?: string): Promise<void>;
     setStatusMany(query: IStatusQuery, newStatus: IStatus, source: Source, auditBody: IAuditProperties): Promise<void>;

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

@@ -50,6 +50,7 @@ const Alert_service_1 = require("../../../../alerts/Alert.service");
 const Issue_service_1 = require("../../../../issues/Issue.service");
 const config_1 = require("../../../../config/config");
 const typedi_2 = require("typedi");
+const constants_1 = require("../../../../constants");
 let LocalDeviceService = (() => {
     let _classDecorators = [(0, typedi_2.Service)()];
     let _classDescriptor;
@@ -119,7 +120,7 @@ let LocalDeviceService = (() => {
             }
             return await this.deviceRepository.getState(deviceId);
         }
-        async setState(deviceId, newState, auditProperties) {
+        async setState(deviceId, newState, auditProperties, eventType) {
             if (!deviceId || !newState) {
                 throw new Error("Device ID and new state are required");
             }
@@ -128,7 +129,7 @@ let LocalDeviceService = (() => {
             const changedKeys = Object.keys(newState).filter((key) => !(0, lodash_1.isEqual)(oldState[key], newState[key]));
             if (changedKeys.length > 0) {
                 await this.deviceRepository.setState(deviceId, newState);
-                return await this.eventHandler.onStateChange(deviceId, newState, auditProperties);
+                return await this.eventHandler.onStateChange(deviceId, newState, auditProperties, eventType);
             }
         }
         async getStatus(deviceId) {
@@ -158,16 +159,20 @@ let LocalDeviceService = (() => {
             else {
                 // For any other status, just update normally
                 await this.deviceRepository.setStatus(deviceId, newStatus);
-                await this.eventHandler.onStatusChange(deviceId, newStatus, auditBody);
+                await this.eventHandler.onStatusChange(deviceId, newStatus, auditBody, constants_1.DT_EVENT_TYPES.DEVICE.STATUS.UNKNOWN);
             }
         }
         async setStatusMany(query, newStatus, source, auditBody) {
+            //TODO: Compare old and new if different then update
             if (!query || !newStatus) {
                 throw new Error("Query and new status are required");
             }
             newStatus.lastUpdated = new Date().toISOString();
+            const eventType = newStatus.online
+                ? constants_1.DT_EVENT_TYPES.DEVICE.STATUS.ONLINE
+                : constants_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE;
             await this.deviceRepository.setStatusMany(query, newStatus);
-            await this.eventHandler.onStatusChangeMany(query, newStatus, auditBody);
+            await this.eventHandler.onStatusChangeMany(query, newStatus, auditBody, eventType);
         }
         async handleOfflineStatus(device, oldStatus, newStatus, source, auditBody, reason, currentTime) {
             const isExistingStatusOnline = oldStatus?.online === true;
@@ -183,7 +188,7 @@ let LocalDeviceService = (() => {
                     default: {},
                 };
                 await this.deviceRepository.setStatus(device.deviceId, newStatus);
-                await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
+                await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody, constants_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE);
             }
             else if (isExistingStatusOffline) {
                 // Existing status is Offline
@@ -202,7 +207,7 @@ let LocalDeviceService = (() => {
                         default: {},
                     };
                     await this.deviceRepository.setStatus(device.deviceId, newStatus);
-                    await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
+                    await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody, constants_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE);
                     // Raise alert (OPERATIONAL only)
                     await this.alertService.raiseDeviceOfflineAlert(device, source, reason);
                     // Raise issue when the device goes offline if longer than the baseline (OPERATIONAL only)
@@ -226,7 +231,7 @@ let LocalDeviceService = (() => {
                     newStatus.lastUpdated = currentTime;
                     newStatus.error = {}; // Clear the error
                     await this.deviceRepository.setStatus(device.deviceId, newStatus);
-                    await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
+                    await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody, constants_1.DT_EVENT_TYPES.DEVICE.STATUS.ONLINE);
                     //TODO: ALERT NEEDED?
                     //  Raise alert
                     await this.alertService.raiseDeviceOnlineAlert(device, source, reason);
@@ -239,7 +244,7 @@ let LocalDeviceService = (() => {
                 newStatus.lastUpdated = currentTime;
                 newStatus.error = undefined; // Clear the error
                 await this.deviceRepository.setStatus(device.deviceId, newStatus);
-                await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
+                await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody, constants_1.DT_EVENT_TYPES.DEVICE.STATUS.ONLINE);
                 //TODO: ALERT NEEDED?
                 //  Raise alert
                 await this.alertService.raiseDeviceOnlineAlert(device, source, reason);

package/dist/entities/property/Property.repository.js

@@ -91,7 +91,6 @@ let PropertyRepository = (() => {
                 return properties.rows.map((property) => property.id);
             }
             catch (error) {
-                console.log(error);
                 throw new Error("Failed to get all properties");
             }
         }

package/dist/events/BaseEventHandler.d.ts

@@ -20,7 +20,7 @@ export declare abstract class BaseEventHandler implements IEventHandler {
      * Handle multiple events - default implementation processes them sequentially
      */
     handleEvents(events: DeviceEvent[]): Promise<void>;
-    onStateChange(deviceId: string, state: Record<string, any>, event: DeviceEvent, auditProperties: IAuditProperties): Promise<void>;
+    onStateChange(deviceId: string, state: Record<string, any>, event: DeviceEvent, auditProperties: IAuditProperties, eventType?: string): Promise<void>;
     /**
      * Check if this handler can process the given event type
      */

package/dist/events/BaseEventHandler.js

@@ -66,9 +66,9 @@ class BaseEventHandler {
         }
     }
     // TODO: Check AuditBody for this function
-    async onStateChange(deviceId, state, event, auditProperties) {
+    async onStateChange(deviceId, state, event, auditProperties, eventType) {
         try {
-            await this.localDeviceService.setState(deviceId, state, auditProperties);
+            await this.localDeviceService.setState(deviceId, state, auditProperties, eventType);
             await this.afterEvent(event);
         }
         catch (error) {

package/dist/events/DeviceEventHandler.js

@@ -89,12 +89,12 @@ let DeviceEventHandler = (() => {
             super([
                 Event_1.DT_EVENT_TYPES.DEVICE.STATUS.ONLINE,
                 Event_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE,
-                Event_1.DT_EVENT_TYPES.DEVICE.STATUS.CHANGED,
-                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CRITICAL,
-                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LOW,
-                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED,
-                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.UPDATED,
-                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.UNKNOWN,
+                Event_1.DT_EVENT_TYPES.DEVICE.STATUS.UNKNOWN,
+                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.REPLACED,
+                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.UNKNOWN,
+                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.LOW,
+                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.CRITICAL,
+                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.UPDATED,
             ], 100);
             // Use dependency injection instead of creating new instance
             this.localHubService = typedi_1.default.get(services_1.LocalHubService);
@@ -141,7 +141,7 @@ let DeviceEventHandler = (() => {
                         source: constants_1.Source.CLOUD_EVENT,
                     });
                     break;
-                case Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED:
+                case Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.UPDATED:
                     await this.localDeviceService.setBatteryLevel(deviceData.deviceId, event?.data?.batteryLevel ?? 0, constants_1.Source.CLOUD_EVENT, {
                         deviceId: deviceData.deviceId,
                         deviceName: deviceData.name,

package/dist/events/EventHandler.d.ts

@@ -1,15 +1,13 @@
 import { IAuditProperties } from "../audit/IAuditProperties";
-import { IStatus, IStatusQuery } from "../entities/device/local/interfaces";
+import { IDevice, IStatus, IStatusQuery } from "../entities/device/local/interfaces";
 export declare class EventHandler {
-    private readonly source;
-    private readonly auditUtils;
     constructor();
-    onDeviceCreate(body: any): Promise<void>;
+    onDeviceCreate(body: IDevice): Promise<void>;
     onDeviceUpdate(deviceId: string, body: any, auditBody: IAuditProperties): Promise<void>;
     onDeviceDelete(deviceId: string, auditBody: IAuditProperties): Promise<void>;
-    onStateChange(deviceId: string, state: any, auditProperties: IAuditProperties): Promise<void>;
-    onStatusChange(deviceId: string, status: any, auditProperties: IAuditProperties): Promise<void>;
-    onStatusChangeMany(query: IStatusQuery, status: IStatus, auditProperties: IAuditProperties): Promise<void>;
+    onStateChange(deviceId: string, state: any, auditProperties: IAuditProperties, eventType?: any): Promise<void>;
+    onStatusChange(deviceId: string, status: any, auditProperties: IAuditProperties, eventType: any): Promise<void>;
+    onStatusChangeMany(query: IStatusQuery, status: IStatus, auditProperties: IAuditProperties, eventType: any): Promise<void>;
     onBatteryLevelChange(deviceId: string, batteryLevel: number, auditProperties: IAuditProperties): Promise<void>;
     onDeviceMetaChange(deviceId: string, metaData: Record<string, any>, auditProperties: IAuditProperties): Promise<void>;
 }

package/dist/events/EventHandler.js

@@ -1,20 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
     function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
     var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
@@ -49,33 +33,17 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
     if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventHandler = void 0;
-const dt_audit_library_1 = require("dt-audit-library");
 const Event_1 = require("../constants/Event");
-const typedi_1 = __importStar(require("typedi"));
-const AuditUtils_1 = require("../audit/AuditUtils");
+const typedi_1 = require("typedi");
+const IAuditProperties_1 = require("../audit/IAuditProperties");
+const audit_1 = require("../audit");
+const constants_1 = require("../constants");
 // TODO: For all the Event handlers, we need to publish the respective events for External Consumption
 let EventHandler = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
@@ -83,92 +51,156 @@ let EventHandler = (() => {
     let _classExtraInitializers = [];
     let _classThis;
     var EventHandler = _classThis = class {
-        constructor() {
-            this.source = "dt-common-device";
-            this.auditUtils = typedi_1.default.get(AuditUtils_1.AuditUtils);
-        }
+        constructor() { }
         async onDeviceCreate(body) {
-            const payload = {
-                eventType: Event_1.DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS,
-                properties: await this.auditUtils.buildAuditProperties(body),
-            };
-            await (0, dt_audit_library_1.publishAudit)(payload);
+            await (0, audit_1.pushAudit)({
+                auditType: Event_1.DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS,
+                auditData: {
+                    deviceId: body.deviceId,
+                    deviceName: body.name,
+                    propertyId: body.propertyId,
+                    zoneId: body.zoneId,
+                    source: constants_1.Source.USER,
+                    resource: IAuditProperties_1.Resource.DEVICE,
+                    actionPayload: body,
+                },
+            });
+            // const payload = {
+            //   eventType: DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS,
+            //   properties: await this.auditUtils.buildAuditProperties(body),
+            // };
+            // await publishAudit(payload);
         }
         async onDeviceUpdate(deviceId, body, auditBody) {
-            const payload = {
-                eventType: Event_1.DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS,
-                properties: await this.auditUtils.buildAuditProperties({
-                    ...auditBody,
+            await (0, audit_1.pushAudit)({
+                auditType: Event_1.DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS,
+                auditData: {
                     deviceId,
-                    ...body,
-                }),
-            };
-            await (0, dt_audit_library_1.publishAudit)(payload);
+                    body,
+                    ...auditBody,
+                },
+            });
+            // const payload = {
+            //   eventType: DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS,
+            //   properties: await this.auditUtils.buildAuditProperties({
+            //     ...auditBody,
+            //     deviceId,
+            //     ...body,
+            //   }),
+            // };
+            // await publishAudit(payload);
         }
         async onDeviceDelete(deviceId, auditBody) {
-            const payload = {
-                eventType: Event_1.DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS,
-                properties: await this.auditUtils.buildAuditProperties({
-                    ...auditBody,
+            await (0, audit_1.pushAudit)({
+                auditType: Event_1.DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS,
+                auditData: {
                     deviceId,
-                }),
-            };
-            await (0, dt_audit_library_1.publishAudit)(payload);
+                    ...auditBody,
+                },
+            });
+            // const payload = {
+            //   eventType: DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS,
+            //   properties: await this.auditUtils.buildAuditProperties({
+            //     ...auditBody,
+            //     deviceId,
+            //   }),
+            // };
+            // await publishAudit(payload);
         }
-        async onStateChange(deviceId, state, auditProperties) {
-            const payload = {
-                eventType: Event_1.DT_EVENT_TYPES.DEVICE.STATE.SET,
-                properties: await this.auditUtils.buildAuditProperties({
-                    ...auditProperties,
+        async onStateChange(deviceId, state, auditProperties, eventType) {
+            await (0, audit_1.pushAudit)({
+                auditType: eventType || Event_1.DT_EVENT_TYPES.DEVICE.STATE.CHANGED,
+                auditData: {
                     deviceId,
-                    ...state,
-                }),
-            };
-            await (0, dt_audit_library_1.publishAudit)(payload);
-        }
-        async onStatusChange(deviceId, status, auditProperties) {
-            const payload = {
-                eventType: Event_1.DT_EVENT_TYPES.DEVICE.STATUS.SET,
-                properties: await this.auditUtils.buildAuditProperties({
+                    state,
                     ...auditProperties,
+                },
+            });
+            // const payload = {
+            //   eventType: eventType || DT_EVENT_TYPES.DEVICE.STATE.CHANGED,
+            //   properties: await this.auditUtils.buildAuditProperties({
+            //     ...auditProperties,
+            //     deviceId,
+            //     ...state,
+            //   }),
+            // };
+            // await publishAudit(payload);
+        }
+        async onStatusChange(deviceId, status, auditProperties, eventType) {
+            await (0, audit_1.pushAudit)({
+                auditType: eventType,
+                auditData: {
                     deviceId,
-                    ...status,
-                }),
-            };
-            await (0, dt_audit_library_1.publishAudit)(payload);
+                    status,
+                    ...auditProperties,
+                },
+            });
+            // const payload = {
+            //   eventType: eventType || DT_EVENT_TYPES.DEVICE.STATUS.CHANGED,
+            //   properties: await this.auditUtils.buildAuditProperties({
+            //     ...auditProperties,
+            //     deviceId,
+            //     ...status,
+            //   }),
+            // };
+            // await publishAudit(payload);
         }
-        async onStatusChangeMany(query, status, auditProperties) {
-            const payload = {
-                eventType: Event_1.DT_EVENT_TYPES.DEVICE.STATUS.UPDATED,
-                properties: await this.auditUtils.buildAuditProperties({
+        async onStatusChangeMany(query, status, auditProperties, eventType) {
+            await (0, audit_1.pushAudit)({
+                auditType: eventType,
+                auditData: {
+                    status,
+                    query,
                     ...auditProperties,
-                    ...query,
-                    ...status,
-                }),
-            };
-            await (0, dt_audit_library_1.publishAudit)(payload);
+                },
+            });
+            // const payload = {
+            //   eventType: eventType || DT_EVENT_TYPES.DEVICE.STATUS.UPDATED,
+            //   properties: await this.auditUtils.buildAuditProperties({
+            //     ...auditProperties,
+            //     ...query,
+            //     ...status,
+            //   }),
+            // };
+            // await publishAudit(payload);
         }
         async onBatteryLevelChange(deviceId, batteryLevel, auditProperties) {
-            const payload = {
-                eventType: Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.SET,
-                properties: await this.auditUtils.buildAuditProperties({
-                    ...auditProperties,
+            await (0, audit_1.pushAudit)({
+                auditType: Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.UPDATED,
+                auditData: {
                     deviceId,
                     batteryLevel,
-                }),
-            };
-            await (0, dt_audit_library_1.publishAudit)(payload);
+                    ...auditProperties,
+                },
+            });
+            // const payload = {
+            //   eventType: DT_EVENT_TYPES.DEVICE.BATTERY_LEVEL.UPDATED,
+            //   properties: await this.auditUtils.buildAuditProperties({
+            //     ...auditProperties,
+            //     deviceId,
+            //     batteryLevel,
+            //   }),
+            // };
+            // await publishAudit(payload);
         }
         async onDeviceMetaChange(deviceId, metaData, auditProperties) {
-            const payload = {
-                eventType: Event_1.DT_EVENT_TYPES.DEVICE.META_DATA.SET,
-                properties: await this.auditUtils.buildAuditProperties({
-                    ...auditProperties,
+            await (0, audit_1.pushAudit)({
+                auditType: Event_1.DT_EVENT_TYPES.DEVICE.METADATA.UPDATED,
+                auditData: {
                     deviceId,
                     metaData,
-                }),
-            };
-            await (0, dt_audit_library_1.publishAudit)(payload);
+                    ...auditProperties,
+                },
+            });
+            // const payload = {
+            //   eventType: DT_EVENT_TYPES.DEVICE.METADATA.UPDATED,
+            //   properties: await this.auditUtils.buildAuditProperties({
+            //     ...auditProperties,
+            //     deviceId,
+            //     metaData,
+            //   }),
+            // };
+            // await publishAudit(payload);
         }
     };
     __setFunctionName(_classThis, "EventHandler");

package/dist/issues/Issue.model.d.ts

@@ -18,7 +18,7 @@ interface IIssueModel extends Model<IIssueDocument, {}, IIssueMethods> {
     findOverdue(includeDeleted?: boolean): Promise<IIssueDocument[]>;
     findUpcoming(days?: number, includeDeleted?: boolean): Promise<IIssueDocument[]>;
 }
-declare const IssueSchema: mongoose.Schema<IIssueDocument, IIssueModel, IIssueMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IIssueDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IIssueDocument>, {}> & Omit<mongoose.FlatRecord<IIssueDocument> & Required<{
+declare const IssueSchema: mongoose.Schema<IIssueDocument, IIssueModel, IIssueMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IIssueDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IIssueDocument>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & Omit<mongoose.FlatRecord<IIssueDocument> & Required<{
     _id: string;
 }> & {
     __v: number;

package/dist/utils/redis.utils.d.ts

@@ -64,5 +64,10 @@ export declare class RedisUtils {
      * @returns 1 if the expiration was set, 0 if the key does not exist
      */
     expire(key: string, seconds: number): Promise<any>;
+    /**
+     * Get all fields and values from a hash
+     * @param key - The key to get
+     * @returns The fields and values
+     */
     hgetAll(key: string): Promise<any>;
 }

package/dist/utils/redis.utils.js

@@ -168,6 +168,11 @@ let RedisUtils = (() => {
                 throw error;
             }
         }
+        /**
+         * Get all fields and values from a hash
+         * @param key - The key to get
+         * @returns The fields and values
+         */
         async hgetAll(key) {
             try {
                 return await this.client.hgetall(key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-common-device",
-  "version": "5.0.5",
+  "version": "5.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -49,7 +49,7 @@
     "dt-pub-sub": "^1.0.0",
     "ioredis": "5.6.1",
     "lodash": "^4.17.21",
-    "mongoose": "8.16.1",
+    "mongoose": "8.17.1",
     "pg": "8.16.3",
     "typedi": "0.10.0"
   }