dt-common-device 13.0.27 → 13.1.1

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

@@ -1,137 +0,0 @@
-import { AlertRepository } from "../repository/Alert.repository";
-import { IAlertDocument } from "../models/Alert.model";
-import { CreateAlertData, UpdateAlertData, AlertCategory, AlertSeverity, EntityType } from "../../../types/alert.types";
-import { AlertBuilder } from "../entities/AlertBuilder";
-export declare class AlertService {
-    private readonly alertRepository;
-    constructor(alertRepository: AlertRepository);
-    /**
-     * Create a readiness alert using AlertBuilder
-     */
-    raiseReadinessAlert(propertyId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
-    /**
-     * Create an operations alert using AlertBuilder
-     */
-    raiseOperationsAlert(propertyId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
-    /**
-     * Create a security alert using AlertBuilder
-     */
-    raiseSecurityAlert(propertyId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
-    /**
-     * Create an energy alert using AlertBuilder
-     */
-    raiseEnergyAlert(propertyId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
-    /**
-     * Create a device-specific alert using AlertBuilder
-     */
-    raiseDeviceAlert(deviceId: string, propertyId: string, title: string, description: string, category?: AlertCategory, severity?: AlertSeverity, createdBy?: string): Promise<IAlertDocument>;
-    /**
-     * Create a hub-specific alert using AlertBuilder
-     */
-    raiseHubAlert(hubId: string, propertyId: string, title: string, description: string, category?: AlertCategory, severity?: AlertSeverity, createdBy?: string): Promise<IAlertDocument>;
-    /**
-     * Create a new alert with business logic validation
-     * Accepts either a CreateAlertData object or an AlertBuilder instance
-     */
-    createAlert(alertData: CreateAlertData | AlertBuilder): Promise<IAlertDocument>;
-    /**
-     * Get alert by ID with business logic
-     */
-    getAlertById(id: string, includeDeleted?: boolean): Promise<IAlertDocument | null>;
-    /**
-     * Get all alerts with business logic filtering
-     */
-    getAlerts(filters?: {
-        propertyId?: string;
-        category?: AlertCategory;
-        severity?: AlertSeverity;
-        entityType?: EntityType;
-        entityId?: string;
-        isActive?: boolean;
-        isRead?: boolean;
-        includeDeleted?: boolean;
-        limit?: number;
-        skip?: number;
-    }): Promise<IAlertDocument[]>;
-    /**
-     * Update an alert with business logic validation
-     */
-    updateAlert(id: string, updateData: UpdateAlertData): Promise<IAlertDocument | null>;
-    /**
-     * Soft delete an alert with business logic
-     */
-    deleteAlert(id: string, deletedBy: string): Promise<boolean>;
-    /**
-     * Mark alert as read with business logic
-     */
-    markAsRead(id: string, updatedBy: string): Promise<IAlertDocument | null>;
-    /**
-     * Mark alert as unread with business logic
-     */
-    markAsUnread(id: string, updatedBy: string): Promise<IAlertDocument | null>;
-    /**
-     * Activate an alert with business logic
-     */
-    activateAlert(id: string, updatedBy: string): Promise<IAlertDocument | null>;
-    /**
-     * Deactivate an alert with business logic
-     */
-    deactivateAlert(id: string, updatedBy: string): Promise<IAlertDocument | null>;
-    /**
-     * Snooze an alert with business logic
-     */
-    snoozeAlert(id: string, until: Date, updatedBy: string): Promise<IAlertDocument | null>;
-    /**
-     * Unsnooze an alert with business logic
-     */
-    unsnoozeAlert(id: string, updatedBy: string): Promise<IAlertDocument | null>;
-    /**
-     * Get alerts by property with business logic
-     */
-    getAlertsByProperty(propertyId: string, includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get alerts by entity with business logic
-     */
-    getAlertsByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get alerts by category with business logic
-     */
-    getAlertsByCategory(category: AlertCategory, includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get alerts by severity with business logic
-     */
-    getAlertsBySeverity(severity: AlertSeverity, includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get active alerts with business logic
-     */
-    getActiveAlerts(includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get unread alerts with business logic
-     */
-    getUnreadAlerts(includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get snoozed alerts with business logic
-     */
-    getSnoozedAlerts(includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get expired snooze alerts with business logic
-     */
-    getExpiredSnoozeAlerts(includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get alert statistics with business logic
-     */
-    getAlertStatistics(propertyId?: string): Promise<{
-        total: number;
-        active: number;
-        unread: number;
-        snoozed: number;
-        bySeverity: Record<AlertSeverity, number>;
-        byCategory: Record<AlertCategory, number>;
-    }>;
-    private validateAlertData;
-    private validateFilters;
-    private validateUpdateData;
-    private validateSnoozeDate;
-    private determineDefaultSeverity;
-    private applyBusinessRules;
-}

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

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

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

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

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

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