dt-common-device 1.3.0 → 2.0.0

package/src/device/local/services/Issue.service.ts

@@ -0,0 +1,872 @@
+import { Service } from "typedi";
+import { IssueRepository } from "../repository/Issue.repository";
+import { IssueModel, IIssueDocument } from "../models/Issue.model";
+import {
+  CreateIssueData,
+  UpdateIssueData,
+  AddCommentData,
+  IssueStatus,
+  IssuePriority,
+  IssuesCategory,
+  EntityType,
+} from "../../../types/issue.types";
+import { IssueBuilder } from "../entities/IssueBuilder";
+
+@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,
+    createdBy: string,
+    category?: IssuesCategory,
+    priority?: IssuePriority,
+    assignedTo?: string,
+    dueDate?: Date
+  ): Promise<IIssueDocument> {
+    const issueBuilder = IssueBuilder.createDeviceIssue(deviceId, 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 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 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;
+  }
+}