dt-common-device 3.0.1 → 3.0.3

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

@@ -1,15 +1,26 @@
 import { IDevice, IStatus } from "../interfaces";
-import { EventHandler } from "src/events/EventHandler";
+import { EventHandler } from "../../../events/EventHandler";
 import { isEqual } from "lodash";
 import { DeviceRepository } from "../repository/Device.repository";
 import Container from "typedi";
+import { AlertService } from "../../../alerts/Alert.service";
+import { IssueService } from "../../../issues/Issue.service";
+import { Source } from "../../../constants/Service";
+import { getConfig } from "../../../config/config";
 
 export class LocalDeviceService {
   private readonly eventHandler: EventHandler;
   private readonly deviceRepository: DeviceRepository;
+  private readonly alertService: AlertService;
+  private readonly issueService: IssueService;
+  private readonly logger;
+
   constructor() {
     this.eventHandler = new EventHandler();
     this.deviceRepository = Container.get(DeviceRepository);
+    this.alertService = Container.get(AlertService);
+    this.issueService = Container.get(IssueService);
+    this.logger = getConfig().LOGGER;
   }
 
   async createDevice(body: IDevice): Promise<IDevice> {
@@ -117,31 +128,168 @@ export class LocalDeviceService {
     return await this.deviceRepository.getStatus(deviceId);
   }
 
-  async setStatus(deviceId: string, newStatus: IStatus) {
+  async setStatus(
+    deviceId: string,
+    newStatus: IStatus,
+    source: Source,
+    reason?: string
+  ) {
     if (!deviceId || !newStatus) {
       throw new Error("Device ID and new status are required");
     }
 
-    const oldStatus = await this.getStatus(deviceId);
-    const isStatusChanged = !isEqual(oldStatus, newStatus);
+    const device = await this.getDevice(deviceId);
+    const oldStatus = device.status;
+    const currentTime = new Date().toISOString();
+
+    // Determine if the new status is ONLINE or OFFLINE
+    const isNewStatusOnline = newStatus.liveStatus === "ONLINE";
+    const isNewStatusOffline = newStatus.liveStatus === "OFFLINE";
+
+    if (isNewStatusOffline) {
+      // New Status = OFFLINE
+      await this.handleOfflineStatus(
+        deviceId,
+        device,
+        oldStatus,
+        newStatus,
+        source,
+        reason,
+        currentTime
+      );
+    } else if (isNewStatusOnline) {
+      // New Status = ONLINE
+      await this.handleOnlineStatus(
+        deviceId,
+        device,
+        oldStatus,
+        newStatus,
+        source,
+        reason,
+        currentTime
+      );
+    } else {
+      // For any other status, just update normally
+      await this.deviceRepository.setStatus(deviceId, newStatus);
+      await this.eventHandler.onStatusChange(deviceId, newStatus);
+    }
+  }
+
+  private async handleOfflineStatus(
+    deviceId: string,
+    device: IDevice,
+    oldStatus: any,
+    newStatus: IStatus,
+    source: Source,
+    reason?: string,
+    currentTime?: string
+  ) {
+    const isExistingStatusOnline = oldStatus?.online === true;
+    const isExistingStatusOffline = oldStatus?.online === false;
+
+    if (isExistingStatusOnline) {
+      // Existing status is Online
+      newStatus.online = true;
+      newStatus.liveStatus = "OFFLINE";
+      newStatus.lastUpdated = currentTime;
+      newStatus.error = {
+        type: "offline",
+        message: reason || "Device went offline",
+        default: {},
+      };
 
-    if (isStatusChanged) {
       await this.deviceRepository.setStatus(deviceId, newStatus);
       await this.eventHandler.onStatusChange(deviceId, newStatus);
+    } else if (isExistingStatusOffline) {
+      // Existing status is Offline
+      const timeLapsed = oldStatus?.lastUpdated
+        ? Date.now() - new Date(oldStatus.lastUpdated).getTime()
+        : 0;
+
+      const baselineTime = await this.getDeviceBaseline(deviceId);
+
+      if (timeLapsed > baselineTime) {
+        // When the time lapsed is higher than the baseline time
+        newStatus.online = false;
+        newStatus.liveStatus = "OFFLINE";
+        newStatus.lastUpdated = currentTime;
+        newStatus.error = {
+          type: "offline",
+          message: reason || "Device has been offline for longer than baseline",
+          default: {},
+        };
+
+        await this.deviceRepository.setStatus(deviceId, newStatus);
+        await this.eventHandler.onStatusChange(deviceId, newStatus);
+
+        // Raise alert
+        await this.alertService.raiseDeviceOfflineAlert(device, source, reason);
+
+        // Raise issue when the device goes offline if longer than the baseline
+        await this.issueService.createDeviceOfflineIssue(
+          device,
+          source,
+          reason
+        );
+      }
     }
+  }
+
+  private async handleOnlineStatus(
+    deviceId: string,
+    device: IDevice,
+    oldStatus: any,
+    newStatus: IStatus,
+    source: Source,
+    reason?: string,
+    currentTime?: string
+  ) {
+    const isExistingStatusOnline = oldStatus?.online === true;
+    const isExistingStatusOffline = oldStatus?.online === false;
 
-    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();
+    if (isExistingStatusOnline) {
+      // Existing status is Online
+      if (oldStatus?.liveStatus === "ONLINE") {
+        // liveStatus = Online → Do nothing
         return;
+      } else if (oldStatus?.liveStatus === "OFFLINE") {
+        // liveStatus = Offline → Follow the step #2 (same as existing status is Offline)
+        newStatus.online = true;
+        newStatus.liveStatus = "ONLINE";
+        newStatus.lastUpdated = currentTime;
+        newStatus.error = {}; // Clear the error
+
+        await this.deviceRepository.setStatus(deviceId, newStatus);
+        await this.eventHandler.onStatusChange(deviceId, newStatus);
+
+        //TODO: ALERT NEEDED?
+        //  Raise alert
+        await this.alertService.raiseDeviceOnlineAlert(device, source, reason);
       }
+    } else if (isExistingStatusOffline) {
+      // Existing status is Offline
+      newStatus.online = true;
+      newStatus.liveStatus = "ONLINE";
+      newStatus.lastUpdated = currentTime;
+      newStatus.error = undefined; // Clear the error
+
+      await this.deviceRepository.setStatus(deviceId, newStatus);
+      await this.eventHandler.onStatusChange(deviceId, newStatus);
+
+      //TODO: ALERT NEEDED?
+      //  Raise alert
+      await this.alertService.raiseDeviceOnlineAlert(device, source, reason);
     }
   }
 
+  private async getDeviceBaseline(deviceId: string): Promise<number> {
+    // TODO: Implement device baseline retrieval
+    // This should return the baseline time in milliseconds for the specific device
+    // For now, returning a default value of 5 minutes (300000ms)
+    // In a real implementation, this would fetch from device configuration or settings
+    return 3600000; // 1 hour in milliseconds
+  }
+
   async getBatteryLevel(deviceId: string) {
     if (!deviceId) {
       throw new Error("Device ID is required");
@@ -149,29 +297,83 @@ export class LocalDeviceService {
     return await this.deviceRepository.getBatteryLevel(deviceId);
   }
 
-  async setBatteryLevel(deviceId: string, batteryLevel: number) {
+  async setBatteryLevel(
+    deviceId: string,
+    batteryLevel: number,
+    source: Source
+  ) {
+    if (!deviceId || batteryLevel === undefined || batteryLevel === null) {
+      throw new Error("Device ID and battery level are required");
+    }
+
+    // Get device information
+    const device = await this.getDevice(deviceId);
+
     // Fetch the old battery level state
-    const oldBatteryLevel = await this.getBatteryLevel(deviceId);
+    const oldBatteryLevel = device.state?.batteryPercentage;
 
+    // Check if battery level has changed
     const isDifferent = !isEqual(oldBatteryLevel?.value, batteryLevel);
 
     if (isDifferent) {
-      await this.deviceRepository.setBatteryLevel(deviceId, batteryLevel);
-      await this.eventHandler.onBatteryLevelChange(deviceId, batteryLevel);
-    }
-
-    // Check if battery is low and not updated for 8 hours
-    if (
-      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();
-      return;
+      // Check if current time is greater than or equal to last updated time (8-hour logic)
+      const shouldUpdate = this.shouldUpdateBatteryLevel(
+        oldBatteryLevel?.lastUpdated
+      );
+
+      if (shouldUpdate) {
+        // Save the battery level in the device
+        await this.deviceRepository.setBatteryLevel(deviceId, batteryLevel);
+        await this.eventHandler.onBatteryLevelChange(deviceId, batteryLevel);
+
+        // Get property threshold
+        const propertyThreshold = await this.getPropertyBatteryThreshold(
+          device.propertyId
+        );
+
+        // Check if battery level is below threshold
+        if (batteryLevel < propertyThreshold) {
+          // Raise alert
+          await this.alertService.raiseDeviceBatteryAlert(
+            device,
+            batteryLevel,
+            propertyThreshold,
+            source
+          );
+
+          // Raise issue when the level is below threshold
+          await this.issueService.createDeviceBatteryIssue(
+            device,
+            batteryLevel,
+            propertyThreshold,
+            source
+          );
+        }
+      }
+    }
+  }
+
+  private shouldUpdateBatteryLevel(lastUpdated?: string): boolean {
+    if (!lastUpdated) {
+      return true; // No previous update, so we should update
     }
+
+    const lastUpdateTime = new Date(lastUpdated).getTime();
+    const currentTime = Date.now();
+    const eightHoursInMs = 8 * 60 * 60 * 1000; // 8 hours in milliseconds
+
+    // Return true if current time is greater than or equal to last updated time + 8 hours
+    return currentTime >= lastUpdateTime + eightHoursInMs;
+  }
+
+  private async getPropertyBatteryThreshold(
+    propertyId: string
+  ): Promise<number> {
+    // TODO: Implement property battery threshold retrieval
+    // This should return the battery threshold for the specific property
+    // For now, returning a default value of 20%
+    // In a real implementation, this would fetch from property configuration or settings
+    return 20; // 20% default threshold
   }
 
   async getMetaData(deviceId: string) {

package/src/events/BaseEventHandler.ts

@@ -1,8 +1,8 @@
 import { DeviceEvent } from "./interfaces/DeviceEvent";
 import { IEventHandler } from "./interfaces/IEventHandler";
-import { getConfig } from "src/config/config";
-import { ILogger } from "src/config/config.types";
-import { LocalDeviceService } from "src/device/local/services/Device.service";
+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[];

package/src/events/BaseEventTransformer.ts

@@ -1,5 +1,5 @@
-import { getConfig } from "src/config/config";
-import { ILogger } from "src/config/config.types";
+import { getConfig } from "../config/config";
+import { ILogger } from "../config/config.types";
 import { DeviceEvent } from "./interfaces/DeviceEvent";
 import { IEventTransformer } from "./interfaces/IEventTransformer";
 

package/src/events/DeviceEventHandler.ts

@@ -1,6 +1,7 @@
-import { DT_EVENT_TYPES } from "src/constants/Event";
-import { IDevice } from "src/device/local/interfaces";
-import { LocalHubService } from "src/device/local/services";
+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,
@@ -82,7 +83,8 @@ export class DeviceEventHandler extends BaseEventHandler {
       case DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED:
         await this.localDeviceService.setBatteryLevel(
           deviceData.deviceId,
-          event?.data?.batteryLevel ?? 0
+          event?.data?.batteryLevel ?? 0,
+          Source.CLOUD_EVENT
         );
         break;
     }

package/src/events/EventHandler.ts

@@ -1,6 +1,6 @@
 import { eventDispatcher } from "dt-pub-sub";
 import { publishAudit } from "dt-audit-library";
-import { DT_EVENT_TYPES } from "src/constants/Event";
+import { DT_EVENT_TYPES } from "../constants/Event";
 
 export class EventHandler {
   private readonly source: string;

package/src/events/EventHandlerOrchestrator.ts

@@ -1,8 +1,8 @@
 import { Service } from "typedi";
 import { IEventHandler } from "./interfaces/IEventHandler";
 import { DeviceEvent } from "./interfaces/DeviceEvent";
-import { ILogger } from "src/config/config.types";
-import { getConfig } from "src/config/config";
+import { ILogger } from "../config/config.types";
+import { getConfig } from "../config/config";
 
 @Service()
 export class EventHandlerOrchestrator {

package/src/events/EventProcessingService.ts

@@ -1,7 +1,7 @@
 import { Service } from "typedi";
 import { DeviceEventHandler } from "./DeviceEventHandler";
-import { ILogger } from "src/config/config.types";
-import { getConfig } from "src/config/config";
+import { ILogger } from "../config/config.types";
+import { getConfig } from "../config/config";
 import { DeviceEvent } from "./interfaces/DeviceEvent";
 import { IEventTransformer } from "./interfaces/IEventTransformer";
 import { EventHandlerOrchestrator } from "./EventHandlerOrchestrator";

package/src/events/InternalEventSubscription.ts

@@ -1,5 +1,5 @@
 import { eventDispatcher } from "dt-pub-sub";
-import { getConfig } from "src/config/config";
+import { getConfig } from "../config/config";
 import {
   IInternalEvent,
   HeartbeatEventData,
@@ -7,7 +7,7 @@ import {
   ReservationEventData,
   ServiceEventData,
 } from "./interfaces/IInternalEvent";
-import { ILogger } from "src/config/config.types";
+import { ILogger } from "../config/config.types";
 
 // Event types enum for better type safety
 export enum InternalEventType {

package/src/index.ts

@@ -1,5 +1,8 @@
 // Main entry point for dt-common-device
 
+// CONSTANTS EXPORTS
+export * from "./constants";
+
 // DEVICE EXPORTS
 export {
   CloudDevice,

package/src/issues/Issue.service.ts

@@ -11,6 +11,8 @@ import {
   EntityType,
 } from "./issue.types";
 import { IssueBuilder } from "./IssueBuilder";
+import { Source } from "../constants/Service";
+import { IDevice } from "../device/local/interfaces";
 
 @Service()
 export class IssueService {
@@ -132,7 +134,7 @@ export class IssueService {
     propertyId: string,
     title: string,
     description: string,
-    createdBy: string,
+    source: Source,
     category?: IssuesCategory,
     priority?: IssuePriority,
     assignedTo?: string,
@@ -141,7 +143,7 @@ export class IssueService {
     const issueBuilder = IssueBuilder.createDeviceIssue(deviceId, propertyId)
       .setTitle(title)
       .setDescription(description)
-      .setCreatedBy(createdBy);
+      .setCreatedBy(source);
 
     if (category) issueBuilder.setCategory(category);
     if (priority) issueBuilder.setPriority(priority);
@@ -205,6 +207,49 @@ export class IssueService {
     return await this.createIssue(issueBuilder);
   }
 
+  /**
+   * Create issue for device going offline longer than baseline
+   */
+  async createDeviceOfflineIssue(
+    device: IDevice,
+    source: Source,
+    reason?: string
+  ): Promise<IIssueDocument> {
+    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,
+      IssuesCategory.OPERATIONS,
+      IssuePriority.HIGH
+    );
+  }
+
+  /**
+   * Create issue for device battery level below threshold
+   */
+  async createDeviceBatteryIssue(
+    device: IDevice,
+    batteryLevel: number,
+    threshold: number,
+    source: Source
+  ): Promise<IIssueDocument> {
+    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,
+      IssuesCategory.ENERGY,
+      IssuePriority.MEDIUM
+    );
+  }
+
   /**
    * Create a maintenance issue using IssueBuilder
    */
@@ -218,7 +263,11 @@ export class IssueService {
     assignedTo?: string,
     dueDate?: Date
   ): Promise<IIssueDocument> {
-    const issueBuilder = IssueBuilder.createMaintenanceIssue(propertyId, entityId, entityType)
+    const issueBuilder = IssueBuilder.createMaintenanceIssue(
+      propertyId,
+      entityId,
+      entityType
+    )
       .setTitle(title)
       .setDescription(description)
       .setCreatedBy(createdBy);
@@ -242,7 +291,11 @@ export class IssueService {
     assignedTo?: string,
     dueDate?: Date
   ): Promise<IIssueDocument> {
-    const issueBuilder = IssueBuilder.createUrgentIssue(propertyId, entityId, entityType)
+    const issueBuilder = IssueBuilder.createUrgentIssue(
+      propertyId,
+      entityId,
+      entityType
+    )
       .setTitle(title)
       .setDescription(description)
       .setCreatedBy(createdBy);
@@ -257,7 +310,9 @@ export class IssueService {
    * Create a new issue with business logic validation
    * Accepts either a CreateIssueData object or an IssueBuilder instance
    */
-  async createIssue(issueData: CreateIssueData | IssueBuilder): Promise<IIssueDocument> {
+  async createIssue(
+    issueData: CreateIssueData | IssueBuilder
+  ): Promise<IIssueDocument> {
     let processedIssueData: CreateIssueData;
 
     // Handle IssueBuilder instance
@@ -272,11 +327,16 @@ export class IssueService {
 
     // Business logic: Set default priority if not provided
     if (!processedIssueData.priority) {
-      processedIssueData.priority = this.determineDefaultPriority(processedIssueData.category);
+      processedIssueData.priority = this.determineDefaultPriority(
+        processedIssueData.category
+      );
     }
 
     // Business logic: Validate due date is in the future
-    if (processedIssueData.dueDate && processedIssueData.dueDate <= new Date()) {
+    if (
+      processedIssueData.dueDate &&
+      processedIssueData.dueDate <= new Date()
+    ) {
       throw new Error("Due date must be in the future");
     }
 

package/src/issues/IssueService.example.ts

@@ -1,3 +1,4 @@
+import { Source } from "../constants";
 import { IssueService } from "./Issue.service";
 import { IssueBuilder } from "./IssueBuilder";
 import { IssuesCategory, IssuePriority, EntityType } from "./issue.types";
@@ -96,7 +97,7 @@ export class IssueServiceExample {
       "prop456",
       "Device Battery Low",
       "Device battery level is below 20%",
-      "system",
+      Source.CLOUD_EVENT,
       undefined, // Use default category
       undefined, // Use default priority
       "maintenance-team",
@@ -109,7 +110,7 @@ export class IssueServiceExample {
       "prop456",
       "Device Firmware Update Available",
       "New firmware version is available for installation",
-      "firmware-manager",
+      Source.CLOUD_EVENT,
       IssuesCategory.READINESS,
       IssuePriority.MEDIUM,
       "admin",
@@ -299,6 +300,7 @@ export class IssueServiceExample {
       assignedTo: "tech-support",
       createdBy: "legacy-system",
       dueDate: new Date("2024-01-20"),
+      source: Source.CLOUD_EVENT,
     };
 
     // This still works with the updated createIssue method

package/src/queue/entities/HybridHttpQueue.ts

@@ -166,6 +166,7 @@ export class HybridHttpQueue {
     method: string;
     url: string;
     body?: any;
+    params?: Record<string, any>;
     headers?: Record<string, string>;
     queueOptions?: {
       connectionId: string;
@@ -173,11 +174,12 @@ export class HybridHttpQueue {
       microservice: string;
     };
   }): Promise<IQueueResponse> {
-    const { method, url, body, headers, queueOptions } = options;
+    const { method, url, body, params, headers, queueOptions } = options;
     // Create HttpCallOption object
     const httpCallOption: HttpCallOption = {
       headers,
       body,
+      params,
       queueOptions,
     };
     // Call handleRequest with the constructed parameters

package/src/queue/interfaces/IHybridHttpQueue.ts

@@ -6,6 +6,7 @@ export interface IHybridHttpQueue {
     method: string;
     url: string;
     body?: any;
+    params?: Record<string, any>;
     headers?: Record<string, string>;
     queueOptions?: {
       connectionId: string;

package/src/queue/services/QueueService.ts

@@ -15,6 +15,7 @@ export class QueueService implements IHybridHttpQueue {
     method: string;
     url: string;
     body?: any;
+    params?: Record<string, any>;
     headers?: Record<string, string>;
     queueOptions?: {
       connectionId: string;

package/src/queue/types/http.types.ts

@@ -13,6 +13,7 @@ export interface HttpRequestOptions {
   method: string;
   url: string;
   body?: any;
+  params?: Record<string, any>;
   headers?: Record<string, string>;
   queueOptions?: {
     connectionId: string;

package/tsconfig.json

@@ -6,10 +6,6 @@
     "declaration": true,
     "outDir": "./dist",
     "rootDir": "./src",
-    "baseUrl": ".",
-    "paths": {
-      "src/*": ["src/*"]
-    },
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,