dt-common-device 3.0.9 → 3.0.11

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

@@ -1,436 +0,0 @@
-import { IDevice, IStatus } from "../interfaces";
-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> {
-    const device = await this.deviceRepository.createDevice(body);
-    await this.eventHandler.onDeviceCreate(device);
-    return device;
-  }
-
-  async getDevice(
-    deviceId: string,
-    withHubDetails: boolean = false
-  ): Promise<IDevice> {
-    if (!deviceId) {
-      throw new Error("Device ID is required");
-    }
-    return await this.deviceRepository.getDevice(deviceId, withHubDetails);
-  }
-
-  async getDevices(
-    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);
-  }
-
-  async getPropertyDevices(
-    propertyId: string,
-    selectDeviceId: boolean = false,
-    type?: string,
-    withHubDetails: boolean = false
-  ): Promise<IDevice[]> {
-    if (!propertyId) {
-      throw new Error("Property ID is required");
-    }
-    return await this.deviceRepository.getPropertyDevices(
-      propertyId,
-      selectDeviceId,
-      type,
-      withHubDetails
-    );
-  }
-
-  async getPropertyDeviceIds(
-    propertyId: string,
-    selectDeviceId: boolean = false,
-    type: string
-  ) {
-    if (!propertyId) {
-      throw new Error("Property ID is required");
-    }
-    return await this.deviceRepository.getPropertyDeviceIds(
-      propertyId,
-      selectDeviceId,
-      type
-    );
-  }
-
-  async updateDevice(deviceId: string, body: any): Promise<any> {
-    if (!deviceId) {
-      throw new Error("Device ID is required");
-    }
-
-    await this.deviceRepository.updateDevice(deviceId, body);
-    return await this.eventHandler.onDeviceUpdate(deviceId, body);
-  }
-
-  async deleteDevice(deviceId: string): Promise<any> {
-    if (!deviceId) {
-      throw new Error("Device ID is required");
-    }
-
-    await this.deviceRepository.deleteDevice(deviceId);
-    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(
-      (key) => !isEqual(oldState[key], newState[key])
-    );
-    if (changedKeys.length > 0) {
-      await this.deviceRepository.setState(deviceId, newState);
-      return await this.eventHandler.onStateChange(deviceId, newState);
-    }
-  }
-
-  async getStatus(deviceId: string) {
-    if (!deviceId) {
-      throw new Error("Device ID is required");
-    }
-    return await this.deviceRepository.getStatus(deviceId);
-  }
-
-  async setStatus(
-    deviceId: string,
-    newStatus: IStatus,
-    source: Source,
-    reason?: string
-  ) {
-    if (!deviceId || !newStatus) {
-      throw new Error("Device ID and new status are required");
-    }
-
-    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: {},
-      };
-
-      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;
-
-    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");
-    }
-    return await this.deviceRepository.getBatteryLevel(deviceId);
-  }
-
-  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 = device.state?.batteryPercentage;
-
-    // Check if battery level has changed
-    const isDifferent = !isEqual(oldBatteryLevel?.value, batteryLevel);
-
-    if (isDifferent) {
-      // 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) {
-    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");
-    }
-    await this.eventHandler.onDeviceMetaChange(deviceId, metaData);
-    return await this.deviceRepository.setMetaData(deviceId, metaData);
-  }
-
-  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);
-  }
-
-  async querySelect(query: any, fields: string[]) {
-    if (!query || Object.keys(query).length === 0) {
-      throw new Error("Query is required");
-    }
-    return await this.deviceRepository.querySelect(query, fields);
-  }
-
-  async queryCount(query: any): Promise<number> {
-    if (!query || Object.keys(query).length === 0) {
-      throw new Error("Query is required");
-    }
-    const count = await this.deviceRepository.queryCount(query);
-    return count;
-  }
-
-  async deleteDevices(query: any) {
-    if (!query || Object.keys(query).length === 0) {
-      throw new Error("Query is required");
-    }
-    return await this.deviceRepository.deleteDevices(query);
-  }
-
-  async queryDevices(query: any) {
-    if (!query || Object.keys(query).length === 0) {
-      throw new Error("Query is required");
-    }
-    const res = await this.deviceRepository.queryDevices(query);
-    return res;
-  }
-}

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

@@ -1,57 +0,0 @@
-import { IDevice } from "../interfaces";
-import { HubRepository } from "../repository/Hub.repository";
-import Container from "typedi";
-
-export class LocalHubService {
-  private readonly hubRepository: HubRepository;
-  constructor() {
-    this.hubRepository = Container.get(HubRepository);
-  }
-
-  async addHub(body: Partial<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/Schedule.service.ts

@@ -1,26 +0,0 @@
-import Container from "typedi";
-import { ScheduleRepository } from "../repository/Schedule.repository";
-import { ISchedule } from "../interfaces/ISchedule";
-
-export class LocalScheduleService {
-  private readonly scheduleRepository: ScheduleRepository;
-  constructor() {
-    this.scheduleRepository = Container.get(ScheduleRepository);
-  }
-
-  async getSchedule(scheduleId: string) {
-    return await this.scheduleRepository.getSchedule(scheduleId);
-  }
-
-  async setSchedule(scheduleId: string, schedule: ISchedule) {
-    return await this.scheduleRepository.setSchedule(scheduleId, schedule);
-  }
-
-  async getScheduleByZone(zoneId: string) {
-    return await this.scheduleRepository.getScheduleByZone(zoneId);
-  }
-
-  async deleteSchedule(scheduleId: string) {
-    return await this.scheduleRepository.deleteSchedule(scheduleId);
-  }
-}

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

@@ -1,3 +0,0 @@
-export * from "./Device.service";
-export * from "./Hub.service";
-export * from "./Schedule.service";