dt-common-device 3.0.10 → 3.0.12

package/src/events/BaseEventHandler.ts

@@ -1,145 +0,0 @@
-import { DeviceEvent } from "./interfaces/DeviceEvent";
-import { IEventHandler } from "./interfaces/IEventHandler";
-import { getConfig } from "../config/config";
-import { ILogger } from "../config/config.types";
-import { LocalDeviceService } from "../device/local/services/Device.service";
-
-export abstract class BaseEventHandler implements IEventHandler {
-  protected readonly supportedEventTypes: string[];
-  protected readonly priority: number;
-  protected readonly logger: ILogger;
-  protected readonly localDeviceService: LocalDeviceService;
-  constructor(supportedEventTypes: string[], priority: number = 100) {
-    this.supportedEventTypes = supportedEventTypes;
-    this.priority = priority;
-    this.logger = getConfig().LOGGER;
-    this.localDeviceService = new LocalDeviceService();
-  }
-
-  /**
-   * Handle a single event - to be implemented by specific handlers
-   */
-  async handleEvent(event: DeviceEvent): Promise<void> {
-    try {
-      await this.beforeEvent(event);
-      await this.onEvent(event);
-    } catch (error) {
-      this.logger.error(
-        `${this.constructor.name}: Error during event processing`,
-        {
-          eventName: event.eventName,
-          deviceId: event.deviceId,
-          error,
-        }
-      );
-      throw error;
-    } finally {
-      await this.afterEvent(event);
-    }
-  }
-
-  async beforeEvent(event: DeviceEvent): Promise<void> {
-    this.logger.info(
-      "[DT | CDL]:[BaseEventHandler]: Before event - Handle Before Event"
-    );
-  }
-
-  abstract onEvent(event: DeviceEvent): Promise<void>;
-
-  async afterEvent(event: DeviceEvent): Promise<void> {
-    this.logger.info(
-      "[DT | CDL]:[BaseEventHandler]: After event - Event processing completed",
-      {
-        eventName: event.eventName,
-        deviceId: event.deviceId,
-        handler: this.constructor.name,
-      }
-    );
-    //TODO: Implement AUDIT Here!
-  }
-
-  /**
-   * Handle multiple events - default implementation processes them sequentially
-   */
-  async handleEvents(events: DeviceEvent[]): Promise<void> {
-    try {
-      this.logger.info(
-        `Processing ${events.length} events with ${this.constructor.name}`
-      );
-
-      for (const event of events) {
-        if (this.canHandle(event.eventName || "unknown")) {
-          await this.handleEvent(event);
-        } else {
-          this.logger.warn(
-            `Event type ${event.eventName} not supported by ${this.constructor.name}`
-          );
-        }
-      }
-    } catch (error) {
-      this.logger.error(`${this.constructor.name}: handleEvents Error`, error);
-    }
-  }
-
-  public async onStateChange(
-    deviceId: string,
-    state: Record<string, any>,
-    event: DeviceEvent
-  ): Promise<void> {
-    try {
-      await this.localDeviceService.setState(deviceId, state);
-      await this.afterEvent(event);
-    } catch (error: any) {
-      this.logger.error(
-        `[DT | CDL]:[BaseEventHandler]: Error during state change: ${
-          error.message || error.toString()
-        }`
-      );
-    }
-  }
-
-  /**
-   * Check if this handler can process the given event type
-   */
-  canHandle(eventType: string): boolean {
-    return this.supportedEventTypes.includes(eventType);
-  }
-
-  /**
-   * Get the priority of this handler
-   */
-  getPriority(): number {
-    return this.priority;
-  }
-
-  /**
-   * Get the event types this handler can process
-   */
-  getSupportedEventTypes(): string[] {
-    return this.supportedEventTypes;
-  }
-
-  /**
-   * Common validation method
-   */
-  protected validateEvent(event: DeviceEvent): boolean {
-    if (!event) {
-      this.logger.error("Event is null or undefined");
-      return false;
-    }
-
-    if (!event.eventName) {
-      this.logger.error("Event name is missing");
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Common error handling method
-   */
-  protected async handleError(error: any, context: string): Promise<void> {
-    this.logger.error(`${this.constructor.name}: ${context} Error`, error);
-  }
-}

package/src/events/BaseEventTransformer.ts

@@ -1,97 +0,0 @@
-import { getConfig } from "../config/config";
-import { ILogger } from "../config/config.types";
-import { DeviceEvent } from "./interfaces/DeviceEvent";
-import { IEventTransformer } from "./interfaces/IEventTransformer";
-
-export abstract class BaseEventTransformer implements IEventTransformer {
-  protected readonly deviceType: string;
-  protected rawData: any;
-  protected readonly logger: ILogger;
-  constructor(deviceType: string, rawData: any) {
-    this.deviceType = deviceType;
-    this.rawData = rawData;
-    this.logger = getConfig().LOGGER;
-  }
-
-  // Parse raw event data - to be implemented by device-specific transformers
-  parseData(rawData: any): any {
-    try {
-      this.logger.info(`${this.deviceType}EventTransformer: Parsed event data`);
-      return rawData;
-    } catch (error) {
-      this.logger.error(
-        `${this.deviceType}EventTransformer: Error parsing data`,
-        error
-      );
-      return null;
-    }
-  }
-
-  /**
-   * Transform parsed data into DeviceEvent format - to be implemented by device-specific transformers
-   */
-  abstract transform(parsedData: any): DeviceEvent | DeviceEvent[];
-
-  /**
-   * Validate transformed event - default implementation, can be overridden
-   */
-  validate(transformedEvent: DeviceEvent): boolean {
-    try {
-      // Basic validation - ensure required fields exist
-      if (!transformedEvent) {
-        this.logger.error("Transformed event is null or undefined");
-        return false;
-      }
-
-      // Add more validation logic as needed
-      return true;
-    } catch (error) {
-      this.logger.error("BaseEventTransformer: validate Error", error);
-      return false;
-    }
-  }
-
-  /**
-   * Get the device type this transformer handles
-   */
-  getDeviceType(): string {
-    return this.deviceType;
-  }
-
-  /**
-   * Execute the full transformation pipeline
-   */
-  executeTransformation(): DeviceEvent[] {
-    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);
-
-      // Step 3: Convert to array format
-      // TODO: Check if any service sends multiple events
-      const events = Array.isArray(transformedResult)
-        ? transformedResult
-        : [transformedResult];
-
-      // Step 4: Validate each event
-      const validEvents = events.filter((event) => this.validate(event));
-
-      this.logger.info(
-        `Transformation completed. ${validEvents.length} valid events created.`
-      );
-      return validEvents;
-    } catch (error) {
-      this.logger.error(
-        "BaseEventTransformer: executeTransformation Error",
-        error
-      );
-      return [];
-    }
-  }
-}

package/src/events/DeviceEventHandler.ts

@@ -1,213 +0,0 @@
-import { Source } from "../constants";
-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,
-          Source.CLOUD_EVENT
-        );
-        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

@@ -1,77 +0,0 @@
-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/events/EventHandler.ts

@@ -1,124 +0,0 @@
-import { eventDispatcher } from "dt-pub-sub";
-import { publishAudit } from "dt-audit-library";
-import { DT_EVENT_TYPES } from "../constants/Event";
-
-export class EventHandler {
-  private readonly source: string;
-  constructor() {
-    this.source = "dt-common-device";
-  }
-
-  async onDeviceCreate(body: any) {
-    // TODO: For Future Consumption
-    // await eventDispatcher.publishEvent(
-    //   DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS,
-    //   body,
-    //   this.source
-    // );
-    const payload = {
-      eventType: DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS,
-      properties: {
-        ...body,
-      },
-    };
-    await publishAudit(payload);
-  }
-
-  async onDeviceUpdate(deviceId: string, body: any) {
-    await eventDispatcher.publishEvent(
-      DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS,
-      { deviceId, body },
-      this.source
-    );
-    const payload = {
-      eventType: DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS,
-      properties: {
-        ...body,
-      },
-    };
-    await publishAudit(payload);
-  }
-
-  async onDeviceDelete(deviceId: string) {
-    await eventDispatcher.publishEvent(
-      DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS,
-      { deviceId },
-      this.source
-    );
-    const payload = {
-      eventType: DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS,
-      properties: {
-        deviceId,
-      },
-    };
-    await publishAudit(payload);
-  }
-
-  async onStateChange(deviceId: string, state: any) {
-    // 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: {
-        deviceId,
-        state,
-      },
-    };
-    await publishAudit(payload);
-  }
-
-  async onStatusChange(deviceId: string, status: any) {
-    // 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: {
-        deviceId,
-        status,
-      },
-    };
-    await publishAudit(payload);
-  }
-
-  async onBatteryLevelChange(deviceId: string, batteryLevel: number) {
-    // 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: {
-        deviceId,
-        batteryLevel,
-      },
-    };
-    await publishAudit(payload);
-  }
-
-  async onDeviceMetaChange(deviceId: string, metaData: Record<string, any>) {
-    // 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: {
-        deviceId,
-        metaData,
-      },
-    };
-    await publishAudit(payload);
-  }
-}