dt-common-device 3.1.5 → 4.0.0

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

@@ -32,17 +32,21 @@ export declare class AlertService {
      */
     raiseHubAlert(hubId: string, propertyId: string, title: string, description: string, category?: AlertCategory | AlertCategory[], severity?: AlertSeverity, createdBy?: string): Promise<IAlertDocument>;
     /**
-     * Raise alert for device going offline
+     * Raise alert for device going offline (OPERATIONAL only)
      */
     raiseDeviceOfflineAlert(device: IDevice, source: Source, reason?: string): Promise<IAlertDocument>;
     /**
-     * Raise alert for device coming online
+     * Raise alert for device coming online (OPERATIONAL only)
      */
     raiseDeviceOnlineAlert(device: IDevice, source: Source, reason?: string): Promise<IAlertDocument>;
     /**
-     * Raise alert for device battery level below threshold
+     * Raise alert for device battery level below threshold (READINESS + OPERATIONAL + ENERGY)
      */
     raiseDeviceBatteryAlert(device: IDevice, batteryLevel: number, threshold: number, source: Source): Promise<IAlertDocument>;
+    /**
+     * Raise alert for device issue (jammed or malfunctioned) (READINESS + OPERATIONAL)
+     */
+    raiseDeviceIssueAlert(device: IDevice, issueType: string, source: Source, reason?: string): Promise<IAlertDocument>;
     /**
      * Create a new alert with business logic validation
      * Accepts either a CreateAlertData object or an AlertBuilder instance

package/dist/alerts/Alert.service.js

@@ -147,22 +147,28 @@ let AlertService = (() => {
             return await this.createAlert(alertBuilder);
         }
         /**
-         * Raise alert for device going offline
+         * Raise alert for device going offline (OPERATIONAL only)
          */
         async raiseDeviceOfflineAlert(device, source, reason) {
             return await this.raiseDeviceAlert(device.deviceId, device.propertyId, "Device Offline", `Device ${device.name} (${device.deviceId}) has gone offline. ${reason ? `Reason: ${reason}` : ""}`, [alert_types_1.AlertCategory.OPERATIONS], alert_types_1.AlertSeverity.HIGH, source);
         }
         /**
-         * Raise alert for device coming online
+         * Raise alert for device coming online (OPERATIONAL only)
          */
         async raiseDeviceOnlineAlert(device, source, reason) {
             return await this.raiseDeviceAlert(device.deviceId, device.propertyId, "Device Online", `Device ${device.name} (${device.deviceId}) is now online. ${reason ? `Reason: ${reason}` : ""}`, [alert_types_1.AlertCategory.OPERATIONS], alert_types_1.AlertSeverity.INFO, source);
         }
         /**
-         * Raise alert for device battery level below threshold
+         * Raise alert for device battery level below threshold (READINESS + OPERATIONAL + ENERGY)
          */
         async raiseDeviceBatteryAlert(device, batteryLevel, threshold, source) {
-            return await this.raiseDeviceAlert(device.deviceId, device.propertyId, "Device Battery Low", `Device ${device.name} (${device.deviceId}) battery level is ${batteryLevel}%, which is below the property threshold of ${threshold}%.`, [alert_types_1.AlertCategory.ENERGY], alert_types_1.AlertSeverity.MEDIUM, source);
+            return await this.raiseDeviceAlert(device.deviceId, device.propertyId, "Device Battery Low", `Device ${device.name} (${device.deviceId}) battery level is ${batteryLevel}%, which is below the property threshold of ${threshold}%.`, [alert_types_1.AlertCategory.READINESS, alert_types_1.AlertCategory.OPERATIONS, alert_types_1.AlertCategory.ENERGY], alert_types_1.AlertSeverity.MEDIUM, source);
+        }
+        /**
+         * Raise alert for device issue (jammed or malfunctioned) (READINESS + OPERATIONAL)
+         */
+        async raiseDeviceIssueAlert(device, issueType, source, reason) {
+            return await this.raiseDeviceAlert(device.deviceId, device.propertyId, `Device Issue - ${issueType}`, `Device ${device.name} (${device.deviceId}) has an issue: ${issueType}. ${reason ? `Reason: ${reason}` : ""}`, [alert_types_1.AlertCategory.READINESS, alert_types_1.AlertCategory.OPERATIONS], alert_types_1.AlertSeverity.HIGH, source);
         }
         /**
          * Create a new alert with business logic validation

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/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>;
 }

package/dist/events/EventHandler.js

@@ -39,10 +39,11 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventHandler = void 0;
-const dt_pub_sub_1 = require("dt-pub-sub");
 const dt_audit_library_1 = require("dt-audit-library");
 const Event_1 = require("../constants/Event");
 const typedi_1 = require("typedi");
+const AuditUtils_1 = require("../audit/AuditUtils");
+// TODO: For all the Event handlers, we need to publish the respective events for External Consumption
 let EventHandler = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;
@@ -53,101 +54,55 @@ let EventHandler = (() => {
             this.source = "dt-common-device";
         }
         async onDeviceCreate(body) {
-            // TODO: For Future Consumption
-            // await eventDispatcher.publishEvent(
-            //   DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS,
-            //   body,
-            //   this.source
-            // );
             const payload = {
                 eventType: Event_1.DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS,
-                properties: {
-                    ...body,
-                },
+                properties: (0, AuditUtils_1.buildAuditProperties)(body),
             };
             await (0, dt_audit_library_1.publishAudit)(payload);
         }
-        async onDeviceUpdate(deviceId, body) {
-            await dt_pub_sub_1.eventDispatcher.publishEvent(Event_1.DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS, { deviceId, body }, this.source);
+        async onDeviceUpdate(deviceId, body, auditBody) {
             const payload = {
                 eventType: Event_1.DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS,
-                properties: {
-                    ...body,
-                },
+                properties: (0, AuditUtils_1.buildAuditProperties)({ ...auditBody, deviceId, ...body }),
             };
             await (0, dt_audit_library_1.publishAudit)(payload);
         }
-        async onDeviceDelete(deviceId) {
-            await dt_pub_sub_1.eventDispatcher.publishEvent(Event_1.DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS, { deviceId }, this.source);
+        async onDeviceDelete(deviceId, auditBody) {
             const payload = {
                 eventType: Event_1.DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS,
-                properties: {
-                    deviceId,
-                },
+                properties: (0, AuditUtils_1.buildAuditProperties)({ ...auditBody, deviceId }),
             };
             await (0, dt_audit_library_1.publishAudit)(payload);
         }
-        async onStateChange(deviceId, state) {
-            // TODO: For Future Consumption
-            /* await eventDispatcher.publishEvent(
-              DT_EVENT_TYPES.DEVICE.STATE.SET,
-              { deviceId, state },
-              this.source
-            ); */
+        async onStateChange(deviceId, state, auditProperties) {
             const payload = {
                 eventType: Event_1.DT_EVENT_TYPES.DEVICE.STATE.SET,
-                properties: {
-                    deviceId,
-                    state,
-                },
+                properties: (0, AuditUtils_1.buildAuditProperties)({ ...auditProperties, deviceId, ...state }),
             };
             await (0, dt_audit_library_1.publishAudit)(payload);
         }
-        async onStatusChange(deviceId, status) {
-            // TODO: For Future Consumption
-            /* await eventDispatcher.publishEvent(
-              DT_EVENT_TYPES.DEVICE.STATUS.SET,
-              { deviceId, status },
-              this.source
-            ); */
+        async onStatusChange(deviceId, status, auditProperties) {
             const payload = {
                 eventType: Event_1.DT_EVENT_TYPES.DEVICE.STATUS.SET,
-                properties: {
-                    deviceId,
-                    status,
-                },
+                properties: (0, AuditUtils_1.buildAuditProperties)({ ...auditProperties, deviceId, ...status }),
             };
             await (0, dt_audit_library_1.publishAudit)(payload);
         }
-        async onBatteryLevelChange(deviceId, batteryLevel) {
-            // TODO: For Future Consumption
-            /* await eventDispatcher.publishEvent(
-              DT_EVENT_TYPES.DEVICE.BATTERY.SET,
-              { deviceId, batteryLevel },
-              this.source
-            ); */
+        async onBatteryLevelChange(deviceId, batteryLevel, auditProperties) {
             const payload = {
                 eventType: Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.SET,
-                properties: {
+                properties: (0, AuditUtils_1.buildAuditProperties)({
+                    ...auditProperties,
                     deviceId,
                     batteryLevel,
-                },
+                }),
             };
             await (0, dt_audit_library_1.publishAudit)(payload);
         }
-        async onDeviceMetaChange(deviceId, metaData) {
-            // TODO: For Future Consumption
-            /*  await eventDispatcher.publishEvent(
-              DT_EVENT_TYPES.DEVICE.META_DATA.SET,
-              { deviceId, metaData },
-              this.source
-            ); */
+        async onDeviceMetaChange(deviceId, metaData, auditProperties) {
             const payload = {
                 eventType: Event_1.DT_EVENT_TYPES.DEVICE.META_DATA.SET,
-                properties: {
-                    deviceId,
-                    metaData,
-                },
+                properties: (0, AuditUtils_1.buildAuditProperties)({ ...auditProperties, deviceId, metaData }),
             };
             await (0, dt_audit_library_1.publishAudit)(payload);
         }

package/dist/events/EventProcessingService.d.ts

@@ -23,7 +23,7 @@ export declare class EventProcessingService {
     /**
      * Transform device event using EventTransformerFactory
      */
-    transformDeviceEventWithTransformer(connectionProvider: string, rawData: any): DeviceEvent | null;
+    transformDeviceEventWithTransformer(connectionProvider: string, rawData: any): Promise<DeviceEvent | null>;
     /**
      * Transform raw event data to DeviceEvent format using EventTransformer
      */

package/dist/events/EventProcessingService.js

@@ -95,7 +95,7 @@ let EventProcessingService = (() => {
         /**
          * Transform device event using EventTransformerFactory
          */
-        transformDeviceEventWithTransformer(connectionProvider, rawData) {
+        async transformDeviceEventWithTransformer(connectionProvider, rawData) {
             try {
                 // Create transformer for the connection provider
                 const transformer = this.deviceEventTransformerFactory.createTransformer(connectionProvider, rawData);
@@ -104,7 +104,7 @@ let EventProcessingService = (() => {
                     return null;
                 }
                 // Execute the transformation pipeline
-                const transformedEvents = transformer.executeTransformation();
+                const transformedEvents = await transformer.executeTransformation();
                 if (transformedEvents.length === 0) {
                     this.logger.warn(`No events transformed for connection provider: ${connectionProvider}`);
                     return null;
@@ -120,10 +120,10 @@ let EventProcessingService = (() => {
         /**
          * Transform raw event data to DeviceEvent format using EventTransformer
          */
-        transformToDeviceEvent(connectionProvider, rawData) {
+        async transformToDeviceEvent(connectionProvider, rawData) {
             try {
                 // Use the transformer-based approach
-                const deviceEvent = this.transformDeviceEventWithTransformer(connectionProvider, rawData);
+                const deviceEvent = await this.transformDeviceEventWithTransformer(connectionProvider, rawData);
                 if (!deviceEvent) {
                     this.logger.warn("Failed to transform event data using transformer", {
                         connectionProvider,
@@ -154,7 +154,7 @@ let EventProcessingService = (() => {
                     eventName: rawData.eventName ?? rawData.type,
                 });
                 // Transform raw data to DeviceEvent using EventTransformer
-                const deviceEvent = this.transformToDeviceEvent(connectionProvider, rawData);
+                const deviceEvent = await this.transformToDeviceEvent(connectionProvider, rawData);
                 if (!deviceEvent) {
                     this.logger.warn("Failed to transform event data", {
                         connectionProvider,

package/dist/events/interfaces/DeviceEvent.d.ts

@@ -3,10 +3,10 @@ export interface DeviceEvent {
     deviceId: string;
     eventName: string;
     data: DeviceEventData;
-    timestamp?: string;
-    connectionProvider?: string;
-    originalEventName?: string;
-    rawEvent?: any;
+    timestamp: string;
+    connectionProvider: string;
+    originalEventName: string;
+    rawEvent: any;
 }
 export interface EventConstructionOptions {
     eventId?: string;
@@ -30,6 +30,10 @@ export interface DeviceEventEntity {
 export interface DeviceEventData {
     mode?: string;
     batteryLevel?: number;
+    deviceName?: string;
+    propertyId?: string;
+    propertyName?: string;
+    [key: string]: any;
 }
 export interface TTLockEventData extends DeviceEventData {
     label: string;

package/dist/events/interfaces/IEventTransformer.d.ts

@@ -1,7 +1,7 @@
 import { DeviceEvent } from "./DeviceEvent";
 export interface IEventTransformer {
     parseData(rawData: any): any;
-    transform(parsedData: any): DeviceEvent | DeviceEvent[];
+    transform(parsedData: any): Promise<DeviceEvent | DeviceEvent[]>;
     validate(transformedEvent: DeviceEvent): boolean;
-    executeTransformation(): DeviceEvent[];
+    executeTransformation(): Promise<DeviceEvent[]>;
 }

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

@@ -40,9 +40,13 @@ export declare class IssueService {
      */
     createDeviceOfflineIssue(device: IDevice, source: Source, reason?: string): Promise<IIssueDocument>;
     /**
-     * Create issue for device battery level below threshold
+     * Create issue for device battery level below threshold (READINESS + OPERATIONAL + ENERGY)
      */
     createDeviceBatteryIssue(device: IDevice, batteryLevel: number, threshold: number, source: Source): Promise<IIssueDocument>;
+    /**
+     * Create issue for device malfunction (jammed or not accepting codes) (READINESS + OPERATIONAL)
+     */
+    createDeviceMalfunctionIssue(device: IDevice, issueType: string, source: Source, reason?: string): Promise<IIssueDocument>;
     /**
      * Create a maintenance issue using IssueBuilder
      */

package/dist/issues/Issue.service.js

@@ -189,11 +189,17 @@ let IssueService = (() => {
             return await this.createDeviceIssue(device.deviceId, device.propertyId, "Device Offline - Requires Attention", `Device ${device.name} (${device.deviceId}) has been offline for longer than the baseline time. ${reason ? `Reason: ${reason}` : ""} This requires immediate attention to restore device functionality.`, source, issue_types_1.IssuesCategory.OPERATIONS, issue_types_1.IssuePriority.HIGH);
         }
         /**
-         * Create issue for device battery level below threshold
+         * Create issue for device battery level below threshold (READINESS + OPERATIONAL + ENERGY)
          */
         async createDeviceBatteryIssue(device, batteryLevel, threshold, source) {
             return await this.createDeviceIssue(device.deviceId, device.propertyId, "Device Battery Low - Requires Attention", `Device ${device.name} (${device.deviceId}) battery level is ${batteryLevel}%, which is below the property threshold of ${threshold}%. This requires immediate attention to replace or charge the device battery.`, source, issue_types_1.IssuesCategory.ENERGY, issue_types_1.IssuePriority.MEDIUM);
         }
+        /**
+         * Create issue for device malfunction (jammed or not accepting codes) (READINESS + OPERATIONAL)
+         */
+        async createDeviceMalfunctionIssue(device, issueType, source, reason) {
+            return await this.createDeviceIssue(device.deviceId, device.propertyId, `Device Malfunction - ${issueType} - Requires Attention`, `Device ${device.name} (${device.deviceId}) has a malfunction: ${issueType}. ${reason ? `Reason: ${reason}` : ""} This requires immediate attention to resolve the device malfunction.`, source, issue_types_1.IssuesCategory.OPERATIONS, issue_types_1.IssuePriority.HIGH);
+        }
         /**
          * Create a maintenance issue using IssueBuilder
          */

package/dist/queue/utils/queueUtils.js

@@ -91,7 +91,7 @@ class QueueUtils {
                 method: method.toLowerCase(),
                 url: url,
                 headers: options.headers || {},
-                timeout: 30000,
+                timeout: 60000,
                 ...(options.body && { data: options.body }),
                 ...(options.params && { params: options.params }),
             });

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

@@ -1,8 +1,67 @@
 export declare class RedisUtils {
     private readonly client;
+    /**
+     * Get a value from Redis
+     * @param key - The key to get
+     * @param field - The field to get
+     * @returns The value
+     */
     hget(key: string, field: string): Promise<any>;
+    /**
+     * Set a value in Redis with a TTL
+     * @param key - The key to set
+     * @param field - The field to set
+     * @param value - The value to set (JSON stringified)
+     * @param ttl - The TTL in seconds
+     * @returns The number of fields set
+     */
+    hsetWithTTL(key: string, field: string, value: string, ttl: number): Promise<number>;
+    /**
+     * Set a value in Redis
+     * @param key - The key to set
+     * @param field - The field to set
+     * @param value - The value to set (JSON stringified)
+     * @returns The number of fields set
+     */
     hset(key: string, field: string, value: string): Promise<number>;
+    /**
+     * Delete a field from a hash
+     * @param key - The key to delete from
+     * @param fields - The fields to delete
+     * @returns The number of fields deleted
+     */
     hdel(key: string, ...fields: string[]): Promise<number>;
+    /**
+     * Set a value in Redis with a TTL
+     * @param key - The key to set
+     * @param value - The value to set (JSON stringified)
+     * @param ttl - The TTL in seconds
+     * @returns The value
+     */
+    set(key: string, value: string, ttl: number): Promise<string>;
+    /**
+     * Get a value from Redis
+     * @param key - The key to get
+     * @returns The value
+     */
+    get(key: string): Promise<string | null>;
+    /**
+     * Delete a key from Redis
+     * @param key - The key to delete
+     * @returns The number of keys deleted
+     */
+    del(key: string): Promise<number>;
+    /**
+     * Check if a key exists
+     * @param key - The key to check
+     * @returns 1 if the key exists, 0 otherwise
+     */
     exists(key: string): Promise<number>;
+    /**
+     * Set an expiration time for a key
+     * @param key - The key to set the expiration for
+     * @param seconds - The number of seconds until the key expires
+     * @returns 1 if the expiration was set, 0 if the key does not exist
+     */
     expire(key: string, seconds: number): Promise<any>;
 }

package/dist/utils/redis.utils.js

@@ -50,6 +50,12 @@ let RedisUtils = (() => {
         constructor() {
             this.client = (0, redis_1.getRedisClient)(); // singleton Redis client instance
         }
+        /**
+         * Get a value from Redis
+         * @param key - The key to get
+         * @param field - The field to get
+         * @returns The value
+         */
         async hget(key, field) {
             try {
                 const value = await this.client.hget(key, field);
@@ -63,6 +69,32 @@ let RedisUtils = (() => {
                 throw error;
             }
         }
+        /**
+         * Set a value in Redis with a TTL
+         * @param key - The key to set
+         * @param field - The field to set
+         * @param value - The value to set (JSON stringified)
+         * @param ttl - The TTL in seconds
+         * @returns The number of fields set
+         */
+        async hsetWithTTL(key, field, value, ttl) {
+            try {
+                await this.hset(key, field, value);
+                await this.expire(key, ttl);
+                return 1;
+            }
+            catch (error) {
+                console.error(`Error setting value for key ${key}:`, error);
+                throw error;
+            }
+        }
+        /**
+         * Set a value in Redis
+         * @param key - The key to set
+         * @param field - The field to set
+         * @param value - The value to set (JSON stringified)
+         * @returns The number of fields set
+         */
         async hset(key, field, value) {
             try {
                 return await this.client.hset(key, field, value);
@@ -72,29 +104,46 @@ let RedisUtils = (() => {
                 throw error;
             }
         }
-        // async del(key: string): Promise<number> {
-        //   return this.client.del(key);
-        // }
+        /**
+         * Delete a field from a hash
+         * @param key - The key to delete from
+         * @param fields - The fields to delete
+         * @returns The number of fields deleted
+         */
         async hdel(key, ...fields) {
             return await this.client.hdel(key, ...fields);
         }
-        // async get(key: string): Promise<string | null> {
-        //   try {
-        //     return await this.client.get(key);
-        //   } catch (error) {
-        //     console.error(`Error getting value for key ${key}:`, error);
-        //     throw error;
-        //   }
-        // }
-        /*  async set(key: string, value: string): Promise<boolean> {
-          try {
-            await this.client.set(key, value);
-            return true;
-          } catch (error) {
-            console.error(`Error setting value for key ${key}:`, error);
-            throw error;
-          }
-        } */
+        /**
+         * Set a value in Redis with a TTL
+         * @param key - The key to set
+         * @param value - The value to set (JSON stringified)
+         * @param ttl - The TTL in seconds
+         * @returns The value
+         */
+        async set(key, value, ttl) {
+            return await this.client.set(key, value, "EX", ttl);
+        }
+        /**
+         * Get a value from Redis
+         * @param key - The key to get
+         * @returns The value
+         */
+        async get(key) {
+            return await this.client.get(key);
+        }
+        /**
+         * Delete a key from Redis
+         * @param key - The key to delete
+         * @returns The number of keys deleted
+         */
+        async del(key) {
+            return await this.client.del(key);
+        }
+        /**
+         * Check if a key exists
+         * @param key - The key to check
+         * @returns 1 if the key exists, 0 otherwise
+         */
         async exists(key) {
             try {
                 return await this.client.exists(key);
@@ -104,6 +153,12 @@ let RedisUtils = (() => {
                 throw error;
             }
         }
+        /**
+         * Set an expiration time for a key
+         * @param key - The key to set the expiration for
+         * @param seconds - The number of seconds until the key expires
+         * @returns 1 if the expiration was set, 0 if the key does not exist
+         */
         async expire(key, seconds) {
             try {
                 return await this.client.expire(key, seconds);

package/package.json

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