dt-common-device 1.3.0 → 2.0.1

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/Device.service.d.ts

@@ -1,10 +1,9 @@
-import { IDevice } from "../interfaces";
+import { IDevice, INewStatus } from "../interfaces";
 export declare class LocalDeviceService {
     private readonly eventHandler;
-    private readonly alertService;
     private readonly deviceRepository;
     constructor();
-    createDevice(body: IDevice): Promise<void>;
+    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[]>;
@@ -14,11 +13,15 @@ export declare class LocalDeviceService {
     getState(deviceId: string): Promise<any>;
     setState(deviceId: string, newState: any): Promise<void>;
     getStatus(deviceId: string): Promise<Record<string, any>>;
-    setStatus(deviceId: string, newStatus: any): Promise<void>;
+    setStatus(deviceId: string, newStatus: INewStatus): Promise<void>;
     getBatteryLevel(deviceId: string): Promise<Record<string, any>>;
-    setBatteryLevel(deviceId: string, newBatteryLevel: any): Promise<void>;
+    setBatteryLevel(deviceId: string, batteryLevel: number): Promise<void>;
     getMetaData(deviceId: string): Promise<any>;
-    setMetaData(deviceId: string, metaData: Record<string, any>): Promise<void>;
+    setMetaData(deviceId: string, metaData: Record<string, any>): Promise<any>;
     getDevicesByZone(zoneId: string): Promise<import("../interfaces/IDtDevice").IDtDevice[]>;
     getDevicesByAccessGroup(accessGroupId: string): Promise<import("../interfaces/IDtDevice").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

@@ -4,22 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalDeviceService = void 0;
-const config_1 = require("../../../config/config");
-const EventHandler_1 = require("../events/EventHandler");
+const EventHandler_1 = require("../../../events/EventHandler");
 const lodash_1 = require("lodash");
-const Alert_service_1 = require("./Alert.service");
 const Device_repository_1 = require("../repository/Device.repository");
 const typedi_1 = __importDefault(require("typedi"));
 class LocalDeviceService {
     constructor() {
-        (0, config_1.checkAwsEnv)();
-        (0, config_1.ensureAuditInitialized)();
         this.eventHandler = new EventHandler_1.EventHandler();
-        this.alertService = new Alert_service_1.AlertService();
         this.deviceRepository = typedi_1.default.get(Device_repository_1.DeviceRepository);
     }
     async createDevice(body) {
-        return await this.eventHandler.onDeviceCreate(body);
+        const device = await this.deviceRepository.createDevice(body);
+        await this.eventHandler.onDeviceCreate(device);
+        return device;
     }
     async getDevice(deviceId, withHubDetails = false) {
         if (!deviceId) {
@@ -71,6 +68,7 @@ class LocalDeviceService {
         const oldState = (await this.getState(deviceId))?.data?.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);
         }
     }
@@ -80,27 +78,22 @@ class LocalDeviceService {
         }
         return await this.deviceRepository.getStatus(deviceId);
     }
-    //TODO: Define type of newStatus
     async setStatus(deviceId, newStatus) {
         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((key) => !(0, lodash_1.isEqual)(oldStatus?.data?.[key], newStatus?.[key]));
-        if (changedKeys.length > 0) {
-            return await this.eventHandler.onStatusChange(deviceId, newStatus);
-        }
-        // If both old and new status are offline, check the time difference between the last offline status and current time
-        if (oldStatus?.data?.online === false &&
-            oldStatus?.data?.lastUpdated &&
-            newStatus?.online === false) {
-            const lastOfflineTime = new Date(oldStatus?.data?.lastUpdated).getTime();
-            const currentTime = Date.now();
-            const timeDifference = currentTime - lastOfflineTime;
-            // Compare it with the baseline profile time of the device. If the difference is higher, then raise an operational alert
-            if (timeDifference > 1000 * 60 * 60 * 24) {
-                return await this.alertService.raiseOperationsAlert();
+        const isStatusChanged = !(0, lodash_1.isEqual)(oldStatus, newStatus);
+        if (isStatusChanged) {
+            await this.deviceRepository.setStatus(deviceId, newStatus);
+            await this.eventHandler.onStatusChange(deviceId, newStatus);
+        }
+        const isBothOffline = oldStatus?.online === false && newStatus?.online === false;
+        if (isBothOffline && oldStatus?.lastUpdated) {
+            const timeDifference = Date.now() - new Date(oldStatus.lastUpdated).getTime();
+            if (timeDifference > 86400000) {
+                //return await this.alertService.raiseOperationsAlert();
+                return;
             }
         }
     }
@@ -110,24 +103,24 @@ class LocalDeviceService {
         }
         return await this.deviceRepository.getBatteryLevel(deviceId);
     }
-    //TODO: Define payload type of newBatteryLevel
-    async setBatteryLevel(deviceId, newBatteryLevel) {
-        if (!deviceId || !newBatteryLevel) {
-            throw new Error("Device ID and new battery level are required");
-        }
-        // If old battery level and new battery level are different
+    async setBatteryLevel(deviceId, batteryLevel) {
+        // Fetch the old battery level state
         const oldBatteryLevel = await this.getBatteryLevel(deviceId);
-        const changedKeys = Object.keys(newBatteryLevel).filter((key) => !(0, lodash_1.isEqual)(oldBatteryLevel?.data?.[key], newBatteryLevel?.[key]));
-        if (changedKeys.length > 0) {
-            return await this.eventHandler.onBatteryLevelChange(deviceId, newBatteryLevel);
-        }
-        // If current battery level is less than 20% and lsat updated time is more than 8 hours, raise an energy alert
-        if (newBatteryLevel?.value < 20 &&
-            oldBatteryLevel?.data?.value < 20 &&
-            new Date(oldBatteryLevel?.data?.lastUpdated).getTime() <
-                Date.now() - 1000 * 60 * 60 * 8) {
-            //TODO: Raise an energy alert
-            await this.alertService.raiseEnergyAlert();
+        const isDifferent = !(0, lodash_1.isEqual)(oldBatteryLevel?.value, batteryLevel);
+        if (isDifferent) {
+            await this.deviceRepository.setBatteryLevel(deviceId, batteryLevel);
+            await this.eventHandler.onBatteryLevelChange(deviceId, batteryLevel);
+        }
+        // Check if battery is low and not updated for 8 hours
+        if (batteryLevel < 20 &&
+            oldBatteryLevel?.value < 20 &&
+            oldBatteryLevel?.lastUpdated &&
+            new Date(oldBatteryLevel.lastUpdated).getTime() <
+                Date.now() - 1000 * 60 * 60 * 8 // 8 hours in ms
+        ) {
+            // TODO: Raise an energy alert
+            // await this.alertService.raiseEnergyAlert();
+            return;
         }
     }
     async getMetaData(deviceId) {
@@ -140,7 +133,8 @@ class LocalDeviceService {
         if (!deviceId || !metaData) {
             throw new Error("Device ID and meta data are required");
         }
-        return await this.eventHandler.onDeviceMetaChange(deviceId, metaData);
+        await this.eventHandler.onDeviceMetaChange(deviceId, metaData);
+        return await this.deviceRepository.setMetaData(deviceId, metaData);
     }
     async getDevicesByZone(zoneId) {
         if (!zoneId) {
@@ -154,5 +148,31 @@ class LocalDeviceService {
         }
         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 count = await this.deviceRepository.queryDevices(query);
+        return count;
+    }
 }
 exports.LocalDeviceService = LocalDeviceService;

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

@@ -0,0 +1,168 @@
+import { IssueRepository } from "../repository/Issue.repository";
+import { IIssueDocument } from "../models/Issue.model";
+import { CreateIssueData, UpdateIssueData, AddCommentData, IssueStatus, IssuePriority, IssuesCategory, EntityType } from "../../../types/issue.types";
+import { IssueBuilder } from "../entities/IssueBuilder";
+export declare class IssueService {
+    private readonly issueRepository;
+    constructor(issueRepository: IssueRepository);
+    /**
+     * Create a readiness issue using IssueBuilder
+     */
+    createReadinessIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    /**
+     * Create an operations issue using IssueBuilder
+     */
+    createOperationsIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    /**
+     * Create a security issue using IssueBuilder
+     */
+    createSecurityIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    /**
+     * Create an energy issue using IssueBuilder
+     */
+    createEnergyIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    /**
+     * Create a device-specific issue using IssueBuilder
+     */
+    createDeviceIssue(deviceId: string, propertyId: string, title: string, description: string, createdBy: string, category?: IssuesCategory, priority?: IssuePriority, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    /**
+     * Create a hub-specific issue using IssueBuilder
+     */
+    createHubIssue(hubId: string, propertyId: string, title: string, description: string, createdBy: string, category?: IssuesCategory, priority?: IssuePriority, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    /**
+     * Create a user-specific issue using IssueBuilder
+     */
+    createUserIssue(userId: string, propertyId: string, title: string, description: string, createdBy: string, category?: IssuesCategory, priority?: IssuePriority, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    /**
+     * Create a maintenance issue using IssueBuilder
+     */
+    createMaintenanceIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    /**
+     * Create an urgent issue using IssueBuilder
+     */
+    createUrgentIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    /**
+     * Create a new issue with business logic validation
+     * Accepts either a CreateIssueData object or an IssueBuilder instance
+     */
+    createIssue(issueData: CreateIssueData | IssueBuilder): Promise<IIssueDocument>;
+    /**
+     * Get issue by ID with business logic
+     */
+    getIssueById(id: string, includeDeleted?: boolean): Promise<IIssueDocument | null>;
+    /**
+     * Get all issues with business logic filtering
+     */
+    getIssues(filters?: {
+        propertyId?: string;
+        assignedTo?: string;
+        status?: IssueStatus;
+        priority?: IssuePriority;
+        category?: IssuesCategory;
+        entityType?: EntityType;
+        entityId?: string;
+        includeDeleted?: boolean;
+        limit?: number;
+        skip?: number;
+    }): Promise<IIssueDocument[]>;
+    /**
+     * Update an issue with business logic validation
+     */
+    updateIssue(id: string, updateData: UpdateIssueData): Promise<IIssueDocument | null>;
+    /**
+     * Soft delete an issue with business logic
+     */
+    deleteIssue(id: string, deletedBy: string): Promise<boolean>;
+    /**
+     * Permanently delete an issue
+     */
+    permanentlyDeleteIssue(id: string): Promise<boolean>;
+    /**
+     * Add a comment with business logic
+     */
+    addComment(issueId: string, commentData: AddCommentData): Promise<IIssueDocument | null>;
+    /**
+     * Update a comment on an issue
+     */
+    updateComment(issueId: string, commentId: string, content: string, userId: string): Promise<boolean>;
+    /**
+     * Remove a comment from an issue
+     */
+    removeComment(issueId: string, commentId: string): Promise<boolean>;
+    /**
+     * Resolve an issue with business logic
+     */
+    resolveIssue(id: string, resolvedBy: string): Promise<IIssueDocument | null>;
+    /**
+     * Reopen a resolved issue
+     */
+    reopenIssue(id: string, reopenedBy: string): Promise<IIssueDocument | null>;
+    /**
+     * Assign an issue with business logic
+     */
+    assignIssue(id: string, userId: string, assignedBy: string): Promise<IIssueDocument | null>;
+    /**
+     * Unassign an issue
+     */
+    unassignIssue(id: string, unassignedBy: string): Promise<IIssueDocument | null>;
+    /**
+     * Get issues by property with business logic
+     */
+    getIssuesByProperty(propertyId: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Get issues assigned to a user with business logic
+     */
+    getIssuesByAssignee(assignedTo: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Get issues by entity
+     */
+    getIssuesByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Get issues by status
+     */
+    getIssuesByStatus(status: IssueStatus, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Get issues by priority
+     */
+    getIssuesByPriority(priority: IssuePriority, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Get overdue issues with business logic
+     */
+    getOverdueIssues(includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Get upcoming issues (due within specified days)
+     */
+    getUpcomingIssues(days?: number, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Get issue statistics with business logic
+     */
+    getIssueStatistics(propertyId?: string): Promise<{
+        total: number;
+        pending: number;
+        inProgress: number;
+        resolved: number;
+        closed: number;
+        overdue: number;
+        byPriority: Record<IssuePriority, number>;
+        byCategory: Record<IssuesCategory, number>;
+    }>;
+    /**
+     * Search issues with business logic
+     */
+    searchIssues(searchTerm: string, filters?: {
+        propertyId?: string;
+        includeDeleted?: boolean;
+        limit?: number;
+        skip?: number;
+    }): Promise<IIssueDocument[]>;
+    private validateIssueData;
+    private validateFilters;
+    private validateUpdateData;
+    private validateStatusTransition;
+    private validatePriorityChange;
+    private determineDefaultPriority;
+    private applyBusinessRules;
+    private shouldUpdateStatusOnComment;
+    private calculateAverageResponseTime;
+    private calculateResolutionRate;
+}