dt-common-device 11.2.0 → 11.2.1

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBasicAlert = createBasicAlert;
+exports.createDeviceAlert = createDeviceAlert;
+exports.createSecurityAlert = createSecurityAlert;
+exports.createEnergyAlert = createEnergyAlert;
+exports.createHubAlert = createHubAlert;
+exports.createSnoozedAlert = createSnoozedAlert;
+exports.createMultipleAlerts = createMultipleAlerts;
+const AlertBuilder_1 = require("./AlertBuilder");
+const alert_types_1 = require("../../../types/alert.types");
+/**
+ * Example usage of AlertBuilder
+ * This file demonstrates various ways to use the AlertBuilder pattern
+ */
+// Example 1: Basic alert creation
+function createBasicAlert() {
+    const alertData = new AlertBuilder_1.AlertBuilder()
+        .setCategory(alert_types_1.AlertCategory.OPERATIONS)
+        .setPropertyId("prop123")
+        .setTitle("Device Offline")
+        .setDescription("Device has been offline for more than 5 minutes")
+        .setEntityId("device456")
+        .setEntityType(alert_types_1.EntityType.DEVICE)
+        .setSeverity(alert_types_1.AlertSeverity.HIGH)
+        .setCreatedBy("user789")
+        .build();
+    return alertData;
+}
+// Example 2: Using static factory methods
+function createDeviceAlert() {
+    const alertData = AlertBuilder_1.AlertBuilder.createDeviceAlert("device123", "prop456")
+        .setCategory(alert_types_1.AlertCategory.READINESS)
+        .setTitle("Device Maintenance Required")
+        .setDescription("Device firmware update is available")
+        .setSeverity(alert_types_1.AlertSeverity.MEDIUM)
+        .setCreatedBy("system")
+        .build();
+    return alertData;
+}
+// Example 3: Using predefined alert types
+function createSecurityAlert() {
+    const alertData = AlertBuilder_1.AlertBuilder.createSecurityAlert()
+        .setPropertyId("prop789")
+        .setTitle("Unauthorized Access Attempt")
+        .setDescription("Multiple failed login attempts detected")
+        .setEntityId("user123")
+        .setEntityType(alert_types_1.EntityType.USER)
+        .setCreatedBy("security-system")
+        .build();
+    return alertData;
+}
+// Example 4: Creating energy alert
+function createEnergyAlert() {
+    const alertData = AlertBuilder_1.AlertBuilder.createEnergyAlert()
+        .setPropertyId("prop101")
+        .setTitle("High Energy Consumption")
+        .setDescription("Energy usage is 20% above normal levels")
+        .setEntityId("zone456")
+        .setEntityType(alert_types_1.EntityType.COLLECTION)
+        .setCreatedBy("energy-monitor")
+        .build();
+    return alertData;
+}
+// Example 5: Creating hub alert
+function createHubAlert() {
+    const alertData = AlertBuilder_1.AlertBuilder.createHubAlert("hub789", "prop202")
+        .setCategory(alert_types_1.AlertCategory.OPERATIONS)
+        .setTitle("Hub Connection Lost")
+        .setDescription("Hub has lost connection to the network")
+        .setSeverity(alert_types_1.AlertSeverity.CRITICAL)
+        .setCreatedBy("network-monitor")
+        .build();
+    return alertData;
+}
+// Example 6: Alert with snooze
+function createSnoozedAlert() {
+    const snoozeUntil = new Date();
+    snoozeUntil.setHours(snoozeUntil.getHours() + 2); // Snooze for 2 hours
+    const alertData = new AlertBuilder_1.AlertBuilder()
+        .setCategory(alert_types_1.AlertCategory.OTHER)
+        .setPropertyId("prop303")
+        .setTitle("Scheduled Maintenance")
+        .setDescription("System maintenance scheduled for tonight")
+        .setEntityType(alert_types_1.EntityType.PROPERTY)
+        .setSeverity(alert_types_1.AlertSeverity.INFO)
+        .setCreatedBy("admin")
+        .setSnoozeUntil(snoozeUntil)
+        .build();
+    return alertData;
+}
+// Example 7: Reusing builder instance
+function createMultipleAlerts() {
+    const builder = new AlertBuilder_1.AlertBuilder()
+        .setPropertyId("prop404")
+        .setCreatedBy("system");
+    const alert1 = builder
+        .setCategory(alert_types_1.AlertCategory.OPERATIONS)
+        .setTitle("Device Temperature High")
+        .setDescription("Device temperature exceeds normal operating range")
+        .setEntityId("device789")
+        .setEntityType(alert_types_1.EntityType.DEVICE)
+        .setSeverity(alert_types_1.AlertSeverity.HIGH)
+        .build();
+    const alert2 = builder
+        .reset()
+        .setPropertyId("prop404")
+        .setCategory(alert_types_1.AlertCategory.ENERGY)
+        .setTitle("Low Battery Warning")
+        .setDescription("Device battery level is below 20%")
+        .setEntityId("device789")
+        .setEntityType(alert_types_1.EntityType.DEVICE)
+        .setSeverity(alert_types_1.AlertSeverity.MEDIUM)
+        .setCreatedBy("system")
+        .build();
+    return [alert1, alert2];
+}

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertBuilder = void 0;
+const alert_types_1 = require("../../../types/alert.types");
+/**
+ * AlertBuilder - A builder pattern implementation for constructing CreateAlertData objects
+ *
+ * This builder provides a fluent interface for creating alert 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 alertData = new AlertBuilder()
+ *   .setCategory(AlertCategory.OPERATIONS)
+ *   .setPropertyId("prop123")
+ *   .setTitle("Device Offline")
+ *   .setDescription("Device has been offline for more than 5 minutes")
+ *   .setEntityId("device456")
+ *   .setEntityType(EntityType.DEVICE)
+ *   .setSeverity(AlertSeverity.HIGH)
+ *   .setCreatedBy("user789")
+ *   .build();
+ */
+class AlertBuilder {
+    constructor() {
+        this.data = {};
+    }
+    /**
+     * Sets the alert 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 alert 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 alert 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 alert severity (optional, defaults to MEDIUM)
+     */
+    setSeverity(severity) {
+        if (severity !== undefined) {
+            this.data.severity = severity;
+        }
+        return this;
+    }
+    /**
+     * Sets the user who created the alert (optional)
+     */
+    setCreatedBy(createdBy) {
+        if (createdBy !== undefined) {
+            this.data.createdBy = createdBy.trim() || undefined;
+        }
+        return this;
+    }
+    /**
+     * Sets the snooze until date (optional)
+     */
+    setSnoozeUntil(snoozeUntil) {
+        if (snoozeUntil !== undefined) {
+            this.data.snoozeUntil = snoozeUntil;
+        }
+        return this;
+    }
+    /**
+     * Validates that all required fields are present
+     */
+    validate() {
+        const requiredFields = ["category", "propertyId", "title", "description", "entityType"];
+        const missingFields = requiredFields.filter(field => !this.data[field]);
+        if (missingFields.length > 0) {
+            throw new Error(`Missing required fields: ${missingFields.join(", ")}`);
+        }
+    }
+    /**
+     * Builds and returns the CreateAlertData object
+     * @throws Error if required fields are missing
+     */
+    build() {
+        this.validate();
+        // Set default severity if not provided
+        if (!this.data.severity) {
+            this.data.severity = alert_types_1.AlertSeverity.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 alert types
+     */
+    static createReadinessAlert() {
+        return new AlertBuilder()
+            .setCategory(alert_types_1.AlertCategory.READINESS)
+            .setSeverity(alert_types_1.AlertSeverity.MEDIUM);
+    }
+    static createOperationsAlert() {
+        return new AlertBuilder()
+            .setCategory(alert_types_1.AlertCategory.OPERATIONS)
+            .setSeverity(alert_types_1.AlertSeverity.HIGH);
+    }
+    static createSecurityAlert() {
+        return new AlertBuilder()
+            .setCategory(alert_types_1.AlertCategory.SECURITY)
+            .setSeverity(alert_types_1.AlertSeverity.CRITICAL);
+    }
+    static createEnergyAlert() {
+        return new AlertBuilder()
+            .setCategory(alert_types_1.AlertCategory.ENERGY)
+            .setSeverity(alert_types_1.AlertSeverity.LOW);
+    }
+    /**
+     * Creates a device-specific alert builder
+     */
+    static createDeviceAlert(deviceId, propertyId) {
+        return new AlertBuilder()
+            .setEntityType(alert_types_1.EntityType.DEVICE)
+            .setEntityId(deviceId)
+            .setPropertyId(propertyId);
+    }
+    /**
+     * Creates a hub-specific alert builder
+     */
+    static createHubAlert(hubId, propertyId) {
+        return new AlertBuilder()
+            .setEntityType(alert_types_1.EntityType.HUB)
+            .setEntityId(hubId)
+            .setPropertyId(propertyId);
+    }
+}
+exports.AlertBuilder = AlertBuilder;

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

@@ -0,0 +1,109 @@
+import { CreateIssueData, IssuesCategory, IssuePriority, EntityType } from "../../../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();
+ */
+export declare class IssueBuilder {
+    private data;
+    /**
+     * Sets the issue category
+     */
+    setCategory(category: IssuesCategory): IssueBuilder;
+    /**
+     * Sets the property ID
+     */
+    setPropertyId(propertyId: string): IssueBuilder;
+    /**
+     * Sets the issue title
+     */
+    setTitle(title: string): IssueBuilder;
+    /**
+     * Sets the issue description
+     */
+    setDescription(description: string): IssueBuilder;
+    /**
+     * Sets the entity ID (optional)
+     */
+    setEntityId(entityId?: string): IssueBuilder;
+    /**
+     * Sets the entity type
+     */
+    setEntityType(entityType: EntityType): IssueBuilder;
+    /**
+     * Sets the issue priority (optional, defaults to MEDIUM)
+     */
+    setPriority(priority?: IssuePriority): IssueBuilder;
+    /**
+     * Sets the user assigned to the issue (optional)
+     */
+    setAssignedTo(assignedTo?: string): IssueBuilder;
+    /**
+     * Sets the user who created the issue (required)
+     */
+    setCreatedBy(createdBy: string): IssueBuilder;
+    /**
+     * Sets the due date (optional)
+     */
+    setDueDate(dueDate?: Date): IssueBuilder;
+    /**
+     * Validates that all required fields are present
+     */
+    private validate;
+    /**
+     * Builds and returns the CreateIssueData object
+     * @throws Error if required fields are missing
+     */
+    build(): CreateIssueData;
+    /**
+     * Resets the builder to its initial state
+     */
+    reset(): IssueBuilder;
+    /**
+     * Creates a new builder instance with predefined values for common issue types
+     */
+    static createReadinessIssue(): IssueBuilder;
+    static createOperationsIssue(): IssueBuilder;
+    static createSecurityIssue(): IssueBuilder;
+    static createEnergyIssue(): IssueBuilder;
+    /**
+     * Creates a device-specific issue builder
+     */
+    static createDeviceIssue(deviceId: string, propertyId: string): IssueBuilder;
+    /**
+     * Creates a hub-specific issue builder
+     */
+    static createHubIssue(hubId: string, propertyId: string): IssueBuilder;
+    /**
+     * Creates a user-specific issue builder
+     */
+    static createUserIssue(userId: string, propertyId: string): IssueBuilder;
+    /**
+     * Creates a property-specific issue builder
+     */
+    static createPropertyIssue(propertyId: string): IssueBuilder;
+    /**
+     * Creates a maintenance issue builder
+     */
+    static createMaintenanceIssue(propertyId: string, entityId?: string, entityType?: EntityType): IssueBuilder;
+    /**
+     * Creates an urgent issue builder
+     */
+    static createUrgentIssue(propertyId: string, entityId?: string, entityType?: EntityType): IssueBuilder;
+}

package/dist/device/local/entities/IssueBuilder.example.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Example usage of IssueBuilder
+ * This file demonstrates various ways to use the IssueBuilder pattern
+ */
+export declare function createBasicIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createDeviceIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createSecurityIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createEnergyIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createHubIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createUserIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createPropertyIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createMaintenanceIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createUrgentIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createMultipleIssues(): import("../../../types/issue.types").CreateIssueData[];
+export declare function createIssueWithDueDate(): import("../../../types/issue.types").CreateIssueData;
+export declare function createUnassignedIssue(): import("../../../types/issue.types").CreateIssueData;

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