dt-common-device 3.1.6 → 4.0.1

package/dist/device/local/events/Events.js

@@ -3,17 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DT_EVENT_TYPES = void 0;
 exports.DT_EVENT_TYPES = {
     DEVICE: {
-        CREATE: {
-            SUCCESS: "device.create.success",
-            FAILED: "device.create.failed",
-        },
-        UPDATE: {
-            SUCCESS: "device.update.success",
-            FAILED: "device.update.failed",
-        },
-        DELETE: {
-            SUCCESS: "device.delete.success",
-            FAILED: "device.delete.failed",
+        DEVICE: {
+            CREATED: "device.device.created",
+            UPDATED: "device.device.updated",
+            DELETED: "device.device.deleted",
         },
         STATE: {
             SET: "device.state.set",
@@ -44,31 +37,17 @@ exports.DT_EVENT_TYPES = {
         },
     },
     CONNECTION: {
-        CREATE: {
-            SUCCESS: "connection.create.success",
-            FAILED: "connection.create.failed",
-        },
-        UPDATE: {
-            SUCCESS: "connection.update.success",
-            FAILED: "connection.update.failed",
-        },
-        DELETE: {
-            SUCCESS: "connection.delete.success",
-            FAILED: "connection.delete.failed",
+        CONNECTION: {
+            CREATED: "connection.connection.created",
+            UPDATED: "connection.connection.updated",
+            DELETED: "connection.connection.deleted",
         },
     },
     PROPERTY: {
-        CREATE: {
-            SUCCESS: "property.create.success",
-            FAILED: "property.create.failed",
-        },
-        UPDATE: {
-            SUCCESS: "property.update.success",
-            FAILED: "property.update.failed",
-        },
-        DELETE: {
-            SUCCESS: "property.delete.success",
-            FAILED: "property.delete.failed",
+        PROPERTY: {
+            CREATED: "property.property.created",
+            UPDATED: "property.property.updated",
+            DELETED: "property.property.deleted",
         },
         PREFERENCES: {
             UPDATED: "property.preferences.updated",

package/dist/device/local/interface.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -1,5 +1,6 @@
 import { IDevice, IStatus } from "../interfaces";
 import { Source } from "../../../constants/Service";
+import { AuditProperties } from "../../../audit/AuditProperties";
 export declare class LocalDeviceService {
     private readonly eventHandler;
     private readonly deviceRepository;
@@ -12,21 +13,22 @@ export declare class LocalDeviceService {
     getDevices(deviceIds: string[], withHubDetails?: boolean): Promise<IDevice[]>;
     getPropertyDevices(propertyId: string, selectDeviceId?: boolean, type?: string, withHubDetails?: boolean): Promise<IDevice[]>;
     getPropertyDeviceIds(propertyId: string, selectDeviceId: boolean | undefined, type: string): Promise<any>;
-    updateDevice(deviceId: string, body: any): Promise<any>;
-    deleteDevice(deviceId: string): Promise<any>;
+    updateDevice(deviceId: string, body: any, auditBody: AuditProperties): Promise<any>;
+    deleteDevice(deviceId: string, auditBody: AuditProperties): Promise<any>;
     getState(deviceId: string): Promise<any>;
-    setState(deviceId: string, newState: any): Promise<void>;
+    setState(deviceId: string, newState: any, auditProperties: AuditProperties): Promise<void>;
     getStatus(deviceId: string): Promise<Record<string, any>>;
-    setStatus(deviceId: string, newStatus: IStatus, source: Source, reason?: string): Promise<void>;
+    setStatus(deviceId: string, newStatus: IStatus, source: Source, auditBody: AuditProperties, reason?: string): Promise<void>;
     private handleOfflineStatus;
     private handleOnlineStatus;
     private getDeviceBaseline;
     getBatteryLevel(deviceId: string): Promise<Record<string, any>>;
-    setBatteryLevel(deviceId: string, batteryLevel: number, source: Source): Promise<void>;
+    setBatteryLevel(deviceId: string, batteryLevel: number, source: Source, auditBody: AuditProperties): Promise<void>;
     private shouldUpdateBatteryLevel;
     private getPropertyBatteryThreshold;
+    private checkForDeviceMalfunctions;
     getMetaData(deviceId: string): Promise<any>;
-    setMetaData(deviceId: string, metaData: Record<string, any>): Promise<any>;
+    setMetaData(deviceId: string, metaData: Record<string, any>, auditBody: AuditProperties): Promise<any>;
     getDevicesByZone(zoneId: string): Promise<import("../interfaces").IDtDevice[]>;
     getDevicesByAccessGroup(accessGroupId: string): Promise<import("../interfaces").IDtDevice[]>;
     querySelect(query: any, fields: string[]): Promise<any>;

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

@@ -93,19 +93,19 @@ let LocalDeviceService = (() => {
             }
             return await this.deviceRepository.getPropertyDeviceIds(propertyId, selectDeviceId, type);
         }
-        async updateDevice(deviceId, body) {
+        async updateDevice(deviceId, body, auditBody) {
             if (!deviceId) {
                 throw new Error("Device ID is required");
             }
             await this.deviceRepository.updateDevice(deviceId, body);
-            return await this.eventHandler.onDeviceUpdate(deviceId, body);
+            return await this.eventHandler.onDeviceUpdate(deviceId, body, auditBody);
         }
-        async deleteDevice(deviceId) {
+        async deleteDevice(deviceId, auditBody) {
             if (!deviceId) {
                 throw new Error("Device ID is required");
             }
             await this.deviceRepository.deleteDevice(deviceId);
-            return await this.eventHandler.onDeviceDelete(deviceId);
+            return await this.eventHandler.onDeviceDelete(deviceId, auditBody);
         }
         async getState(deviceId) {
             if (!deviceId) {
@@ -113,7 +113,7 @@ let LocalDeviceService = (() => {
             }
             return await this.deviceRepository.getState(deviceId);
         }
-        async setState(deviceId, newState) {
+        async setState(deviceId, newState, auditProperties) {
             if (!deviceId || !newState) {
                 throw new Error("Device ID and new state are required");
             }
@@ -122,7 +122,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);
+                return await this.eventHandler.onStateChange(deviceId, newState, auditProperties);
             }
         }
         async getStatus(deviceId) {
@@ -131,7 +131,7 @@ let LocalDeviceService = (() => {
             }
             return await this.deviceRepository.getStatus(deviceId);
         }
-        async setStatus(deviceId, newStatus, source, reason) {
+        async setStatus(deviceId, newStatus, source, auditBody, reason) {
             if (!deviceId || !newStatus) {
                 throw new Error("Device ID and new status are required");
             }
@@ -143,19 +143,19 @@ let LocalDeviceService = (() => {
             const isNewStatusOffline = newStatus.liveStatus === "OFFLINE";
             if (isNewStatusOffline) {
                 // New Status = OFFLINE
-                await this.handleOfflineStatus(deviceId, device, oldStatus, newStatus, source, reason, currentTime);
+                await this.handleOfflineStatus(device, oldStatus, newStatus, source, auditBody, reason, currentTime);
             }
             else if (isNewStatusOnline) {
                 // New Status = ONLINE
-                await this.handleOnlineStatus(deviceId, device, oldStatus, newStatus, source, reason, currentTime);
+                await this.handleOnlineStatus(device, oldStatus, newStatus, source, auditBody, reason, currentTime);
             }
             else {
                 // For any other status, just update normally
                 await this.deviceRepository.setStatus(deviceId, newStatus);
-                await this.eventHandler.onStatusChange(deviceId, newStatus);
+                await this.eventHandler.onStatusChange(deviceId, newStatus, auditBody);
             }
         }
-        async handleOfflineStatus(deviceId, device, oldStatus, newStatus, source, reason, currentTime) {
+        async handleOfflineStatus(device, oldStatus, newStatus, source, auditBody, reason, currentTime) {
             const isExistingStatusOnline = oldStatus?.online === true;
             const isExistingStatusOffline = oldStatus?.online === false;
             if (isExistingStatusOnline) {
@@ -168,15 +168,15 @@ let LocalDeviceService = (() => {
                     message: reason || "Device went offline",
                     default: {},
                 };
-                await this.deviceRepository.setStatus(deviceId, newStatus);
-                await this.eventHandler.onStatusChange(deviceId, newStatus);
+                await this.deviceRepository.setStatus(device.deviceId, newStatus);
+                await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
             }
             else if (isExistingStatusOffline) {
                 // Existing status is Offline
                 const timeLapsed = oldStatus?.lastUpdated
                     ? Date.now() - new Date(oldStatus.lastUpdated).getTime()
                     : 0;
-                const baselineTime = await this.getDeviceBaseline(deviceId);
+                const baselineTime = await this.getDeviceBaseline(device.deviceId);
                 if (timeLapsed > baselineTime) {
                     // When the time lapsed is higher than the baseline time
                     newStatus.online = false;
@@ -187,16 +187,16 @@ let LocalDeviceService = (() => {
                         message: reason || "Device has been offline for longer than baseline",
                         default: {},
                     };
-                    await this.deviceRepository.setStatus(deviceId, newStatus);
-                    await this.eventHandler.onStatusChange(deviceId, newStatus);
-                    // Raise alert
+                    await this.deviceRepository.setStatus(device.deviceId, newStatus);
+                    await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
+                    // Raise alert (OPERATIONAL only)
                     await this.alertService.raiseDeviceOfflineAlert(device, source, reason);
-                    // Raise issue when the device goes offline if longer than the baseline
+                    // Raise issue when the device goes offline if longer than the baseline (OPERATIONAL only)
                     await this.issueService.createDeviceOfflineIssue(device, source, reason);
                 }
             }
         }
-        async handleOnlineStatus(deviceId, device, oldStatus, newStatus, source, reason, currentTime) {
+        async handleOnlineStatus(device, oldStatus, newStatus, source, auditBody, reason, currentTime) {
             const isExistingStatusOnline = oldStatus?.online === true;
             const isExistingStatusOffline = oldStatus?.online === false;
             if (isExistingStatusOnline) {
@@ -211,8 +211,8 @@ let LocalDeviceService = (() => {
                     newStatus.liveStatus = "ONLINE";
                     newStatus.lastUpdated = currentTime;
                     newStatus.error = {}; // Clear the error
-                    await this.deviceRepository.setStatus(deviceId, newStatus);
-                    await this.eventHandler.onStatusChange(deviceId, newStatus);
+                    await this.deviceRepository.setStatus(device.deviceId, newStatus);
+                    await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
                     //TODO: ALERT NEEDED?
                     //  Raise alert
                     await this.alertService.raiseDeviceOnlineAlert(device, source, reason);
@@ -224,8 +224,8 @@ let LocalDeviceService = (() => {
                 newStatus.liveStatus = "ONLINE";
                 newStatus.lastUpdated = currentTime;
                 newStatus.error = undefined; // Clear the error
-                await this.deviceRepository.setStatus(deviceId, newStatus);
-                await this.eventHandler.onStatusChange(deviceId, newStatus);
+                await this.deviceRepository.setStatus(device.deviceId, newStatus);
+                await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
                 //TODO: ALERT NEEDED?
                 //  Raise alert
                 await this.alertService.raiseDeviceOnlineAlert(device, source, reason);
@@ -244,7 +244,7 @@ let LocalDeviceService = (() => {
             }
             return await this.deviceRepository.getBatteryLevel(deviceId);
         }
-        async setBatteryLevel(deviceId, batteryLevel, source) {
+        async setBatteryLevel(deviceId, batteryLevel, source, auditBody) {
             if (!deviceId || batteryLevel === undefined || batteryLevel === null) {
                 throw new Error("Device ID and battery level are required");
             }
@@ -260,7 +260,7 @@ let LocalDeviceService = (() => {
                 if (shouldUpdate) {
                     // Save the battery level in the device
                     await this.deviceRepository.setBatteryLevel(deviceId, batteryLevel);
-                    await this.eventHandler.onBatteryLevelChange(deviceId, batteryLevel);
+                    await this.eventHandler.onBatteryLevelChange(deviceId, batteryLevel, auditBody);
                     // Get property threshold
                     const propertyThreshold = await this.getPropertyBatteryThreshold(device.propertyId);
                     // Check if battery level is below threshold
@@ -290,17 +290,39 @@ let LocalDeviceService = (() => {
             // In a real implementation, this would fetch from property configuration or settings
             return 20; // 20% default threshold
         }
+        async checkForDeviceMalfunctions(device, source, reason) {
+            // TODO: Implement device malfunction detection logic
+            // This should check for:
+            // - Lock jammed
+            // - Device not accepting codes
+            // - Other malfunction indicators
+            // For now, we'll check if the reason indicates a malfunction
+            const malfunctionIndicators = [
+                "jammed",
+                "not accepting codes",
+                "malfunction",
+                "error",
+                "failure",
+            ];
+            const hasMalfunction = malfunctionIndicators.some((indicator) => reason?.toLowerCase().includes(indicator));
+            if (hasMalfunction) {
+                // Raise alert for device malfunction (READINESS + OPERATIONAL)
+                await this.alertService.raiseDeviceIssueAlert(device, "Device Malfunction Detected", source, reason);
+                // Raise issue for device malfunction (READINESS + OPERATIONAL)
+                await this.issueService.createDeviceMalfunctionIssue(device, "Device Malfunction", source, reason);
+            }
+        }
         async getMetaData(deviceId) {
             if (!deviceId) {
                 throw new Error("Device ID is required");
             }
             return await this.deviceRepository.getMetaData(deviceId);
         }
-        async setMetaData(deviceId, metaData) {
+        async setMetaData(deviceId, metaData, auditBody) {
             if (!deviceId || !metaData) {
                 throw new Error("Device ID and meta data are required");
             }
-            await this.eventHandler.onDeviceMetaChange(deviceId, metaData);
+            await this.eventHandler.onDeviceMetaChange(deviceId, metaData, auditBody);
             return await this.deviceRepository.setMetaData(deviceId, metaData);
         }
         async getDevicesByZone(zoneId) {

package/dist/device/local/services/DeviceHub.service.d.ts

@@ -0,0 +1,11 @@
+import { IHubCreateParams } from "../interfaces";
+export declare class DeviceHubService {
+    private readonly baseUrl;
+    constructor();
+    addHub(body: IHubCreateParams): Promise<any>;
+    getHubs(hubIds: string[]): Promise<any>;
+    getHub(hubId: string): Promise<any>;
+    updateHub(hubId: string, body: any): Promise<any>;
+    deleteHub(hubId: string): Promise<any>;
+    deleteAllHubs(hubIds: string[]): Promise<any>;
+}

package/dist/device/local/services/DeviceHub.service.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceHubService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../../../config/config");
+class DeviceHubService {
+    constructor() {
+        const { DEVICE_SERVICE } = (0, config_1.getConfig)();
+        if (!DEVICE_SERVICE) {
+            throw new Error("DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE.");
+        }
+        this.baseUrl = DEVICE_SERVICE;
+    }
+    async addHub(body) {
+        return await axios_1.default.post(`${this.baseUrl}/devices/hubs`, body);
+    }
+    //get hubs takes an array of hub ids as query params
+    async getHubs(hubIds) {
+        const query = hubIds && hubIds.length ? `?ids=${hubIds.join(",")}` : "";
+        return await axios_1.default.get(`${this.baseUrl}/devices/hubs${query}`);
+    }
+    //get hub takes a hub id in params
+    async getHub(hubId) {
+        return await axios_1.default.get(`${this.baseUrl}/devices/hubs/${hubId}`);
+    }
+    async updateHub(hubId, body) {
+        return await axios_1.default.put(`${this.baseUrl}/devices/hubs/${hubId}`, body);
+    }
+    async deleteHub(hubId) {
+        return await axios_1.default.delete(`${this.baseUrl}/devices/hubs/${hubId}`);
+    }
+    async deleteAllHubs(hubIds) {
+        const query = hubIds.length ? `?ids=${hubIds.join(",")}` : "";
+        return await axios_1.default.delete(`${this.baseUrl}/devices/hubs${query}`);
+    }
+}
+exports.DeviceHubService = DeviceHubService;

package/dist/events/BaseEventHandler.d.ts

@@ -2,6 +2,7 @@ import { DeviceEvent } from "./interfaces/DeviceEvent";
 import { IEventHandler } from "./interfaces/IEventHandler";
 import { ILogger } from "../config/config.types";
 import { LocalDeviceService } from "../device/local/services/Device.service";
+import { AuditProperties } from "../audit/AuditProperties";
 export declare abstract class BaseEventHandler implements IEventHandler {
     protected readonly supportedEventTypes: string[];
     protected readonly priority: number;
@@ -19,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): Promise<void>;
+    onStateChange(deviceId: string, state: Record<string, any>, event: DeviceEvent, auditProperties: AuditProperties): Promise<void>;
     /**
      * Check if this handler can process the given event type
      */

package/dist/events/BaseEventHandler.js

@@ -65,9 +65,10 @@ class BaseEventHandler {
             this.logger.error(`${this.constructor.name}: handleEvents Error`, error);
         }
     }
-    async onStateChange(deviceId, state, event) {
+    // TODO: Check AuditBody for this function
+    async onStateChange(deviceId, state, event, auditProperties) {
         try {
-            await this.localDeviceService.setState(deviceId, state);
+            await this.localDeviceService.setState(deviceId, state, auditProperties);
             await this.afterEvent(event);
         }
         catch (error) {

package/dist/events/BaseEventTransformer.d.ts

@@ -10,7 +10,7 @@ export declare abstract class BaseEventTransformer implements IEventTransformer
     /**
      * Transform parsed data into DeviceEvent format - to be implemented by device-specific transformers
      */
-    abstract transform(parsedData: any): DeviceEvent | DeviceEvent[];
+    abstract transform(parsedData: any): Promise<DeviceEvent | DeviceEvent[]>;
     /**
      * Validate transformed event - default implementation, can be overridden
      */
@@ -22,5 +22,5 @@ export declare abstract class BaseEventTransformer implements IEventTransformer
     /**
      * Execute the full transformation pipeline
      */
-    executeTransformation(): DeviceEvent[];
+    executeTransformation(): Promise<DeviceEvent[]>;
 }

package/dist/events/BaseEventTransformer.js

@@ -46,13 +46,13 @@ class BaseEventTransformer {
     /**
      * Execute the full transformation pipeline
      */
-    executeTransformation() {
+    async executeTransformation() {
         try {
             this.logger.info(`Starting transformation for device type: ${this.deviceType}`);
             // Step 1: Parse the raw data
             const parsedData = this.parseData(this.rawData);
             // Step 2: Transform to DeviceEvent format
-            const transformedResult = this.transform(parsedData);
+            const transformedResult = await this.transform(parsedData);
             // Step 3: Convert to array format
             // TODO: Check if any service sends multiple events
             const events = Array.isArray(transformedResult)

package/dist/events/DeviceEventHandler.d.ts

@@ -1,15 +1,10 @@
 import { IDevice } from "../device/local/interfaces";
 import { BaseEventHandler } from "./BaseEventHandler";
-import { DeviceEvent, DeviceEventEntity, EventConstructionOptions } from "./interfaces/DeviceEvent";
+import { DeviceEvent } from "./interfaces/DeviceEvent";
 export declare class DeviceEventHandler extends BaseEventHandler {
     private readonly localHubService;
     constructor();
     onEvent(event: DeviceEvent): Promise<void>;
     updateDeviceEventData(deviceData: IDevice, event: DeviceEvent): Promise<void>;
     extractHubDetails(device: IDevice): Promise<any[]>;
-    constructDeviceEventEntity(eventData: any, device: IDevice, hubDetails: any[], options?: EventConstructionOptions): DeviceEventEntity;
-    dumpToEventOperation(data: any, device: IDevice): Promise<void>;
-    updateTablesBasedOnEventType(eventData: any, device: IDevice): Promise<void>;
-    updateDeviceStatus(data: any, device: IDevice): Promise<void>;
-    updateDeviceBattery(data: any, device: IDevice): Promise<void>;
 }

package/dist/events/DeviceEventHandler.js

@@ -92,6 +92,8 @@ let DeviceEventHandler = (() => {
                 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,
             ], 100);
             // Use dependency injection instead of creating new instance
             this.localHubService = typedi_1.default.get(services_1.LocalHubService);
@@ -106,13 +108,9 @@ let DeviceEventHandler = (() => {
                     throw new Error("[DT | CDL]:[DeviceEventHandler]: deviceId does not exist");
                 }
                 await this.updateDeviceEventData(device, event);
-                // Update relevant tables based on event type
-                await this.updateTablesBasedOnEventType(event, device);
-                // Save event logs
-                await this.dumpToEventOperation(event, device);
             }
             catch (error) {
-                this.logger.error("[DT | CDL]:[DeviceEventHandler]: Error processing event", error);
+                this.logger.error(`[DT | CDL]:[DeviceEventHandler]: Error processing event: ${event.eventName} ERROR: ${error}`);
                 throw error;
             }
         }
@@ -134,10 +132,20 @@ let DeviceEventHandler = (() => {
                                 default: {},
                             },
                         },
+                    }, {
+                        deviceId: deviceData.deviceId,
+                        deviceName: deviceData.name,
+                        propertyId: deviceData.propertyId,
+                        resource: "device",
                     });
                     break;
                 case Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED:
-                    await this.localDeviceService.setBatteryLevel(deviceData.deviceId, event?.data?.batteryLevel ?? 0, constants_1.Source.CLOUD_EVENT);
+                    await this.localDeviceService.setBatteryLevel(deviceData.deviceId, event?.data?.batteryLevel ?? 0, constants_1.Source.CLOUD_EVENT, {
+                        deviceId: deviceData.deviceId,
+                        deviceName: deviceData.name,
+                        propertyId: deviceData.propertyId,
+                        resource: "device",
+                    });
                     break;
             }
         }
@@ -159,75 +167,6 @@ let DeviceEventHandler = (() => {
             }
             return hubDetails;
         }
-        constructDeviceEventEntity(eventData, device, hubDetails, options = {}) {
-            return {
-                event: {
-                    eventId: options.eventId || eventData?.eventId || "",
-                    eventName: options.eventName || eventData?.eventName || "",
-                    status: options.status || eventData?.status || "",
-                    mode: options.mode || eventData?.data?.mode,
-                    userName: options.userName || eventData?.userName || "",
-                    userId: options.userId || eventData?.userId || "",
-                    userType: options.userType || eventData?.userType || "",
-                    raw_event: options.rawEvent || eventData?.rawData || {},
-                    batteryLevel: options.batteryLevel || eventData?.data?.batteryLevel || "",
-                    reason: options.reason || eventData?.data?.reason || "",
-                    eventDescription: options.eventDescription || eventData?.event || "",
-                },
-                device: {
-                    id: eventData?.deviceId || "",
-                    name: device?.name || "",
-                    type: device?.deviceType?.type || "",
-                    brand: device?.specifications?.manufacturer || "",
-                    model: device?.specifications?.model || "",
-                },
-                hub: hubDetails,
-                property: {
-                    id: eventData?.property?.id || "",
-                    name: eventData?.property?.name || "",
-                    location: eventData?.property?.apartment || "",
-                },
-            };
-        }
-        async dumpToEventOperation(data, device) {
-            try {
-                const hubDetails = await this.extractHubDetails(device);
-                const eventData = this.constructDeviceEventEntity(data, device, hubDetails, {
-                    status: data.eventName === "lock.unlock" ? "UNLOCKED" : "LOCKED",
-                    rawEvent: data.rawData,
-                });
-                this.logger.info("[DT | CDL]:[DeviceEventHandler]: Event data dumped to event operation", { eventData });
-            }
-            catch (error) {
-                this.logger.error("[DT | CDL]:[DeviceEventHandler]: Error dumping to event operation", error);
-            }
-        }
-        async updateTablesBasedOnEventType(eventData, device) {
-            switch (eventData.eventName) {
-                case Event_1.DT_EVENT_TYPES.DEVICE.STATUS.ONLINE:
-                case Event_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE:
-                case Event_1.DT_EVENT_TYPES.DEVICE.STATUS.CHANGED:
-                    this.updateDeviceStatus(eventData, device);
-                    break;
-                case Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED:
-                case Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CRITICAL:
-                case Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LOW:
-                    this.updateDeviceBattery(eventData, device);
-                    break;
-            }
-        }
-        async updateDeviceStatus(data, device) {
-            this.logger.info("[DT | CDL]:[DeviceEventHandler]: Updating device status", {
-                data,
-                device,
-            });
-        }
-        async updateDeviceBattery(data, device) {
-            this.logger.info("[DT | CDL]:[DeviceEventHandler]: Updating device battery", {
-                data,
-                device,
-            });
-        }
     };
     __setFunctionName(_classThis, "DeviceEventHandler");
     (() => {

package/dist/events/DeviceEventTransformerFactory.js

@@ -72,10 +72,10 @@ let DeviceEventTransformerFactory = (() => {
                     // Default validation - always return true
                     return true;
                 }
-                executeTransformation() {
+                async executeTransformation() {
                     try {
                         const parsedData = this.parseData(this.rawData);
-                        const transformedResult = this.transform(parsedData);
+                        const transformedResult = await this.transform(parsedData);
                         const events = Array.isArray(transformedResult) ? transformedResult : [transformedResult];
                         return events.filter((event) => this.validate(event));
                     }

package/dist/events/EventHandler.d.ts

@@ -1,11 +1,12 @@
+import { AuditProperties } from "../audit/AuditProperties";
 export declare class EventHandler {
     private readonly source;
     constructor();
     onDeviceCreate(body: any): Promise<void>;
-    onDeviceUpdate(deviceId: string, body: any): Promise<void>;
-    onDeviceDelete(deviceId: string): Promise<void>;
-    onStateChange(deviceId: string, state: any): Promise<void>;
-    onStatusChange(deviceId: string, status: any): Promise<void>;
-    onBatteryLevelChange(deviceId: string, batteryLevel: number): Promise<void>;
-    onDeviceMetaChange(deviceId: string, metaData: Record<string, any>): Promise<void>;
+    onDeviceUpdate(deviceId: string, body: any, auditBody: AuditProperties): Promise<void>;
+    onDeviceDelete(deviceId: string, auditBody: AuditProperties): Promise<void>;
+    onStateChange(deviceId: string, state: any, auditProperties: AuditProperties): Promise<void>;
+    onStatusChange(deviceId: string, status: any, auditProperties: AuditProperties): Promise<void>;
+    onBatteryLevelChange(deviceId: string, batteryLevel: number, auditProperties: AuditProperties): Promise<void>;
+    onDeviceMetaChange(deviceId: string, metaData: Record<string, any>, auditProperties: AuditProperties): Promise<void>;
 }