dt-common-device 1.3.0 → 2.0.1

package/src/device/local/services/IssueService.example.ts

@@ -0,0 +1,307 @@
+import { IssueService } from "./Issue.service";
+import { IssueBuilder } from "../entities/IssueBuilder";
+import { IssuesCategory, IssuePriority, EntityType } from "../../../types/issue.types";
+
+/**
+ * Example usage of the updated IssueService with IssueBuilder integration
+ * This file demonstrates various ways to use the IssueService with the new IssueBuilder
+ */
+
+export class IssueServiceExample {
+  constructor(private readonly issueService: IssueService) {}
+
+  /**
+   * Example 1: Using the updated createIssue method with IssueBuilder
+   */
+  async createIssueWithBuilder() {
+    const issueBuilder = new IssueBuilder()
+      .setCategory(IssuesCategory.OPERATIONS)
+      .setPropertyId("prop123")
+      .setTitle("Device Maintenance Required")
+      .setDescription("Device requires scheduled maintenance")
+      .setEntityId("device456")
+      .setEntityType(EntityType.DEVICE)
+      .setPriority(IssuePriority.HIGH)
+      .setAssignedTo("tech789")
+      .setCreatedBy("user123")
+      .setDueDate(new Date("2024-01-15"));
+
+    // Pass the IssueBuilder directly to createIssue
+    const issue = await this.issueService.createIssue(issueBuilder);
+    return issue;
+  }
+
+  /**
+   * Example 2: Using convenience methods for specific issue types
+   */
+  async createSpecificIssues() {
+    // Create a readiness issue
+    const readinessIssue = await this.issueService.createReadinessIssue(
+      "prop123",
+      "System Maintenance Required",
+      "System maintenance is scheduled for tonight",
+      "admin",
+      "system456",
+      EntityType.PROPERTY,
+      "maintenance-team",
+      new Date("2024-01-20")
+    );
+
+    // Create an operations issue
+    const operationsIssue = await this.issueService.createOperationsIssue(
+      "prop123",
+      "Device Temperature High",
+      "Device temperature exceeds normal operating range",
+      "monitor",
+      "device789",
+      EntityType.DEVICE,
+      "tech-support",
+      new Date("2024-01-10")
+    );
+
+    // Create a security issue
+    const securityIssue = await this.issueService.createSecurityIssue(
+      "prop123",
+      "Unauthorized Access Attempt",
+      "Multiple failed login attempts detected",
+      "security-system",
+      "user123",
+      EntityType.USER,
+      "security-team",
+      new Date("2024-01-05")
+    );
+
+    // Create an energy issue
+    const energyIssue = await this.issueService.createEnergyIssue(
+      "prop123",
+      "High Energy Consumption",
+      "Energy usage is 20% above normal levels",
+      "energy-monitor",
+      "zone456",
+      EntityType.COLLECTION,
+      "energy-manager",
+      new Date("2024-01-25")
+    );
+
+    return { readinessIssue, operationsIssue, securityIssue, energyIssue };
+  }
+
+  /**
+   * Example 3: Using device-specific issue methods
+   */
+  async createDeviceIssues() {
+    // Create a device issue with default category and priority
+    const deviceIssue1 = await this.issueService.createDeviceIssue(
+      "device123",
+      "prop456",
+      "Device Battery Low",
+      "Device battery level is below 20%",
+      "system",
+      undefined, // Use default category
+      undefined, // Use default priority
+      "maintenance-team",
+      new Date("2024-01-12")
+    );
+
+    // Create a device issue with custom category and priority
+    const deviceIssue2 = await this.issueService.createDeviceIssue(
+      "device789",
+      "prop456",
+      "Device Firmware Update Available",
+      "New firmware version is available for installation",
+      "firmware-manager",
+      IssuesCategory.READINESS,
+      IssuePriority.MEDIUM,
+      "admin",
+      new Date("2024-01-20")
+    );
+
+    return { deviceIssue1, deviceIssue2 };
+  }
+
+  /**
+   * Example 4: Using hub-specific issue methods
+   */
+  async createHubIssues() {
+    // Create a hub issue with default settings
+    const hubIssue1 = await this.issueService.createHubIssue(
+      "hub123",
+      "prop456",
+      "Hub Connection Lost",
+      "Hub has lost connection to the network",
+      "network-monitor",
+      undefined, // Use default category
+      undefined, // Use default priority
+      "network-admin",
+      new Date("2024-01-05")
+    );
+
+    // Create a hub issue with custom settings
+    const hubIssue2 = await this.issueService.createHubIssue(
+      "hub789",
+      "prop456",
+      "Hub Maintenance Required",
+      "Hub requires scheduled maintenance",
+      "maintenance-system",
+      IssuesCategory.READINESS,
+      IssuePriority.LOW,
+      "technician",
+      new Date("2024-01-15")
+    );
+
+    return { hubIssue1, hubIssue2 };
+  }
+
+  /**
+   * Example 5: Using user-specific issue methods
+   */
+  async createUserIssues() {
+    // Create a user issue
+    const userIssue = await this.issueService.createUserIssue(
+      "user456",
+      "prop303",
+      "User Access Review Required",
+      "User access permissions need review",
+      "access-control",
+      IssuesCategory.SECURITY,
+      IssuePriority.MEDIUM,
+      "hr-admin",
+      new Date("2024-01-30")
+    );
+
+    return { userIssue };
+  }
+
+  /**
+   * Example 6: Using maintenance and urgent issue methods
+   */
+  async createMaintenanceAndUrgentIssues() {
+    // Create a maintenance issue
+    const maintenanceIssue = await this.issueService.createMaintenanceIssue(
+      "prop505",
+      "Scheduled Device Maintenance",
+      "Regular maintenance is scheduled for this device",
+      "maintenance-scheduler",
+      "device789",
+      EntityType.DEVICE,
+      "technician",
+      new Date("2024-01-12")
+    );
+
+    // Create an urgent issue
+    const urgentIssue = await this.issueService.createUrgentIssue(
+      "prop606",
+      "Critical Hub Failure",
+      "Hub is experiencing critical failures",
+      "monitoring-system",
+      "hub123",
+      EntityType.HUB,
+      "emergency-tech",
+      new Date("2024-01-03")
+    );
+
+    return { maintenanceIssue, urgentIssue };
+  }
+
+  /**
+   * Example 7: Using static factory methods with IssueBuilder
+   */
+  async createIssuesWithStaticMethods() {
+    // Create a device issue using static factory method
+    const deviceIssue = IssueBuilder.createDeviceIssue("device123", "prop456")
+      .setCategory(IssuesCategory.OPERATIONS)
+      .setTitle("Device Offline")
+      .setDescription("Device has been offline for more than 5 minutes")
+      .setPriority(IssuePriority.HIGH)
+      .setAssignedTo("tech-support")
+      .setCreatedBy("monitor")
+      .setDueDate(new Date("2024-01-10"));
+
+    const issue1 = await this.issueService.createIssue(deviceIssue);
+
+    // Create a hub issue using static factory method
+    const hubIssue = IssueBuilder.createHubIssue("hub789", "prop202")
+      .setCategory(IssuesCategory.SECURITY)
+      .setTitle("Hub Security Breach")
+      .setDescription("Unauthorized access attempt detected on hub")
+      .setPriority(IssuePriority.CRITICAL)
+      .setAssignedTo("security-team")
+      .setCreatedBy("security-system")
+      .setDueDate(new Date("2024-01-05"));
+
+    const issue2 = await this.issueService.createIssue(hubIssue);
+
+    return { issue1, issue2 };
+  }
+
+  /**
+   * Example 8: Creating multiple issues efficiently
+   */
+  async createMultipleIssues() {
+    const issues = [];
+
+    // Create multiple device issues efficiently
+    const deviceIds = ["device1", "device2", "device3"];
+    const propertyId = "prop123";
+
+    for (const deviceId of deviceIds) {
+      const issueBuilder = IssueBuilder.createDeviceIssue(deviceId, propertyId)
+        .setCategory(IssuesCategory.OPERATIONS)
+        .setTitle(`Device ${deviceId} Status`)
+        .setDescription(`Status check for device ${deviceId}`)
+        .setPriority(IssuePriority.MEDIUM)
+        .setAssignedTo("batch-processor")
+        .setCreatedBy("batch-processor")
+        .setDueDate(new Date("2024-01-15"));
+
+      const issue = await this.issueService.createIssue(issueBuilder);
+      issues.push(issue);
+    }
+
+    return issues;
+  }
+
+  /**
+   * Example 9: Creating issue with due date calculation
+   */
+  async createIssueWithDueDate() {
+    const dueDate = new Date();
+    dueDate.setDate(dueDate.getDate() + 7); // Due in 7 days
+
+    const issueBuilder = new IssueBuilder()
+      .setCategory(IssuesCategory.READINESS)
+      .setPropertyId("prop808")
+      .setTitle("System Update Required")
+      .setDescription("System requires critical security update")
+      .setEntityType(EntityType.PROPERTY)
+      .setPriority(IssuePriority.HIGH)
+      .setAssignedTo("system-admin")
+      .setCreatedBy("update-manager")
+      .setDueDate(dueDate);
+
+    const issue = await this.issueService.createIssue(issueBuilder);
+    return issue;
+  }
+
+  /**
+   * Example 10: Backward compatibility - still works with CreateIssueData
+   */
+  async createIssueWithLegacyData() {
+    const issueData = {
+      category: IssuesCategory.OPERATIONS,
+      propertyId: "prop123",
+      title: "Legacy Issue",
+      description: "This issue was created using the old CreateIssueData format",
+      entityId: "device456",
+      entityType: EntityType.DEVICE,
+      priority: IssuePriority.MEDIUM,
+      assignedTo: "tech-support",
+      createdBy: "legacy-system",
+      dueDate: new Date("2024-01-20")
+    };
+
+    // This still works with the updated createIssue method
+    const issue = await this.issueService.createIssue(issueData);
+    return issue;
+  }
+} 

package/src/device/local/services/index.ts

@@ -1,5 +1,7 @@
-export { LocalDeviceService } from "./Device.service";
-export { LocalHubService } from "./Hub.service";
-export { LocalConnectionService } from "./Connection.service";
-export { LocalPropertyService } from "./Property.service";
-export { LocalScheduleService } from "./Schedule.service";
+export * from "./Alert.service";
+export * from "./Connection.service";
+export * from "./Device.service";
+export * from "./Hub.service";
+export * from "./Issue.service";
+export * from "./Property.service";
+export * from "./Schedule.service";

package/src/events/BaseEventHandler.ts

@@ -0,0 +1,145 @@
+import { DeviceEvent } from "./interfaces/DeviceEvent";
+import { IEventHandler } from "./interfaces/IEventHandler";
+import { getConfig } from "../config/config";
+import { ILogger } from "../types/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

@@ -0,0 +1,97 @@
+import { getConfig } from "../config/config";
+import { ILogger } from "../types/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 [];
+    }
+  }
+}