dt-common-device 3.0.10 → 3.0.11

package/src/issues/IssueService.example.ts

@@ -1,310 +0,0 @@
-import { Source } from "../constants";
-import { IssueService } from "./Issue.service";
-import { IssueBuilder } from "./IssueBuilder";
-import { IssuesCategory, IssuePriority, EntityType } from "./issue.types";
-
-/**
- * Example usage of the updated IssueService with IssueBuilder integration
- * This file demonstrates various ways to use the IssueService with the new IssueBuilder
- */
-
-export class IssueServiceExample {
-  constructor(private readonly issueService: IssueService) {}
-
-  /**
-   * Example 1: Using the updated createIssue method with IssueBuilder
-   */
-  async createIssueWithBuilder() {
-    const issueBuilder = 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"));
-
-    // Pass the IssueBuilder directly to createIssue
-    const issue = await this.issueService.createIssue(issueBuilder);
-    return issue;
-  }
-
-  /**
-   * Example 2: Using convenience methods for specific issue types
-   */
-  async createSpecificIssues() {
-    // Create a readiness issue
-    const readinessIssue = await this.issueService.createReadinessIssue(
-      "prop123",
-      "System Maintenance Required",
-      "System maintenance is scheduled for tonight",
-      "admin",
-      "system456",
-      EntityType.PROPERTY,
-      "maintenance-team",
-      new Date("2024-01-20")
-    );
-
-    // Create an operations issue
-    const operationsIssue = await this.issueService.createOperationsIssue(
-      "prop123",
-      "Device Temperature High",
-      "Device temperature exceeds normal operating range",
-      "monitor",
-      "device789",
-      EntityType.DEVICE,
-      "tech-support",
-      new Date("2024-01-10")
-    );
-
-    // Create a security issue
-    const securityIssue = await this.issueService.createSecurityIssue(
-      "prop123",
-      "Unauthorized Access Attempt",
-      "Multiple failed login attempts detected",
-      "security-system",
-      "user123",
-      EntityType.USER,
-      "security-team",
-      new Date("2024-01-05")
-    );
-
-    // Create an energy issue
-    const energyIssue = await this.issueService.createEnergyIssue(
-      "prop123",
-      "High Energy Consumption",
-      "Energy usage is 20% above normal levels",
-      "energy-monitor",
-      "zone456",
-      EntityType.COLLECTION,
-      "energy-manager",
-      new Date("2024-01-25")
-    );
-
-    return { readinessIssue, operationsIssue, securityIssue, energyIssue };
-  }
-
-  /**
-   * Example 3: Using device-specific issue methods
-   */
-  async createDeviceIssues() {
-    // Create a device issue with default category and priority
-    const deviceIssue1 = await this.issueService.createDeviceIssue(
-      "device123",
-      "prop456",
-      "Device Battery Low",
-      "Device battery level is below 20%",
-      Source.CLOUD_EVENT,
-      undefined, // Use default category
-      undefined, // Use default priority
-      "maintenance-team",
-      new Date("2024-01-12")
-    );
-
-    // Create a device issue with custom category and priority
-    const deviceIssue2 = await this.issueService.createDeviceIssue(
-      "device789",
-      "prop456",
-      "Device Firmware Update Available",
-      "New firmware version is available for installation",
-      Source.CLOUD_EVENT,
-      IssuesCategory.READINESS,
-      IssuePriority.MEDIUM,
-      "admin",
-      new Date("2024-01-20")
-    );
-
-    return { deviceIssue1, deviceIssue2 };
-  }
-
-  /**
-   * Example 4: Using hub-specific issue methods
-   */
-  async createHubIssues() {
-    // Create a hub issue with default settings
-    const hubIssue1 = await this.issueService.createHubIssue(
-      "hub123",
-      "prop456",
-      "Hub Connection Lost",
-      "Hub has lost connection to the network",
-      "network-monitor",
-      undefined, // Use default category
-      undefined, // Use default priority
-      "network-admin",
-      new Date("2024-01-05")
-    );
-
-    // Create a hub issue with custom settings
-    const hubIssue2 = await this.issueService.createHubIssue(
-      "hub789",
-      "prop456",
-      "Hub Maintenance Required",
-      "Hub requires scheduled maintenance",
-      "maintenance-system",
-      IssuesCategory.READINESS,
-      IssuePriority.LOW,
-      "technician",
-      new Date("2024-01-15")
-    );
-
-    return { hubIssue1, hubIssue2 };
-  }
-
-  /**
-   * Example 5: Using user-specific issue methods
-   */
-  async createUserIssues() {
-    // Create a user issue
-    const userIssue = await this.issueService.createUserIssue(
-      "user456",
-      "prop303",
-      "User Access Review Required",
-      "User access permissions need review",
-      "access-control",
-      IssuesCategory.SECURITY,
-      IssuePriority.MEDIUM,
-      "hr-admin",
-      new Date("2024-01-30")
-    );
-
-    return { userIssue };
-  }
-
-  /**
-   * Example 6: Using maintenance and urgent issue methods
-   */
-  async createMaintenanceAndUrgentIssues() {
-    // Create a maintenance issue
-    const maintenanceIssue = await this.issueService.createMaintenanceIssue(
-      "prop505",
-      "Scheduled Device Maintenance",
-      "Regular maintenance is scheduled for this device",
-      "maintenance-scheduler",
-      "device789",
-      EntityType.DEVICE,
-      "technician",
-      new Date("2024-01-12")
-    );
-
-    // Create an urgent issue
-    const urgentIssue = await this.issueService.createUrgentIssue(
-      "prop606",
-      "Critical Hub Failure",
-      "Hub is experiencing critical failures",
-      "monitoring-system",
-      "hub123",
-      EntityType.HUB,
-      "emergency-tech",
-      new Date("2024-01-03")
-    );
-
-    return { maintenanceIssue, urgentIssue };
-  }
-
-  /**
-   * Example 7: Using static factory methods with IssueBuilder
-   */
-  async createIssuesWithStaticMethods() {
-    // Create a device issue using static factory method
-    const deviceIssue = IssueBuilder.createDeviceIssue("device123", "prop456")
-      .setCategory(IssuesCategory.OPERATIONS)
-      .setTitle("Device Offline")
-      .setDescription("Device has been offline for more than 5 minutes")
-      .setPriority(IssuePriority.HIGH)
-      .setAssignedTo("tech-support")
-      .setCreatedBy("monitor")
-      .setDueDate(new Date("2024-01-10"));
-
-    const issue1 = await this.issueService.createIssue(deviceIssue);
-
-    // Create a hub issue using static factory method
-    const hubIssue = IssueBuilder.createHubIssue("hub789", "prop202")
-      .setCategory(IssuesCategory.SECURITY)
-      .setTitle("Hub Security Breach")
-      .setDescription("Unauthorized access attempt detected on hub")
-      .setPriority(IssuePriority.CRITICAL)
-      .setAssignedTo("security-team")
-      .setCreatedBy("security-system")
-      .setDueDate(new Date("2024-01-05"));
-
-    const issue2 = await this.issueService.createIssue(hubIssue);
-
-    return { issue1, issue2 };
-  }
-
-  /**
-   * Example 8: Creating multiple issues efficiently
-   */
-  async createMultipleIssues() {
-    const issues = [];
-
-    // Create multiple device issues efficiently
-    const deviceIds = ["device1", "device2", "device3"];
-    const propertyId = "prop123";
-
-    for (const deviceId of deviceIds) {
-      const issueBuilder = IssueBuilder.createDeviceIssue(deviceId, propertyId)
-        .setCategory(IssuesCategory.OPERATIONS)
-        .setTitle(`Device ${deviceId} Status`)
-        .setDescription(`Status check for device ${deviceId}`)
-        .setPriority(IssuePriority.MEDIUM)
-        .setAssignedTo("batch-processor")
-        .setCreatedBy("batch-processor")
-        .setDueDate(new Date("2024-01-15"));
-
-      const issue = await this.issueService.createIssue(issueBuilder);
-      issues.push(issue);
-    }
-
-    return issues;
-  }
-
-  /**
-   * Example 9: Creating issue with due date calculation
-   */
-  async createIssueWithDueDate() {
-    const dueDate = new Date();
-    dueDate.setDate(dueDate.getDate() + 7); // Due in 7 days
-
-    const issueBuilder = 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);
-
-    const issue = await this.issueService.createIssue(issueBuilder);
-    return issue;
-  }
-
-  /**
-   * Example 10: Backward compatibility - still works with CreateIssueData
-   */
-  async createIssueWithLegacyData() {
-    const issueData = {
-      category: IssuesCategory.OPERATIONS,
-      propertyId: "prop123",
-      title: "Legacy Issue",
-      description:
-        "This issue was created using the old CreateIssueData format",
-      entityId: "device456",
-      entityType: EntityType.DEVICE,
-      priority: IssuePriority.MEDIUM,
-      assignedTo: "tech-support",
-      createdBy: "legacy-system",
-      dueDate: new Date("2024-01-20"),
-      source: Source.CLOUD_EVENT,
-    };
-
-    // This still works with the updated createIssue method
-    const issue = await this.issueService.createIssue(issueData);
-    return issue;
-  }
-}

package/src/issues/index.ts

@@ -1,2 +0,0 @@
-export * from "./Issue.service";
-export * from "./issue.types";

package/src/issues/issue.types.ts

@@ -1,98 +0,0 @@
-export enum IssuesCategory {
-  READINESS = "READINESS",
-  OPERATIONS = "OPERATIONS",
-  SECURITY = "SECURITY",
-  ENERGY = "ENERGY",
-  OTHER = "OTHER",
-}
-
-export enum EntityType {
-  DEVICE = "DEVICE",
-  COLLECTION = "COLLECTION",
-  USER = "USER",
-  INTEGRATION = "INTEGRATION",
-  PROPERTY = "PROPERTY",
-  HUB = "HUB",
-  SCHEDULE = "SCHEDULE",
-  ALERT = "ALERT",
-  OTHER = "OTHER",
-}
-
-export enum IssueStatus {
-  PENDING = "PENDING",
-  IN_PROGRESS = "IN_PROGRESS",
-  RESOLVED = "RESOLVED",
-  CLOSED = "CLOSED",
-  CANCELLED = "CANCELLED",
-  ON_HOLD = "ON_HOLD",
-}
-
-export enum IssuePriority {
-  LOW = "LOW",
-  MEDIUM = "MEDIUM",
-  HIGH = "HIGH",
-  CRITICAL = "CRITICAL",
-  URGENT = "URGENT",
-}
-
-export interface IssueComment {
-  id: string;
-  userId: string;
-  content: string;
-  createdAt: Date;
-  updatedAt?: Date;
-}
-
-export interface IssueDocument {
-  _id: string;
-  category: IssuesCategory;
-  propertyId: string;
-  title: string;
-  description: string;
-  entityId?: string;
-  entityType: EntityType;
-  status: IssueStatus;
-  priority: IssuePriority;
-  assignedTo?: string;
-  createdBy: string;
-  updatedBy?: string;
-  isDeleted: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-  resolvedAt?: Date;
-  dueDate?: Date;
-  comments?: IssueComment[];
-}
-
-export interface CreateIssueData {
-  category: IssuesCategory;
-  propertyId: string;
-  title: string;
-  description: string;
-  entityId?: string;
-  entityType: EntityType;
-  priority?: IssuePriority;
-  assignedTo?: string;
-  createdBy: string;
-  dueDate?: Date;
-}
-
-export interface UpdateIssueData {
-  category?: IssuesCategory;
-  title?: string;
-  description?: string;
-  entityId?: string;
-  entityType?: EntityType;
-  status?: IssueStatus;
-  priority?: IssuePriority;
-  assignedTo?: string;
-  updatedBy: string;
-  resolvedAt?: Date;
-  dueDate?: Date;
-  isDeleted?: boolean;
-}
-
-export interface AddCommentData {
-  userId: string;
-  content: string;
-}

package/src/property/IProperty.ts

@@ -1,30 +0,0 @@
-export interface IProperty {
-  id: string;
-  name: string;
-  apartment: string;
-  city: string;
-  country: string;
-  state: string;
-  street: string;
-  zipCode: string;
-  createdBy?: string;
-  isDeleted: boolean;
-  imageURL: string;
-  timezone: string;
-  officialName?: string;
-  sameAsOfficialName?: boolean;
-  phoneNumber?: string;
-  phoneNumberCountryCode?: string;
-  propertyKey?: string;
-  hubNetworkId?: string;
-  isTimeZoneOverridden: boolean;
-  createdAt: string;
-  updatedAt: string;
-  propertyBillingId?: string;
-}
-
-export interface IPropertySettings {
-  id: string;
-  propertyId: string;
-  settings: Record<string, any>;
-}

package/src/property/Property.repository.ts

@@ -1,53 +0,0 @@
-import { getPostgresClient } from "../db";
-import { Service } from "typedi";
-import { IProperty, IPropertySettings } from "./IProperty";
-
-@Service()
-export class PropertyRepository {
-  private readonly postgres;
-  constructor() {
-    this.postgres = getPostgresClient();
-  }
-
-  async getPropertyPreferences(
-    propertyId: string
-  ): Promise<IPropertySettings | null> {
-    try {
-      const propertyPreferences = await this.postgres.query(
-        `SELECT * FROM dt_property_settings WHERE "propertyId" = $1`,
-        [propertyId]
-      );
-      if (propertyPreferences.rows.length > 0) {
-        return propertyPreferences.rows[0];
-      }
-      return null;
-    } catch (error) {
-      console.log(error);
-      throw new Error("Failed to get property preferences");
-    }
-  }
-
-  async getProperty(propertyId: string): Promise<IProperty | null> {
-    const property = await this.postgres.query(
-      "SELECT * FROM dt_properties WHERE id = $1",
-      [propertyId]
-    );
-    if (property.rows.length > 0) {
-      return property.rows[0];
-    }
-    return null;
-  }
-
-  async getAllProperties() {
-    try {
-      //Retrieve all the properties ids from the database
-      const properties = await this.postgres.query(
-        "SELECT id FROM dt_properties"
-      );
-      return properties.rows.map((property) => property.id);
-    } catch (error) {
-      console.log(error);
-      throw new Error("Failed to get all properties");
-    }
-  }
-}

package/src/property/Property.service.ts

@@ -1,38 +0,0 @@
-import { PropertyRepository } from "./Property.repository";
-
-export class LocalPropertyService {
-  private readonly propertyRepository: PropertyRepository;
-  constructor() {
-    this.propertyRepository = new PropertyRepository();
-  }
-
-  async getPropertyPreferences(propertyId: string) {
-    if (!propertyId) {
-      throw new Error("Property ID is required");
-    }
-    return await this.propertyRepository.getPropertyPreferences(propertyId);
-  }
-
-  async getProperty(propertyId: string) {
-    if (!propertyId) {
-      throw new Error("Property ID is required");
-    }
-    return await this.propertyRepository.getProperty(propertyId);
-  }
-
-  async getPropertyTimeZone(propertyId: string) {
-    if (!propertyId) {
-      throw new Error("Property ID is required");
-    }
-    const property = await this.propertyRepository.getProperty(propertyId);
-    if (!property) {
-      throw new Error("Property not found");
-    }
-    return property.timezone;
-  }
-
-  async getAllProperties() {
-    const properties = await this.propertyRepository.getAllProperties();
-    return properties;
-  }
-}

package/src/property/index.ts

@@ -1,2 +0,0 @@
-export * from "./IProperty";
-export * from "./Property.service";