dt-common-device 3.0.10 → 3.0.12

package/src/issues/Issue.repository.ts

@@ -1,517 +0,0 @@
-import { Service } from "typedi";
-import { IssueModel, IIssueDocument } from "./Issue.model";
-import {
-  CreateIssueData,
-  UpdateIssueData,
-  IssueStatus,
-  IssuePriority,
-  IssuesCategory,
-  EntityType,
-} from "./issue.types";
-
-@Service()
-export class IssueRepository {
-  /**
-   * Create a new issue
-   */
-  async create(issueData: CreateIssueData): Promise<IIssueDocument> {
-    try {
-      const issue = new IssueModel({
-        ...issueData,
-        status: IssueStatus.PENDING,
-        priority: issueData.priority || IssuePriority.MEDIUM,
-        isDeleted: false,
-      });
-
-      return await issue.save();
-    } catch (error) {
-      throw new Error(
-        `Failed to create issue: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Find issue by ID
-   */
-  async findById(
-    id: string,
-    includeDeleted = false
-  ): Promise<IIssueDocument | null> {
-    try {
-      const query: any = { _id: id };
-      if (!includeDeleted) {
-        query.isDeleted = false;
-      }
-      return await IssueModel.findOne(query);
-    } catch (error) {
-      throw new Error(
-        `Failed to find issue by ID: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Find all issues with filters
-   */
-  async findAll(
-    filters: {
-      propertyId?: string;
-      assignedTo?: string;
-      status?: IssueStatus;
-      priority?: IssuePriority;
-      category?: IssuesCategory;
-      entityType?: EntityType;
-      entityId?: string;
-      includeDeleted?: boolean;
-      limit?: number;
-      skip?: number;
-      sort?: { [key: string]: 1 | -1 };
-    } = {}
-  ): Promise<IIssueDocument[]> {
-    try {
-      const query: any = {};
-
-      if (filters.propertyId) query.propertyId = filters.propertyId;
-      if (filters.assignedTo) query.assignedTo = filters.assignedTo;
-      if (filters.status) query.status = filters.status;
-      if (filters.priority) query.priority = filters.priority;
-      if (filters.category) query.category = filters.category;
-      if (filters.entityType) query.entityType = filters.entityType;
-      if (filters.entityId) query.entityId = filters.entityId;
-      if (!filters.includeDeleted) query.isDeleted = false;
-
-      const queryBuilder = IssueModel.find(query);
-
-      if (filters.sort) {
-        queryBuilder.sort(filters.sort);
-      } else {
-        queryBuilder.sort({ createdAt: -1 });
-      }
-
-      if (filters.skip) queryBuilder.skip(filters.skip);
-      if (filters.limit) queryBuilder.limit(filters.limit);
-
-      return await queryBuilder.exec();
-    } catch (error) {
-      throw new Error(
-        `Failed to find issues: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Update an issue
-   */
-  async update(
-    id: string,
-    updateData: UpdateIssueData
-  ): Promise<IIssueDocument | null> {
-    try {
-      return await IssueModel.findByIdAndUpdate(
-        id,
-        { ...updateData, updatedAt: new Date() },
-        { new: true, runValidators: true }
-      );
-    } catch (error) {
-      throw new Error(
-        `Failed to update issue: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Soft delete an issue
-   */
-  async softDelete(id: string, deletedBy: string): Promise<boolean> {
-    try {
-      const result = await IssueModel.findByIdAndUpdate(id, {
-        isDeleted: true,
-        updatedBy: deletedBy,
-        updatedAt: new Date(),
-      });
-      return !!result;
-    } catch (error) {
-      throw new Error(
-        `Failed to soft delete issue: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Permanently delete an issue
-   */
-  async hardDelete(id: string): Promise<boolean> {
-    try {
-      const result = await IssueModel.findByIdAndDelete(id);
-      return !!result;
-    } catch (error) {
-      throw new Error(
-        `Failed to permanently delete issue: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Count issues with filters
-   */
-  async count(
-    filters: {
-      propertyId?: string;
-      assignedTo?: string;
-      status?: IssueStatus;
-      priority?: IssuePriority;
-      category?: IssuesCategory;
-      entityType?: EntityType;
-      entityId?: string;
-      includeDeleted?: boolean;
-    } = {}
-  ): Promise<number> {
-    try {
-      const query: any = {};
-
-      if (filters.propertyId) query.propertyId = filters.propertyId;
-      if (filters.assignedTo) query.assignedTo = filters.assignedTo;
-      if (filters.status) query.status = filters.status;
-      if (filters.priority) query.priority = filters.priority;
-      if (filters.category) query.category = filters.category;
-      if (filters.entityType) query.entityType = filters.entityType;
-      if (filters.entityId) query.entityId = filters.entityId;
-      if (!filters.includeDeleted) query.isDeleted = false;
-
-      return await IssueModel.countDocuments(query);
-    } catch (error) {
-      throw new Error(
-        `Failed to count issues: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Find issues by property
-   */
-  async findByProperty(
-    propertyId: string,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    try {
-      return await IssueModel.findByProperty(propertyId, includeDeleted);
-    } catch (error) {
-      throw new Error(
-        `Failed to find issues by property: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Find issues by assignee
-   */
-  async findByAssignee(
-    assignedTo: string,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    try {
-      return await IssueModel.findByAssignee(assignedTo, includeDeleted);
-    } catch (error) {
-      throw new Error(
-        `Failed to find issues by assignee: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Find issues by entity
-   */
-  async findByEntity(
-    entityId: string,
-    entityType: EntityType,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    try {
-      return await IssueModel.findByEntity(
-        entityId,
-        entityType,
-        includeDeleted
-      );
-    } catch (error) {
-      throw new Error(
-        `Failed to find issues by entity: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Find issues by status
-   */
-  async findByStatus(
-    status: IssueStatus,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    try {
-      return await IssueModel.findByStatus(status, includeDeleted);
-    } catch (error) {
-      throw new Error(
-        `Failed to find issues by status: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Find issues by priority
-   */
-  async findByPriority(
-    priority: IssuePriority,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    try {
-      return await IssueModel.findByPriority(priority, includeDeleted);
-    } catch (error) {
-      throw new Error(
-        `Failed to find issues by priority: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Find overdue issues
-   */
-  async findOverdue(includeDeleted = false): Promise<IIssueDocument[]> {
-    try {
-      return await IssueModel.findOverdue(includeDeleted);
-    } catch (error) {
-      throw new Error(
-        `Failed to find overdue issues: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Find upcoming issues
-   */
-  async findUpcoming(
-    days: number = 7,
-    includeDeleted = false
-  ): Promise<IIssueDocument[]> {
-    try {
-      return await IssueModel.findUpcoming(days, includeDeleted);
-    } catch (error) {
-      throw new Error(
-        `Failed to find upcoming issues: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Search issues by text
-   */
-  async search(
-    searchTerm: string,
-    filters: {
-      propertyId?: string;
-      includeDeleted?: boolean;
-      limit?: number;
-      skip?: number;
-    } = {}
-  ): Promise<IIssueDocument[]> {
-    try {
-      const query: any = {
-        $or: [
-          { title: { $regex: searchTerm, $options: "i" } },
-          { description: { $regex: searchTerm, $options: "i" } },
-        ],
-      };
-
-      if (filters.propertyId) query.propertyId = filters.propertyId;
-      if (!filters.includeDeleted) query.isDeleted = false;
-
-      const queryBuilder = IssueModel.find(query).sort({ createdAt: -1 });
-
-      if (filters.skip) queryBuilder.skip(filters.skip);
-      if (filters.limit) queryBuilder.limit(filters.limit);
-
-      return await queryBuilder.exec();
-    } catch (error) {
-      throw new Error(
-        `Failed to search issues: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Get issue statistics
-   */
-  async getStatistics(propertyId?: string): Promise<{
-    total: number;
-    pending: number;
-    inProgress: number;
-    resolved: number;
-    closed: number;
-    overdue: number;
-    byPriority: Record<IssuePriority, number>;
-    byCategory: Record<IssuesCategory, number>;
-  }> {
-    try {
-      const query: any = { isDeleted: false };
-      if (propertyId) query.propertyId = propertyId;
-
-      const [
-        total,
-        pending,
-        inProgress,
-        resolved,
-        closed,
-        overdue,
-        priorityStats,
-        categoryStats,
-      ] = await Promise.all([
-        IssueModel.countDocuments(query),
-        IssueModel.countDocuments({ ...query, status: IssueStatus.PENDING }),
-        IssueModel.countDocuments({
-          ...query,
-          status: IssueStatus.IN_PROGRESS,
-        }),
-        IssueModel.countDocuments({ ...query, status: IssueStatus.RESOLVED }),
-        IssueModel.countDocuments({ ...query, status: IssueStatus.CLOSED }),
-        IssueModel.countDocuments({
-          ...query,
-          dueDate: { $lt: new Date() },
-          status: {
-            $nin: [
-              IssueStatus.RESOLVED,
-              IssueStatus.CLOSED,
-              IssueStatus.CANCELLED,
-            ],
-          },
-        }),
-        IssueModel.aggregate([
-          { $match: query },
-          { $group: { _id: "$priority", count: { $sum: 1 } } },
-        ]),
-        IssueModel.aggregate([
-          { $match: query },
-          { $group: { _id: "$category", count: { $sum: 1 } } },
-        ]),
-      ]);
-
-      const byPriority = Object.values(IssuePriority).reduce(
-        (acc, priority) => {
-          acc[priority] = 0;
-          return acc;
-        },
-        {} as Record<IssuePriority, number>
-      );
-
-      const byCategory = Object.values(IssuesCategory).reduce(
-        (acc, category) => {
-          acc[category] = 0;
-          return acc;
-        },
-        {} as Record<IssuesCategory, number>
-      );
-
-      priorityStats.forEach((stat: { _id: string; count: number }) => {
-        if (stat._id in byPriority) {
-          byPriority[stat._id as IssuePriority] = stat.count;
-        }
-      });
-
-      categoryStats.forEach((stat: { _id: string; count: number }) => {
-        if (stat._id in byCategory) {
-          byCategory[stat._id as IssuesCategory] = stat.count;
-        }
-      });
-
-      return {
-        total,
-        pending,
-        inProgress,
-        resolved,
-        closed,
-        overdue,
-        byPriority,
-        byCategory,
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get issue statistics: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Bulk update issues
-   */
-  async bulkUpdate(
-    ids: string[],
-    updateData: Partial<UpdateIssueData>
-  ): Promise<number> {
-    try {
-      const result = await IssueModel.updateMany(
-        { _id: { $in: ids } },
-        { ...updateData, updatedAt: new Date() }
-      );
-      return result.modifiedCount;
-    } catch (error) {
-      throw new Error(
-        `Failed to bulk update issues: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-
-  /**
-   * Bulk soft delete issues
-   */
-  async bulkSoftDelete(ids: string[], deletedBy: string): Promise<number> {
-    try {
-      const result = await IssueModel.updateMany(
-        { _id: { $in: ids } },
-        {
-          isDeleted: true,
-          updatedBy: deletedBy,
-          updatedAt: new Date(),
-        }
-      );
-      return result.modifiedCount;
-    } catch (error) {
-      throw new Error(
-        `Failed to bulk soft delete issues: ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
-  }
-}