dt-common-device 1.3.0 → 2.0.1

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

@@ -1,23 +1,30 @@
-import axios from "axios";
-import { IDevice } from "../interfaces/IDevice";
+import { IDevice, INewStatus } from "../interfaces/IDevice";
 import { getConfig } from "../../../config/config";
 import { getPostgresClient } from "../../../db";
 import { Service } from "typedi";
 import { IDtDevice } from "../interfaces/IDtDevice";
+import { getDeviceServiceAxiosInstance } from "../../../utils/http-utils";
 
 @Service()
 export class DeviceRepository {
-  private readonly baseUrl: string;
   private readonly postgres;
+  private readonly axiosInstance;
+
   constructor() {
-    const { DEVICE_SERVICE } = getConfig();
-    if (!DEVICE_SERVICE) {
+    this.postgres = getPostgresClient();
+    this.axiosInstance = getDeviceServiceAxiosInstance();
+  }
+
+  async createDevice(body: IDevice): Promise<IDevice> {
+    try {
+      const response = await this.axiosInstance.post(`/devices`, body);
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error("Failed to create device:", error);
       throw new Error(
-        "DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE."
+        `Failed to create device: ${error.message || "Unknown error"}`
       );
     }
-    this.baseUrl = DEVICE_SERVICE;
-    this.postgres = getPostgresClient();
   }
 
   async getDevice(
@@ -25,13 +32,15 @@ export class DeviceRepository {
     withHubDetails: boolean = false
   ): Promise<IDevice> {
     try {
-      const response = await axios.get(
-        `${this.baseUrl}/devices/${deviceId}?withHubDetails=${withHubDetails} `
+      const response = await this.axiosInstance.get(
+        `/devices/${deviceId}?withHubDetails=${withHubDetails} `
       );
       return response.data;
     } catch (error: any) {
-      console.log(error);
-      throw new Error(`Failed to get device: ${error.message}`);
+      getConfig().LOGGER.error(`Failed to get device ${deviceId}:`, error);
+      throw new Error(
+        `Failed to get device: ${error.message || "Unknown error"}`
+      );
     }
   }
 
@@ -39,10 +48,17 @@ export class DeviceRepository {
     deviceIds: string[],
     withHubDetails: boolean = false
   ): Promise<IDevice[]> {
-    const response = await axios.get(`${this.baseUrl}/devices`, {
-      params: { deviceIds, withHubDetails },
-    });
-    return response.data;
+    try {
+      const response = await this.axiosInstance.get(`/devices`, {
+        params: { deviceIds, withHubDetails },
+      });
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error("Failed to get devices:", error);
+      throw new Error(
+        `Failed to get devices: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async getPropertyDevices(
@@ -51,10 +67,20 @@ export class DeviceRepository {
     type?: string,
     withHubDetails: boolean = false
   ): Promise<IDevice[]> {
-    const response = await axios.get(`${this.baseUrl}/devices`, {
-      params: { propertyId, selectDeviceId, type, withHubDetails },
-    });
-    return response.data;
+    try {
+      const response = await this.axiosInstance.get(`/devices`, {
+        params: { propertyId, selectDeviceId, type, withHubDetails },
+      });
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(
+        `Failed to get property devices for ${propertyId}:`,
+        error
+      );
+      throw new Error(
+        `Failed to get property devices: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async getPropertyDeviceIds(
@@ -62,26 +88,160 @@ export class DeviceRepository {
     selectDeviceId: boolean = false,
     manufacturer: string
   ) {
-    const response = await axios.get(`${this.baseUrl}/devices`, {
-      params: { propertyId, selectDeviceId, manufacturer },
-    });
-    return response.data;
+    try {
+      const response = await this.axiosInstance.get(`/devices`, {
+        params: { propertyId, selectDeviceId, manufacturer },
+      });
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(
+        `Failed to get property device IDs for ${propertyId}:`,
+        error
+      );
+      throw new Error(
+        `Failed to get property device IDs: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async getState(deviceId: string): Promise<any> {
-    return await axios.get(`${this.baseUrl}/devices/${deviceId}/state`);
+    try {
+      const response = await this.axiosInstance.get(
+        `/devices/${deviceId}/state`
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(
+        `Failed to get device state for ${deviceId}:`,
+        error
+      );
+      throw new Error(
+        `Failed to get device state: ${error.message || "Unknown error"}`
+      );
+    }
+  }
+
+  async setState(deviceId: string, state: any): Promise<any> {
+    try {
+      const response = await this.axiosInstance.put(
+        `/devices/${deviceId}/state`,
+        state
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(
+        `Failed to set device state for ${deviceId}:`,
+        error
+      );
+      throw new Error(
+        `Failed to set device state: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async getStatus(deviceId: string): Promise<Record<string, any>> {
-    return await axios.get(`${this.baseUrl}/devices/${deviceId}/status`);
+    try {
+      const response = await this.axiosInstance.get(
+        `/devices/${deviceId}/status`
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(
+        `Failed to get device status for ${deviceId}:`,
+        error
+      );
+      throw new Error(
+        `Failed to get device status: ${error.message || "Unknown error"}`
+      );
+    }
+  }
+
+  async setStatus(deviceId: string, newStatus: INewStatus) {
+    try {
+      const response = await this.axiosInstance.put(
+        `/devices/${deviceId}/status`,
+        newStatus
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(
+        `Failed to set device status for ${deviceId}:`,
+        error
+      );
+      throw new Error(
+        `Failed to set device status: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async getBatteryLevel(deviceId: string): Promise<Record<string, any>> {
-    return await axios.get(`${this.baseUrl}/devices/${deviceId}/battery-level`);
+    try {
+      const response = await this.axiosInstance.get(
+        `/devices/${deviceId}/battery-level`
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(
+        `Failed to get battery level for ${deviceId}:`,
+        error
+      );
+      throw new Error(
+        `Failed to get battery level: ${error.message || "Unknown error"}`
+      );
+    }
+  }
+
+  async setBatteryLevel(deviceId: string, newBatteryLevel: any) {
+    try {
+      const response = await this.axiosInstance.put(
+        `/devices/${deviceId}/battery-level`,
+        { newBatteryLevel }
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(
+        `Failed to set battery level for ${deviceId}:`,
+        error
+      );
+      throw new Error(
+        `Failed to set battery level: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async getMetaData(deviceId: string): Promise<any> {
-    return await axios.get(`${this.baseUrl}/devices/${deviceId}/metaData`);
+    try {
+      const response = await this.axiosInstance.get(
+        `/devices/${deviceId}/metaData`
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(
+        `Failed to get metadata for ${deviceId}:`,
+        error
+      );
+      throw new Error(
+        `Failed to get metadata: ${error.message || "Unknown error"}`
+      );
+    }
+  }
+
+  async setMetaData(deviceId: string, metaData: Record<string, any>) {
+    try {
+      const response = await this.axiosInstance.put(
+        `/devices/${deviceId}/metaData`,
+        metaData
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(
+        `Failed to set metadata for ${deviceId}:`,
+        error
+      );
+      throw new Error(
+        `Failed to set metadata: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async getDevicesByAccessGroup(accessGroupId: string): Promise<IDtDevice[]> {
@@ -98,7 +258,10 @@ export class DeviceRepository {
       }
       return [];
     } catch (error) {
-      console.log(error);
+      getConfig().LOGGER.error(
+        `Failed to get devices by access group ${accessGroupId}:`,
+        error
+      );
       throw new Error("Failed to get devices by access group");
     }
   }
@@ -114,8 +277,66 @@ export class DeviceRepository {
       }
       return [];
     } catch (error) {
-      console.log(error);
+      getConfig().LOGGER.error(
+        `Failed to get devices by zone ${zoneId}:`,
+        error
+      );
       throw new Error("Failed to get device by zone");
     }
   }
+
+  async querySelect(query: any, fields: string[]) {
+    try {
+      const response = await this.axiosInstance.post(`/devices/select`, {
+        query,
+        fields,
+      });
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error("Failed to query select devices:", error);
+      throw new Error(
+        `Failed to query select devices: ${error.message || "Unknown error"}`
+      );
+    }
+  }
+
+  //remove - use existing query function
+  async queryCount(query: any): Promise<number> {
+    try {
+      const response = await this.axiosInstance.post(`/devices/count`, query);
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error("Failed to query count devices:", error);
+      throw new Error(
+        `Failed to query count devices: ${error.message || "Unknown error"}`
+      );
+    }
+  }
+
+  async deleteDevices(query: any) {
+    try {
+      const response = await this.axiosInstance.post(
+        `/devices/deleteMany`,
+        query
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error("Failed to delete devices:", error);
+      throw new Error(
+        `Failed to delete devices: ${error.message || "Unknown error"}`
+      );
+    }
+  }
+
+  async queryDevices(query: any) {
+    try {
+      const response = await this.axiosInstance.post(`/devices/query`, query);
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error("Failed to query devices:", error);
+      throw new Error(
+        `Failed to query devices: ${error.message || "Unknown error"}`
+      );
+    }
+  }
 }

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

@@ -1,51 +1,107 @@
-import axios from "axios";
 import { getConfig } from "../../../config/config";
 import { getPostgresClient } from "../../../db";
 import { Service } from "typedi";
 import { IDevice } from "../interfaces";
+import { getDeviceServiceAxiosInstance } from "../../../utils/http-utils";
 
 @Service()
 export class HubRepository {
-  private readonly baseUrl: string;
   private readonly postgres;
+  private readonly axiosInstance;
+
   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();
+    this.axiosInstance = getDeviceServiceAxiosInstance();
   }
 
   async addHub(body: Partial<IDevice>): Promise<IDevice> {
-    return await axios.post(`${this.baseUrl}/devices/hubs`, body);
+    try {
+      const response = await this.axiosInstance.post(`/devices/hubs`, body);
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error("Failed to add hub:", error);
+      throw new Error(`Failed to add hub: ${error.message || "Unknown error"}`);
+    }
   }
 
   async getHubs(hubIds: string[]): Promise<IDevice[]> {
-    const query = hubIds && hubIds.length ? `?ids=${hubIds.join(",")}` : "";
-    return await axios.get(`${this.baseUrl}/devices/hubs${query}`);
+    try {
+      const query = hubIds && hubIds.length ? `?ids=${hubIds.join(",")}` : "";
+      const response = await this.axiosInstance.get(`/devices/hubs${query}`);
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error("Failed to get hubs:", error);
+      throw new Error(
+        `Failed to get hubs: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async getHub(hubId: string): Promise<IDevice> {
-    return await axios.get(`${this.baseUrl}/devices/hubs/${hubId}`);
+    try {
+      const response = await this.axiosInstance.get(`/devices/hubs/${hubId}`);
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(`Failed to get hub ${hubId}:`, error);
+      throw new Error(
+        `Failed to get hub ${hubId}: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async updateHub(hubId: string, body: any): Promise<IDevice> {
-    return await axios.put(`${this.baseUrl}/devices/hubs/${hubId}`, body);
+    try {
+      const response = await this.axiosInstance.put(
+        `/devices/hubs/${hubId}`,
+        body
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(`Failed to update hub ${hubId}:`, error);
+      throw new Error(
+        `Failed to update hub ${hubId}: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async getStatus(hubId: string): Promise<"ONLINE" | "OFFLINE" | "UNKNOWN"> {
-    return await axios.get(`${this.baseUrl}/devices/hubs/${hubId}/status`);
+    try {
+      const response = await this.axiosInstance.get(
+        `/devices/hubs/${hubId}/status`
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(`Failed to get hub status ${hubId}:`, error);
+      throw new Error(
+        `Failed to get hub status ${hubId}: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async deleteHub(hubId: string): Promise<any> {
-    return await axios.delete(`${this.baseUrl}/devices/hubs/${hubId}`);
+    try {
+      const response = await this.axiosInstance.delete(
+        `/devices/hubs/${hubId}`
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(`Failed to delete hub ${hubId}:`, error);
+      throw new Error(
+        `Failed to delete hub ${hubId}: ${error.message || "Unknown error"}`
+      );
+    }
   }
 
   async deleteAllHubs(hubIds: string[]): Promise<any> {
-    const query = hubIds.length ? `?ids=${hubIds.join(",")}` : "";
-    return await axios.delete(`${this.baseUrl}/devices/hubs${query}`);
+    try {
+      const query = hubIds.length ? `?ids=${hubIds.join(",")}` : "";
+      const response = await this.axiosInstance.delete(`/devices/hubs${query}`);
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error("Failed to delete all hubs:", error);
+      throw new Error(
+        `Failed to delete all hubs: ${error.message || "Unknown error"}`
+      );
+    }
   }
 }