dt-common-device 11.2.0 → 11.2.2

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/entities/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueBuilder = exports.AlertBuilder = void 0;
+var AlertBuilder_1 = require("./AlertBuilder");
+Object.defineProperty(exports, "AlertBuilder", { enumerable: true, get: function () { return AlertBuilder_1.AlertBuilder; } });
+var IssueBuilder_1 = require("./IssueBuilder");
+Object.defineProperty(exports, "IssueBuilder", { enumerable: true, get: function () { return IssueBuilder_1.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/EventHandler.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = void 0;
+const dt_pub_sub_1 = require("dt-pub-sub");
+const dt_audit_library_1 = require("dt-audit-library");
+const Events_1 = require("./Events");
+class EventHandler {
+    constructor() {
+        this.source = "dt-common-device";
+    }
+    async onDeviceCreate(body) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.CREATED, body, this.source);
+        const payload = {
+            eventType: Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.CREATED,
+            properties: {
+                ...body,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onDeviceUpdate(deviceId, body) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.UPDATED, { deviceId, body }, this.source);
+        const payload = {
+            eventType: Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.UPDATED,
+            properties: {
+                ...body,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onDeviceDelete(deviceId) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.DELETED, { deviceId }, this.source);
+        const payload = {
+            eventType: Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.DELETED,
+            properties: {
+                deviceId,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onStateChange(deviceId, state) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.STATE.SET, { deviceId, state }, this.source);
+        const payload = {
+            eventType: Events_1.DT_EVENT_TYPES.DEVICE.STATE.SET,
+            properties: {
+                deviceId,
+                state,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onStatusChange(deviceId, status) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.STATUS.SET, { deviceId, status }, this.source);
+        const payload = {
+            eventType: Events_1.DT_EVENT_TYPES.DEVICE.STATUS.SET,
+            properties: {
+                deviceId,
+                status,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onBatteryLevelChange(deviceId, batteryLevel) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.BATTERY.SET, { deviceId, batteryLevel }, this.source);
+        const payload = {
+            eventType: Events_1.DT_EVENT_TYPES.DEVICE.BATTERY.SET,
+            properties: {
+                deviceId,
+                batteryLevel,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onDeviceMetaChange(deviceId, metaData) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.META_DATA.SET, { deviceId, metaData }, this.source);
+        const payload = {
+            eventType: Events_1.DT_EVENT_TYPES.DEVICE.META_DATA.SET,
+            properties: {
+                deviceId,
+                metaData,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+}
+exports.EventHandler = EventHandler;

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/Events.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DT_EVENT_TYPES = void 0;
+exports.DT_EVENT_TYPES = {
+    DEVICE: {
+        DEVICE: {
+            CREATED: "device.device.created",
+            UPDATED: "device.device.updated",
+            DELETED: "device.device.deleted",
+        },
+        STATE: {
+            SET: "device.state.set",
+            UNKNOWN: "device.state.unknown",
+            UPDATED: "device.state.updated",
+            CHANGED: "device.state.changed",
+        },
+        STATUS: {
+            SET: "device.status.set",
+            ONLINE: "device.status.online",
+            OFFLINE: "device.status.offline",
+            UNKNOWN: "device.status.unknown",
+            UPDATED: "device.status.updated",
+            CHANGED: "device.status.changed",
+        },
+        BATTERY: {
+            SET: "device.battery.set",
+            UNKNOWN: "device.battery.unknown",
+            LOW: "device.battery.low",
+            CRITICAL: "device.battery.critical",
+            UPDATED: "device.battery.updated",
+            CHANGED: "device.battery.changed",
+        },
+        META_DATA: {
+            SET: "device.metaData.set",
+            UPDATED: "device.metaData.updated",
+            CHANGED: "device.metaData.changed",
+        },
+    },
+    CONNECTION: {
+        CONNECTION: {
+            CREATED: "connection.connection.created",
+            UPDATED: "connection.connection.updated",
+            DELETED: "connection.connection.deleted",
+        },
+    },
+    PROPERTY: {
+        PROPERTY: {
+            CREATED: "property.property.created",
+            UPDATED: "property.property.updated",
+            DELETED: "property.property.deleted",
+        },
+        PREFERENCES: {
+            UPDATED: "property.preferences.updated",
+            CREATED: "property.preferences.created",
+        },
+    },
+};

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/events/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = exports.DT_EVENT_TYPES = void 0;
+var Events_1 = require("./Events");
+Object.defineProperty(exports, "DT_EVENT_TYPES", { enumerable: true, get: function () { return Events_1.DT_EVENT_TYPES; } });
+var EventHandler_1 = require("./EventHandler");
+Object.defineProperty(exports, "EventHandler", { enumerable: true, get: function () { return EventHandler_1.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/handler/EventHandler.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = void 0;
+const dt_pub_sub_1 = require("dt-pub-sub");
+const dt_audit_library_1 = require("dt-audit-library");
+class EventHandler {
+    constructor() {
+        this.source = "dt-common-device";
+    }
+    async onStateChange(deviceId, state) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent("device.state.set", { deviceId, state }, this.source);
+        const payload = {
+            eventType: "device.state.set",
+            properties: {
+                deviceId,
+                state,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onStatusChange(deviceId, status) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent("device.status.set", { deviceId, status }, this.source);
+        const payload = {
+            eventType: "device.status.set",
+            properties: {
+                deviceId,
+                status,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onBatteryLevelChange(deviceId, batteryLevel) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent("device.battery.set", { deviceId, batteryLevel }, this.source);
+        const payload = {
+            eventType: "device.battery.set",
+            properties: {
+                deviceId,
+                batteryLevel,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+}
+exports.EventHandler = EventHandler;

package/dist/device/local/interface.js

@@ -0,0 +1 @@
+"use strict";

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/IConnection.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionProvider = void 0;
+var ConnectionProvider;
+(function (ConnectionProvider) {
+    ConnectionProvider["Smartthings"] = "Smartthings";
+    ConnectionProvider["SaltoKS"] = "SaltoKS";
+    ConnectionProvider["TTLock"] = "TTLock";
+    ConnectionProvider["Tuya"] = "Tuya";
+    ConnectionProvider["Schlage"] = "Schlage";
+    ConnectionProvider["YaleWifi"] = "YaleWifi";
+    ConnectionProvider["Sensibo"] = "Sensibo";
+    ConnectionProvider["Devicethread"] = "Devicethread";
+})(ConnectionProvider || (exports.ConnectionProvider = ConnectionProvider = {}));

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/IDevice.js

@@ -0,0 +1,10 @@
+"use strict";
+// Interfaces for DeviceService methods
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IStatus = void 0;
+class IStatus {
+    constructor() {
+        this.online = false;
+    }
+}
+exports.IStatus = 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/IDtDevice.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });