dt-common-device 11.2.2 → 11.2.3

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

@@ -1,148 +0,0 @@
-"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

@@ -1,8 +0,0 @@
-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

@@ -1,32 +0,0 @@
-"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

@@ -1,40 +0,0 @@
-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

@@ -1,391 +0,0 @@
-"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

@@ -1,11 +0,0 @@
-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>;
-}