dt-common-device 1.3.0 → 2.0.1

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

@@ -0,0 +1,229 @@
+import { AlertService } from "./Alert.service";
+import { AlertBuilder } from "../entities/AlertBuilder";
+import { AlertCategory, AlertSeverity, EntityType } from "../../../types/alert.types";
+
+/**
+ * Example usage of the updated AlertService with AlertBuilder integration
+ * This file demonstrates various ways to use the AlertService with the new AlertBuilder
+ */
+
+export class AlertServiceExample {
+  constructor(private readonly alertService: AlertService) {}
+
+  /**
+   * Example 1: Using the updated createAlert method with AlertBuilder
+   */
+  async createAlertWithBuilder() {
+    const alertBuilder = new AlertBuilder()
+      .setCategory(AlertCategory.OPERATIONS)
+      .setPropertyId("prop123")
+      .setTitle("Device Offline")
+      .setDescription("Device has been offline for more than 5 minutes")
+      .setEntityId("device456")
+      .setEntityType(EntityType.DEVICE)
+      .setSeverity(AlertSeverity.HIGH)
+      .setCreatedBy("user789");
+
+    // Pass the AlertBuilder directly to createAlert
+    const alert = await this.alertService.createAlert(alertBuilder);
+    return alert;
+  }
+
+  /**
+   * Example 2: Using convenience methods for specific alert types
+   */
+  async createSpecificAlerts() {
+    // Create a readiness alert
+    const readinessAlert = await this.alertService.raiseReadinessAlert(
+      "prop123",
+      "System Maintenance Required",
+      "System maintenance is scheduled for tonight",
+      "system456",
+      EntityType.PROPERTY,
+      "admin"
+    );
+
+    // Create an operations alert
+    const operationsAlert = await this.alertService.raiseOperationsAlert(
+      "prop123",
+      "Device Temperature High",
+      "Device temperature exceeds normal operating range",
+      "device789",
+      EntityType.DEVICE,
+      "monitor"
+    );
+
+    // Create a security alert
+    const securityAlert = await this.alertService.raiseSecurityAlert(
+      "prop123",
+      "Unauthorized Access Attempt",
+      "Multiple failed login attempts detected",
+      "user123",
+      EntityType.USER,
+      "security-system"
+    );
+
+    // Create an energy alert
+    const energyAlert = await this.alertService.raiseEnergyAlert(
+      "prop123",
+      "High Energy Consumption",
+      "Energy usage is 20% above normal levels",
+      "zone456",
+      EntityType.COLLECTION,
+      "energy-monitor"
+    );
+
+    return { readinessAlert, operationsAlert, securityAlert, energyAlert };
+  }
+
+  /**
+   * Example 3: Using device-specific alert methods
+   */
+  async createDeviceAlerts() {
+    // Create a device alert with default category and severity
+    const deviceAlert1 = await this.alertService.raiseDeviceAlert(
+      "device123",
+      "prop456",
+      "Device Battery Low",
+      "Device battery level is below 20%",
+      undefined, // Use default category
+      undefined, // Use default severity
+      "system"
+    );
+
+    // Create a device alert with custom category and severity
+    const deviceAlert2 = await this.alertService.raiseDeviceAlert(
+      "device789",
+      "prop456",
+      "Device Firmware Update Available",
+      "New firmware version is available for installation",
+      AlertCategory.READINESS,
+      AlertSeverity.MEDIUM,
+      "firmware-manager"
+    );
+
+    return { deviceAlert1, deviceAlert2 };
+  }
+
+  /**
+   * Example 4: Using hub-specific alert methods
+   */
+  async createHubAlerts() {
+    // Create a hub alert with default settings
+    const hubAlert1 = await this.alertService.raiseHubAlert(
+      "hub123",
+      "prop456",
+      "Hub Connection Lost",
+      "Hub has lost connection to the network",
+      undefined, // Use default category
+      undefined, // Use default severity
+      "network-monitor"
+    );
+
+    // Create a hub alert with custom settings
+    const hubAlert2 = await this.alertService.raiseHubAlert(
+      "hub789",
+      "prop456",
+      "Hub Maintenance Required",
+      "Hub requires scheduled maintenance",
+      AlertCategory.READINESS,
+      AlertSeverity.LOW,
+      "maintenance-system"
+    );
+
+    return { hubAlert1, hubAlert2 };
+  }
+
+  /**
+   * Example 5: Using static factory methods with AlertBuilder
+   */
+  async createAlertsWithStaticMethods() {
+    // Create a device alert using static factory method
+    const deviceAlert = AlertBuilder.createDeviceAlert("device123", "prop456")
+      .setCategory(AlertCategory.OPERATIONS)
+      .setTitle("Device Offline")
+      .setDescription("Device has been offline for more than 5 minutes")
+      .setSeverity(AlertSeverity.HIGH)
+      .setCreatedBy("monitor");
+
+    const alert1 = await this.alertService.createAlert(deviceAlert);
+
+    // Create a hub alert using static factory method
+    const hubAlert = AlertBuilder.createHubAlert("hub789", "prop202")
+      .setCategory(AlertCategory.SECURITY)
+      .setTitle("Hub Security Breach")
+      .setDescription("Unauthorized access attempt detected on hub")
+      .setSeverity(AlertSeverity.CRITICAL)
+      .setCreatedBy("security-system");
+
+    const alert2 = await this.alertService.createAlert(hubAlert);
+
+    return { alert1, alert2 };
+  }
+
+  /**
+   * Example 6: Creating multiple alerts efficiently
+   */
+  async createMultipleAlerts() {
+    const alerts = [];
+
+    // Create multiple device alerts efficiently
+    const deviceIds = ["device1", "device2", "device3"];
+    const propertyId = "prop123";
+
+    for (const deviceId of deviceIds) {
+      const alertBuilder = AlertBuilder.createDeviceAlert(deviceId, propertyId)
+        .setCategory(AlertCategory.OPERATIONS)
+        .setTitle(`Device ${deviceId} Status`)
+        .setDescription(`Status check for device ${deviceId}`)
+        .setSeverity(AlertSeverity.MEDIUM)
+        .setCreatedBy("batch-processor");
+
+      const alert = await this.alertService.createAlert(alertBuilder);
+      alerts.push(alert);
+    }
+
+    return alerts;
+  }
+
+  /**
+   * Example 7: Creating alerts with snooze functionality
+   */
+  async createSnoozedAlert() {
+    const snoozeUntil = new Date();
+    snoozeUntil.setHours(snoozeUntil.getHours() + 2); // Snooze for 2 hours
+
+    const alertBuilder = new AlertBuilder()
+      .setCategory(AlertCategory.OTHER)
+      .setPropertyId("prop303")
+      .setTitle("Scheduled Maintenance")
+      .setDescription("System maintenance scheduled for tonight")
+      .setEntityType(EntityType.PROPERTY)
+      .setSeverity(AlertSeverity.INFO)
+      .setCreatedBy("admin")
+      .setSnoozeUntil(snoozeUntil);
+
+    const alert = await this.alertService.createAlert(alertBuilder);
+    return alert;
+  }
+
+  /**
+   * Example 8: Backward compatibility - still works with CreateAlertData
+   */
+  async createAlertWithLegacyData() {
+    const alertData = {
+      category: AlertCategory.OPERATIONS,
+      propertyId: "prop123",
+      title: "Legacy Alert",
+      description: "This alert was created using the old CreateAlertData format",
+      entityId: "device456",
+      entityType: EntityType.DEVICE,
+      severity: AlertSeverity.MEDIUM,
+      createdBy: "legacy-system"
+    };
+
+    // This still works with the updated createAlert method
+    const alert = await this.alertService.createAlert(alertData);
+    return alert;
+  }
+} 

package/src/device/local/services/Device.service.ts

@@ -1,25 +1,21 @@
-import { checkAwsEnv, ensureAuditInitialized } from "../../../config/config";
-import { IDevice } from "../interfaces";
-import { EventHandler } from "../events/EventHandler";
+import { IDevice, INewStatus } from "../interfaces";
+import { EventHandler } from "../../../events/EventHandler";
 import { isEqual } from "lodash";
-import { AlertService } from "./Alert.service";
 import { DeviceRepository } from "../repository/Device.repository";
 import Container from "typedi";
 
 export class LocalDeviceService {
   private readonly eventHandler: EventHandler;
-  private readonly alertService: AlertService;
   private readonly deviceRepository: DeviceRepository;
   constructor() {
-    checkAwsEnv();
-    ensureAuditInitialized();
     this.eventHandler = new EventHandler();
-    this.alertService = new AlertService();
     this.deviceRepository = Container.get(DeviceRepository);
   }
 
-  async createDevice(body: IDevice): Promise<void> {
-    return await this.eventHandler.onDeviceCreate(body);
+  async createDevice(body: IDevice): Promise<IDevice> {
+    const device = await this.deviceRepository.createDevice(body);
+    await this.eventHandler.onDeviceCreate(device);
+    return device;
   }
 
   async getDevice(
@@ -105,6 +101,7 @@ export class LocalDeviceService {
       (key) => !isEqual(oldState[key], newState[key])
     );
     if (changedKeys.length > 0) {
+      await this.deviceRepository.setState(deviceId, newState);
       return await this.eventHandler.onStateChange(deviceId, newState);
     }
   }
@@ -116,31 +113,27 @@ export class LocalDeviceService {
     return await this.deviceRepository.getStatus(deviceId);
   }
 
-  //TODO: Define type of newStatus
-  async setStatus(deviceId: string, newStatus: any) {
+  async setStatus(deviceId: string, newStatus: INewStatus) {
     if (!deviceId || !newStatus) {
       throw new Error("Device ID and new status are required");
     }
-    // If old status and new status are different
+
     const oldStatus = await this.getStatus(deviceId);
-    const changedKeys = Object.keys(newStatus).filter(
-      (key) => !isEqual(oldStatus?.data?.[key], newStatus?.[key])
-    );
-    if (changedKeys.length > 0) {
-      return await this.eventHandler.onStatusChange(deviceId, newStatus);
+    const isStatusChanged = !isEqual(oldStatus, newStatus);
+
+    if (isStatusChanged) {
+      await this.deviceRepository.setStatus(deviceId, newStatus);
+      await this.eventHandler.onStatusChange(deviceId, newStatus);
     }
-    // If both old and new status are offline, check the time difference between the last offline status and current time
-    if (
-      oldStatus?.data?.online === false &&
-      oldStatus?.data?.lastUpdated &&
-      newStatus?.online === false
-    ) {
-      const lastOfflineTime = new Date(oldStatus?.data?.lastUpdated).getTime();
-      const currentTime = Date.now();
-      const timeDifference = currentTime - lastOfflineTime;
-      // Compare it with the baseline profile time of the device. If the difference is higher, then raise an operational alert
-      if (timeDifference > 1000 * 60 * 60 * 24) {
-        return await this.alertService.raiseOperationsAlert();
+
+    const isBothOffline =
+      oldStatus?.online === false && newStatus?.online === false;
+    if (isBothOffline && oldStatus?.lastUpdated) {
+      const timeDifference =
+        Date.now() - new Date(oldStatus.lastUpdated).getTime();
+      if (timeDifference > 86400000) {
+        //return await this.alertService.raiseOperationsAlert();
+        return;
       }
     }
   }
@@ -152,33 +145,31 @@ export class LocalDeviceService {
     return await this.deviceRepository.getBatteryLevel(deviceId);
   }
 
-  //TODO: Define payload type of newBatteryLevel
-  async setBatteryLevel(deviceId: string, newBatteryLevel: any) {
-    if (!deviceId || !newBatteryLevel) {
-      throw new Error("Device ID and new battery level are required");
-    }
-    // If old battery level and new battery level are different
+  async setBatteryLevel(deviceId: string, batteryLevel: number) {
+    // Fetch the old battery level state
     const oldBatteryLevel = await this.getBatteryLevel(deviceId);
-    const changedKeys = Object.keys(newBatteryLevel).filter(
-      (key) => !isEqual(oldBatteryLevel?.data?.[key], newBatteryLevel?.[key])
-    );
-    if (changedKeys.length > 0) {
-      return await this.eventHandler.onBatteryLevelChange(
-        deviceId,
-        newBatteryLevel
-      );
+
+    const isDifferent = !isEqual(oldBatteryLevel?.value, batteryLevel);
+
+    if (isDifferent) {
+      await this.deviceRepository.setBatteryLevel(deviceId, batteryLevel);
+      await this.eventHandler.onBatteryLevelChange(deviceId, batteryLevel);
     }
-    // If current battery level is less than 20% and lsat updated time is more than 8 hours, raise an energy alert
+
+    // Check if battery is low and not updated for 8 hours
     if (
-      newBatteryLevel?.value < 20 &&
-      oldBatteryLevel?.data?.value < 20 &&
-      new Date(oldBatteryLevel?.data?.lastUpdated).getTime() <
-        Date.now() - 1000 * 60 * 60 * 8
+      batteryLevel < 20 &&
+      oldBatteryLevel?.value < 20 &&
+      oldBatteryLevel?.lastUpdated &&
+      new Date(oldBatteryLevel.lastUpdated).getTime() <
+        Date.now() - 1000 * 60 * 60 * 8 // 8 hours in ms
     ) {
-      //TODO: Raise an energy alert
-      await this.alertService.raiseEnergyAlert();
+      // TODO: Raise an energy alert
+      // await this.alertService.raiseEnergyAlert();
+      return;
     }
   }
+
   async getMetaData(deviceId: string) {
     if (!deviceId) {
       throw new Error("Device ID is required");
@@ -189,7 +180,8 @@ export class LocalDeviceService {
     if (!deviceId || !metaData) {
       throw new Error("Device ID and meta data are required");
     }
-    return await this.eventHandler.onDeviceMetaChange(deviceId, metaData);
+    await this.eventHandler.onDeviceMetaChange(deviceId, metaData);
+    return await this.deviceRepository.setMetaData(deviceId, metaData);
   }
 
   async getDevicesByZone(zoneId: string) {
@@ -205,4 +197,34 @@ export class LocalDeviceService {
     }
     return await this.deviceRepository.getDevicesByAccessGroup(accessGroupId);
   }
+
+  async querySelect(query: any, fields: string[]) {
+    if (!query || Object.keys(query).length === 0) {
+      throw new Error("Query is required");
+    }
+    return await this.deviceRepository.querySelect(query, fields);
+  }
+
+  async queryCount(query: any): Promise<number> {
+    if (!query || Object.keys(query).length === 0) {
+      throw new Error("Query is required");
+    }
+    const count = await this.deviceRepository.queryCount(query);
+    return count;
+  }
+
+  async deleteDevices(query: any) {
+    if (!query || Object.keys(query).length === 0) {
+      throw new Error("Query is required");
+    }
+    return await this.deviceRepository.deleteDevices(query);
+  }
+
+  async queryDevices(query: any) {
+    if (!query || Object.keys(query).length === 0) {
+      throw new Error("Query is required");
+    }
+    const count = await this.deviceRepository.queryDevices(query);
+    return count;
+  }
 }