dt-common-device 1.3.0 → 2.0.0

package/src/device/local/repository/Issue.repository.ts

@@ -0,0 +1,517 @@
+import { Service } from "typedi";
+import { IssueModel, IIssueDocument } from "../models/Issue.model";
+import {
+  CreateIssueData,
+  UpdateIssueData,
+  IssueStatus,
+  IssuePriority,
+  IssuesCategory,
+  EntityType,
+} from "../../../types/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"
+        }`
+      );
+    }
+  }
+}

package/src/device/local/repository/Schedule.repository.ts

@@ -1,56 +1,62 @@
 import { Service } from "typedi";
 import { getConfig } from "../../../config/config";
-import axios from "axios";
 import { ISchedule } from "../interfaces/ISchedule";
+import { getDeviceServiceAxiosInstance } from "../../../utils/http-utils";
 
 @Service()
 export class ScheduleRepository {
-  private readonly baseUrl: string;
+  private readonly axiosInstance;
+
   constructor() {
-    const { DEVICE_SERVICE } = getConfig();
-    if (!DEVICE_SERVICE) {
-      throw new Error(
-        "DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE."
-      );
-    }
-    this.baseUrl = DEVICE_SERVICE;
+    this.axiosInstance = getDeviceServiceAxiosInstance();
   }
+
   async getSchedule(scheduleId: string) {
     try {
-      const response = await axios.get(
-        `${this.baseUrl}/devices/schedule?id=${scheduleId}`
+      const response = await this.axiosInstance.get(
+        `/devices/schedule?id=${scheduleId}`
       );
       return response.data;
     } catch (error: any) {
-      console.log(error);
-      throw new Error(`Failed to get schedule: ${error.response.data.message}`);
+      getConfig().LOGGER.error(`Failed to get schedule ${scheduleId}:`, error);
+      const errorMessage =
+        error.response?.data?.message || error.message || "Unknown error";
+      throw new Error(`Failed to get schedule: ${errorMessage}`);
     }
   }
 
   async getScheduleByZone(zoneId: string) {
     try {
-      const response = await axios.get(
-        `${this.baseUrl}/devices/schedules?zoneId=${zoneId}`
+      const response = await this.axiosInstance.get(
+        `/devices/schedules?zoneId=${zoneId}`
       );
       return response.data;
     } catch (error: any) {
-      console.log(error);
-      throw new Error(`Failed to get schedule: ${error.response.data.message}`);
+      getConfig().LOGGER.error(
+        `Failed to get schedule by zone ${zoneId}:`,
+        error
+      );
+      const errorMessage =
+        error.response?.data?.message || error.message || "Unknown error";
+      throw new Error(`Failed to get schedule: ${errorMessage}`);
     }
   }
 
   async setSchedule(scheduleId: string, schedule: ISchedule) {
     try {
-      const response = await axios.put(
-        `${this.baseUrl}/devices/schedules/${scheduleId}`,
+      const response = await this.axiosInstance.put(
+        `/devices/schedules/${scheduleId}`,
         schedule
       );
       return response.data;
     } catch (error: any) {
-      console.log(error);
-      throw new Error(
-        `Failed to update schedule: ${error.response.data.message}`
+      getConfig().LOGGER.error(
+        `Failed to update schedule ${scheduleId}:`,
+        error
       );
+      const errorMessage =
+        error.response?.data?.message || error.message || "Unknown error";
+      throw new Error(`Failed to update schedule: ${errorMessage}`);
     }
   }
 }