dt-common-device 13.1.3 → 13.1.4

package/dist/device/local/services/AlertService.example.d.ts

@@ -0,0 +1,55 @@
+import { AlertService } from "./Alert.service";
+/**
+ * Example usage of the updated AlertService with AlertBuilder integration
+ * This file demonstrates various ways to use the AlertService with the new AlertBuilder
+ */
+export declare class AlertServiceExample {
+    private readonly alertService;
+    constructor(alertService: AlertService);
+    /**
+     * Example 1: Using the updated createAlert method with AlertBuilder
+     */
+    createAlertWithBuilder(): Promise<import("../../../types/alert.types").AlertDocument>;
+    /**
+     * Example 2: Using convenience methods for specific alert types
+     */
+    createSpecificAlerts(): Promise<{
+        readinessAlert: import("../../../types/alert.types").AlertDocument;
+        operationsAlert: import("../../../types/alert.types").AlertDocument;
+        securityAlert: import("../../../types/alert.types").AlertDocument;
+        energyAlert: import("../../../types/alert.types").AlertDocument;
+    }>;
+    /**
+     * Example 3: Using device-specific alert methods
+     */
+    createDeviceAlerts(): Promise<{
+        deviceAlert1: import("../../../types/alert.types").AlertDocument;
+        deviceAlert2: import("../../../types/alert.types").AlertDocument;
+    }>;
+    /**
+     * Example 4: Using hub-specific alert methods
+     */
+    createHubAlerts(): Promise<{
+        hubAlert1: import("../../../types/alert.types").AlertDocument;
+        hubAlert2: import("../../../types/alert.types").AlertDocument;
+    }>;
+    /**
+     * Example 5: Using static factory methods with AlertBuilder
+     */
+    createAlertsWithStaticMethods(): Promise<{
+        alert1: import("../../../types/alert.types").AlertDocument;
+        alert2: import("../../../types/alert.types").AlertDocument;
+    }>;
+    /**
+     * Example 6: Creating multiple alerts efficiently
+     */
+    createMultipleAlerts(): Promise<import("../../../types/alert.types").AlertDocument[]>;
+    /**
+     * Example 7: Creating alerts with snooze functionality
+     */
+    createSnoozedAlert(): Promise<import("../../../types/alert.types").AlertDocument>;
+    /**
+     * Example 8: Backward compatibility - still works with CreateAlertData
+     */
+    createAlertWithLegacyData(): Promise<import("../../../types/alert.types").AlertDocument>;
+}

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/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/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>;
+}

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

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

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;
+}