dt-common-device 1.3.0 → 2.0.0

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

@@ -0,0 +1,263 @@
+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 class IssueBuilder {
+  private data: Partial<CreateIssueData> = {};
+
+  /**
+   * Sets the issue category
+   */
+  setCategory(category: IssuesCategory): IssueBuilder {
+    this.data.category = category;
+    return this;
+  }
+
+  /**
+   * Sets the property ID
+   */
+  setPropertyId(propertyId: string): IssueBuilder {
+    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: string): IssueBuilder {
+    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: string): IssueBuilder {
+    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): IssueBuilder {
+    if (entityId !== undefined) {
+      this.data.entityId = entityId.trim() || undefined;
+    }
+    return this;
+  }
+
+  /**
+   * Sets the entity type
+   */
+  setEntityType(entityType: EntityType): IssueBuilder {
+    this.data.entityType = entityType;
+    return this;
+  }
+
+  /**
+   * Sets the issue priority (optional, defaults to MEDIUM)
+   */
+  setPriority(priority?: IssuePriority): IssueBuilder {
+    if (priority !== undefined) {
+      this.data.priority = priority;
+    }
+    return this;
+  }
+
+  /**
+   * Sets the user assigned to the issue (optional)
+   */
+  setAssignedTo(assignedTo?: string): IssueBuilder {
+    if (assignedTo !== undefined) {
+      this.data.assignedTo = assignedTo.trim() || undefined;
+    }
+    return this;
+  }
+
+  /**
+   * Sets the user who created the issue (required)
+   */
+  setCreatedBy(createdBy: string): IssueBuilder {
+    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?: Date): IssueBuilder {
+    if (dueDate !== undefined) {
+      this.data.dueDate = dueDate;
+    }
+    return this;
+  }
+
+  /**
+   * Validates that all required fields are present
+   */
+  private validate(): void {
+    const requiredFields = ["category", "propertyId", "title", "description", "entityType", "createdBy"];
+    const missingFields = requiredFields.filter(field => !this.data[field as keyof CreateIssueData]);
+
+    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(): CreateIssueData {
+    this.validate();
+
+    // Set default priority if not provided
+    if (!this.data.priority) {
+      this.data.priority = IssuePriority.MEDIUM;
+    }
+
+    return this.data as CreateIssueData;
+  }
+
+  /**
+   * Resets the builder to its initial state
+   */
+  reset(): IssueBuilder {
+    this.data = {};
+    return this;
+  }
+
+  /**
+   * Creates a new builder instance with predefined values for common issue types
+   */
+  static createReadinessIssue(): IssueBuilder {
+    return new IssueBuilder()
+      .setCategory(IssuesCategory.READINESS)
+      .setPriority(IssuePriority.MEDIUM);
+  }
+
+  static createOperationsIssue(): IssueBuilder {
+    return new IssueBuilder()
+      .setCategory(IssuesCategory.OPERATIONS)
+      .setPriority(IssuePriority.HIGH);
+  }
+
+  static createSecurityIssue(): IssueBuilder {
+    return new IssueBuilder()
+      .setCategory(IssuesCategory.SECURITY)
+      .setPriority(IssuePriority.CRITICAL);
+  }
+
+  static createEnergyIssue(): IssueBuilder {
+    return new IssueBuilder()
+      .setCategory(IssuesCategory.ENERGY)
+      .setPriority(IssuePriority.LOW);
+  }
+
+  /**
+   * Creates a device-specific issue builder
+   */
+  static createDeviceIssue(deviceId: string, propertyId: string): IssueBuilder {
+    return new IssueBuilder()
+      .setEntityType(EntityType.DEVICE)
+      .setEntityId(deviceId)
+      .setPropertyId(propertyId);
+  }
+
+  /**
+   * Creates a hub-specific issue builder
+   */
+  static createHubIssue(hubId: string, propertyId: string): IssueBuilder {
+    return new IssueBuilder()
+      .setEntityType(EntityType.HUB)
+      .setEntityId(hubId)
+      .setPropertyId(propertyId);
+  }
+
+  /**
+   * Creates a user-specific issue builder
+   */
+  static createUserIssue(userId: string, propertyId: string): IssueBuilder {
+    return new IssueBuilder()
+      .setEntityType(EntityType.USER)
+      .setEntityId(userId)
+      .setPropertyId(propertyId);
+  }
+
+  /**
+   * Creates a property-specific issue builder
+   */
+  static createPropertyIssue(propertyId: string): IssueBuilder {
+    return new IssueBuilder()
+      .setEntityType(EntityType.PROPERTY)
+      .setEntityId(propertyId)
+      .setPropertyId(propertyId);
+  }
+
+  /**
+   * Creates a maintenance issue builder
+   */
+  static createMaintenanceIssue(propertyId: string, entityId?: string, entityType?: EntityType): IssueBuilder {
+    const builder = new IssueBuilder()
+      .setCategory(IssuesCategory.READINESS)
+      .setPropertyId(propertyId)
+      .setPriority(IssuePriority.MEDIUM);
+
+    if (entityId) builder.setEntityId(entityId);
+    if (entityType) builder.setEntityType(entityType);
+
+    return builder;
+  }
+
+  /**
+   * Creates an urgent issue builder
+   */
+  static createUrgentIssue(propertyId: string, entityId?: string, entityType?: EntityType): IssueBuilder {
+    const builder = new IssueBuilder()
+      .setCategory(IssuesCategory.OPERATIONS)
+      .setPropertyId(propertyId)
+      .setPriority(IssuePriority.URGENT);
+
+    if (entityId) builder.setEntityId(entityId);
+    if (entityType) builder.setEntityType(entityType);
+
+    return builder;
+  }
+} 

package/src/device/local/entities/README.md

@@ -0,0 +1,173 @@
+# AlertBuilder - Builder Pattern Implementation
+
+## Overview
+
+The `AlertBuilder` is a TypeScript implementation of the Builder design pattern, specifically designed to help construct `CreateAlertData` objects with a fluent interface. This is a standard and widely-used design pattern in TypeScript for creating complex objects with optional parameters.
+
+## Why Use the Builder Pattern?
+
+The Builder pattern is particularly useful for:
+
+1. **Complex Object Construction**: When creating objects with many optional parameters
+2. **Fluent Interface**: Provides a readable, chainable API
+3. **Validation**: Ensures required fields are provided before object creation
+4. **Default Values**: Automatically sets sensible defaults
+5. **Type Safety**: Provides compile-time type checking
+
+## Usage Examples
+
+### Basic Usage
+
+```typescript
+import { AlertBuilder } from "./AlertBuilder";
+import { AlertCategory, AlertSeverity, EntityType } from "../../../types/alert.types";
+
+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();
+```
+
+### Using Static Factory Methods
+
+```typescript
+// Create a device-specific alert
+const deviceAlert = AlertBuilder.createDeviceAlert("device123", "prop456")
+  .setCategory(AlertCategory.READINESS)
+  .setTitle("Device Maintenance Required")
+  .setDescription("Device firmware update is available")
+  .setSeverity(AlertSeverity.MEDIUM)
+  .setCreatedBy("system")
+  .build();
+
+// Create a hub-specific alert
+const hubAlert = 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();
+```
+
+### Using Predefined Alert Types
+
+```typescript
+// Security alert with CRITICAL severity
+const securityAlert = AlertBuilder.createSecurityAlert()
+  .setPropertyId("prop789")
+  .setTitle("Unauthorized Access Attempt")
+  .setDescription("Multiple failed login attempts detected")
+  .setEntityId("user123")
+  .setEntityType(EntityType.USER)
+  .setCreatedBy("security-system")
+  .build();
+
+// Energy alert with LOW severity
+const energyAlert = 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();
+```
+
+### Reusing Builder Instances
+
+```typescript
+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();
+```
+
+## Available Methods
+
+### Instance Methods
+
+- `setCategory(category: AlertCategory)`: Sets the alert category
+- `setPropertyId(propertyId: string)`: Sets the property ID (required)
+- `setTitle(title: string)`: Sets the alert title (required)
+- `setDescription(description: string)`: Sets the alert description (required)
+- `setEntityId(entityId?: string)`: Sets the entity ID (optional)
+- `setEntityType(entityType: EntityType)`: Sets the entity type (required)
+- `setSeverity(severity?: AlertSeverity)`: Sets the alert severity (optional, defaults to MEDIUM)
+- `setCreatedBy(createdBy?: string)`: Sets the user who created the alert (optional)
+- `setSnoozeUntil(snoozeUntil?: Date)`: Sets the snooze until date (optional)
+- `build()`: Builds and returns the CreateAlertData object
+- `reset()`: Resets the builder to its initial state
+
+### Static Factory Methods
+
+- `createReadinessAlert()`: Creates a builder with READINESS category and MEDIUM severity
+- `createOperationsAlert()`: Creates a builder with OPERATIONS category and HIGH severity
+- `createSecurityAlert()`: Creates a builder with SECURITY category and CRITICAL severity
+- `createEnergyAlert()`: Creates a builder with ENERGY category and LOW severity
+- `createDeviceAlert(deviceId: string, propertyId: string)`: Creates a device-specific alert builder
+- `createHubAlert(hubId: string, propertyId: string)`: Creates a hub-specific alert builder
+
+## Validation
+
+The builder automatically validates that all required fields are present when `build()` is called. Required fields are:
+
+- `category`
+- `propertyId`
+- `title`
+- `description`
+- `entityType`
+
+If any required field is missing, an error will be thrown with details about which fields are missing.
+
+## Default Values
+
+- `severity`: Defaults to `AlertSeverity.MEDIUM` if not specified
+
+## Error Handling
+
+The builder includes comprehensive error handling:
+
+- Validates required fields before building
+- Trims whitespace from string inputs
+- Validates that propertyId and title are not empty strings
+- Provides clear error messages for missing or invalid data
+
+## Design Pattern Benefits
+
+This implementation follows the Builder pattern which provides:
+
+1. **Separation of Concerns**: Object construction is separated from object representation
+2. **Fluent Interface**: Method chaining for better readability
+3. **Immutability**: Each method returns a new builder instance
+4. **Validation**: Built-in validation before object creation
+5. **Flexibility**: Easy to add new fields or modify existing ones
+6. **Type Safety**: Full TypeScript support with compile-time checking
+
+This is indeed a standard design pattern in TypeScript and is widely used in enterprise applications for constructing complex objects with many optional parameters. 

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

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

package/src/device/local/interfaces/IDevice.ts

@@ -37,18 +37,20 @@ export interface IDevice {
     id: string;
     type: string;
   };
-  status: {
-    online: boolean;
-    error?: {
-      type?: string;
-      message?: string;
-      default?: object;
-    };
-    lastUpdated?: string;
-  };
+  status: INewStatus;
   state?: object;
   metaData?: object;
   createdAt?: Date;
   updatedAt?: Date;
   hubDeviceDetails?: IDevice[];
 }
+
+export class INewStatus {
+  online: boolean = false;
+  error?: {
+    type?: string;
+    message?: string;
+    default?: object;
+  };
+  lastUpdated?: string;
+}