dt-common-device 1.3.0 → 2.0.1

package/src/db/db.ts

@@ -1,11 +1,10 @@
 import { Pool } from "pg";
-import { getPostgresDbUri } from "../config/config";
-
-const URI = getPostgresDbUri();
-
-let pool: Pool | null = null;
+import { getMongoUri, getPostgresDbUri } from "../config/config";
+import mongoose from "mongoose";
 
 export function getPostgresClient() {
+  const URI = getPostgresDbUri();
+  let pool: Pool | null = null;
   if (!pool) {
     pool = new Pool({
       connectionString: URI,
@@ -13,3 +12,13 @@ export function getPostgresClient() {
   }
   return pool;
 }
+
+export const connectDatabase = async (): Promise<void> => {
+  try {
+    const URI = getMongoUri();
+    await mongoose.connect(URI);
+    console.log(`Connected to MongoDB at ${URI.split("/").at(-1)}`);
+  } catch (error: any) {
+    console.error("Error connecting to MongoDB:", error);
+  }
+};

package/src/device/cloud/entities/CloudDevice.ts

@@ -33,4 +33,8 @@ export abstract class CloudDevice implements ICloudDevice {
   async getStatus(connectionId: string, deviceId: string): Promise<string> {
     throw new Error("Method not implemented in Super Class.");
   }
+
+  async toLocalDevice(): Promise<IDevice> {
+    return {} as IDevice;
+  }
 }

package/src/device/local/entities/AlertBuilder.example.ts

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

package/src/device/local/entities/AlertBuilder.ts

@@ -0,0 +1,202 @@
+import {
+  CreateAlertData,
+  AlertCategory,
+  AlertSeverity,
+  EntityType,
+} from "../../../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();
+ */
+export class AlertBuilder {
+  private data: Partial<CreateAlertData> = {};
+
+  /**
+   * Sets the alert category
+   */
+  setCategory(category: AlertCategory): AlertBuilder {
+    this.data.category = category;
+    return this;
+  }
+
+  /**
+   * Sets the property ID
+   */
+  setPropertyId(propertyId: string): AlertBuilder {
+    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: string): AlertBuilder {
+    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: string): AlertBuilder {
+    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?: string): AlertBuilder {
+    if (entityId !== undefined) {
+      this.data.entityId = entityId.trim() || undefined;
+    }
+    return this;
+  }
+
+  /**
+   * Sets the entity type
+   */
+  setEntityType(entityType: EntityType): AlertBuilder {
+    this.data.entityType = entityType;
+    return this;
+  }
+
+  /**
+   * Sets the alert severity (optional, defaults to MEDIUM)
+   */
+  setSeverity(severity?: AlertSeverity): AlertBuilder {
+    if (severity !== undefined) {
+      this.data.severity = severity;
+    }
+    return this;
+  }
+
+  /**
+   * Sets the user who created the alert (optional)
+   */
+  setCreatedBy(createdBy?: string): AlertBuilder {
+    if (createdBy !== undefined) {
+      this.data.createdBy = createdBy.trim() || undefined;
+    }
+    return this;
+  }
+
+  /**
+   * Sets the snooze until date (optional)
+   */
+  setSnoozeUntil(snoozeUntil?: Date): AlertBuilder {
+    if (snoozeUntil !== undefined) {
+      this.data.snoozeUntil = snoozeUntil;
+    }
+    return this;
+  }
+
+  /**
+   * Validates that all required fields are present
+   */
+  private validate(): void {
+    const requiredFields = ["category", "propertyId", "title", "description", "entityType"];
+    const missingFields = requiredFields.filter(field => !this.data[field as keyof CreateAlertData]);
+
+    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(): CreateAlertData {
+    this.validate();
+
+    // Set default severity if not provided
+    if (!this.data.severity) {
+      this.data.severity = AlertSeverity.MEDIUM;
+    }
+
+    return this.data as CreateAlertData;
+  }
+
+  /**
+   * Resets the builder to its initial state
+   */
+  reset(): AlertBuilder {
+    this.data = {};
+    return this;
+  }
+
+  /**
+   * Creates a new builder instance with predefined values for common alert types
+   */
+  static createReadinessAlert(): AlertBuilder {
+    return new AlertBuilder()
+      .setCategory(AlertCategory.READINESS)
+      .setSeverity(AlertSeverity.MEDIUM);
+  }
+
+  static createOperationsAlert(): AlertBuilder {
+    return new AlertBuilder()
+      .setCategory(AlertCategory.OPERATIONS)
+      .setSeverity(AlertSeverity.HIGH);
+  }
+
+  static createSecurityAlert(): AlertBuilder {
+    return new AlertBuilder()
+      .setCategory(AlertCategory.SECURITY)
+      .setSeverity(AlertSeverity.CRITICAL);
+  }
+
+  static createEnergyAlert(): AlertBuilder {
+    return new AlertBuilder()
+      .setCategory(AlertCategory.ENERGY)
+      .setSeverity(AlertSeverity.LOW);
+  }
+
+  /**
+   * Creates a device-specific alert builder
+   */
+  static createDeviceAlert(deviceId: string, propertyId: string): AlertBuilder {
+    return new AlertBuilder()
+      .setEntityType(EntityType.DEVICE)
+      .setEntityId(deviceId)
+      .setPropertyId(propertyId);
+  }
+
+  /**
+   * Creates a hub-specific alert builder
+   */
+  static createHubAlert(hubId: string, propertyId: string): AlertBuilder {
+    return new AlertBuilder()
+      .setEntityType(EntityType.HUB)
+      .setEntityId(hubId)
+      .setPropertyId(propertyId);
+  }
+
+
+} 

package/src/device/local/entities/IssueBuilder.example.ts

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