dt-common-device 1.3.0 → 2.0.0

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

@@ -0,0 +1,465 @@
+import { Service } from "typedi";
+import { AlertModel, IAlertDocument } from "../models/Alert.model";
+import {
+  CreateAlertData,
+  UpdateAlertData,
+  AlertCategory,
+  AlertSeverity,
+  EntityType,
+} from "../../../types/alert.types";
+
+@Service()
+export class AlertRepository {
+  /**
+   * Create a new alert
+   */
+  async create(alertData: CreateAlertData): Promise<IAlertDocument> {
+    try {
+      const alert = new AlertModel({
+        ...alertData,
+        severity: alertData.severity || AlertSeverity.MEDIUM,
+        isRead: false,
+        isActive: true,
+        isDeleted: false,
+      });
+
+      return await alert.save();
+    } catch (error) {
+      throw new Error(
+        `Failed to create alert: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Find alert by ID
+   */
+  async findById(
+    id: string,
+    includeDeleted = false
+  ): Promise<IAlertDocument | null> {
+    try {
+      const query: any = { _id: id };
+      if (!includeDeleted) {
+        query.isDeleted = false;
+      }
+      return await AlertModel.findOne(query);
+    } catch (error) {
+      throw new Error(
+        `Failed to find alert by ID: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Find all alerts with filters
+   */
+  async findAll(
+    filters: {
+      propertyId?: string;
+      category?: AlertCategory;
+      severity?: AlertSeverity;
+      entityType?: EntityType;
+      entityId?: string;
+      isActive?: boolean;
+      isRead?: boolean;
+      includeDeleted?: boolean;
+      limit?: number;
+      skip?: number;
+      sort?: { [key: string]: 1 | -1 };
+    } = {}
+  ): Promise<IAlertDocument[]> {
+    try {
+      const query: any = {};
+
+      if (filters.propertyId) query.propertyId = filters.propertyId;
+      if (filters.category) query.category = filters.category;
+      if (filters.severity) query.severity = filters.severity;
+      if (filters.entityType) query.entityType = filters.entityType;
+      if (filters.entityId) query.entityId = filters.entityId;
+      if (filters.isActive !== undefined) query.isActive = filters.isActive;
+      if (filters.isRead !== undefined) query.isRead = filters.isRead;
+      if (!filters.includeDeleted) query.isDeleted = false;
+
+      const queryBuilder = AlertModel.find(query);
+
+      if (filters.sort) {
+        queryBuilder.sort(filters.sort);
+      } else {
+        queryBuilder.sort({ severity: -1, 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 alerts: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Update an alert
+   */
+  async update(
+    id: string,
+    updateData: UpdateAlertData
+  ): Promise<IAlertDocument | null> {
+    try {
+      return await AlertModel.findByIdAndUpdate(
+        id,
+        { ...updateData, updatedAt: new Date() },
+        { new: true, runValidators: true }
+      );
+    } catch (error) {
+      throw new Error(
+        `Failed to update alert: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Soft delete an alert
+   */
+  async softDelete(id: string, deletedBy: string): Promise<boolean> {
+    try {
+      const result = await AlertModel.findByIdAndUpdate(id, {
+        isDeleted: true,
+        updatedBy: deletedBy,
+        updatedAt: new Date(),
+      });
+      return !!result;
+    } catch (error) {
+      throw new Error(
+        `Failed to soft delete alert: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Permanently delete an alert
+   */
+  async hardDelete(id: string): Promise<boolean> {
+    try {
+      const result = await AlertModel.findByIdAndDelete(id);
+      return !!result;
+    } catch (error) {
+      throw new Error(
+        `Failed to permanently delete alert: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Count alerts with filters
+   */
+  async count(
+    filters: {
+      propertyId?: string;
+      category?: AlertCategory;
+      severity?: AlertSeverity;
+      entityType?: EntityType;
+      entityId?: string;
+      isActive?: boolean;
+      isRead?: boolean;
+      includeDeleted?: boolean;
+    } = {}
+  ): Promise<number> {
+    try {
+      const query: any = {};
+
+      if (filters.propertyId) query.propertyId = filters.propertyId;
+      if (filters.category) query.category = filters.category;
+      if (filters.severity) query.severity = filters.severity;
+      if (filters.entityType) query.entityType = filters.entityType;
+      if (filters.entityId) query.entityId = filters.entityId;
+      if (filters.isActive !== undefined) query.isActive = filters.isActive;
+      if (filters.isRead !== undefined) query.isRead = filters.isRead;
+      if (!filters.includeDeleted) query.isDeleted = false;
+
+      return await AlertModel.countDocuments(query);
+    } catch (error) {
+      throw new Error(
+        `Failed to count alerts: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Find alerts by property
+   */
+  async findByProperty(
+    propertyId: string,
+    includeDeleted = false
+  ): Promise<IAlertDocument[]> {
+    try {
+      return await AlertModel.findByProperty(propertyId, includeDeleted);
+    } catch (error) {
+      throw new Error(
+        `Failed to find alerts by property: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Find alerts by entity
+   */
+  async findByEntity(
+    entityId: string,
+    entityType: EntityType,
+    includeDeleted = false
+  ): Promise<IAlertDocument[]> {
+    try {
+      return await AlertModel.findByEntity(
+        entityId,
+        entityType,
+        includeDeleted
+      );
+    } catch (error) {
+      throw new Error(
+        `Failed to find alerts by entity: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Find alerts by category
+   */
+  async findByCategory(
+    category: AlertCategory,
+    includeDeleted = false
+  ): Promise<IAlertDocument[]> {
+    try {
+      return await AlertModel.findByCategory(category, includeDeleted);
+    } catch (error) {
+      throw new Error(
+        `Failed to find alerts by category: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Find alerts by severity
+   */
+  async findBySeverity(
+    severity: AlertSeverity,
+    includeDeleted = false
+  ): Promise<IAlertDocument[]> {
+    try {
+      return await AlertModel.findBySeverity(severity, includeDeleted);
+    } catch (error) {
+      throw new Error(
+        `Failed to find alerts by severity: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Find active alerts
+   */
+  async findActive(includeDeleted = false): Promise<IAlertDocument[]> {
+    try {
+      return await AlertModel.findActive(includeDeleted);
+    } catch (error) {
+      throw new Error(
+        `Failed to find active alerts: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Find unread alerts
+   */
+  async findUnread(includeDeleted = false): Promise<IAlertDocument[]> {
+    try {
+      return await AlertModel.findUnread(includeDeleted);
+    } catch (error) {
+      throw new Error(
+        `Failed to find unread alerts: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Find snoozed alerts
+   */
+  async findSnoozed(includeDeleted = false): Promise<IAlertDocument[]> {
+    try {
+      return await AlertModel.findSnoozed(includeDeleted);
+    } catch (error) {
+      throw new Error(
+        `Failed to find snoozed alerts: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Find expired snooze alerts
+   */
+  async findExpiredSnooze(includeDeleted = false): Promise<IAlertDocument[]> {
+    try {
+      return await AlertModel.findExpiredSnooze(includeDeleted);
+    } catch (error) {
+      throw new Error(
+        `Failed to find expired snooze alerts: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Get alert statistics
+   */
+  async getStatistics(propertyId?: string): Promise<{
+    total: number;
+    active: number;
+    unread: number;
+    snoozed: number;
+    bySeverity: Record<AlertSeverity, number>;
+    byCategory: Record<AlertCategory, number>;
+  }> {
+    try {
+      const query: any = { isDeleted: false };
+      if (propertyId) query.propertyId = propertyId;
+
+      const [total, active, unread, snoozed, severityStats, categoryStats] =
+        await Promise.all([
+          AlertModel.countDocuments(query),
+          AlertModel.countDocuments({ ...query, isActive: true }),
+          AlertModel.countDocuments({ ...query, isRead: false }),
+          AlertModel.countDocuments({
+            ...query,
+            snoozeUntil: { $exists: true, $ne: null },
+          }),
+          AlertModel.aggregate([
+            { $match: query },
+            { $group: { _id: "$severity", count: { $sum: 1 } } },
+          ]),
+          AlertModel.aggregate([
+            { $match: query },
+            { $group: { _id: "$category", count: { $sum: 1 } } },
+          ]),
+        ]);
+
+      const bySeverity = Object.values(AlertSeverity).reduce(
+        (acc, severity) => {
+          acc[severity] = 0;
+          return acc;
+        },
+        {} as Record<AlertSeverity, number>
+      );
+
+      const byCategory = Object.values(AlertCategory).reduce(
+        (acc, category) => {
+          acc[category] = 0;
+          return acc;
+        },
+        {} as Record<AlertCategory, number>
+      );
+
+      // Type-safe handling of aggregation results
+      severityStats.forEach((stat: { _id: string; count: number }) => {
+        if (stat._id in bySeverity) {
+          bySeverity[stat._id as AlertSeverity] = stat.count;
+        }
+      });
+
+      categoryStats.forEach((stat: { _id: string; count: number }) => {
+        if (stat._id in byCategory) {
+          byCategory[stat._id as AlertCategory] = stat.count;
+        }
+      });
+
+      return {
+        total,
+        active,
+        unread,
+        snoozed,
+        bySeverity,
+        byCategory,
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get alert statistics: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Bulk update alerts
+   */
+  async bulkUpdate(
+    ids: string[],
+    updateData: Partial<UpdateAlertData>
+  ): Promise<number> {
+    try {
+      const result = await AlertModel.updateMany(
+        { _id: { $in: ids } },
+        { ...updateData, updatedAt: new Date() }
+      );
+      return result.modifiedCount;
+    } catch (error) {
+      throw new Error(
+        `Failed to bulk update alerts: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Bulk soft delete alerts
+   */
+  async bulkSoftDelete(ids: string[], deletedBy: string): Promise<number> {
+    try {
+      const result = await AlertModel.updateMany(
+        { _id: { $in: ids } },
+        {
+          isDeleted: true,
+          updatedBy: deletedBy,
+          updatedAt: new Date(),
+        }
+      );
+      return result.modifiedCount;
+    } catch (error) {
+      throw new Error(
+        `Failed to bulk soft delete alerts: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+}