dt-common-device/dist/issues/Issue.service.d.ts

A secure and robust device management library for IoT applications

import { IIssueDocument } from "./Issue.model";
import { CreateIssueData, UpdateIssueData, AddCommentData, IssuePriority, IssuesCategory, EntityType, EntitySubType, IIssueQuery } from "./issue.types";
import { IssueBuilder } from "./IssueBuilder";
import { Source } from "../constants/Service";
import { IDevice } from "../entities/device/local/interfaces";
export declare class IssueService {
    private readonly issueRepository;
    constructor();
    /**
     * Create an operations issue using IssueBuilder
     */
    createOperationsIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
    /**
     * Create a security issue using IssueBuilder
     */
    createSecurityIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
    /**
     * Create an energy issue using IssueBuilder
     */
    createEnergyIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
    /**
     * Create a device-specific issue using IssueBuilder
     */
    createDeviceIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
    /**
     * Create a hub-specific issue using IssueBuilder
     */
    createHubIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
    /**
     * Create a user-specific issue using IssueBuilder
     */
    createUserIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
    /**
     * Create issue for device going offline longer than baseline
     */
    createDeviceOfflineIssue(device: IDevice, source: Source, reason?: string): Promise<IIssueDocument | null>;
    /**
     * Create issue for device battery level below threshold (READINESS + OPERATIONAL + ENERGY)
     */
    createDeviceBatteryIssue(device: IDevice, batteryLevel: number, threshold: number, priority: IssuePriority, source: Source): Promise<IIssueDocument | null>;
    createAccountMissingDeviceIssue(connection: {
        id: string;
        provider: string;
        deviceCount: number;
        type?: string;
    }, propertyId: string, source: Source): Promise<IIssueDocument | null>;
    createAccountUnauthorizedIssue(account: {
        accountId: string;
        accountType: EntityType;
        propertyId: string;
        name: string;
        accountSubType: EntitySubType;
    }, source: Source, reason?: string): Promise<IIssueDocument | null>;
    /**
     * Create issue for device malfunction (jammed or not accepting codes) (READINESS + OPERATIONAL)
     */
    createDeviceMalfunctionIssue(device: IDevice, source: Source, reason?: string): Promise<IIssueDocument | null>;
    createLockJammedIssue(device: IDevice, source: Source): Promise<IIssueDocument | null>;
    /**
     * Create a maintenance issue using IssueBuilder
     */
    createMaintenanceIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
    /**
     * Create a high priority issue using IssueBuilder
     */
    createHighPriorityIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
    /**
     * Create a new issue with business logic validation
     * Accepts either a CreateIssueData object or an IssueBuilder instance
     */
    createIssue(issueData: CreateIssueData | IssueBuilder): Promise<IIssueDocument | null>;
    /**
     * Get issue by ID with business logic
     */
    getIssueById(id: string, includeDeleted?: boolean): Promise<IIssueDocument | null>;
    /**
     * Get all issues with business logic filtering
     */
    query(filters: IIssueQuery): Promise<IIssueDocument[]>;
    issueCount(filters: IIssueQuery): Promise<number>;
    /**
     * Update an issue with business logic validation
     */
    updateIssue(id: string, updateData: UpdateIssueData): Promise<IIssueDocument | null>;
    deleteIssues(filters: IIssueQuery, deletedBy: string, softDelete?: boolean): Promise<boolean>;
    /**
     * 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>;
    /**
     * Cancel/Close/Resolve/Ignore/In_Progress/On_Hold an issue based on query
     * This method will find an issue matching the query and update its status
     */
    performIssueAction(query: IIssueQuery, action: "cancel" | "close" | "resolve" | "ignore" | "in_progress" | "on_hold", updatedBy: string): Promise<IIssueDocument | null>;
    /**
     * Get issues assigned to a user with business logic
     */
    getIssuesByAssignee(assignedTo: string, 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, zoneId?: 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;
        zoneId?: string;
        includeDeleted?: boolean;
        limit?: number;
        skip?: number;
    }): Promise<IIssueDocument[]>;
    /**
     * Get issues by zone ID
     */
    getIssuesByZoneId(zoneId: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
    /**
     * Get issues by zone ID and status
     */
    getIssuesByZoneIdAndStatus(zoneId: string, status: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
    /**
     * Get issues by multiple zone IDs
     */
    getIssuesByZoneIds(zoneIds: string[], includeDeleted?: boolean): Promise<IIssueDocument[]>;
    private validateIssueData;
    private validateFilters;
    private validateUpdateData;
    private validateStatusTransition;
    private validatePriorityChange;
    private determineDefaultPriority;
    private applyBusinessRules;
    private shouldUpdateStatusOnComment;
    private calculateAverageResponseTime;
    private calculateResolutionRate;
}