dt-common-device 13.0.25 → 13.0.26

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

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBasicIssue = createBasicIssue;
+exports.createDeviceIssue = createDeviceIssue;
+exports.createSecurityIssue = createSecurityIssue;
+exports.createEnergyIssue = createEnergyIssue;
+exports.createHubIssue = createHubIssue;
+exports.createUserIssue = createUserIssue;
+exports.createPropertyIssue = createPropertyIssue;
+exports.createMaintenanceIssue = createMaintenanceIssue;
+exports.createUrgentIssue = createUrgentIssue;
+exports.createMultipleIssues = createMultipleIssues;
+exports.createIssueWithDueDate = createIssueWithDueDate;
+exports.createUnassignedIssue = createUnassignedIssue;
+const IssueBuilder_1 = require("./IssueBuilder");
+const issue_types_1 = require("../../../types/issue.types");
+/**
+ * Example usage of IssueBuilder
+ * This file demonstrates various ways to use the IssueBuilder pattern
+ */
+// Example 1: Basic issue creation
+function createBasicIssue() {
+    const issueData = new IssueBuilder_1.IssueBuilder()
+        .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+        .setPropertyId("prop123")
+        .setTitle("Device Maintenance Required")
+        .setDescription("Device requires scheduled maintenance")
+        .setEntityId("device456")
+        .setEntityType(issue_types_1.EntityType.DEVICE)
+        .setPriority(issue_types_1.IssuePriority.HIGH)
+        .setAssignedTo("tech789")
+        .setCreatedBy("user123")
+        .setDueDate(new Date("2024-01-15"))
+        .build();
+    return issueData;
+}
+// Example 2: Using static factory methods
+function createDeviceIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createDeviceIssue("device123", "prop456")
+        .setCategory(issue_types_1.IssuesCategory.READINESS)
+        .setTitle("Device Firmware Update")
+        .setDescription("Device firmware update is available")
+        .setPriority(issue_types_1.IssuePriority.MEDIUM)
+        .setAssignedTo("admin")
+        .setCreatedBy("system")
+        .setDueDate(new Date("2024-01-20"))
+        .build();
+    return issueData;
+}
+// Example 3: Using predefined issue types
+function createSecurityIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createSecurityIssue()
+        .setPropertyId("prop789")
+        .setTitle("Security Breach Detected")
+        .setDescription("Unauthorized access attempt detected")
+        .setEntityId("user123")
+        .setEntityType(issue_types_1.EntityType.USER)
+        .setAssignedTo("security-team")
+        .setCreatedBy("security-system")
+        .setDueDate(new Date("2024-01-10"))
+        .build();
+    return issueData;
+}
+// Example 4: Creating energy issue
+function createEnergyIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createEnergyIssue()
+        .setPropertyId("prop101")
+        .setTitle("High Energy Consumption")
+        .setDescription("Energy usage is 20% above normal levels")
+        .setEntityId("zone456")
+        .setEntityType(issue_types_1.EntityType.COLLECTION)
+        .setAssignedTo("energy-manager")
+        .setCreatedBy("energy-monitor")
+        .setDueDate(new Date("2024-01-25"))
+        .build();
+    return issueData;
+}
+// Example 5: Creating hub issue
+function createHubIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createHubIssue("hub789", "prop202")
+        .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+        .setTitle("Hub Connection Lost")
+        .setDescription("Hub has lost connection to the network")
+        .setPriority(issue_types_1.IssuePriority.CRITICAL)
+        .setAssignedTo("network-admin")
+        .setCreatedBy("network-monitor")
+        .setDueDate(new Date("2024-01-05"))
+        .build();
+    return issueData;
+}
+// Example 6: Creating user-specific issue
+function createUserIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createUserIssue("user456", "prop303")
+        .setCategory(issue_types_1.IssuesCategory.SECURITY)
+        .setTitle("User Access Review Required")
+        .setDescription("User access permissions need review")
+        .setPriority(issue_types_1.IssuePriority.MEDIUM)
+        .setAssignedTo("hr-admin")
+        .setCreatedBy("access-control")
+        .setDueDate(new Date("2024-01-30"))
+        .build();
+    return issueData;
+}
+// Example 7: Creating property-specific issue
+function createPropertyIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createPropertyIssue("prop404")
+        .setCategory(issue_types_1.IssuesCategory.READINESS)
+        .setTitle("Property Maintenance Schedule")
+        .setDescription("Annual property maintenance is due")
+        .setPriority(issue_types_1.IssuePriority.LOW)
+        .setAssignedTo("property-manager")
+        .setCreatedBy("maintenance-system")
+        .setDueDate(new Date("2024-02-15"))
+        .build();
+    return issueData;
+}
+// Example 8: Creating maintenance issue
+function createMaintenanceIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createMaintenanceIssue("prop505", "device789", issue_types_1.EntityType.DEVICE)
+        .setTitle("Scheduled Device Maintenance")
+        .setDescription("Regular maintenance is scheduled for this device")
+        .setAssignedTo("technician")
+        .setCreatedBy("maintenance-scheduler")
+        .setDueDate(new Date("2024-01-12"))
+        .build();
+    return issueData;
+}
+// Example 9: Creating urgent issue
+function createUrgentIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createUrgentIssue("prop606", "hub123", issue_types_1.EntityType.HUB)
+        .setTitle("Critical Hub Failure")
+        .setDescription("Hub is experiencing critical failures")
+        .setAssignedTo("emergency-tech")
+        .setCreatedBy("monitoring-system")
+        .setDueDate(new Date("2024-01-03"))
+        .build();
+    return issueData;
+}
+// Example 10: Reusing builder instance
+function createMultipleIssues() {
+    const builder = new IssueBuilder_1.IssueBuilder()
+        .setPropertyId("prop707")
+        .setCreatedBy("batch-processor");
+    const issue1 = builder
+        .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+        .setTitle("Device Temperature High")
+        .setDescription("Device temperature exceeds normal operating range")
+        .setEntityId("device789")
+        .setEntityType(issue_types_1.EntityType.DEVICE)
+        .setPriority(issue_types_1.IssuePriority.HIGH)
+        .setAssignedTo("tech-support")
+        .build();
+    const issue2 = builder
+        .reset()
+        .setPropertyId("prop707")
+        .setCategory(issue_types_1.IssuesCategory.ENERGY)
+        .setTitle("Low Battery Warning")
+        .setDescription("Device battery level is below 20%")
+        .setEntityId("device789")
+        .setEntityType(issue_types_1.EntityType.DEVICE)
+        .setPriority(issue_types_1.IssuePriority.MEDIUM)
+        .setAssignedTo("maintenance-team")
+        .setCreatedBy("batch-processor")
+        .build();
+    return [issue1, issue2];
+}
+// Example 11: Creating issue with due date calculation
+function createIssueWithDueDate() {
+    const dueDate = new Date();
+    dueDate.setDate(dueDate.getDate() + 7); // Due in 7 days
+    const issueData = new IssueBuilder_1.IssueBuilder()
+        .setCategory(issue_types_1.IssuesCategory.READINESS)
+        .setPropertyId("prop808")
+        .setTitle("System Update Required")
+        .setDescription("System requires critical security update")
+        .setEntityType(issue_types_1.EntityType.PROPERTY)
+        .setPriority(issue_types_1.IssuePriority.HIGH)
+        .setAssignedTo("system-admin")
+        .setCreatedBy("update-manager")
+        .setDueDate(dueDate)
+        .build();
+    return issueData;
+}
+// Example 12: Creating issue without assignment
+function createUnassignedIssue() {
+    const issueData = new IssueBuilder_1.IssueBuilder()
+        .setCategory(issue_types_1.IssuesCategory.OTHER)
+        .setPropertyId("prop909")
+        .setTitle("General Inquiry")
+        .setDescription("General inquiry about system functionality")
+        .setEntityType(issue_types_1.EntityType.PROPERTY)
+        .setPriority(issue_types_1.IssuePriority.LOW)
+        .setCreatedBy("user-inquiry")
+        .build();
+    return issueData;
+}

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