dt-common-device 1.2.4 → 1.2.5

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

@@ -1,16 +1,27 @@
-import { checkAwsEnv, ensureAuditInitialized } from "../../../config/config";
+import axios from "axios";
+import {
+  getConfig,
+  checkAwsEnv,
+  ensureAuditInitialized,
+} from "../../../config/config";
 import { IDevice } from "../interfaces";
+import { eventDispatcher } from "dt-pub-sub";
+import { publishAudit } from "dt-audit-library";
 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 source = "dt-common-device";
   private readonly eventHandler: EventHandler;
   private readonly alertService: AlertService;
+  //private readonly redis;
   private readonly deviceRepository: DeviceRepository;
   constructor() {
+    // this.redis = getRedisClient();
     checkAwsEnv();
     ensureAuditInitialized();
     this.eventHandler = new EventHandler();
@@ -26,9 +37,6 @@ export class LocalDeviceService {
     deviceId: string,
     withHubDetails: boolean = false
   ): Promise<IDevice> {
-    if (!deviceId) {
-      throw new Error("Device ID is required");
-    }
     return await this.deviceRepository.getDevice(deviceId, withHubDetails);
   }
 
@@ -36,9 +44,6 @@ export class LocalDeviceService {
     deviceIds: string[],
     withHubDetails: boolean = false
   ): Promise<IDevice[]> {
-    if (!deviceIds.length) {
-      throw new Error("At least one device ID is required");
-    }
     return await this.deviceRepository.getDevices(deviceIds, withHubDetails);
   }
 
@@ -46,9 +51,6 @@ export class LocalDeviceService {
     propertyId: string,
     withHubDetails: boolean = false
   ): Promise<IDevice[]> {
-    if (!propertyId) {
-      throw new Error("Property ID is required");
-    }
     return await this.deviceRepository.getPropertyDevices(
       propertyId,
       withHubDetails
@@ -56,30 +58,18 @@ export class LocalDeviceService {
   }
 
   async updateDevice(deviceId: string, body: any): Promise<any> {
-    if (!deviceId) {
-      throw new Error("Device ID is required");
-    }
     return await this.eventHandler.onDeviceUpdate(deviceId, body);
   }
 
   async deleteDevice(deviceId: string): Promise<any> {
-    if (!deviceId) {
-      throw new Error("Device ID is required");
-    }
     return await this.eventHandler.onDeviceDelete(deviceId);
   }
 
   async getState(deviceId: string) {
-    if (!deviceId) {
-      throw new Error("Device ID is required");
-    }
     return await this.deviceRepository.getState(deviceId);
   }
 
   async setState(deviceId: string, newState: any) {
-    if (!deviceId || !newState) {
-      throw new Error("Device ID and new state are required");
-    }
     // If old state and new state are different
     const oldState = (await this.getState(deviceId))?.data?.state || {};
     const changedKeys = Object.keys(newState).filter(
@@ -91,16 +81,10 @@ export class LocalDeviceService {
   }
 
   async getStatus(deviceId: string) {
-    if (!deviceId) {
-      throw new Error("Device ID is required");
-    }
     return await this.deviceRepository.getStatus(deviceId);
   }
 
   async setStatus(deviceId: string, newStatus: any) {
-    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(
@@ -126,15 +110,9 @@ export class LocalDeviceService {
   }
 
   async getBatteryLevel(deviceId: string) {
-    if (!deviceId) {
-      throw new Error("Device ID is required");
-    }
     return await this.deviceRepository.getBatteryLevel(deviceId);
   }
   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
     const oldBatteryLevel = await this.getBatteryLevel(deviceId);
     const changedKeys = Object.keys(newBatteryLevel).filter(
@@ -158,29 +136,29 @@ export class LocalDeviceService {
     }
   }
   async getMetaData(deviceId: string) {
-    if (!deviceId) {
-      throw new Error("Device ID is required");
-    }
     return await this.deviceRepository.getMetaData(deviceId);
   }
   async setMetaData(deviceId: string, metaData: Record<string, any>) {
-    if (!deviceId || !metaData) {
-      throw new Error("Device ID and meta data are required");
-    }
-    return await this.eventHandler.onDeviceMetaChange(deviceId, metaData);
+    await eventDispatcher.publishEvent(
+      "device.metaData.set",
+      { deviceId, metaData },
+      this.source
+    );
+    const payload = {
+      eventType: "device.metaData.set",
+      properties: {
+        deviceId,
+        metaData,
+      },
+    };
+    await publishAudit(payload);
   }
 
   async getDevicesByZone(zoneId: string) {
-    if (!zoneId) {
-      throw new Error("Zone ID is required");
-    }
     return await this.deviceRepository.getDevicesByZone(zoneId);
   }
 
   async getDevicesByAccessGroup(accessGroupId: string) {
-    if (!accessGroupId) {
-      throw new Error("Access Group ID is required");
-    }
     return await this.deviceRepository.getDevicesByAccessGroup(accessGroupId);
   }
 }

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

@@ -8,50 +8,31 @@ export class LocalHubService {
     this.hubRepository = Container.get(HubRepository);
   }
 
-  async addHub(body: Partial<IDevice>): Promise<IDevice> {
+  async addHub(body: IDevice): Promise<IDevice> {
     return await this.hubRepository.addHub(body);
   }
 
   async getHubs(hubIds: string[]): Promise<IDevice[]> {
-    if (!hubIds.length) {
-      throw new Error("At least one hub ID is required");
-    }
     return await this.hubRepository.getHubs(hubIds);
   }
 
   async getHub(hubId: string): Promise<IDevice> {
-    if (!hubId) {
-      throw new Error("Hub ID is required");
-    }
     return await this.hubRepository.getHub(hubId);
   }
 
   async updateHub(hubId: string, body: Partial<IDevice>): Promise<IDevice> {
-    if (!hubId) {
-      throw new Error("Hub ID is required");
-    }
     return await this.hubRepository.updateHub(hubId, body);
   }
 
   async getStatus(hubId: string): Promise<any> {
-    if (!hubId) {
-      throw new Error("Hub ID is required");
-    }
     return await this.hubRepository.getStatus(hubId);
   }
 
   async deleteHub(hubId: string): Promise<any> {
-    if (!hubId) {
-      throw new Error("Hub ID is required");
-    }
     return await this.hubRepository.deleteHub(hubId);
   }
 
-
   async deleteAllHubs(hubIds: string[]): Promise<any> {
-    if (!hubIds.length) {
-      throw new Error("At least one hub ID is required");
-    }
     return await this.hubRepository.deleteAllHubs(hubIds);
   }
 }

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

@@ -7,27 +7,23 @@ export class LocalPropertyService {
   }
 
   async getPropertyPreferences(propertyId: string) {
-    if (!propertyId) {
-      throw new Error("Property ID is required");
-    }
     return await this.propertyRepository.getPropertyPreferences(propertyId);
   }
 
   async getProperty(propertyId: string) {
-    if (!propertyId) {
-      throw new Error("Property ID is required");
-    }
     return await this.propertyRepository.getProperty(propertyId);
   }
 
   async getPropertyTimeZone(propertyId: string) {
-    if (!propertyId) {
-      throw new Error("Property ID is required");
-    }
     const property = await this.propertyRepository.getProperty(propertyId);
     if (!property) {
       throw new Error("Property not found");
     }
     return property.timezone;
   }
+
+  async getAllProperties() {
+    const properties = await this.propertyRepository.getAllProperties();
+    return properties;
+  }
 }

package/src/index.ts

@@ -3,8 +3,9 @@
 // Cloud exports
 export {
   CloudDevice,
-  CloudDeviceService,
   DeviceFactory,
+  CloudConnection,
+  CloudDeviceService,
 } from "./device/cloud/entities";
 export {
   LocalDeviceService,
@@ -15,6 +16,7 @@ export {
 } from "./device/local/services";
 
 export * from "./device/cloud/interfaces";
+export * from "./device/cloud/types";
 
 // Local exports
 export * from "./device/local/interfaces";

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

@@ -1,27 +0,0 @@
-export interface IConnection {
-  id?: string;
-  createdAt?: Date;
-  updatedAt?: Date;
-  isDeleted?: boolean;
-  connectionName: string;
-  connectionRefId: string;
-  propertyId: string;
-  connectionProvider: ConnectionProvider;
-  accessToken?: string;
-  refreshToken?: string;
-  clientId?: string;
-  clientSecret: string;
-  isActive?: boolean;
-  metaData?: any;
-}
-
-export enum ConnectionProvider {
-  Smartthings = "Smartthings",
-  SaltoKS = "SaltoKS",
-  TTLock = "TTLock",
-  Tuya = "Tuya",
-  Schlage = "Schlage",
-  YaleWifi = "YaleWifi",
-  Sensibo = "Sensibo",
-  Devicethread = "Devicethread",
-}