dt-common-device 13.1.3 → 13.1.5

package/dist/device/local/entities/IssueBuilder.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueBuilder = void 0;
+const issue_types_1 = require("../../../types/issue.types");
+/**
+ * IssueBuilder - A builder pattern implementation for constructing CreateIssueData objects
+ *
+ * This builder provides a fluent interface for creating issue data with proper validation
+ * and default values. It follows the Builder pattern which is a standard design pattern
+ * in TypeScript for constructing complex objects.
+ *
+ * Usage example:
+ * const issueData = new IssueBuilder()
+ *   .setCategory(IssuesCategory.OPERATIONS)
+ *   .setPropertyId("prop123")
+ *   .setTitle("Device Maintenance Required")
+ *   .setDescription("Device requires scheduled maintenance")
+ *   .setEntityId("device456")
+ *   .setEntityType(EntityType.DEVICE)
+ *   .setPriority(IssuePriority.HIGH)
+ *   .setAssignedTo("tech789")
+ *   .setCreatedBy("user123")
+ *   .setDueDate(new Date("2024-01-15"))
+ *   .build();
+ */
+class IssueBuilder {
+    constructor() {
+        this.data = {};
+    }
+    /**
+     * Sets the issue category
+     */
+    setCategory(category) {
+        this.data.category = category;
+        return this;
+    }
+    /**
+     * Sets the property ID
+     */
+    setPropertyId(propertyId) {
+        if (!propertyId || propertyId.trim() === "") {
+            throw new Error("Property ID is required and cannot be empty");
+        }
+        this.data.propertyId = propertyId;
+        return this;
+    }
+    /**
+     * Sets the issue title
+     */
+    setTitle(title) {
+        if (!title || title.trim() === "") {
+            throw new Error("Title is required and cannot be empty");
+        }
+        this.data.title = title.trim();
+        return this;
+    }
+    /**
+     * Sets the issue description
+     */
+    setDescription(description) {
+        if (!description || description.trim() === "") {
+            throw new Error("Description is required and cannot be empty");
+        }
+        this.data.description = description.trim();
+        return this;
+    }
+    /**
+     * Sets the entity ID (optional)
+     */
+    setEntityId(entityId) {
+        if (entityId !== undefined) {
+            this.data.entityId = entityId.trim() || undefined;
+        }
+        return this;
+    }
+    /**
+     * Sets the entity type
+     */
+    setEntityType(entityType) {
+        this.data.entityType = entityType;
+        return this;
+    }
+    /**
+     * Sets the issue priority (optional, defaults to MEDIUM)
+     */
+    setPriority(priority) {
+        if (priority !== undefined) {
+            this.data.priority = priority;
+        }
+        return this;
+    }
+    /**
+     * Sets the user assigned to the issue (optional)
+     */
+    setAssignedTo(assignedTo) {
+        if (assignedTo !== undefined) {
+            this.data.assignedTo = assignedTo.trim() || undefined;
+        }
+        return this;
+    }
+    /**
+     * Sets the user who created the issue (required)
+     */
+    setCreatedBy(createdBy) {
+        if (!createdBy || createdBy.trim() === "") {
+            throw new Error("Created by user is required and cannot be empty");
+        }
+        this.data.createdBy = createdBy.trim();
+        return this;
+    }
+    /**
+     * Sets the due date (optional)
+     */
+    setDueDate(dueDate) {
+        if (dueDate !== undefined) {
+            this.data.dueDate = dueDate;
+        }
+        return this;
+    }
+    /**
+     * Validates that all required fields are present
+     */
+    validate() {
+        const requiredFields = ["category", "propertyId", "title", "description", "entityType", "createdBy"];
+        const missingFields = requiredFields.filter(field => !this.data[field]);
+        if (missingFields.length > 0) {
+            throw new Error(`Missing required fields: ${missingFields.join(", ")}`);
+        }
+    }
+    /**
+     * Builds and returns the CreateIssueData object
+     * @throws Error if required fields are missing
+     */
+    build() {
+        this.validate();
+        // Set default priority if not provided
+        if (!this.data.priority) {
+            this.data.priority = issue_types_1.IssuePriority.MEDIUM;
+        }
+        return this.data;
+    }
+    /**
+     * Resets the builder to its initial state
+     */
+    reset() {
+        this.data = {};
+        return this;
+    }
+    /**
+     * Creates a new builder instance with predefined values for common issue types
+     */
+    static createReadinessIssue() {
+        return new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.READINESS)
+            .setPriority(issue_types_1.IssuePriority.MEDIUM);
+    }
+    static createOperationsIssue() {
+        return new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+            .setPriority(issue_types_1.IssuePriority.HIGH);
+    }
+    static createSecurityIssue() {
+        return new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.SECURITY)
+            .setPriority(issue_types_1.IssuePriority.CRITICAL);
+    }
+    static createEnergyIssue() {
+        return new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.ENERGY)
+            .setPriority(issue_types_1.IssuePriority.LOW);
+    }
+    /**
+     * Creates a device-specific issue builder
+     */
+    static createDeviceIssue(deviceId, propertyId) {
+        return new IssueBuilder()
+            .setEntityType(issue_types_1.EntityType.DEVICE)
+            .setEntityId(deviceId)
+            .setPropertyId(propertyId);
+    }
+    /**
+     * Creates a hub-specific issue builder
+     */
+    static createHubIssue(hubId, propertyId) {
+        return new IssueBuilder()
+            .setEntityType(issue_types_1.EntityType.HUB)
+            .setEntityId(hubId)
+            .setPropertyId(propertyId);
+    }
+    /**
+     * Creates a user-specific issue builder
+     */
+    static createUserIssue(userId, propertyId) {
+        return new IssueBuilder()
+            .setEntityType(issue_types_1.EntityType.USER)
+            .setEntityId(userId)
+            .setPropertyId(propertyId);
+    }
+    /**
+     * Creates a property-specific issue builder
+     */
+    static createPropertyIssue(propertyId) {
+        return new IssueBuilder()
+            .setEntityType(issue_types_1.EntityType.PROPERTY)
+            .setEntityId(propertyId)
+            .setPropertyId(propertyId);
+    }
+    /**
+     * Creates a maintenance issue builder
+     */
+    static createMaintenanceIssue(propertyId, entityId, entityType) {
+        const builder = new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.READINESS)
+            .setPropertyId(propertyId)
+            .setPriority(issue_types_1.IssuePriority.MEDIUM);
+        if (entityId)
+            builder.setEntityId(entityId);
+        if (entityType)
+            builder.setEntityType(entityType);
+        return builder;
+    }
+    /**
+     * Creates an urgent issue builder
+     */
+    static createUrgentIssue(propertyId, entityId, entityType) {
+        const builder = new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+            .setPropertyId(propertyId)
+            .setPriority(issue_types_1.IssuePriority.URGENT);
+        if (entityId)
+            builder.setEntityId(entityId);
+        if (entityType)
+            builder.setEntityType(entityType);
+        return builder;
+    }
+}
+exports.IssueBuilder = IssueBuilder;

package/dist/device/local/entities/index.d.ts

@@ -0,0 +1,2 @@
+export { AlertBuilder } from "./AlertBuilder";
+export { IssueBuilder } from "./IssueBuilder";

package/dist/device/local/events/EventHandler.d.ts

@@ -0,0 +1,11 @@
+export declare class EventHandler {
+    private readonly source;
+    constructor();
+    onDeviceCreate(body: any): Promise<void>;
+    onDeviceUpdate(deviceId: string, body: any): Promise<void>;
+    onDeviceDelete(deviceId: string): Promise<void>;
+    onStateChange(deviceId: string, state: any): Promise<void>;
+    onStatusChange(deviceId: string, status: any): Promise<void>;
+    onBatteryLevelChange(deviceId: string, batteryLevel: number): Promise<void>;
+    onDeviceMetaChange(deviceId: string, metaData: Record<string, any>): Promise<void>;
+}

package/dist/device/local/events/Events.d.ts

@@ -0,0 +1,54 @@
+export declare const DT_EVENT_TYPES: {
+    DEVICE: {
+        DEVICE: {
+            CREATED: string;
+            UPDATED: string;
+            DELETED: string;
+        };
+        STATE: {
+            SET: string;
+            UNKNOWN: string;
+            UPDATED: string;
+            CHANGED: string;
+        };
+        STATUS: {
+            SET: string;
+            ONLINE: string;
+            OFFLINE: string;
+            UNKNOWN: string;
+            UPDATED: string;
+            CHANGED: string;
+        };
+        BATTERY: {
+            SET: string;
+            UNKNOWN: string;
+            LOW: string;
+            CRITICAL: string;
+            UPDATED: string;
+            CHANGED: string;
+        };
+        META_DATA: {
+            SET: string;
+            UPDATED: string;
+            CHANGED: string;
+        };
+    };
+    CONNECTION: {
+        CONNECTION: {
+            CREATED: string;
+            UPDATED: string;
+            DELETED: string;
+        };
+    };
+    PROPERTY: {
+        PROPERTY: {
+            CREATED: string;
+            UPDATED: string;
+            DELETED: string;
+        };
+        PREFERENCES: {
+            UPDATED: string;
+            CREATED: string;
+        };
+    };
+};

package/dist/device/local/events/index.d.ts

@@ -0,0 +1,2 @@
+export { DT_EVENT_TYPES } from "./Events";
+export { EventHandler } from "./EventHandler";

package/dist/device/local/handler/EventHandler.d.ts

@@ -0,0 +1,7 @@
+export declare class EventHandler {
+    private readonly source;
+    constructor();
+    onStateChange(deviceId: string, state: any): Promise<void>;
+    onStatusChange(deviceId: string, status: any): Promise<void>;
+    onBatteryLevelChange(deviceId: string, batteryLevel: number): Promise<void>;
+}

package/dist/device/local/interfaces/IConnection.d.ts

@@ -0,0 +1,26 @@
+export interface IConnection {
+    id?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    isDeleted?: boolean;
+    connectionName: string;
+    connectionRefId: string;
+    propertyId: string;
+    connectionProvider: ConnectionProvider;
+    accessToken?: string;
+    refreshToken?: string;
+    clientId?: string;
+    clientSecret: string;
+    isActive?: boolean;
+    metaData?: any;
+}
+export declare enum ConnectionProvider {
+    Smartthings = "Smartthings",
+    SaltoKS = "SaltoKS",
+    TTLock = "TTLock",
+    Tuya = "Tuya",
+    Schlage = "Schlage",
+    YaleWifi = "YaleWifi",
+    Sensibo = "Sensibo",
+    Devicethread = "Devicethread"
+}

package/dist/device/local/interfaces/IDevice.d.ts

@@ -0,0 +1,68 @@
+export interface IDevice {
+    deviceId: string;
+    propertyId: string;
+    zoneId: string;
+    name: string;
+    hubId: string[];
+    specifications: {
+        manufacturer?: string;
+        model?: string;
+        firmware?: {
+            version?: string;
+            newVersionAvailable?: boolean;
+            newVersion?: string;
+            mandatoryUpdate?: boolean;
+        };
+    };
+    protocol: {
+        location?: {
+            id?: string;
+            name?: string;
+            city?: string;
+        };
+        name?: string;
+        room?: {
+            id?: string;
+            name?: string;
+        };
+        accountId?: string;
+    };
+    connection: {
+        id: string;
+        name: string;
+    };
+    deviceType: {
+        id: string;
+        type: string;
+    };
+    status: IStatus;
+    isActive: {
+        value: boolean;
+        lastUpdated: string;
+    };
+    state?: Record<string, any>;
+    metaData?: Record<string, any>;
+    createdAt?: Date;
+    updatedAt?: Date;
+    hubDeviceDetails?: IDevice[];
+    capabilities?: Record<string, any>;
+}
+export declare class IStatus {
+    online: boolean;
+    liveStatus?: "ONLINE" | "OFFLINE";
+    error?: {
+        type?: string;
+        message?: string;
+        default?: object;
+    };
+    lastUpdated?: string;
+}
+export interface IStatusQuery {
+    deviceIds?: string[];
+    zoneId?: string;
+    propertyId?: string;
+}
+export interface IStatusUpdateRequest {
+    query: IStatusQuery;
+    status: IStatus;
+}

package/dist/device/local/interfaces/IDtDevice.d.ts

@@ -0,0 +1,16 @@
+export interface IDtDevice {
+    id: string;
+    name: string;
+    type: string;
+    zoneId: string;
+    deviceType: string;
+    deviceId: string;
+    deviceNetworkId: string;
+    propertyId: string;
+    connectionId: string;
+    hubId: string;
+    isBatteryLowAlertSent: boolean;
+    createdAt: string;
+    updatedAt: string;
+    isActive: boolean;
+}

package/dist/device/local/interfaces/IHub.d.ts

@@ -0,0 +1,46 @@
+export interface IHub {
+    deviceId: string;
+    propertyId: string;
+    name: string;
+    hubId?: string[];
+    specifications: {
+        manufacturer?: string;
+        model?: string;
+        firmware?: {
+            version?: string;
+            newVersionAvailable?: boolean;
+            newVersion?: string;
+            mandatoryUpdate?: boolean;
+        };
+    };
+    protocol: {
+        location?: {
+            id?: string;
+            name?: string;
+            city?: string;
+        };
+        name?: string;
+        room?: {
+            id?: string;
+            name?: string;
+        };
+        accountId?: string;
+    };
+    deviceType: {
+        id: string;
+        type: string;
+    };
+    status: {
+        online: boolean;
+        error?: {
+            type?: string;
+            message?: string;
+            default?: object;
+        };
+        lastUpdated?: Date;
+    };
+    state?: object;
+    metaData?: object;
+    createdAt?: Date;
+    updatedAt?: Date;
+}

package/dist/device/local/interfaces/IProperty.d.ts

@@ -0,0 +1,29 @@
+export interface IProperty {
+    id: string;
+    name: string;
+    apartment: string;
+    city: string;
+    country: string;
+    state: string;
+    street: string;
+    zipCode: string;
+    createdBy?: string;
+    isDeleted: boolean;
+    imageURL: string;
+    timezone: string;
+    officialName?: string;
+    sameAsOfficialName?: boolean;
+    phoneNumber?: string;
+    phoneNumberCountryCode?: string;
+    propertyKey?: string;
+    hubNetworkId?: string;
+    isTimeZoneOverridden: boolean;
+    createdAt: string;
+    updatedAt: string;
+    propertyBillingId?: string;
+}
+export interface IPropertySettings {
+    id: string;
+    propertyId: string;
+    settings: Record<string, any>;
+}

package/dist/device/local/interfaces/ISchedule.d.ts

@@ -0,0 +1,25 @@
+export interface ISchedule {
+    id?: string;
+    name: string;
+    deviceId: string;
+    scheduleId: string | null;
+    state: {
+        targetTemperature?: number;
+        temperatureUnit?: "C" | "F";
+        mode?: "cool" | "heat" | "fan" | "dry" | "auto";
+        swing?: "stopped" | "rangeFull" | "fixedTop" | "fixedMiddleTop" | "fixedMiddle" | "fixedMiddleBottom" | "fixedBottom";
+        fanLevel?: "auto" | "low" | "medium" | "high";
+    };
+    startTime: string;
+    endTime: string;
+    recurringDays: ("Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday")[];
+    createTime?: string;
+    nextTime?: string;
+    nextTimeSecondsFromNow?: number;
+    targetTimeLocal: string;
+    timezone: string;
+    scheduleInheritedFrom: "zone" | "device";
+    zoneId: string;
+    userId: string;
+    status?: "SET" | "UNSET";
+}

package/dist/device/local/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IDevice";
+export * from "./IDtDevice";
+export * from "./ISchedule";

package/dist/device/local/models/Alert.model.d.ts

@@ -0,0 +1,28 @@
+import mongoose, { Model } from "mongoose";
+import { AlertCategory, AlertSeverity, EntityType, AlertDocument as IAlertDocument, CreateAlertData, UpdateAlertData } from "../../../types/alert.types";
+interface IAlertMethods {
+    markAsRead(updatedBy: string): void;
+    markAsUnread(updatedBy: string): void;
+    activate(updatedBy: string): void;
+    deactivate(updatedBy: string): void;
+    snooze(until: Date, updatedBy: string): void;
+    unsnooze(updatedBy: string): void;
+}
+interface IAlertModel extends Model<IAlertDocument, {}, IAlertMethods> {
+    findByProperty(propertyId: string, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findByCategory(category: AlertCategory, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findBySeverity(severity: AlertSeverity, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findActive(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findUnread(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findSnoozed(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findExpiredSnooze(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+}
+declare const AlertSchema: mongoose.Schema<IAlertDocument, IAlertModel, IAlertMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IAlertDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IAlertDocument>, {}> & Omit<mongoose.FlatRecord<IAlertDocument> & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, keyof IAlertMethods> & IAlertMethods>;
+export declare const AlertModel: IAlertModel;
+export { AlertSchema };
+export type { IAlertDocument, CreateAlertData, UpdateAlertData, IAlertMethods, IAlertModel, };

package/dist/device/local/models/Issue.model.d.ts

@@ -0,0 +1,28 @@
+import mongoose, { Model } from "mongoose";
+import { EntityType, IssueStatus, IssuePriority, IssueDocument as IIssueDocument, CreateIssueData, UpdateIssueData, AddCommentData } from "../../../types/issue.types";
+interface IIssueMethods {
+    addComment(commentData: AddCommentData): void;
+    updateComment(commentId: string, content: string, userId: string): boolean;
+    removeComment(commentId: string): boolean;
+    resolve(resolvedBy: string): void;
+    reopen(updatedBy: string): void;
+    assign(userId: string, assignedBy: string): void;
+    unassign(unassignedBy: string): void;
+}
+interface IIssueModel extends Model<IIssueDocument, {}, IIssueMethods> {
+    findByProperty(propertyId: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findByAssignee(assignedTo: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findByStatus(status: IssueStatus, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findByPriority(priority: IssuePriority, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findOverdue(includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findUpcoming(days?: number, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+}
+declare const IssueSchema: mongoose.Schema<IIssueDocument, IIssueModel, IIssueMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IIssueDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IIssueDocument>, {}> & Omit<mongoose.FlatRecord<IIssueDocument> & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, keyof IIssueMethods> & IIssueMethods>;
+export declare const IssueModel: IIssueModel;
+export { IssueSchema };
+export type { IIssueDocument, CreateIssueData, UpdateIssueData, AddCommentData, IIssueMethods, IIssueModel, };