dt-common-device 3.0.9 → 3.0.11

package/src/issues/Issue.service.ts

@@ -1,932 +0,0 @@
-import { Service } from "typedi";
-import { IssueRepository } from "./Issue.repository";
-import { IssueModel, IIssueDocument } from "./Issue.model";
-import {
-  CreateIssueData,
-  UpdateIssueData,
-  AddCommentData,
-  IssueStatus,
-  IssuePriority,
-  IssuesCategory,
-  EntityType,
-} from "./issue.types";
-import { IssueBuilder } from "./IssueBuilder";
-import { Source } from "../constants/Service";
-import { IDevice } from "../device/local/interfaces";
-
-@Service()
-export class IssueService {
-  constructor(private readonly issueRepository: IssueRepository) {}
-
-  /**
-   * Create a readiness issue using IssueBuilder
-   */
-  async createReadinessIssue(
-    propertyId: string,
-    title: string,
-    description: string,
-    createdBy: string,
-    entityId?: string,
-    entityType?: EntityType,
-    assignedTo?: string,
-    dueDate?: Date
-  ): Promise<IIssueDocument> {
-    const issueBuilder = IssueBuilder.createReadinessIssue()
-      .setPropertyId(propertyId)
-      .setTitle(title)
-      .setDescription(description)
-      .setCreatedBy(createdBy);
-
-    if (entityId) issueBuilder.setEntityId(entityId);
-    if (entityType) issueBuilder.setEntityType(entityType);
-    if (assignedTo) issueBuilder.setAssignedTo(assignedTo);
-    if (dueDate) issueBuilder.setDueDate(dueDate);
-
-    return await this.createIssue(issueBuilder);
-  }
-
-  /**
-   * Create an operations issue using IssueBuilder
-   */
-  async createOperationsIssue(
-    propertyId: string,
-    title: string,
-    description: string,
-    createdBy: string,
-    entityId?: string,
-    entityType?: EntityType,
-    assignedTo?: string,
-    dueDate?: Date
-  ): Promise<IIssueDocument> {
-    const issueBuilder = IssueBuilder.createOperationsIssue()
-      .setPropertyId(propertyId)
-      .setTitle(title)
-      .setDescription(description)
-      .setCreatedBy(createdBy);
-
-    if (entityId) issueBuilder.setEntityId(entityId);
-    if (entityType) issueBuilder.setEntityType(entityType);
-    if (assignedTo) issueBuilder.setAssignedTo(assignedTo);
-    if (dueDate) issueBuilder.setDueDate(dueDate);
-
-    return await this.createIssue(issueBuilder);
-  }
-
-  /**
-   * Create a security issue using IssueBuilder
-   */
-  async createSecurityIssue(
-    propertyId: string,
-    title: string,
-    description: string,
-    createdBy: string,
-    entityId?: string,
-    entityType?: EntityType,
-    assignedTo?: string,
-    dueDate?: Date
-  ): Promise<IIssueDocument> {
-    const issueBuilder = IssueBuilder.createSecurityIssue()
-      .setPropertyId(propertyId)
-      .setTitle(title)
-      .setDescription(description)
-      .setCreatedBy(createdBy);
-
-    if (entityId) issueBuilder.setEntityId(entityId);
-    if (entityType) issueBuilder.setEntityType(entityType);
-    if (assignedTo) issueBuilder.setAssignedTo(assignedTo);
-    if (dueDate) issueBuilder.setDueDate(dueDate);
-
-    return await this.createIssue(issueBuilder);
-  }
-
-  /**
-   * Create an energy issue using IssueBuilder
-   */
-  async createEnergyIssue(
-    propertyId: string,
-    title: string,
-    description: string,
-    createdBy: string,
-    entityId?: string,
-    entityType?: EntityType,
-    assignedTo?: string,
-    dueDate?: Date
-  ): Promise<IIssueDocument> {
-    const issueBuilder = IssueBuilder.createEnergyIssue()
-      .setPropertyId(propertyId)
-      .setTitle(title)
-      .setDescription(description)
-      .setCreatedBy(createdBy);
-
-    if (entityId) issueBuilder.setEntityId(entityId);
-    if (entityType) issueBuilder.setEntityType(entityType);
-    if (assignedTo) issueBuilder.setAssignedTo(assignedTo);
-    if (dueDate) issueBuilder.setDueDate(dueDate);
-
-    return await this.createIssue(issueBuilder);
-  }
-
-  /**
-   * Create a device-specific issue using IssueBuilder
-   */
-  async createDeviceIssue(
-    deviceId: string,
-    propertyId: string,
-    title: string,
-    description: string,
-    source: Source,
-    category?: IssuesCategory,
-    priority?: IssuePriority,
-    assignedTo?: string,
-    dueDate?: Date
-  ): Promise<IIssueDocument> {
-    const issueBuilder = IssueBuilder.createDeviceIssue(deviceId, propertyId)
-      .setTitle(title)
-      .setDescription(description)
-      .setCreatedBy(source);
-
-    if (category) issueBuilder.setCategory(category);
-    if (priority) issueBuilder.setPriority(priority);
-    if (assignedTo) issueBuilder.setAssignedTo(assignedTo);
-    if (dueDate) issueBuilder.setDueDate(dueDate);
-
-    return await this.createIssue(issueBuilder);
-  }
-
-  /**
-   * Create a hub-specific issue using IssueBuilder
-   */
-  async createHubIssue(
-    hubId: string,
-    propertyId: string,
-    title: string,
-    description: string,
-    createdBy: string,
-    category?: IssuesCategory,
-    priority?: IssuePriority,
-    assignedTo?: string,
-    dueDate?: Date
-  ): Promise<IIssueDocument> {
-    const issueBuilder = IssueBuilder.createHubIssue(hubId, propertyId)
-      .setTitle(title)
-      .setDescription(description)
-      .setCreatedBy(createdBy);
-
-    if (category) issueBuilder.setCategory(category);
-    if (priority) issueBuilder.setPriority(priority);
-    if (assignedTo) issueBuilder.setAssignedTo(assignedTo);
-    if (dueDate) issueBuilder.setDueDate(dueDate);
-
-    return await this.createIssue(issueBuilder);
-  }
-
-  /**
-   * Create a user-specific issue using IssueBuilder
-   */
-  async createUserIssue(
-    userId: string,
-    propertyId: string,
-    title: string,
-    description: string,
-    createdBy: string,
-    category?: IssuesCategory,
-    priority?: IssuePriority,
-    assignedTo?: string,
-    dueDate?: Date
-  ): Promise<IIssueDocument> {
-    const issueBuilder = IssueBuilder.createUserIssue(userId, propertyId)
-      .setTitle(title)
-      .setDescription(description)
-      .setCreatedBy(createdBy);
-
-    if (category) issueBuilder.setCategory(category);
-    if (priority) issueBuilder.setPriority(priority);
-    if (assignedTo) issueBuilder.setAssignedTo(assignedTo);
-    if (dueDate) issueBuilder.setDueDate(dueDate);
-
-    return await this.createIssue(issueBuilder);
-  }
-
-  /**
-   * Create issue for device going offline longer than baseline
-   */
-  async createDeviceOfflineIssue(
-    device: IDevice,
-    source: Source,
-    reason?: string
-  ): Promise<IIssueDocument> {
-    return await this.createDeviceIssue(
-      device.deviceId,
-      device.propertyId,
-      "Device Offline - Requires Attention",
-      `Device ${device.name} (${
-        device.deviceId
-      }) has been offline for longer than the baseline time. ${
-        reason ? `Reason: ${reason}` : ""
-      } This requires immediate attention to restore device functionality.`,
-      source,
-      IssuesCategory.OPERATIONS,
-      IssuePriority.HIGH
-    );
-  }
-
-  /**
-   * Create issue for device battery level below threshold
-   */
-  async createDeviceBatteryIssue(
-    device: IDevice,
-    batteryLevel: number,
-    threshold: number,
-    source: Source
-  ): Promise<IIssueDocument> {
-    return await this.createDeviceIssue(
-      device.deviceId,
-      device.propertyId,
-      "Device Battery Low - Requires Attention",
-      `Device ${device.name} (${device.deviceId}) battery level is ${batteryLevel}%, which is below the property threshold of ${threshold}%. This requires immediate attention to replace or charge the device battery.`,
-      source,
-      IssuesCategory.ENERGY,
-      IssuePriority.MEDIUM
-    );
-  }
-
-  /**
-   * Create a maintenance issue using IssueBuilder
-   */
-  async createMaintenanceIssue(
-    propertyId: string,
-    title: string,
-    description: string,
-    createdBy: string,
-    entityId?: string,
-    entityType?: EntityType,
-    assignedTo?: string,
-    dueDate?: Date
-  ): Promise<IIssueDocument> {
-    const issueBuilder = IssueBuilder.createMaintenanceIssue(
-      propertyId,
-      entityId,
-      entityType
-    )
-      .setTitle(title)
-      .setDescription(description)
-      .setCreatedBy(createdBy);
-
-    if (assignedTo) issueBuilder.setAssignedTo(assignedTo);
-    if (dueDate) issueBuilder.setDueDate(dueDate);
-
-    return await this.createIssue(issueBuilder);
-  }
-
-  /**
-   * Create an urgent issue using IssueBuilder
-   */
-  async createUrgentIssue(
-    propertyId: string,
-    title: string,
-    description: string,
-    createdBy: string,
-    entityId?: string,
-    entityType?: EntityType,
-    assignedTo?: string,
-    dueDate?: Date
-  ): Promise<IIssueDocument> {
-    const issueBuilder = IssueBuilder.createUrgentIssue(
-      propertyId,
-      entityId,
-      entityType
-    )
-      .setTitle(title)
-      .setDescription(description)
-      .setCreatedBy(createdBy);
-
-    if (assignedTo) issueBuilder.setAssignedTo(assignedTo);
-    if (dueDate) issueBuilder.setDueDate(dueDate);
-
-    return await this.createIssue(issueBuilder);
-  }
-
-  /**
-   * Create a new issue with business logic validation
-   * Accepts either a CreateIssueData object or an IssueBuilder instance
-   */
-  async createIssue(
-    issueData: CreateIssueData | IssueBuilder
-  ): Promise<IIssueDocument> {
-    let processedIssueData: CreateIssueData;
-
-    // Handle IssueBuilder instance
-    if (issueData instanceof IssueBuilder) {
-      processedIssueData = issueData.build();
-    } else {
-      processedIssueData = issueData;
-    }
-
-    // Business logic: Validate issue data
-    this.validateIssueData(processedIssueData);
-
-    // Business logic: Set default priority if not provided
-    if (!processedIssueData.priority) {
-      processedIssueData.priority = this.determineDefaultPriority(
-        processedIssueData.category
-      );
-    }
-
-    // Business logic: Validate due date is in the future
-    if (
-      processedIssueData.dueDate &&
-      processedIssueData.dueDate <= new Date()
-    ) {
-      throw new Error("Due date must be in the future");
-    }
-
-    return await this.issueRepository.create(processedIssueData);
-  }
-
-  /**
-   * Get issue by ID with business logic
-   */
-  async getIssueById(
-    id: string,
-    includeDeleted = false
-  ): Promise<IIssueDocument | null> {
-    if (!id) {
-      throw new Error("Issue ID is required");
-    }
-
-    const issue = await this.issueRepository.findById(id, includeDeleted);
-
-    // Business logic: Check if issue is overdue
-    if (
-      issue?.dueDate &&
-      issue.dueDate < new Date() &&
-      issue.status !== IssueStatus.RESOLVED
-    ) {
-      // You could add a flag or handle overdue logic here
-      console.warn(`Issue ${id} is overdue`);
-    }
-
-    return issue;
-  }
-
-  /**
-   * Get all issues with business logic filtering
-   */
-  async getIssues(
-    filters: {
-      propertyId?: string;
-      assignedTo?: string;
-      status?: IssueStatus;
-      priority?: IssuePriority;
-      category?: IssuesCategory;
-      entityType?: EntityType;
-      entityId?: string;
-      includeDeleted?: boolean;
-      limit?: number;
-      skip?: number;
-    } = {}
-  ): Promise<IIssueDocument[]> {
-    // Business logic: Validate filters
-    this.validateFilters(filters);
-
-    // Business logic: Apply business rules to filters
-    const enhancedFilters = this.applyBusinessRules(filters);
-
-    return await this.issueRepository.findAll(enhancedFilters);
-  }
-
-  /**
-   * Update an issue with business logic validation
-   */
-  async updateIssue(
-    id: string,
-    updateData: UpdateIssueData
-  ): Promise<IIssueDocument | null> {
-    if (!id) {
-      throw new Error("Issue ID is required");
-    }
-
-    // Business logic: Validate update data
-    this.validateUpdateData(updateData);
-
-    // Business logic: Check if issue exists and is not deleted
-    const existingIssue = await this.issueRepository.findById(id);
-    if (!existingIssue) {
-      throw new Error("Issue not found");
-    }
-
-    // Business logic: Handle status transitions
-    if (updateData.status) {
-      this.validateStatusTransition(existingIssue.status, updateData.status);
-    }
-
-    // Business logic: Handle priority changes
-    if (updateData.priority) {
-      this.validatePriorityChange(existingIssue.priority, updateData.priority);
-    }
-
-    return await this.issueRepository.update(id, updateData);
-  }
-
-  /**
-   * Soft delete an issue with business logic
-   */
-  async deleteIssue(id: string, deletedBy: string): Promise<boolean> {
-    if (!id || !deletedBy) {
-      throw new Error("Issue ID and deleted by user are required");
-    }
-
-    // Business logic: Check if issue can be deleted
-    const issue = await this.issueRepository.findById(id);
-    if (!issue) {
-      throw new Error("Issue not found");
-    }
-
-    // Business logic: Prevent deletion of resolved issues (optional rule)
-    if (issue.status === IssueStatus.RESOLVED) {
-      throw new Error("Cannot delete resolved issues");
-    }
-
-    return await this.issueRepository.softDelete(id, deletedBy);
-  }
-
-  /**
-   * Permanently delete an issue
-   */
-  async permanentlyDeleteIssue(id: string): Promise<boolean> {
-    return await this.issueRepository.hardDelete(id);
-  }
-
-  /**
-   * Add a comment with business logic
-   */
-  async addComment(
-    issueId: string,
-    commentData: AddCommentData
-  ): Promise<IIssueDocument | null> {
-    if (!issueId || !commentData.userId || !commentData.content) {
-      throw new Error("Issue ID, user ID, and comment content are required");
-    }
-
-    // Business logic: Check if issue exists and is active
-    const issue = await this.issueRepository.findById(issueId);
-    if (!issue) {
-      throw new Error("Issue not found");
-    }
-
-    if (issue.isDeleted) {
-      throw new Error("Cannot add comment to deleted issue");
-    }
-
-    // Business logic: Update issue status based on comment (optional)
-    const shouldUpdateStatus = this.shouldUpdateStatusOnComment(
-      commentData.content
-    );
-
-    if (shouldUpdateStatus && issue.status === IssueStatus.PENDING) {
-      await this.issueRepository.update(issueId, {
-        status: IssueStatus.IN_PROGRESS,
-        updatedBy: commentData.userId,
-      });
-    }
-
-    // Add comment using the model instance methods
-    const issueModel = await IssueModel.findById(issueId);
-    if (issueModel) {
-      issueModel.addComment(commentData);
-      return await issueModel.save();
-    }
-
-    return null;
-  }
-
-  /**
-   * Update a comment on an issue
-   */
-  async updateComment(
-    issueId: string,
-    commentId: string,
-    content: string,
-    userId: string
-  ): Promise<boolean> {
-    const issueModel = await IssueModel.findById(issueId);
-    if (!issueModel) return false;
-
-    const success = issueModel.updateComment(commentId, content, userId);
-    if (success) {
-      await issueModel.save();
-    }
-    return success;
-  }
-
-  /**
-   * Remove a comment from an issue
-   */
-  async removeComment(issueId: string, commentId: string): Promise<boolean> {
-    const issueModel = await IssueModel.findById(issueId);
-    if (!issueModel) return false;
-
-    const success = issueModel.removeComment(commentId);
-    if (success) {
-      await issueModel.save();
-    }
-    return success;
-  }
-
-  /**
-   * Resolve an issue with business logic
-   */
-  async resolveIssue(
-    id: string,
-    resolvedBy: string
-  ): Promise<IIssueDocument | null> {
-    if (!id || !resolvedBy) {
-      throw new Error("Issue ID and resolved by user are required");
-    }
-
-    // Business logic: Check if issue can be resolved
-    const issue = await this.issueRepository.findById(id);
-    if (!issue) {
-      throw new Error("Issue not found");
-    }
-
-    if (issue.status === IssueStatus.RESOLVED) {
-      throw new Error("Issue is already resolved");
-    }
-
-    if (issue.status === IssueStatus.CANCELLED) {
-      throw new Error("Cannot resolve cancelled issue");
-    }
-
-    // Business logic: Auto-assign if not assigned
-    if (!issue.assignedTo) {
-      await this.issueRepository.update(id, {
-        assignedTo: resolvedBy,
-        updatedBy: resolvedBy,
-      });
-    }
-
-    // Resolve the issue using model instance methods
-    const issueModel = await IssueModel.findById(id);
-    if (issueModel) {
-      issueModel.resolve(resolvedBy);
-      return await issueModel.save();
-    }
-
-    return null;
-  }
-
-  /**
-   * Reopen a resolved issue
-   */
-  async reopenIssue(
-    id: string,
-    reopenedBy: string
-  ): Promise<IIssueDocument | null> {
-    const issueModel = await IssueModel.findById(id);
-    if (!issueModel) return null;
-
-    issueModel.reopen(reopenedBy);
-    return await issueModel.save();
-  }
-
-  /**
-   * Assign an issue with business logic
-   */
-  async assignIssue(
-    id: string,
-    userId: string,
-    assignedBy: string
-  ): Promise<IIssueDocument | null> {
-    if (!id || !userId || !assignedBy) {
-      throw new Error(
-        "Issue ID, assignee user ID, and assigned by user are required"
-      );
-    }
-
-    // Business logic: Check if issue can be assigned
-    const issue = await this.issueRepository.findById(id);
-    if (!issue) {
-      throw new Error("Issue not found");
-    }
-
-    if (
-      issue.status === IssueStatus.RESOLVED ||
-      issue.status === IssueStatus.CLOSED
-    ) {
-      throw new Error("Cannot assign resolved or closed issue");
-    }
-
-    // Business logic: Update status to IN_PROGRESS when assigned
-    const updateData: UpdateIssueData = {
-      assignedTo: userId,
-      updatedBy: assignedBy,
-    };
-
-    if (issue.status === IssueStatus.PENDING) {
-      updateData.status = IssueStatus.IN_PROGRESS;
-    }
-
-    return await this.issueRepository.update(id, updateData);
-  }
-
-  /**
-   * Unassign an issue
-   */
-  async unassignIssue(
-    id: string,
-    unassignedBy: string
-  ): Promise<IIssueDocument | null> {
-    const issueModel = await IssueModel.findById(id);
-    if (!issueModel) return null;
-
-    issueModel.unassign(unassignedBy);
-    return await issueModel.save();
-  }
-
-  /**
-   * Get issues by property with business logic
-   */
-  async getIssuesByProperty(
-    propertyId: string,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    if (!propertyId) {
-      throw new Error("Property ID is required");
-    }
-
-    return await this.issueRepository.findByProperty(
-      propertyId,
-      includeDeleted
-    );
-  }
-
-  /**
-   * Get issues assigned to a user with business logic
-   */
-  async getIssuesByAssignee(
-    assignedTo: string,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    if (!assignedTo) {
-      throw new Error("Assignee user ID is required");
-    }
-
-    return await this.issueRepository.findByAssignee(
-      assignedTo,
-      includeDeleted
-    );
-  }
-
-  /**
-   * Get issues by entity
-   */
-  async getIssuesByEntity(
-    entityId: string,
-    entityType: EntityType,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    return await this.issueRepository.findByEntity(
-      entityId,
-      entityType,
-      includeDeleted
-    );
-  }
-
-  /**
-   * Get issues by status
-   */
-  async getIssuesByStatus(
-    status: IssueStatus,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    return await this.issueRepository.findByStatus(status, includeDeleted);
-  }
-
-  /**
-   * Get issues by priority
-   */
-  async getIssuesByPriority(
-    priority: IssuePriority,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    return await this.issueRepository.findByPriority(priority, includeDeleted);
-  }
-
-  /**
-   * Get overdue issues with business logic
-   */
-  async getOverdueIssues(includeDeleted = false): Promise<IIssueDocument[]> {
-    const overdueIssues = await this.issueRepository.findOverdue(
-      includeDeleted
-    );
-
-    // Business logic: Log overdue issues for monitoring
-    if (overdueIssues.length > 0) {
-      console.warn(`Found ${overdueIssues.length} overdue issues`);
-    }
-
-    return overdueIssues;
-  }
-
-  /**
-   * Get upcoming issues (due within specified days)
-   */
-  async getUpcomingIssues(
-    days: number = 7,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    return await this.issueRepository.findUpcoming(days, includeDeleted);
-  }
-
-  /**
-   * Get issue statistics with business logic
-   */
-  async getIssueStatistics(propertyId?: string): Promise<{
-    total: number;
-    pending: number;
-    inProgress: number;
-    resolved: number;
-    closed: number;
-    overdue: number;
-    byPriority: Record<IssuePriority, number>;
-    byCategory: Record<IssuesCategory, number>;
-  }> {
-    const stats = await this.issueRepository.getStatistics(propertyId);
-
-    // Business logic: Calculate additional metrics
-    const responseTime = this.calculateAverageResponseTime(stats);
-    const resolutionRate = this.calculateResolutionRate(stats);
-
-    // Log resolution rate for monitoring
-    console.log(`Resolution rate: ${resolutionRate.toFixed(2)}%`);
-    console.log(`Response time: ${responseTime.toFixed(2)} days`);
-
-    // Business logic: Add alerts for critical metrics
-    if (stats.overdue > 0) {
-      console.warn(`Alert: ${stats.overdue} overdue issues detected`);
-    }
-
-    if (stats.byPriority[IssuePriority.CRITICAL] > 0) {
-      console.error(
-        `Alert: ${
-          stats.byPriority[IssuePriority.CRITICAL]
-        } critical issues require immediate attention`
-      );
-    }
-
-    return stats;
-  }
-
-  /**
-   * Search issues with business logic
-   */
-  async searchIssues(
-    searchTerm: string,
-    filters: {
-      propertyId?: string;
-      includeDeleted?: boolean;
-      limit?: number;
-      skip?: number;
-    } = {}
-  ): Promise<IIssueDocument[]> {
-    if (!searchTerm || searchTerm.trim().length < 2) {
-      throw new Error("Search term must be at least 2 characters long");
-    }
-
-    return await this.issueRepository.search(searchTerm, filters);
-  }
-
-  // Private business logic methods
-
-  private validateIssueData(data: CreateIssueData): void {
-    if (!data.title || data.title.trim().length < 5) {
-      throw new Error("Issue title must be at least 5 characters long");
-    }
-
-    if (!data.description || data.description.trim().length < 10) {
-      throw new Error("Issue description must be at least 10 characters long");
-    }
-
-    if (!data.propertyId) {
-      throw new Error("Property ID is required");
-    }
-
-    if (!data.createdBy) {
-      throw new Error("Created by user ID is required");
-    }
-  }
-
-  private validateFilters(filters: any): void {
-    if (filters.limit && (filters.limit < 1 || filters.limit > 100)) {
-      throw new Error("Limit must be between 1 and 100");
-    }
-
-    if (filters.skip && filters.skip < 0) {
-      throw new Error("Skip must be non-negative");
-    }
-  }
-
-  private validateUpdateData(data: UpdateIssueData): void {
-    if (data.title && data.title.trim().length < 5) {
-      throw new Error("Issue title must be at least 5 characters long");
-    }
-
-    if (data.description && data.description.trim().length < 10) {
-      throw new Error("Issue description must be at least 10 characters long");
-    }
-  }
-
-  private validateStatusTransition(
-    currentStatus: IssueStatus,
-    newStatus: IssueStatus
-  ): void {
-    const validTransitions: Record<IssueStatus, IssueStatus[]> = {
-      [IssueStatus.PENDING]: [
-        IssueStatus.IN_PROGRESS,
-        IssueStatus.CANCELLED,
-        IssueStatus.ON_HOLD,
-      ],
-      [IssueStatus.IN_PROGRESS]: [
-        IssueStatus.RESOLVED,
-        IssueStatus.CANCELLED,
-        IssueStatus.ON_HOLD,
-      ],
-      [IssueStatus.RESOLVED]: [IssueStatus.CLOSED, IssueStatus.PENDING], // Reopen
-      [IssueStatus.CLOSED]: [IssueStatus.PENDING], // Reopen
-      [IssueStatus.CANCELLED]: [IssueStatus.PENDING], // Reopen
-      [IssueStatus.ON_HOLD]: [IssueStatus.PENDING, IssueStatus.IN_PROGRESS],
-    };
-
-    if (!validTransitions[currentStatus]?.includes(newStatus)) {
-      throw new Error(
-        `Invalid status transition from ${currentStatus} to ${newStatus}`
-      );
-    }
-  }
-
-  private validatePriorityChange(
-    currentPriority: IssuePriority,
-    newPriority: IssuePriority
-  ): void {
-    // Business rule: Only allow priority escalation, not de-escalation for critical issues
-    if (
-      currentPriority === IssuePriority.CRITICAL &&
-      newPriority !== IssuePriority.CRITICAL
-    ) {
-      throw new Error("Cannot de-escalate priority of critical issues");
-    }
-  }
-
-  private determineDefaultPriority(category: IssuesCategory): IssuePriority {
-    // Business logic: Determine default priority based on category
-    const categoryPriorities: Record<IssuesCategory, IssuePriority> = {
-      [IssuesCategory.READINESS]: IssuePriority.MEDIUM,
-      [IssuesCategory.OPERATIONS]: IssuePriority.HIGH,
-      [IssuesCategory.SECURITY]: IssuePriority.CRITICAL,
-      [IssuesCategory.ENERGY]: IssuePriority.LOW,
-      [IssuesCategory.OTHER]: IssuePriority.MEDIUM,
-    };
-
-    return categoryPriorities[category] || IssuePriority.MEDIUM;
-  }
-
-  private applyBusinessRules(filters: any): any {
-    // Business logic: Apply additional filters based on business rules
-    const enhancedFilters = { ...filters };
-
-    // Example: Always exclude cancelled issues unless explicitly requested
-    if (
-      !enhancedFilters.status ||
-      enhancedFilters.status !== IssueStatus.CANCELLED
-    ) {
-      enhancedFilters.status = { $ne: IssueStatus.CANCELLED };
-    }
-
-    return enhancedFilters;
-  }
-
-  private shouldUpdateStatusOnComment(content: string): boolean {
-    // Business logic: Determine if comment should trigger status change
-    const statusKeywords = [
-      "working on",
-      "investigating",
-      "fixing",
-      "resolving",
-    ];
-    return statusKeywords.some((keyword) =>
-      content.toLowerCase().includes(keyword)
-    );
-  }
-
-  private calculateAverageResponseTime(stats: any): number {
-    // Business logic: Calculate average response time (placeholder)
-    return 0;
-  }
-
-  private calculateResolutionRate(stats: any): number {
-    // Business logic: Calculate resolution rate
-    if (stats.total === 0) return 0;
-    return ((stats.resolved + stats.closed) / stats.total) * 100;
-  }
-}