dt-common-device 1.3.0 → 2.0.0

package/src/events/DeviceEventHandler.ts

@@ -0,0 +1,211 @@
+import { DT_EVENT_TYPES } from "../constants/Event";
+import { IDevice } from "../device/local/interfaces";
+import { LocalHubService } from "../device/local/services";
+import { BaseEventHandler } from "./BaseEventHandler";
+import {
+  DeviceEvent,
+  DeviceEventEntity,
+  EventConstructionOptions,
+} from "./interfaces/DeviceEvent";
+
+export class DeviceEventHandler extends BaseEventHandler {
+  private readonly localHubService: LocalHubService;
+  constructor() {
+    super(
+      [
+        DT_EVENT_TYPES.DEVICE.STATUS.ONLINE,
+        DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE,
+        DT_EVENT_TYPES.DEVICE.STATUS.CHANGED,
+        DT_EVENT_TYPES.DEVICE.BATTERY.CRITICAL,
+        DT_EVENT_TYPES.DEVICE.BATTERY.LOW,
+        DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED,
+      ],
+      100
+    );
+    this.localHubService = new LocalHubService();
+  }
+
+  async onEvent(event: DeviceEvent): Promise<void> {
+    this.logger.info("[DT | CDL]:[DeviceEventHandler]: Processing event", {
+      eventName: event.eventName,
+    });
+
+    try {
+      const device: IDevice = await this.localDeviceService.getDevice(
+        event.deviceId
+      );
+      if (!device?.deviceId) {
+        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
+      );
+      throw error;
+    }
+  }
+
+  async updateDeviceEventData(
+    deviceData: IDevice,
+    event: DeviceEvent
+  ): Promise<void> {
+    switch (event.eventName) {
+      case DT_EVENT_TYPES.DEVICE.STATUS.ONLINE:
+      case DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE:
+        await this.localDeviceService.setState(deviceData.deviceId, {
+          status: {
+            online: event.eventName === DT_EVENT_TYPES.DEVICE.STATUS.ONLINE,
+            lastUpdated: new Date().toISOString(),
+            error: {
+              type:
+                event.eventName === DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE
+                  ? "offline"
+                  : "",
+              message:
+                event.eventName === DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE
+                  ? "Device is offline"
+                  : "",
+              default: {},
+            },
+          },
+        });
+        break;
+      case DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED:
+        await this.localDeviceService.setBatteryLevel(
+          deviceData.deviceId,
+          event?.data?.batteryLevel ?? 0
+        );
+        break;
+    }
+  }
+
+  async extractHubDetails(device: IDevice): Promise<any[]> {
+    const hubIds = device?.hubId;
+    const hubDetails: any[] = [];
+
+    if (hubIds) {
+      for (const hubId of hubIds) {
+        const hubDetail: IDevice = await this.localHubService.getHub(hubId);
+        hubDetails.push({
+          id: hubDetail?.deviceId,
+          name: hubDetail?.name,
+          type: hubDetail?.deviceType?.type,
+          brand: hubDetail?.specifications?.manufacturer,
+          model: hubDetail?.specifications?.model,
+          status: hubDetail?.status?.online ? "ONLINE" : "OFFLINE",
+        });
+      }
+    }
+
+    return hubDetails;
+  }
+
+  constructDeviceEventEntity(
+    eventData: any,
+    device: IDevice,
+    hubDetails: any[],
+    options: EventConstructionOptions = {}
+  ): DeviceEventEntity {
+    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: any, device: IDevice): Promise<void> {
+    try {
+      const hubDetails = await this.extractHubDetails(device);
+
+      const eventData: DeviceEventEntity = 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: any,
+    device: IDevice
+  ): Promise<void> {
+    switch (eventData.eventName) {
+      case DT_EVENT_TYPES.DEVICE.STATUS.ONLINE:
+      case DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE:
+      case DT_EVENT_TYPES.DEVICE.STATUS.CHANGED:
+        this.updateDeviceStatus(eventData, device);
+        break;
+      case DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED:
+      case DT_EVENT_TYPES.DEVICE.BATTERY.CRITICAL:
+      case DT_EVENT_TYPES.DEVICE.BATTERY.LOW:
+        this.updateDeviceBattery(eventData, device);
+        break;
+    }
+  }
+
+  async updateDeviceStatus(data: any, device: IDevice) {
+    this.logger.info(
+      "[DT | CDL]:[DeviceEventHandler]: Updating device status",
+      {
+        data,
+        device,
+      }
+    );
+  }
+
+  async updateDeviceBattery(data: any, device: IDevice) {
+    this.logger.info(
+      "[DT | CDL]:[DeviceEventHandler]: Updating device battery",
+      {
+        data,
+        device,
+      }
+    );
+  }
+}

package/src/events/DeviceEventTransformerFactory.ts

@@ -0,0 +1,77 @@
+import { Service } from 'typedi';
+import { IEventTransformer } from './interfaces/IEventTransformer';
+
+/**
+ * Abstract base factory for creating device event transformers
+ * This class can be moved to dt-common-device and extended by specific device type factories
+ */
+@Service()
+export abstract class DeviceEventTransformerFactory {
+  /**
+   * Create the appropriate event transformer based on device type
+   * This method should be implemented by subclasses to handle specific device types
+   */
+  public abstract createTransformer(deviceType: string, rawData: any): IEventTransformer | null;
+
+  /**
+   * Create a default transformer for unsupported or generic device types
+   * This method can be overridden by subclasses to provide device-specific default behavior
+   */
+  protected createDefaultTransformer(deviceType: string, rawData: any): IEventTransformer {
+    return new (class implements IEventTransformer {
+      private readonly deviceType: string;
+      private readonly rawData: any;
+
+      constructor(deviceType: string, rawData: any) {
+        this.deviceType = deviceType;
+        this.rawData = rawData;
+      }
+
+      parseData(rawData: any): any {
+        // Default parsing - return as-is
+        return rawData;
+      }
+
+      transform(parsedData: any): any {
+        // Default transformation - return as-is
+        return parsedData;
+      }
+
+      validate(transformedEvent: any): boolean {
+        // Default validation - always return true
+        return true;
+      }
+
+      executeTransformation(): any[] {
+        try {
+          const parsedData = this.parseData(this.rawData);
+          const transformedResult = this.transform(parsedData);
+          const events = Array.isArray(transformedResult) ? transformedResult : [transformedResult];
+          return events.filter((event) => this.validate(event));
+        } catch (error) {
+          console.error(`Error in default transformer for device type ${this.deviceType}:`, error);
+          return [];
+        }
+      }
+    })(deviceType, rawData);
+  }
+
+
+  /**
+   * Handle unsupported device types
+   * This method can be overridden by subclasses to provide custom handling
+   */
+  protected handleUnsupportedDeviceType(deviceType: string): IEventTransformer | null {
+    console.warn(`Unsupported device type: ${deviceType}`);
+    return null;
+  }
+
+  /**
+   * Handle errors during transformer creation
+   * This method can be overridden by subclasses to provide custom error handling
+   */
+  protected handleTransformerCreationError(deviceType: string, error: any): IEventTransformer | null {
+    console.error(`Error creating transformer for device type ${deviceType}:`, error);
+    return null;
+  }
+}

package/src/{device/local/events → events}/EventHandler.ts

@@ -1,6 +1,6 @@
 import { eventDispatcher } from "dt-pub-sub";
 import { publishAudit } from "dt-audit-library";
-import { DT_EVENT_TYPES } from "./Events";
+import { DT_EVENT_TYPES } from "../constants/Event";
 
 export class EventHandler {
   private readonly source: string;
@@ -10,12 +10,12 @@ export class EventHandler {
 
   async onDeviceCreate(body: any) {
     await eventDispatcher.publishEvent(
-      DT_EVENT_TYPES.DEVICE.DEVICE.CREATED,
+      DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS,
       body,
       this.source
     );
     const payload = {
-      eventType: DT_EVENT_TYPES.DEVICE.DEVICE.CREATED,
+      eventType: DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS,
       properties: {
         ...body,
       },
@@ -25,12 +25,12 @@ export class EventHandler {
 
   async onDeviceUpdate(deviceId: string, body: any) {
     await eventDispatcher.publishEvent(
-      DT_EVENT_TYPES.DEVICE.DEVICE.UPDATED,
+      DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS,
       { deviceId, body },
       this.source
     );
     const payload = {
-      eventType: DT_EVENT_TYPES.DEVICE.DEVICE.UPDATED,
+      eventType: DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS,
       properties: {
         ...body,
       },
@@ -40,12 +40,12 @@ export class EventHandler {
 
   async onDeviceDelete(deviceId: string) {
     await eventDispatcher.publishEvent(
-      DT_EVENT_TYPES.DEVICE.DEVICE.DELETED,
+      DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS,
       { deviceId },
       this.source
     );
     const payload = {
-      eventType: DT_EVENT_TYPES.DEVICE.DEVICE.DELETED,
+      eventType: DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS,
       properties: {
         deviceId,
       },
@@ -54,11 +54,12 @@ export class EventHandler {
   }
 
   async onStateChange(deviceId: string, state: any) {
-    await eventDispatcher.publishEvent(
+    // TODO: For Future Consumption
+    /* await eventDispatcher.publishEvent(
       DT_EVENT_TYPES.DEVICE.STATE.SET,
       { deviceId, state },
       this.source
-    );
+    ); */
     const payload = {
       eventType: DT_EVENT_TYPES.DEVICE.STATE.SET,
       properties: {
@@ -70,11 +71,12 @@ export class EventHandler {
   }
 
   async onStatusChange(deviceId: string, status: any) {
-    await eventDispatcher.publishEvent(
+    // TODO: For Future Consumption
+    /* await eventDispatcher.publishEvent(
       DT_EVENT_TYPES.DEVICE.STATUS.SET,
       { deviceId, status },
       this.source
-    );
+    ); */
     const payload = {
       eventType: DT_EVENT_TYPES.DEVICE.STATUS.SET,
       properties: {
@@ -86,11 +88,12 @@ export class EventHandler {
   }
 
   async onBatteryLevelChange(deviceId: string, batteryLevel: number) {
-    await eventDispatcher.publishEvent(
+    // TODO: For Future Consumption
+    /* await eventDispatcher.publishEvent(
       DT_EVENT_TYPES.DEVICE.BATTERY.SET,
       { deviceId, batteryLevel },
       this.source
-    );
+    ); */
     const payload = {
       eventType: DT_EVENT_TYPES.DEVICE.BATTERY.SET,
       properties: {
@@ -102,11 +105,12 @@ export class EventHandler {
   }
 
   async onDeviceMetaChange(deviceId: string, metaData: Record<string, any>) {
-    await eventDispatcher.publishEvent(
+    // TODO: For Future Consumption
+    /*  await eventDispatcher.publishEvent(
       DT_EVENT_TYPES.DEVICE.META_DATA.SET,
       { deviceId, metaData },
       this.source
-    );
+    ); */
     const payload = {
       eventType: DT_EVENT_TYPES.DEVICE.META_DATA.SET,
       properties: {

package/src/events/EventHandlerOrchestrator.ts

@@ -0,0 +1,119 @@
+import { Service } from "typedi";
+import { IEventHandler } from "./interfaces/IEventHandler";
+import { DeviceEvent } from "./interfaces/DeviceEvent";
+import { ILogger } from "../types/config.types";
+import { getConfig } from "../config/config";
+
+@Service()
+export class EventHandlerOrchestrator {
+  private handlers: IEventHandler[] = [];
+  private readonly logger: ILogger;
+  constructor() {
+    this.logger = getConfig().LOGGER;
+  }
+  /**
+   * Register a handler with the orchestrator
+   */
+  registerHandler(handler: IEventHandler): void {
+    this.handlers.push(handler);
+    // Sort handlers by priority (lower numbers = higher priority)
+    this.handlers.sort((a, b) => a.getPriority() - b.getPriority());
+    this.logger.info(
+      `Registered handler: ${
+        handler.constructor.name
+      } with priority ${handler.getPriority()}`
+    );
+  }
+
+  /**
+   * Register multiple handlers
+   */
+  registerHandlers(handlers: IEventHandler[]): void {
+    handlers.forEach((handler) => this.registerHandler(handler));
+  }
+
+  /**
+   * Process a single event through the handler hierarchy
+   */
+  async processEvent(event: DeviceEvent): Promise<void> {
+    try {
+      this.logger.info(
+        `Processing event: ${event.eventName} for device: ${event.deviceId}`
+      );
+
+      const applicableHandlers = this.handlers.filter((handler) =>
+        handler.canHandle(event.eventName)
+      );
+
+      if (applicableHandlers.length === 0) {
+        this.logger.warn(
+          `No handlers found for event type: ${event.eventName}`
+        );
+        return;
+      }
+
+      this.logger.info(
+        `Found ${applicableHandlers.length} handlers for event: ${event.eventName}`
+      );
+
+      // Process with each applicable handler in priority order
+      for (const handler of applicableHandlers) {
+        try {
+          await handler.handleEvent(event);
+          this.logger.info(`Event processed by: ${handler.constructor.name}`);
+        } catch (error) {
+          this.logger.error(
+            `Error in handler ${handler.constructor.name}:`,
+            error
+          );
+          // Continue with other handlers even if one fails
+        }
+      }
+    } catch (error) {
+      this.logger.error(
+        "Error in EventHandlerOrchestrator.processEvent:",
+        error
+      );
+    }
+  }
+
+  /**
+   * Process multiple events
+   */
+  async processEvents(events: DeviceEvent[]): Promise<void> {
+    try {
+      this.logger.info(`Processing ${events.length} events`);
+
+      for (const event of events) {
+        await this.processEvent(event);
+      }
+    } catch (error) {
+      this.logger.error(
+        "Error in EventHandlerOrchestrator.processEvents:",
+        error
+      );
+    }
+  }
+
+  /**
+   * Get all registered handlers
+   */
+  getHandlers(): IEventHandler[] {
+    return [...this.handlers];
+  }
+
+  /**
+   * Get handlers that can handle a specific event type
+   */
+  getHandlersForEventType(eventType: string): IEventHandler[] {
+    return this.handlers.filter((handler) => handler.canHandle(eventType));
+  }
+
+  /**
+   * Clear all registered handlers
+   */
+  clearHandlers(): void {
+    this.handlers = [];
+    this.logger.info("All handlers cleared");
+  }
+}