dt-common-device 3.0.9 → 3.0.11

package/src/alerts/Alert.repository.ts

@@ -1,487 +0,0 @@
-import { Service } from "typedi";
-import { AlertModel, IAlertDocument } from "./Alert.model";
-import {
-  CreateAlertData,
-  UpdateAlertData,
-  AlertCategory,
-  AlertSeverity,
-  EntityType,
-} from "./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 | 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) {
-        if (Array.isArray(filters.category)) {
-          query.category = { $in: filters.category };
-        } else {
-          query.category = { $in: [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 | 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) {
-        if (Array.isArray(filters.category)) {
-          query.category = { $in: filters.category };
-        } else {
-          query.category = { $in: [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 | AlertCategory[],
-    includeDeleted = false
-  ): Promise<IAlertDocument[]> {
-    try {
-      if (Array.isArray(category)) {
-        // Use $in operator for array of categories
-        const query: any = { category: { $in: category } };
-        if (!includeDeleted) {
-          query.isDeleted = false;
-        }
-        return await AlertModel.find(query).sort({ createdAt: -1 });
-      } else {
-        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 },
-            { $unwind: "$category" },
-            { $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"
-        }`
-      );
-    }
-  }
-}