dt-common-device 1.0.20 → 1.2.1

package/src/device/local/events/EventHandler.ts

@@ -0,0 +1,101 @@
+import { eventDispatcher } from "dt-pub-sub";
+import { publishAudit } from "dt-audit-library";
+import { DeviceEvents } from "./Events";
+
+export class EventHandler {
+  private readonly source = "dt-common-device";
+  constructor() {}
+
+  async onDeviceCreate(body: any) {
+    await eventDispatcher.publishEvent(
+      DeviceEvents.DEVICE_CREATED,
+      body,
+      this.source
+    );
+    const payload = {
+      eventType: DeviceEvents.DEVICE_CREATED,
+      properties: {
+        ...body,
+      },
+    };
+    await publishAudit(payload);
+  }
+
+  async onDeviceUpdate(deviceId: string, body: any) {
+    await eventDispatcher.publishEvent(
+      DeviceEvents.DEVICE_UPDATED,
+      { deviceId, body },
+      this.source
+    );
+    const payload = {
+      eventType: DeviceEvents.DEVICE_UPDATED,
+      properties: {
+        ...body,
+      },
+    };
+    await publishAudit(payload);
+  }
+
+  async onDeviceDelete(deviceId: string) {
+    await eventDispatcher.publishEvent(
+      DeviceEvents.DEVICE_DELETED,
+      { deviceId },
+      this.source
+    );
+    const payload = {
+      eventType: DeviceEvents.DEVICE_DELETED,
+      properties: {
+        deviceId,
+      },
+    };
+    await publishAudit(payload);
+  }
+
+  async onStateChange(deviceId: string, state: any) {
+    await eventDispatcher.publishEvent(
+      DeviceEvents.DEVICE_STATE_SET,
+      { deviceId, state },
+      this.source
+    );
+    const payload = {
+      eventType: DeviceEvents.DEVICE_STATE_SET,
+      properties: {
+        deviceId,
+        state,
+      },
+    };
+    await publishAudit(payload);
+  }
+
+  async onStatusChange(deviceId: string, status: any) {
+    await eventDispatcher.publishEvent(
+      DeviceEvents.DEVICE_STATUS_SET,
+      { deviceId, status },
+      this.source
+    );
+    const payload = {
+      eventType: DeviceEvents.DEVICE_STATUS_SET,
+      properties: {
+        deviceId,
+        status,
+      },
+    };
+    await publishAudit(payload);
+  }
+
+  async onBatteryLevelChange(deviceId: string, batteryLevel: number) {
+    await eventDispatcher.publishEvent(
+      DeviceEvents.DEVICE_BATTERY_SET,
+      { deviceId, batteryLevel },
+      this.source
+    );
+    const payload = {
+      eventType: DeviceEvents.DEVICE_BATTERY_SET,
+      properties: {
+        deviceId,
+        batteryLevel,
+      },
+    };
+    await publishAudit(payload);
+  }
+}

package/src/device/local/events/Events.ts

@@ -0,0 +1,23 @@
+export const DeviceEvents = {
+  DEVICE_CREATED: "device.created",
+  DEVICE_UPDATED: "device.updated",
+  DEVICE_DELETED: "device.deleted",
+  DEVICE_STATE_SET: "device.state.set",
+  DEVICE_STATUS_SET: "device.status.set",
+  DEVICE_BATTERY_SET: "device.battery.set",
+  DEVICE_META_DATA_SET: "device.metaData.set",
+};
+
+export const ConnectionEvents = {
+  CONNECTION_UPDATED: "connection.updated",
+  CONNECTION_DELETED: "connection.deleted",
+  CONNECTION_CREATED: "connection.created",
+};
+
+export const PropertyEvents = {
+  PROPERTY_UPDATED: "property.updated",
+  PROPERTY_DELETED: "property.deleted",
+  PROPERTY_CREATED: "property.created",
+  PROPERTY_PREFERENCES_UPDATED: "property.preferences.updated",
+  PROPERTY_PREFERENCES_CREATED: "property.preferences.created",
+};

package/src/device/local/interfaces/IDtDevice.ts

@@ -0,0 +1,16 @@
+export interface IDtDevice {
+  id: string;
+  name: string;
+  type: string;
+  zoneId: string;
+  deviceType: string;
+  deviceId: string;
+  deviceNetworkId: string;
+  propertyId: string;
+  connectionId: string;
+  hubId: string;
+  isBatteryLowAlertSent: boolean;
+  createdAt: string;
+  updatedAt: string;
+  isActive: boolean;
+}

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

@@ -1,2 +1 @@
 export * from "./IDevice";
-export * from "./IHub";

package/src/device/local/repository/Connection.repository.ts

@@ -0,0 +1,32 @@
+import { getPostgresClient } from "../../../db";
+import { IConnection } from "../../cloud/types";
+import { Service } from "typedi";
+
+@Service()
+export class ConnectionRepository {
+  private readonly pool;
+  constructor() {
+    this.pool = getPostgresClient();
+  }
+  async getConnectionById(connectionId: string): Promise<IConnection> {
+    const result = await this.pool.query(
+      "SELECT * FROM dt_connections WHERE id = $1",
+      [connectionId]
+    );
+    return result.rows[0];
+  }
+
+  async updateConnection(connectionId: string, data: Partial<IConnection>) {
+    // Build dynamic SET clause
+    const setClause = Object.keys(data)
+      .map((key, index) => `${key} = $${index + 2}`)
+      .join(", ");
+
+    const values = Object.values(data);
+    const result = await this.pool.query(
+      `UPDATE dt_connections SET ${setClause}, updated_at = NOW() WHERE id = $1 RETURNING *`,
+      [connectionId, ...values]
+    );
+    return result.rows[0];
+  }
+}

package/src/device/local/repository/Device.repository.ts

@@ -0,0 +1,106 @@
+import axios from "axios";
+import { IDevice } from "../interfaces/IDevice";
+import { getConfig } from "../../../config/config";
+import { getPostgresClient } from "../../../db";
+import { Service } from "typedi";
+import { IDtDevice } from "../interfaces/IDtDevice";
+
+@Service()
+export class DeviceRepository {
+  private readonly baseUrl: string;
+  private readonly postgres;
+  constructor() {
+    const { DEVICE_SERVICE } = getConfig();
+    if (!DEVICE_SERVICE) {
+      throw new Error(
+        "DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE."
+      );
+    }
+    this.baseUrl = DEVICE_SERVICE;
+    this.postgres = getPostgresClient();
+  }
+
+  async getDevice(
+    deviceId: string,
+    withHubDetails: boolean = false
+  ): Promise<IDevice> {
+    try {
+      const response = await axios.get(
+        `${this.baseUrl}/devices/${deviceId}?withHubDetails=${withHubDetails} `
+      );
+      return response.data;
+    } catch (error: any) {
+      console.log(error);
+      throw new Error(`Failed to get device: ${error.message}`);
+    }
+  }
+
+  async getDevices(
+    deviceIds: string[],
+    withHubDetails: boolean = false
+  ): Promise<IDevice[]> {
+    return await axios.get(`${this.baseUrl}/devices`, {
+      params: { deviceIds, withHubDetails },
+    });
+  }
+
+  async getPropertyDevices(
+    propertyId: string,
+    withHubDetails: boolean = false
+  ): Promise<IDevice[]> {
+    return await axios.get(`${this.baseUrl}/devices`, {
+      params: { propertyId, withHubDetails },
+    });
+  }
+
+  async getState(deviceId: string): Promise<any> {
+    return await axios.get(`${this.baseUrl}/devices/${deviceId}/state`);
+  }
+
+  async getStatus(deviceId: string): Promise<Record<string, any>> {
+    return await axios.get(`${this.baseUrl}/devices/${deviceId}/status`);
+  }
+
+  async getBatteryLevel(deviceId: string): Promise<Record<string, any>> {
+    return await axios.get(`${this.baseUrl}/devices/${deviceId}/battery-level`);
+  }
+
+  async getMetaData(deviceId: string): Promise<any> {
+    return await axios.get(`${this.baseUrl}/devices/${deviceId}/metaData`);
+  }
+
+  async getDevicesByAccessGroup(accessGroupId: string): Promise<IDtDevice[]> {
+    try {
+      const result = await this.postgres.query(
+        `SELECT d.* FROM dt_devices d
+         INNER JOIN dt_zones_collection_map zcm ON d.zoneId = zcm.zoneId
+         WHERE zcm.collectionId = $1`,
+        [accessGroupId]
+      );
+
+      if (result.rows.length > 0) {
+        return result.rows;
+      }
+      return [];
+    } catch (error) {
+      console.log(error);
+      throw new Error("Failed to get devices by access group");
+    }
+  }
+
+  async getDevicesByZone(zoneId: string): Promise<IDtDevice[]> {
+    try {
+      const result = await this.postgres.query(
+        "SELECT * FROM dt_devices WHERE zoneId = $1",
+        [zoneId]
+      );
+      if (result.rows.length > 0) {
+        return result.rows;
+      }
+      return [];
+    } catch (error) {
+      console.log(error);
+      throw new Error("Failed to get device by zone");
+    }
+  }
+}

package/src/device/local/repository/Hub.repository.ts

@@ -0,0 +1,51 @@
+import axios from "axios";
+import { getConfig } from "../../../config/config";
+import { getPostgresClient } from "../../../db";
+import { Service } from "typedi";
+import { IDevice } from "../interfaces";
+
+@Service()
+export class HubRepository {
+  private readonly baseUrl: string;
+  private readonly postgres;
+  constructor() {
+    const { DEVICE_SERVICE } = getConfig();
+    if (!DEVICE_SERVICE) {
+      throw new Error(
+        "DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE."
+      );
+    }
+    this.baseUrl = DEVICE_SERVICE;
+    this.postgres = getPostgresClient();
+  }
+
+  async addHub(body: any): Promise<IDevice> {
+    return await axios.post(`${this.baseUrl}/devices/hubs`, body);
+  }
+
+  async getHubs(hubIds: string[]): Promise<IDevice[]> {
+    const query = hubIds && hubIds.length ? `?ids=${hubIds.join(",")}` : "";
+    return await axios.get(`${this.baseUrl}/devices/hubs${query}`);
+  }
+
+  async getHub(hubId: string): Promise<IDevice> {
+    return await axios.get(`${this.baseUrl}/devices/hubs/${hubId}`);
+  }
+
+  async updateHub(hubId: string, body: any): Promise<IDevice> {
+    return await axios.put(`${this.baseUrl}/devices/hubs/${hubId}`, body);
+  }
+
+  async getStatus(hubId: string): Promise<"ONLINE" | "OFFLINE" | "UNKNOWN"> {
+    return await axios.get(`${this.baseUrl}/devices/hubs/${hubId}/status`);
+  }
+
+  async deleteHub(hubId: string): Promise<any> {
+    return await axios.delete(`${this.baseUrl}/devices/hubs/${hubId}`);
+  }
+
+  async deleteAllHubs(hubIds: string[]): Promise<any> {
+    const query = hubIds.length ? `?ids=${hubIds.join(",")}` : "";
+    return await axios.delete(`${this.baseUrl}/devices/hubs${query}`);
+  }
+}

package/src/device/local/repository/Property.repository.ts

@@ -0,0 +1,32 @@
+import { getPostgresClient } from "../../../db";
+import { Service } from "typedi";
+
+@Service()
+export class PropertyRepository {
+  private readonly postgres;
+  constructor() {
+    this.postgres = getPostgresClient();
+  }
+
+  async getPropertyPreferences(
+    propertyId: string
+  ): Promise<{ id: string; propertyId: string; settings: string } | null> {
+    try {
+      const propertyPreferences = await this.postgres.query(
+        "SELECT * FROM dt_property_settings WHERE propertyId = $1",
+        [propertyId]
+      );
+      if (propertyPreferences.rows.length > 0) {
+        return {
+          id: propertyPreferences.rows[0].id,
+          propertyId: propertyPreferences.rows[0].propertyId,
+          settings: JSON.parse(propertyPreferences.rows[0].settings),
+        };
+      }
+      return null;
+    } catch (error) {
+      console.log(error);
+      throw new Error("Failed to get property preferences");
+    }
+  }
+}

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

@@ -1,16 +1,18 @@
-import { getPostgresClient } from "../../../db";
-import { IConnection } from "../interfaces/IConnection";
+import { Container } from "typedi";
+import { IConnection } from "../../cloud/types";
+import { ConnectionRepository } from "../repository/Connection.repository";
+
 export class LocalConnectionService {
-  private readonly pool;
+  private readonly connectionRepository: ConnectionRepository;
   constructor() {
-    this.pool = getPostgresClient();
+    this.connectionRepository = Container.get(ConnectionRepository);
   }
 
   async getConnection(connectionId: string): Promise<IConnection> {
-    const result = await this.pool.query(
-      "SELECT * FROM dt_connections WHERE id = $1",
-      [connectionId]
-    );
-    return result.rows[0];
+    return await this.connectionRepository.getConnectionById(connectionId);
+  }
+
+  async updateConnection(connectionId: string, data: any) {
+    return await this.connectionRepository.updateConnection(connectionId, data);
   }
 }

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

@@ -7,111 +7,66 @@ import {
 import { IDevice } from "../interfaces";
 import { eventDispatcher } from "dt-pub-sub";
 import { publishAudit } from "dt-audit-library";
-import { EventHandler } from "../handler/EventHandler";
+import { EventHandler } from "../events/EventHandler";
 import { isEqual } from "lodash";
 import { AlertService } from "./Alert.service";
 import { getPostgresClient } from "../../../db";
+import { DeviceRepository } from "../repository/Device.repository";
+import Container from "typedi";
 
 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;
+  private readonly deviceRepository: DeviceRepository;
   constructor() {
-    const { DEVICE_SERVICE } = getConfig();
-    if (!DEVICE_SERVICE) {
-      throw new Error(
-        "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();
+    this.deviceRepository = Container.get(DeviceRepository);
   }
 
   async createDevice(body: IDevice): Promise<void> {
-    await eventDispatcher.publishEvent("device.created", body, this.source);
-    const payload = {
-      eventType: "device.created",
-      properties: {
-        ...body,
-      },
-    };
-    await publishAudit(payload);
+    return await this.eventHandler.onDeviceCreate(body);
   }
 
   async getDevice(
     deviceId: string,
     withHubDetails: boolean = false
   ): Promise<IDevice> {
-    try {
-      const response = await axios.get(
-        `${this.baseUrl}/devices/${deviceId}?withHubDetails=${withHubDetails} `
-      );
-      return response.data;
-    } catch (error: any) {
-      console.log(error);
-      throw new Error(`Failed to get device: ${error.message}`);
-    }
+    return await this.deviceRepository.getDevice(deviceId, withHubDetails);
   }
 
   async getDevices(
     deviceIds: string[],
     withHubDetails: boolean = false
   ): Promise<IDevice[]> {
-    return await axios.get(`${this.baseUrl}/devices`, {
-      params: { deviceIds, withHubDetails },
-    });
+    return await this.deviceRepository.getDevices(deviceIds, withHubDetails);
   }
 
   async getPropertyDevices(
     propertyId: string,
     withHubDetails: boolean = false
   ): Promise<IDevice[]> {
-    return await axios.get(`${this.baseUrl}/devices`, {
-      params: { propertyId, withHubDetails },
-    });
+    return await this.deviceRepository.getPropertyDevices(
+      propertyId,
+      withHubDetails
+    );
   }
 
   async updateDevice(deviceId: string, body: any): Promise<any> {
-    //return await axios.put(`${this.baseUrl}/devices/${deviceId}`, body);
-    await eventDispatcher.publishEvent(
-      "device.updated",
-      { deviceId, body },
-      this.source
-    );
-    const payload = {
-      eventType: "device.updated",
-      properties: {
-        ...body,
-      },
-    };
-    await publishAudit(payload);
+    return await this.eventHandler.onDeviceUpdate(deviceId, body);
   }
 
   async deleteDevice(deviceId: string): Promise<any> {
-    await eventDispatcher.publishEvent(
-      "device.deleted",
-      { deviceId },
-      this.source
-    );
-    const payload = {
-      eventType: "device.deleted",
-      properties: {
-        deviceId,
-      },
-    };
-    await publishAudit(payload);
+    return await this.eventHandler.onDeviceDelete(deviceId);
   }
 
   async getState(deviceId: string) {
-    return await axios.get(`${this.baseUrl}/devices/${deviceId}/state`);
+    return await this.deviceRepository.getState(deviceId);
   }
 
   async setState(deviceId: string, newState: any) {
@@ -126,7 +81,7 @@ export class LocalDeviceService {
   }
 
   async getStatus(deviceId: string) {
-    return await axios.get(`${this.baseUrl}/devices/${deviceId}/status`);
+    return await this.deviceRepository.getStatus(deviceId);
   }
 
   async setStatus(deviceId: string, newStatus: any) {
@@ -155,7 +110,7 @@ export class LocalDeviceService {
   }
 
   async getBatteryLevel(deviceId: string) {
-    return await axios.get(`${this.baseUrl}/devices/${deviceId}/battery-level`);
+    return await this.deviceRepository.getBatteryLevel(deviceId);
   }
   async setBatteryLevel(deviceId: string, newBatteryLevel: any) {
     // If old battery level and new battery level are different
@@ -181,7 +136,7 @@ export class LocalDeviceService {
     }
   }
   async getMetaData(deviceId: string) {
-    return await axios.get(`${this.baseUrl}/devices/${deviceId}/metaData`);
+    return await this.deviceRepository.getMetaData(deviceId);
   }
   async setMetaData(deviceId: string, metaData: Record<string, any>) {
     await eventDispatcher.publishEvent(
@@ -199,54 +154,11 @@ export class LocalDeviceService {
     await publishAudit(payload);
   }
 
-  async getDeviceByZone(zoneId: string) {
-    try {
-      // 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) {
-        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");
-    }
+  async getDevicesByZone(zoneId: string) {
+    return await this.deviceRepository.getDevicesByZone(zoneId);
   }
 
   async getDevicesByAccessGroup(accessGroupId: string) {
-    try {
-      // Fetch from Postgres if not in cache
-      const result = await this.postgres.query(
-        "SELECT * FROM dt_group WHERE id = $1",
-        [accessGroupId]
-      );
-      if (result.rows.length > 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.postgres.query(
-        "SELECT * FROM dt_property_settings WHERE propertyId = $1",
-        [propertyId]
-      );
-      if (propertyPreferences.rows.length > 0) {
-        return propertyPreferences.rows[0];
-      }
-      return null;
-    } catch (error) {
-      console.log(error);
-      throw new Error("Failed to get property preferences");
-    }
+    return await this.deviceRepository.getDevicesByAccessGroup(accessGroupId);
   }
 }

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

@@ -1,49 +1,38 @@
-import axios from "axios";
-import { getConfig } from "../../../config/config";
-import { IHub } from "../interfaces";
-
-export class HubService {
-  private readonly baseUrl: string;
+import { IDevice } from "../interfaces";
+import { HubRepository } from "../repository/Hub.repository";
+import Container from "typedi";
 
+export class LocalHubService {
+  private readonly hubRepository: HubRepository;
   constructor() {
-    const { DEVICE_SERVICE } = getConfig();
-    if (!DEVICE_SERVICE) {
-      throw new Error(
-        "DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE."
-      );
-    }
-    this.baseUrl = DEVICE_SERVICE;
+    this.hubRepository = Container.get(HubRepository);
   }
 
-  async addHub(body: IHub): Promise<any> {
-    return await axios.post(`${this.baseUrl}/devices/hubs`, body);
+  async addHub(body: IDevice): Promise<IDevice> {
+    return await this.hubRepository.addHub(body);
   }
 
-  //get hubs takes an array of hub ids as query params
-  async getHubs(hubIds: string[]): Promise<IHub[]> {
-    const query = hubIds && hubIds.length ? `?ids=${hubIds.join(",")}` : "";
-    return await axios.get(`${this.baseUrl}/devices/hubs${query}`);
+  async getHubs(hubIds: string[]): Promise<IDevice[]> {
+    return await this.hubRepository.getHubs(hubIds);
   }
 
-  //get hub takes a hub id in params
-  async getHub(hubId: string): Promise<IHub> {
-    return await axios.get(`${this.baseUrl}/devices/hubs/${hubId}`);
+  async getHub(hubId: string): Promise<IDevice> {
+    return await this.hubRepository.getHub(hubId);
   }
 
-  async updateHub(hubId: string, body: any): Promise<any> {
-    return await axios.put(`${this.baseUrl}/devices/hubs/${hubId}`, body);
+  async updateHub(hubId: string, body: Partial<IDevice>): Promise<IDevice> {
+    return await this.hubRepository.updateHub(hubId, body);
   }
 
   async getStatus(hubId: string): Promise<any> {
-    return await axios.get(`${this.baseUrl}/devices/hubs/${hubId}/status`);
+    return await this.hubRepository.getStatus(hubId);
   }
 
   async deleteHub(hubId: string): Promise<any> {
-    return await axios.delete(`${this.baseUrl}/devices/hubs/${hubId}`);
+    return await this.hubRepository.deleteHub(hubId);
   }
 
   async deleteAllHubs(hubIds: string[]): Promise<any> {
-    const query = hubIds.length ? `?ids=${hubIds.join(",")}` : "";
-    return await axios.delete(`${this.baseUrl}/devices/hubs${query}`);
+    return await this.hubRepository.deleteAllHubs(hubIds);
   }
 }