dt-common-device 3.1.6 → 4.0.1

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

@@ -31,6 +31,26 @@ export declare class RedisUtils {
      * @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
@@ -44,4 +64,5 @@ 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>;
+    hgetAll(key: string): Promise<any>;
 }

package/dist/utils/redis.utils.js

@@ -113,6 +113,32 @@ let RedisUtils = (() => {
         async hdel(key, ...fields) {
             return await this.client.hdel(key, ...fields);
         }
+        /**
+         * 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
@@ -142,6 +168,15 @@ let RedisUtils = (() => {
                 throw error;
             }
         }
+        async hgetAll(key) {
+            try {
+                return await this.client.hgetall(key);
+            }
+            catch (error) {
+                console.error(`Error getting all values for key ${key}:`, error);
+                throw error;
+            }
+        }
     };
     __setFunctionName(_classThis, "RedisUtils");
     (() => {

package/package.json

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