dt-common-device 11.2.0 → 11.2.2

package/dist/device/local/services/AlertService.example.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertServiceExample = void 0;
+const AlertBuilder_1 = require("../entities/AlertBuilder");
+const alert_types_1 = require("../../../types/alert.types");
+/**
+ * Example usage of the updated AlertService with AlertBuilder integration
+ * This file demonstrates various ways to use the AlertService with the new AlertBuilder
+ */
+class AlertServiceExample {
+    constructor(alertService) {
+        this.alertService = alertService;
+    }
+    /**
+     * Example 1: Using the updated createAlert method with AlertBuilder
+     */
+    async createAlertWithBuilder() {
+        const alertBuilder = new AlertBuilder_1.AlertBuilder()
+            .setCategory(alert_types_1.AlertCategory.OPERATIONS)
+            .setPropertyId("prop123")
+            .setTitle("Device Offline")
+            .setDescription("Device has been offline for more than 5 minutes")
+            .setEntityId("device456")
+            .setEntityType(alert_types_1.EntityType.DEVICE)
+            .setSeverity(alert_types_1.AlertSeverity.HIGH)
+            .setCreatedBy("user789");
+        // Pass the AlertBuilder directly to createAlert
+        const alert = await this.alertService.createAlert(alertBuilder);
+        return alert;
+    }
+    /**
+     * Example 2: Using convenience methods for specific alert types
+     */
+    async createSpecificAlerts() {
+        // Create a readiness alert
+        const readinessAlert = await this.alertService.raiseReadinessAlert("prop123", "System Maintenance Required", "System maintenance is scheduled for tonight", "system456", alert_types_1.EntityType.PROPERTY, "admin");
+        // Create an operations alert
+        const operationsAlert = await this.alertService.raiseOperationsAlert("prop123", "Device Temperature High", "Device temperature exceeds normal operating range", "device789", alert_types_1.EntityType.DEVICE, "monitor");
+        // Create a security alert
+        const securityAlert = await this.alertService.raiseSecurityAlert("prop123", "Unauthorized Access Attempt", "Multiple failed login attempts detected", "user123", alert_types_1.EntityType.USER, "security-system");
+        // Create an energy alert
+        const energyAlert = await this.alertService.raiseEnergyAlert("prop123", "High Energy Consumption", "Energy usage is 20% above normal levels", "zone456", alert_types_1.EntityType.COLLECTION, "energy-monitor");
+        return { readinessAlert, operationsAlert, securityAlert, energyAlert };
+    }
+    /**
+     * Example 3: Using device-specific alert methods
+     */
+    async createDeviceAlerts() {
+        // Create a device alert with default category and severity
+        const deviceAlert1 = await this.alertService.raiseDeviceAlert("device123", "prop456", "Device Battery Low", "Device battery level is below 20%", undefined, // Use default category
+        undefined, // Use default severity
+        "system");
+        // Create a device alert with custom category and severity
+        const deviceAlert2 = await this.alertService.raiseDeviceAlert("device789", "prop456", "Device Firmware Update Available", "New firmware version is available for installation", alert_types_1.AlertCategory.READINESS, alert_types_1.AlertSeverity.MEDIUM, "firmware-manager");
+        return { deviceAlert1, deviceAlert2 };
+    }
+    /**
+     * Example 4: Using hub-specific alert methods
+     */
+    async createHubAlerts() {
+        // Create a hub alert with default settings
+        const hubAlert1 = await this.alertService.raiseHubAlert("hub123", "prop456", "Hub Connection Lost", "Hub has lost connection to the network", undefined, // Use default category
+        undefined, // Use default severity
+        "network-monitor");
+        // Create a hub alert with custom settings
+        const hubAlert2 = await this.alertService.raiseHubAlert("hub789", "prop456", "Hub Maintenance Required", "Hub requires scheduled maintenance", alert_types_1.AlertCategory.READINESS, alert_types_1.AlertSeverity.LOW, "maintenance-system");
+        return { hubAlert1, hubAlert2 };
+    }
+    /**
+     * Example 5: Using static factory methods with AlertBuilder
+     */
+    async createAlertsWithStaticMethods() {
+        // Create a device alert using static factory method
+        const deviceAlert = AlertBuilder_1.AlertBuilder.createDeviceAlert("device123", "prop456")
+            .setCategory(alert_types_1.AlertCategory.OPERATIONS)
+            .setTitle("Device Offline")
+            .setDescription("Device has been offline for more than 5 minutes")
+            .setSeverity(alert_types_1.AlertSeverity.HIGH)
+            .setCreatedBy("monitor");
+        const alert1 = await this.alertService.createAlert(deviceAlert);
+        // Create a hub alert using static factory method
+        const hubAlert = AlertBuilder_1.AlertBuilder.createHubAlert("hub789", "prop202")
+            .setCategory(alert_types_1.AlertCategory.SECURITY)
+            .setTitle("Hub Security Breach")
+            .setDescription("Unauthorized access attempt detected on hub")
+            .setSeverity(alert_types_1.AlertSeverity.CRITICAL)
+            .setCreatedBy("security-system");
+        const alert2 = await this.alertService.createAlert(hubAlert);
+        return { alert1, alert2 };
+    }
+    /**
+     * Example 6: Creating multiple alerts efficiently
+     */
+    async createMultipleAlerts() {
+        const alerts = [];
+        // Create multiple device alerts efficiently
+        const deviceIds = ["device1", "device2", "device3"];
+        const propertyId = "prop123";
+        for (const deviceId of deviceIds) {
+            const alertBuilder = AlertBuilder_1.AlertBuilder.createDeviceAlert(deviceId, propertyId)
+                .setCategory(alert_types_1.AlertCategory.OPERATIONS)
+                .setTitle(`Device ${deviceId} Status`)
+                .setDescription(`Status check for device ${deviceId}`)
+                .setSeverity(alert_types_1.AlertSeverity.MEDIUM)
+                .setCreatedBy("batch-processor");
+            const alert = await this.alertService.createAlert(alertBuilder);
+            alerts.push(alert);
+        }
+        return alerts;
+    }
+    /**
+     * Example 7: Creating alerts with snooze functionality
+     */
+    async createSnoozedAlert() {
+        const snoozeUntil = new Date();
+        snoozeUntil.setHours(snoozeUntil.getHours() + 2); // Snooze for 2 hours
+        const alertBuilder = new AlertBuilder_1.AlertBuilder()
+            .setCategory(alert_types_1.AlertCategory.OTHER)
+            .setPropertyId("prop303")
+            .setTitle("Scheduled Maintenance")
+            .setDescription("System maintenance scheduled for tonight")
+            .setEntityType(alert_types_1.EntityType.PROPERTY)
+            .setSeverity(alert_types_1.AlertSeverity.INFO)
+            .setCreatedBy("admin")
+            .setSnoozeUntil(snoozeUntil);
+        const alert = await this.alertService.createAlert(alertBuilder);
+        return alert;
+    }
+    /**
+     * Example 8: Backward compatibility - still works with CreateAlertData
+     */
+    async createAlertWithLegacyData() {
+        const alertData = {
+            category: alert_types_1.AlertCategory.OPERATIONS,
+            propertyId: "prop123",
+            title: "Legacy Alert",
+            description: "This alert was created using the old CreateAlertData format",
+            entityId: "device456",
+            entityType: alert_types_1.EntityType.DEVICE,
+            severity: alert_types_1.AlertSeverity.MEDIUM,
+            createdBy: "legacy-system"
+        };
+        // This still works with the updated createAlert method
+        const alert = await this.alertService.createAlert(alertData);
+        return alert;
+    }
+}
+exports.AlertServiceExample = AlertServiceExample;

package/dist/device/local/services/Connection.service.d.ts

@@ -0,0 +1,8 @@
+import { IConnection } from "../interfaces/IConnection";
+export declare class LocalConnectionService {
+    private readonly connectionRepository;
+    constructor();
+    createConnection(data: Partial<IConnection>): Promise<IConnection>;
+    getConnection(connectionId: string): Promise<IConnection>;
+    updateConnection(connectionId: string, data: Partial<IConnection>): Promise<IConnection>;
+}

package/dist/device/local/services/Connection.service.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalConnectionService = void 0;
+const typedi_1 = require("typedi");
+const Connection_repository_1 = require("../repository/Connection.repository");
+class LocalConnectionService {
+    constructor() {
+        this.connectionRepository = typedi_1.Container.get(Connection_repository_1.ConnectionRepository);
+    }
+    async createConnection(data) {
+        if (!data.connectionName ||
+            !data.connectionRefId ||
+            !data.propertyId ||
+            !data.connectionProvider) {
+            throw new Error("Missing required fields");
+        }
+        return await this.connectionRepository.createConnection(data);
+    }
+    async getConnection(connectionId) {
+        if (!connectionId) {
+            throw new Error("Connection ID is required");
+        }
+        return await this.connectionRepository.getConnectionById(connectionId);
+    }
+    async updateConnection(connectionId, data) {
+        if (!connectionId) {
+            throw new Error("Connection ID is required");
+        }
+        return await this.connectionRepository.updateConnection(connectionId, data);
+    }
+}
+exports.LocalConnectionService = LocalConnectionService;

package/dist/device/local/services/Device.service.d.ts

@@ -0,0 +1,40 @@
+import { IDevice, IStatus, IStatusQuery } from "../interfaces";
+import { Source } from "../../../constants/Service";
+import { AuditProperties } from "../../../audit/AuditProperties";
+export declare class LocalDeviceService {
+    private readonly eventHandler;
+    private readonly deviceRepository;
+    private readonly alertService;
+    private readonly issueService;
+    private readonly logger;
+    constructor();
+    createDevice(body: IDevice): Promise<IDevice>;
+    getDevice(deviceId: string, withHubDetails?: boolean): Promise<IDevice>;
+    getDevices(deviceIds: string[], withHubDetails?: boolean): Promise<IDevice[]>;
+    getPropertyDevices(propertyId: string, selectDeviceId?: boolean, type?: string, withHubDetails?: boolean): Promise<IDevice[]>;
+    getPropertyDeviceIds(propertyId: string, selectDeviceId: boolean | undefined, type: string): Promise<any>;
+    updateDevice(deviceId: string, body: any, auditBody: AuditProperties): Promise<any>;
+    updateDevices(query: any, updateData: any): Promise<any>;
+    deleteDevice(deviceId: string, auditBody: AuditProperties): Promise<any>;
+    getState(deviceId: string): Promise<any>;
+    setState(deviceId: string, newState: any, auditProperties: AuditProperties): Promise<void>;
+    getStatus(deviceId: string): Promise<Record<string, any>>;
+    setStatus(deviceId: string, newStatus: IStatus, source: Source, auditBody: AuditProperties, reason?: string): Promise<void>;
+    setStatusMany(query: IStatusQuery, newStatus: IStatus, source: Source, auditBody: AuditProperties): Promise<void>;
+    private handleOfflineStatus;
+    private handleOnlineStatus;
+    private getDeviceBaseline;
+    getBatteryLevel(deviceId: string): Promise<Record<string, any>>;
+    setBatteryLevel(deviceId: string, batteryLevel: number, source: Source, auditBody: AuditProperties): Promise<void>;
+    private shouldUpdateBatteryLevel;
+    private getPropertyBatteryThreshold;
+    private checkForDeviceMalfunctions;
+    getMetaData(deviceId: string): Promise<any>;
+    setMetaData(deviceId: string, metaData: Record<string, any>, auditBody: AuditProperties): Promise<any>;
+    getDevicesByZone(zoneId: string): Promise<import("../interfaces").IDtDevice[]>;
+    getDevicesByAccessGroup(accessGroupId: string): Promise<import("../interfaces").IDtDevice[]>;
+    querySelect(query: any, fields: string[]): Promise<any>;
+    queryCount(query: any): Promise<number>;
+    deleteDevices(query: any): Promise<any>;
+    queryDevices(query: any): Promise<any>;
+}

package/dist/device/local/services/Device.service.js

@@ -0,0 +1,391 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalDeviceService = void 0;
+const EventHandler_1 = require("../../../events/EventHandler");
+const lodash_1 = require("lodash");
+const Device_repository_1 = require("../repository/Device.repository");
+const typedi_1 = __importDefault(require("typedi"));
+const Alert_service_1 = require("../../../alerts/Alert.service");
+const Issue_service_1 = require("../../../issues/Issue.service");
+const config_1 = require("../../../config/config");
+const typedi_2 = require("typedi");
+let LocalDeviceService = (() => {
+    let _classDecorators = [(0, typedi_2.Service)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var LocalDeviceService = _classThis = class {
+        constructor() {
+            // Use dependency injection instead of creating new instances
+            this.eventHandler = typedi_1.default.get(EventHandler_1.EventHandler);
+            this.deviceRepository = typedi_1.default.get(Device_repository_1.DeviceRepository);
+            this.alertService = typedi_1.default.get(Alert_service_1.AlertService);
+            this.issueService = typedi_1.default.get(Issue_service_1.IssueService);
+            this.logger = (0, config_1.getConfig)().LOGGER;
+        }
+        async createDevice(body) {
+            const device = await this.deviceRepository.createDevice(body);
+            await this.eventHandler.onDeviceCreate(device);
+            return device;
+        }
+        async getDevice(deviceId, withHubDetails = false) {
+            if (!deviceId) {
+                throw new Error("Device ID is required");
+            }
+            return await this.deviceRepository.getDevice(deviceId, withHubDetails);
+        }
+        async getDevices(deviceIds, withHubDetails = false) {
+            if (!deviceIds.length) {
+                throw new Error("At least one device ID is required");
+            }
+            return await this.deviceRepository.getDevices(deviceIds, withHubDetails);
+        }
+        async getPropertyDevices(propertyId, selectDeviceId = false, type, withHubDetails = false) {
+            if (!propertyId) {
+                throw new Error("Property ID is required");
+            }
+            return await this.deviceRepository.getPropertyDevices(propertyId, selectDeviceId, type, withHubDetails);
+        }
+        async getPropertyDeviceIds(propertyId, selectDeviceId = false, type) {
+            if (!propertyId) {
+                throw new Error("Property ID is required");
+            }
+            return await this.deviceRepository.getPropertyDeviceIds(propertyId, selectDeviceId, type);
+        }
+        async updateDevice(deviceId, body, auditBody) {
+            if (!deviceId) {
+                throw new Error("Device ID is required");
+            }
+            await this.deviceRepository.updateDevice(deviceId, body);
+            return await this.eventHandler.onDeviceUpdate(deviceId, body, auditBody);
+        }
+        async updateDevices(query, updateData) {
+            if (!query || !updateData) {
+                throw new Error("Query and update data are required");
+            }
+            return await this.deviceRepository.updateDevices(query, updateData);
+        }
+        async deleteDevice(deviceId, auditBody) {
+            if (!deviceId) {
+                throw new Error("Device ID is required");
+            }
+            await this.deviceRepository.deleteDevice(deviceId);
+            return await this.eventHandler.onDeviceDelete(deviceId, auditBody);
+        }
+        async getState(deviceId) {
+            if (!deviceId) {
+                throw new Error("Device ID is required");
+            }
+            return await this.deviceRepository.getState(deviceId);
+        }
+        async setState(deviceId, newState, auditProperties) {
+            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))?.state ?? {};
+            const changedKeys = Object.keys(newState).filter((key) => !(0, lodash_1.isEqual)(oldState[key], newState[key]));
+            if (changedKeys.length > 0) {
+                await this.deviceRepository.setState(deviceId, newState);
+                return await this.eventHandler.onStateChange(deviceId, newState, auditProperties);
+            }
+        }
+        async getStatus(deviceId) {
+            if (!deviceId) {
+                throw new Error("Device ID is required");
+            }
+            return await this.deviceRepository.getStatus(deviceId);
+        }
+        async setStatus(deviceId, newStatus, source, auditBody, reason) {
+            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(device, oldStatus, newStatus, source, auditBody, reason, currentTime);
+            }
+            else if (isNewStatusOnline) {
+                // New Status = ONLINE
+                await this.handleOnlineStatus(device, oldStatus, newStatus, source, auditBody, reason, currentTime);
+            }
+            else {
+                // For any other status, just update normally
+                await this.deviceRepository.setStatus(deviceId, newStatus);
+                await this.eventHandler.onStatusChange(deviceId, newStatus, auditBody);
+            }
+        }
+        async setStatusMany(query, newStatus, source, auditBody) {
+            if (!query || !newStatus) {
+                throw new Error("Query and new status are required");
+            }
+            newStatus.lastUpdated = new Date().toISOString();
+            await this.deviceRepository.setStatusMany(query, newStatus);
+            await this.eventHandler.onStatusChangeMany(query, newStatus, auditBody);
+        }
+        async handleOfflineStatus(device, oldStatus, newStatus, source, auditBody, reason, currentTime) {
+            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(device.deviceId, newStatus);
+                await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
+            }
+            else if (isExistingStatusOffline) {
+                // Existing status is Offline
+                const timeLapsed = oldStatus?.lastUpdated
+                    ? Date.now() - new Date(oldStatus.lastUpdated).getTime()
+                    : 0;
+                const baselineTime = await this.getDeviceBaseline(device.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(device.deviceId, newStatus);
+                    await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
+                    // Raise alert (OPERATIONAL only)
+                    await this.alertService.raiseDeviceOfflineAlert(device, source, reason);
+                    // Raise issue when the device goes offline if longer than the baseline (OPERATIONAL only)
+                    await this.issueService.createDeviceOfflineIssue(device, source, reason);
+                }
+            }
+        }
+        async handleOnlineStatus(device, oldStatus, newStatus, source, auditBody, reason, currentTime) {
+            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(device.deviceId, newStatus);
+                    await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
+                    //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(device.deviceId, newStatus);
+                await this.eventHandler.onStatusChange(device.deviceId, newStatus, auditBody);
+                //TODO: ALERT NEEDED?
+                //  Raise alert
+                await this.alertService.raiseDeviceOnlineAlert(device, source, reason);
+            }
+        }
+        async getDeviceBaseline(deviceId) {
+            // 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) {
+            if (!deviceId) {
+                throw new Error("Device ID is required");
+            }
+            return await this.deviceRepository.getBatteryLevel(deviceId);
+        }
+        async setBatteryLevel(deviceId, batteryLevel, source, auditBody) {
+            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 = !(0, lodash_1.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, auditBody);
+                    // 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);
+                    }
+                }
+            }
+        }
+        shouldUpdateBatteryLevel(lastUpdated) {
+            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;
+        }
+        async getPropertyBatteryThreshold(propertyId) {
+            // 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 checkForDeviceMalfunctions(device, source, reason) {
+            // TODO: Implement device malfunction detection logic
+            // This should check for:
+            // - Lock jammed
+            // - Device not accepting codes
+            // - Other malfunction indicators
+            // For now, we'll check if the reason indicates a malfunction
+            const malfunctionIndicators = [
+                "jammed",
+                "not accepting codes",
+                "malfunction",
+                "error",
+                "failure",
+            ];
+            const hasMalfunction = malfunctionIndicators.some((indicator) => reason?.toLowerCase().includes(indicator));
+            if (hasMalfunction) {
+                // Raise alert for device malfunction (READINESS + OPERATIONAL)
+                await this.alertService.raiseDeviceIssueAlert(device, "Device Malfunction Detected", source, reason);
+                // Raise issue for device malfunction (READINESS + OPERATIONAL)
+                await this.issueService.createDeviceMalfunctionIssue(device, "Device Malfunction", source, reason);
+            }
+        }
+        async getMetaData(deviceId) {
+            if (!deviceId) {
+                throw new Error("Device ID is required");
+            }
+            return await this.deviceRepository.getMetaData(deviceId);
+        }
+        async setMetaData(deviceId, metaData, auditBody) {
+            if (!deviceId || !metaData) {
+                throw new Error("Device ID and meta data are required");
+            }
+            await this.eventHandler.onDeviceMetaChange(deviceId, metaData, auditBody);
+            return await this.deviceRepository.setMetaData(deviceId, metaData);
+        }
+        async getDevicesByZone(zoneId) {
+            if (!zoneId) {
+                throw new Error("Zone ID is required");
+            }
+            return await this.deviceRepository.getDevicesByZone(zoneId);
+        }
+        async getDevicesByAccessGroup(accessGroupId) {
+            if (!accessGroupId) {
+                throw new Error("Access Group ID is required");
+            }
+            return await this.deviceRepository.getDevicesByAccessGroup(accessGroupId);
+        }
+        async querySelect(query, fields) {
+            if (!query || Object.keys(query).length === 0) {
+                throw new Error("Query is required");
+            }
+            return await this.deviceRepository.querySelect(query, fields);
+        }
+        async queryCount(query) {
+            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) {
+            if (!query || Object.keys(query).length === 0) {
+                throw new Error("Query is required");
+            }
+            return await this.deviceRepository.deleteDevices(query);
+        }
+        async queryDevices(query) {
+            if (!query || Object.keys(query).length === 0) {
+                throw new Error("Query is required");
+            }
+            const res = await this.deviceRepository.queryDevices(query);
+            return res;
+        }
+    };
+    __setFunctionName(_classThis, "LocalDeviceService");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        LocalDeviceService = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return LocalDeviceService = _classThis;
+})();
+exports.LocalDeviceService = LocalDeviceService;

package/dist/device/local/services/DeviceHub.service.d.ts

@@ -0,0 +1,11 @@
+import { IHubCreateParams } from "../interfaces";
+export declare class DeviceHubService {
+    private readonly baseUrl;
+    constructor();
+    addHub(body: IHubCreateParams): Promise<any>;
+    getHubs(hubIds: string[]): Promise<any>;
+    getHub(hubId: string): Promise<any>;
+    updateHub(hubId: string, body: any): Promise<any>;
+    deleteHub(hubId: string): Promise<any>;
+    deleteAllHubs(hubIds: string[]): Promise<any>;
+}