dt-common-device 1.0.12 → 1.0.14

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

@@ -0,0 +1,15 @@
+import { getPostgresClient } from "../../../db";
+export class ConnectionService {
+  private readonly pool;
+  constructor() {
+    this.pool = getPostgresClient();
+  }
+
+  async getConnection(connectionId: string) {
+    const result = await this.pool.query(
+      "SELECT * FROM dt_connections WHERE id = $1",
+      [connectionId]
+    );
+    return result.rows[0];
+  }
+}

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

@@ -1,4 +1,3 @@
-//TODO: Import Redis
 import axios from "axios";
 import {
   getConfig,
@@ -10,12 +9,16 @@ import { eventDispatcher } from "dt-pub-sub";
 import { publishAudit } from "dt-audit-library";
 import { EventHandler } from "../handler/EventHandler";
 import { isEqual } from "lodash";
+import { AlertService } from "./Alert.service";
+import { getRedisClient, getPostgresClient } from "../../../db";
 
-export class DeviceService {
+export class LocalDeviceService {
   private readonly baseUrl: string;
   private readonly source = "dt-common-device";
   private readonly eventHandler: EventHandler;
-
+  private readonly alertService: AlertService;
+  private readonly redis;
+  private readonly postgres;
   constructor() {
     const { DEVICE_SERVICE } = getConfig();
     if (!DEVICE_SERVICE) {
@@ -23,10 +26,13 @@ export class DeviceService {
         "DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE."
       );
     }
+    this.redis = getRedisClient();
+    this.postgres = getPostgresClient();
     this.baseUrl = DEVICE_SERVICE;
     checkAwsEnv();
     ensureAuditInitialized();
     this.eventHandler = new EventHandler();
+    this.alertService = new AlertService();
   }
 
   async createDevice(body: IDevice): Promise<void> {
@@ -103,14 +109,11 @@ export class DeviceService {
   }
 
   async setState(deviceId: string, state: any) {
-    // If old status and new status are different
+    // If old state and new state are different
     const oldState = await this.getState(deviceId);
-    if (!isEqual(oldState, state)) {
-      this.eventHandler.onStateChange(deviceId, state);
+    if (!isEqual(oldState?.data?.state, state)) {
+      return await this.eventHandler.onStateChange(deviceId, state);
     }
-    // If offline, check the time difference between the last offline status and current time
-    // Compare it with the baseline profile time of the device. If the difference is higher, then raise an operational alert
-    //deviceAlertService.raiseOperationalAlert();
   }
 
   async getStatus(deviceId: string) {
@@ -121,25 +124,43 @@ export class DeviceService {
     // If old status and new status are different
     const oldStatus = await this.getStatus(deviceId);
     if (!isEqual(oldStatus, status)) {
-      this.eventHandler.onStatusChange(deviceId, status);
+      return await this.eventHandler.onStatusChange(deviceId, status);
+    }
+    // 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 &&
+      status?.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();
+      }
     }
-    // If offline, check the time difference between the last offline status and current time
-    // Compare it with the baseline profile time of the device. If the difference is higher, then raise an operational alert
-    //deviceAlertService.raiseOperationalAlert();
   }
 
   async getBatteryLevel(deviceId: string) {
     return await axios.get(`${this.baseUrl}/devices/${deviceId}/battery-level`);
   }
   async setBatteryLevel(deviceId: string, batteryLevel: number) {
-    // If old status and new status are different
-
-    // and the last battery level received time more than 8 hours {
-    this.eventHandler.onBatteryLevelChange(deviceId, batteryLevel);
-    //       if(batteryLevel < propertySettingBatteryThreshold) {
-    //            deviceAlertService.raiseEnergyAlert({});
-    //       }
-    //  }
+    // If old battery level and new battery level are different
+    const oldBatteryLevel = await this.getBatteryLevel(deviceId);
+    if (!isEqual(oldBatteryLevel?.data?.value, batteryLevel)) {
+      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
+    if (
+      batteryLevel < 20 &&
+      oldBatteryLevel?.data?.value < 20 &&
+      new Date(oldBatteryLevel?.data?.lastUpdated).getTime() <
+        Date.now() - 1000 * 60 * 60 * 8
+    ) {
+      //TODO: Raise an energy alert
+      await this.alertService.raiseEnergyAlert();
+    }
   }
   async getMetaData(deviceId: string) {
     return await axios.get(`${this.baseUrl}/devices/${deviceId}/metaData`);
@@ -162,11 +183,25 @@ export class DeviceService {
 
   async getDeviceByZone(zoneId: string) {
     try {
-      //Step 1: Check if zone data available in redis
-      //Step 2: If not available, fetch uaing smart-cloud-node zone api
-      //Step 3: Store the zone data in redis
-      //Step 4: Return the zone data
-      //Step 5: If zone data is available in redis, return the zone data
+      // Step 1: Check if zone data is available in Redis
+      let cached = await this.redis.get(`zone:${zoneId}`);
+      if (cached) {
+        // Parse if stored as JSON string
+        return typeof cached === "string" ? JSON.parse(cached) : cached;
+      }
+
+      // If not available, fetch from PostgreSQL DB
+      const result = await this.postgres.query(
+        "SELECT * FROM dt_devices WHERE zoneId = $1",
+        [zoneId]
+      );
+      if (result.rows.length > 0) {
+        // Store in Redis as JSON string
+        await this.redis.set(`zone:${zoneId}`, JSON.stringify(result.rows[0]));
+        return result.rows[0];
+      }
+      // If data is not available, return null
+      return null;
     } catch (error) {
       console.log(error);
       throw new Error("Failed to get device by zone");
@@ -175,14 +210,55 @@ export class DeviceService {
 
   async getDevicesByAccessGroup(accessGroupId: string) {
     try {
-      //Step 1: Check if access group data available in redis
-      //Step 2: If not available, fetch using smart-cloud-node access-group api
-      //Step 3: Store the access group data in redis
-      //Step 4: Return the access group data
-      //Step 5: If access group data is available in redis, return the access group data
+      // Try to get from Redis
+      let cached = await this.redis.get(`accessGroup:${accessGroupId}`);
+      if (cached) {
+        return typeof cached === "string" ? JSON.parse(cached) : cached;
+      }
+      // Fetch from Postgres if not in cache
+      const result = await this.postgres.query(
+        "SELECT * FROM access_groups WHERE id = $1",
+        [accessGroupId]
+      );
+      if (result.rows.length > 0) {
+        // Cache in Redis as JSON string
+        await this.redis.set(
+          `accessGroup:${accessGroupId}`,
+          JSON.stringify(result.rows[0])
+        );
+        return result.rows[0];
+      }
+      return null;
     } catch (error) {
       console.log(error);
       throw new Error("Failed to get devices by access group");
     }
   }
+
+  async getPropertyPreferences(propertyId: string) {
+    try {
+      const propertyPreferences = await this.redis.get(
+        `propertyPreferences:${propertyId}`
+      );
+      if (!propertyPreferences) {
+        const propertyPreferences = await this.postgres.query(
+          "SELECT * FROM property_preferences WHERE property_id = $1",
+          [propertyId]
+        );
+        if (propertyPreferences.rows.length > 0) {
+          await this.redis.set(
+            `propertyPreferences:${propertyId}`,
+            propertyPreferences.rows[0]
+          );
+          return propertyPreferences.rows[0];
+        }
+        return null;
+      } else {
+        return propertyPreferences;
+      }
+    } catch (error) {
+      console.log(error);
+      throw new Error("Failed to get property preferences");
+    }
+  }
 }

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

@@ -1,2 +1,3 @@
-export { DeviceService as LocalDeviceService } from "./Device.service";
+export { LocalDeviceService } from "./Device.service";
 export { HubService as LocalHubService } from "./Hub.service";
+export { ConnectionService } from "./Connection.service";

package/src/index.ts

@@ -3,16 +3,20 @@
 // Cloud exports
 export {
   CloudDeviceService,
-  CloudHubService,
-  CloudConnectionService,
+  ConnectionService as CloudConnectionService,
 } from "./device/cloud/services";
-export { LocalDeviceService, LocalHubService } from "./device/local/services";
+export { CloudDevice, DeviceFactory } from "./device/cloud/entities";
+export {
+  LocalDeviceService,
+  LocalHubService,
+  ConnectionService,
+} from "./device/local/services";
 
-export * as cloudInterfaces from "./device/cloud/interfaces";
+export * from "./device/cloud/interfaces";
 export * from "./device/cloud/types";
 
 // Local exports
-export * as localInterfaces from "./device/local/interfaces";
+export * from "./device/local/interfaces";
 
 //initialize export
 export { initialize, getConfig } from "./config/config";

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

@@ -1,41 +0,0 @@
-import { IDeviceService } from "../interfaces";
-import { IConnection, IDevice } from "../types";
-
-export abstract class DeviceService implements IDeviceService {
-  // IDevice properties
-  deviceId!: string;
-  propertyId!: string;
-  name!: string;
-  hubId!: string[];
-  deviceType!: {
-    id: string;
-    type: string;
-  };
-  status!: {
-    online: boolean;
-    error?: {
-      type?: string;
-      message?: string;
-    };
-    lastUpdated?: string;
-  };
-  state?: Record<string, any>;
-  metaData?: Record<string, any>;
-  zone?: {
-    id: string;
-    name: string;
-    zoneType: string;
-    parentZone?: { id: string; name: string; zoneType: string };
-  };
-  connection!: IConnection;
-
-  constructor(device: IDevice) {
-    Object.assign(this, device);
-  }
-
-  abstract getDevices(connection: IConnection): Promise<Record<string, any>[]>;
-  abstract getDevice(connectionId: string, deviceId: string): Promise<any>;
-  abstract getBattery(deviceId: string): Promise<number | string>;
-  abstract getStatus(connectionId: string, deviceId: string): Promise<string>;
-  abstract getState(deviceId: string): Promise<string>;
-}

package/src/device/cloud/services/Hub.service.ts

@@ -1,34 +0,0 @@
-import { IHubService } from "../interfaces";
-import { IConnection, IDevice } from "../types";
-
-export abstract class HubService implements IHubService {
-  // IDevice properties
-  deviceId!: string;
-  propertyId!: string;
-  name!: string;
-  deviceType!: {
-    id: string;
-    type: string;
-  };
-  status!: {
-    online: boolean;
-    error?: {
-      type?: string;
-      message?: string;
-    };
-    lastUpdated?: string;
-  };
-  metaData?: Record<string, any>;
-  connection!: IConnection;
-
-  constructor(hub: IDevice) {
-    Object.assign(this, hub);
-  }
-  
-  abstract getHubs(connectionId: string): Promise<any[] | null>;
-  abstract getHub(
-    connectionId: string,
-    hubId: string
-  ): Promise<Record<string, any>>;
-  abstract getStatus(connectionId: string, hubId: string): Promise<string>;
-}