dt-common-device 3.0.10 → 3.0.11

package/src/alerts/Alert.service.ts

@@ -1,711 +0,0 @@
-import { Service } from "typedi";
-import { AlertRepository } from "./Alert.repository";
-import { AlertModel, IAlertDocument } from "./Alert.model";
-import {
-  CreateAlertData,
-  UpdateAlertData,
-  AlertCategory,
-  AlertSeverity,
-  EntityType,
-} from "./alert.types";
-import { Source } from "../constants/Service";
-import { AlertBuilder } from "./AlertBuilder";
-import { IDevice } from "../device/local/interfaces";
-
-@Service()
-export class AlertService {
-  constructor(private readonly alertRepository: AlertRepository) {}
-
-  /**
-   * Create a readiness alert using AlertBuilder
-   */
-  async raiseReadinessAlert(
-    propertyId: string,
-    title: string,
-    description: string,
-    entityId?: string,
-    entityType?: EntityType,
-    createdBy?: string
-  ): Promise<IAlertDocument> {
-    const alertBuilder = AlertBuilder.createReadinessAlert()
-      .setPropertyId(propertyId)
-      .setTitle(title)
-      .setDescription(description);
-
-    if (entityId) alertBuilder.setEntityId(entityId);
-    if (entityType) alertBuilder.setEntityType(entityType);
-    if (createdBy) alertBuilder.setCreatedBy(createdBy);
-
-    return await this.createAlert(alertBuilder);
-  }
-
-  /**
-   * Create an operations alert using AlertBuilder
-   */
-  async raiseOperationsAlert(
-    propertyId: string,
-    title: string,
-    description: string,
-    entityId?: string,
-    entityType?: EntityType,
-    createdBy?: string
-  ): Promise<IAlertDocument> {
-    const alertBuilder = AlertBuilder.createOperationsAlert()
-      .setPropertyId(propertyId)
-      .setTitle(title)
-      .setDescription(description);
-
-    if (entityId) alertBuilder.setEntityId(entityId);
-    if (entityType) alertBuilder.setEntityType(entityType);
-    if (createdBy) alertBuilder.setCreatedBy(createdBy);
-
-    return await this.createAlert(alertBuilder);
-  }
-
-  /**
-   * Create a security alert using AlertBuilder
-   */
-  async raiseSecurityAlert(
-    propertyId: string,
-    title: string,
-    description: string,
-    entityId?: string,
-    entityType?: EntityType,
-    createdBy?: string
-  ): Promise<IAlertDocument> {
-    const alertBuilder = AlertBuilder.createSecurityAlert()
-      .setPropertyId(propertyId)
-      .setTitle(title)
-      .setDescription(description);
-
-    if (entityId) alertBuilder.setEntityId(entityId);
-    if (entityType) alertBuilder.setEntityType(entityType);
-    if (createdBy) alertBuilder.setCreatedBy(createdBy);
-
-    return await this.createAlert(alertBuilder);
-  }
-
-  /**
-   * Create an energy alert using AlertBuilder
-   */
-  async raiseEnergyAlert(
-    propertyId: string,
-    title: string,
-    description: string,
-    entityId?: string,
-    entityType?: EntityType,
-    createdBy?: string
-  ): Promise<IAlertDocument> {
-    const alertBuilder = AlertBuilder.createEnergyAlert()
-      .setPropertyId(propertyId)
-      .setTitle(title)
-      .setDescription(description);
-
-    if (entityId) alertBuilder.setEntityId(entityId);
-    if (entityType) alertBuilder.setEntityType(entityType);
-    if (createdBy) alertBuilder.setCreatedBy(createdBy);
-
-    return await this.createAlert(alertBuilder);
-  }
-
-  /**
-   * Create a device-specific alert using AlertBuilder
-   */
-  async raiseDeviceAlert(
-    deviceId: string,
-    propertyId: string,
-    title: string,
-    description: string,
-    category?: AlertCategory | AlertCategory[],
-    severity?: AlertSeverity,
-    source?: Source
-  ): Promise<IAlertDocument> {
-    const alertBuilder = AlertBuilder.createDeviceAlert(deviceId, propertyId)
-      .setTitle(title)
-      .setDescription(description);
-
-    if (category) alertBuilder.setCategory(category);
-    if (severity) alertBuilder.setSeverity(severity);
-    if (source) alertBuilder.setCreatedBy(source);
-
-    return await this.createAlert(alertBuilder);
-  }
-
-  /**
-   * Create a hub-specific alert using AlertBuilder
-   */
-  async raiseHubAlert(
-    hubId: string,
-    propertyId: string,
-    title: string,
-    description: string,
-    category?: AlertCategory | AlertCategory[],
-    severity?: AlertSeverity,
-    createdBy?: string
-  ): Promise<IAlertDocument> {
-    const alertBuilder = AlertBuilder.createHubAlert(hubId, propertyId)
-      .setTitle(title)
-      .setDescription(description);
-
-    if (category) alertBuilder.setCategory(category);
-    if (severity) alertBuilder.setSeverity(severity);
-    if (createdBy) alertBuilder.setCreatedBy(createdBy);
-
-    return await this.createAlert(alertBuilder);
-  }
-
-  /**
-   * Raise alert for device going offline
-   */
-  async raiseDeviceOfflineAlert(
-    device: IDevice,
-    source: Source,
-    reason?: string
-  ): Promise<IAlertDocument> {
-    return await this.raiseDeviceAlert(
-      device.deviceId,
-      device.propertyId,
-      "Device Offline",
-      `Device ${device.name} (${device.deviceId}) has gone offline. ${
-        reason ? `Reason: ${reason}` : ""
-      }`,
-      [AlertCategory.OPERATIONS],
-      AlertSeverity.HIGH,
-      source
-    );
-  }
-
-  /**
-   * Raise alert for device coming online
-   */
-  async raiseDeviceOnlineAlert(
-    device: IDevice,
-    source: Source,
-    reason?: string
-  ): Promise<IAlertDocument> {
-    return await this.raiseDeviceAlert(
-      device.deviceId,
-      device.propertyId,
-      "Device Online",
-      `Device ${device.name} (${device.deviceId}) is now online. ${
-        reason ? `Reason: ${reason}` : ""
-      }`,
-      [AlertCategory.OPERATIONS],
-      AlertSeverity.INFO,
-      source
-    );
-  }
-
-  /**
-   * Raise alert for device battery level below threshold
-   */
-  async raiseDeviceBatteryAlert(
-    device: IDevice,
-    batteryLevel: number,
-    threshold: number,
-    source: Source
-  ): Promise<IAlertDocument> {
-    return await this.raiseDeviceAlert(
-      device.deviceId,
-      device.propertyId,
-      "Device Battery Low",
-      `Device ${device.name} (${device.deviceId}) battery level is ${batteryLevel}%, which is below the property threshold of ${threshold}%.`,
-      [AlertCategory.ENERGY],
-      AlertSeverity.MEDIUM,
-      source
-    );
-  }
-
-  /**
-   * Create a new alert with business logic validation
-   * Accepts either a CreateAlertData object or an AlertBuilder instance
-   */
-  async createAlert(
-    alertData: CreateAlertData | AlertBuilder
-  ): Promise<IAlertDocument> {
-    let processedAlertData: CreateAlertData;
-
-    // Handle AlertBuilder instance
-    if (alertData instanceof AlertBuilder) {
-      processedAlertData = alertData.build();
-    } else {
-      processedAlertData = alertData;
-    }
-
-    // Business logic: Validate alert data
-    this.validateAlertData(processedAlertData);
-
-    // Business logic: Set default severity if not provided
-    if (!processedAlertData.severity) {
-      processedAlertData.severity = this.determineDefaultSeverity(
-        processedAlertData.category
-      );
-    }
-
-    // Business logic: Validate snooze date is in the future
-    if (
-      processedAlertData.snoozeUntil &&
-      processedAlertData.snoozeUntil <= new Date()
-    ) {
-      throw new Error("Snooze date must be in the future");
-    }
-
-    return await this.alertRepository.create(processedAlertData);
-  }
-
-  /**
-   * Get alert by ID with business logic
-   */
-  async getAlertById(
-    id: string,
-    includeDeleted = false
-  ): Promise<IAlertDocument | null> {
-    if (!id) {
-      throw new Error("Alert ID is required");
-    }
-
-    const alert = await this.alertRepository.findById(id, includeDeleted);
-
-    // Business logic: Check if alert is snoozed and expired
-    if (alert?.snoozeUntil && alert.snoozeUntil <= new Date()) {
-      console.warn(`Alert ${id} snooze has expired`);
-    }
-
-    return alert;
-  }
-
-  /**
-   * Get all alerts with business logic filtering
-   */
-  async getAlerts(
-    filters: {
-      propertyId?: string;
-      category?: AlertCategory | AlertCategory[];
-      severity?: AlertSeverity;
-      entityType?: EntityType;
-      entityId?: string;
-      isActive?: boolean;
-      isRead?: boolean;
-      includeDeleted?: boolean;
-      limit?: number;
-      skip?: number;
-    } = {}
-  ): Promise<IAlertDocument[]> {
-    // Business logic: Validate filters
-    this.validateFilters(filters);
-
-    // Business logic: Apply business rules to filters
-    const enhancedFilters = this.applyBusinessRules(filters);
-
-    return await this.alertRepository.findAll(enhancedFilters);
-  }
-
-  /**
-   * Update an alert with business logic validation
-   */
-  async updateAlert(
-    id: string,
-    updateData: UpdateAlertData
-  ): Promise<IAlertDocument | null> {
-    if (!id) {
-      throw new Error("Alert ID is required");
-    }
-
-    // Business logic: Validate update data
-    this.validateUpdateData(updateData);
-
-    // Business logic: Check if alert exists and is not deleted
-    const existingAlert = await this.alertRepository.findById(id);
-    if (!existingAlert) {
-      throw new Error("Alert not found");
-    }
-
-    // Business logic: Handle snooze validation
-    if (updateData.snoozeUntil) {
-      this.validateSnoozeDate(updateData.snoozeUntil);
-    }
-
-    return await this.alertRepository.update(id, updateData);
-  }
-
-  /**
-   * Soft delete an alert with business logic
-   */
-  async deleteAlert(id: string, deletedBy: string): Promise<boolean> {
-    if (!id || !deletedBy) {
-      throw new Error("Alert ID and deleted by user are required");
-    }
-
-    // Business logic: Check if alert can be deleted
-    const alert = await this.alertRepository.findById(id);
-    if (!alert) {
-      throw new Error("Alert not found");
-    }
-
-    // Business logic: Prevent deletion of critical alerts (optional rule)
-    if (alert.severity === AlertSeverity.CRITICAL) {
-      throw new Error("Cannot delete critical alerts");
-    }
-
-    return await this.alertRepository.softDelete(id, deletedBy);
-  }
-
-  /**
-   * Mark alert as read with business logic
-   */
-  async markAsRead(
-    id: string,
-    updatedBy: string
-  ): Promise<IAlertDocument | null> {
-    if (!id || !updatedBy) {
-      throw new Error("Alert ID and updated by user are required");
-    }
-
-    const alertModel = await AlertModel.findById(id);
-    if (!alertModel) return null;
-
-    alertModel.markAsRead(updatedBy);
-    return await alertModel.save();
-  }
-
-  /**
-   * Mark alert as unread with business logic
-   */
-  async markAsUnread(
-    id: string,
-    updatedBy: string
-  ): Promise<IAlertDocument | null> {
-    if (!id || !updatedBy) {
-      throw new Error("Alert ID and updated by user are required");
-    }
-
-    const alertModel = await AlertModel.findById(id);
-    if (!alertModel) return null;
-
-    alertModel.markAsUnread(updatedBy);
-    return await alertModel.save();
-  }
-
-  /**
-   * Activate an alert with business logic
-   */
-  async activateAlert(
-    id: string,
-    updatedBy: string
-  ): Promise<IAlertDocument | null> {
-    if (!id || !updatedBy) {
-      throw new Error("Alert ID and updated by user are required");
-    }
-
-    const alertModel = await AlertModel.findById(id);
-    if (!alertModel) return null;
-
-    alertModel.activate(updatedBy);
-    return await alertModel.save();
-  }
-
-  /**
-   * Deactivate an alert with business logic
-   */
-  async deactivateAlert(
-    id: string,
-    updatedBy: string
-  ): Promise<IAlertDocument | null> {
-    if (!id || !updatedBy) {
-      throw new Error("Alert ID and updated by user are required");
-    }
-
-    const alertModel = await AlertModel.findById(id);
-    if (!alertModel) return null;
-
-    alertModel.deactivate(updatedBy);
-    return await alertModel.save();
-  }
-
-  /**
-   * Snooze an alert with business logic
-   */
-  async snoozeAlert(
-    id: string,
-    until: Date,
-    updatedBy: string
-  ): Promise<IAlertDocument | null> {
-    if (!id || !until || !updatedBy) {
-      throw new Error(
-        "Alert ID, snooze date, and updated by user are required"
-      );
-    }
-
-    // Business logic: Validate snooze date
-    this.validateSnoozeDate(until);
-
-    const alertModel = await AlertModel.findById(id);
-    if (!alertModel) return null;
-
-    alertModel.snooze(until, updatedBy);
-    return await alertModel.save();
-  }
-
-  /**
-   * Unsnooze an alert with business logic
-   */
-  async unsnoozeAlert(
-    id: string,
-    updatedBy: string
-  ): Promise<IAlertDocument | null> {
-    if (!id || !updatedBy) {
-      throw new Error("Alert ID and updated by user are required");
-    }
-
-    const alertModel = await AlertModel.findById(id);
-    if (!alertModel) return null;
-
-    alertModel.unsnooze(updatedBy);
-    return await alertModel.save();
-  }
-
-  /**
-   * Get alerts by property with business logic
-   */
-  async getAlertsByProperty(
-    propertyId: string,
-    includeDeleted = false
-  ): Promise<IAlertDocument[]> {
-    if (!propertyId) {
-      throw new Error("Property ID is required");
-    }
-
-    return await this.alertRepository.findByProperty(
-      propertyId,
-      includeDeleted
-    );
-  }
-
-  /**
-   * Get alerts by entity with business logic
-   */
-  async getAlertsByEntity(
-    entityId: string,
-    entityType: EntityType,
-    includeDeleted = false
-  ): Promise<IAlertDocument[]> {
-    if (!entityId || !entityType) {
-      throw new Error("Entity ID and entity type are required");
-    }
-
-    return await this.alertRepository.findByEntity(
-      entityId,
-      entityType,
-      includeDeleted
-    );
-  }
-
-  /**
-   * Get alerts by category with business logic
-   */
-  async getAlertsByCategory(
-    category: AlertCategory | AlertCategory[],
-    includeDeleted = false
-  ): Promise<IAlertDocument[]> {
-    if (!category) {
-      throw new Error("Alert category is required");
-    }
-
-    return await this.alertRepository.findByCategory(category, includeDeleted);
-  }
-
-  /**
-   * Get alerts by severity with business logic
-   */
-  async getAlertsBySeverity(
-    severity: AlertSeverity,
-    includeDeleted = false
-  ): Promise<IAlertDocument[]> {
-    if (!severity) {
-      throw new Error("Alert severity is required");
-    }
-
-    return await this.alertRepository.findBySeverity(severity, includeDeleted);
-  }
-
-  /**
-   * Get active alerts with business logic
-   */
-  async getActiveAlerts(includeDeleted = false): Promise<IAlertDocument[]> {
-    const activeAlerts = await this.alertRepository.findActive(includeDeleted);
-
-    // Business logic: Log active alerts for monitoring
-    if (activeAlerts.length > 0) {
-      console.log(`Found ${activeAlerts.length} active alerts`);
-    }
-
-    return activeAlerts;
-  }
-
-  /**
-   * Get unread alerts with business logic
-   */
-  async getUnreadAlerts(includeDeleted = false): Promise<IAlertDocument[]> {
-    const unreadAlerts = await this.alertRepository.findUnread(includeDeleted);
-
-    // Business logic: Log unread alerts for monitoring
-    if (unreadAlerts.length > 0) {
-      console.warn(`Found ${unreadAlerts.length} unread alerts`);
-    }
-
-    return unreadAlerts;
-  }
-
-  /**
-   * Get snoozed alerts with business logic
-   */
-  async getSnoozedAlerts(includeDeleted = false): Promise<IAlertDocument[]> {
-    return await this.alertRepository.findSnoozed(includeDeleted);
-  }
-
-  /**
-   * Get expired snooze alerts with business logic
-   */
-  async getExpiredSnoozeAlerts(
-    includeDeleted = false
-  ): Promise<IAlertDocument[]> {
-    const expiredAlerts = await this.alertRepository.findExpiredSnooze(
-      includeDeleted
-    );
-
-    // Business logic: Log expired snooze alerts
-    if (expiredAlerts.length > 0) {
-      console.warn(`Found ${expiredAlerts.length} alerts with expired snooze`);
-    }
-
-    return expiredAlerts;
-  }
-
-  /**
-   * Get alert statistics with business logic
-   */
-  async getAlertStatistics(propertyId?: string): Promise<{
-    total: number;
-    active: number;
-    unread: number;
-    snoozed: number;
-    bySeverity: Record<AlertSeverity, number>;
-    byCategory: Record<AlertCategory, number>;
-  }> {
-    const stats = await this.alertRepository.getStatistics(propertyId);
-
-    // Business logic: Add alerts for critical metrics
-    if (stats.unread > 0) {
-      console.warn(`Alert: ${stats.unread} unread alerts require attention`);
-    }
-
-    if (stats.bySeverity[AlertSeverity.CRITICAL] > 0) {
-      console.error(
-        `Alert: ${
-          stats.bySeverity[AlertSeverity.CRITICAL]
-        } critical alerts require immediate attention`
-      );
-    }
-
-    if (stats.bySeverity[AlertSeverity.HIGH] > 0) {
-      console.warn(
-        `Alert: ${
-          stats.bySeverity[AlertSeverity.HIGH]
-        } high severity alerts require attention`
-      );
-    }
-
-    return stats;
-  }
-
-  // Private business logic methods
-
-  private validateAlertData(data: CreateAlertData): void {
-    if (!data.title || data.title.trim().length < 3) {
-      throw new Error("Alert title must be at least 3 characters long");
-    }
-
-    if (!data.description || data.description.trim().length < 5) {
-      throw new Error("Alert description must be at least 5 characters long");
-    }
-
-    if (!data.propertyId) {
-      throw new Error("Property ID is required");
-    }
-
-    if (!data.entityType) {
-      throw new Error("Entity type 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: UpdateAlertData): void {
-    if (data.title && data.title.trim().length < 3) {
-      throw new Error("Alert title must be at least 3 characters long");
-    }
-
-    if (data.description && data.description.trim().length < 5) {
-      throw new Error("Alert description must be at least 5 characters long");
-    }
-  }
-
-  private validateSnoozeDate(snoozeUntil: Date): void {
-    if (snoozeUntil <= new Date()) {
-      throw new Error("Snooze date must be in the future");
-    }
-  }
-
-  private determineDefaultSeverity(
-    category: AlertCategory | AlertCategory[]
-  ): AlertSeverity {
-    // Business logic: Determine default severity based on category
-    const categorySeverities: Record<AlertCategory, AlertSeverity> = {
-      [AlertCategory.READINESS]: AlertSeverity.MEDIUM,
-      [AlertCategory.OPERATIONS]: AlertSeverity.HIGH,
-      [AlertCategory.SECURITY]: AlertSeverity.CRITICAL,
-      [AlertCategory.ENERGY]: AlertSeverity.LOW,
-      [AlertCategory.OTHER]: AlertSeverity.MEDIUM,
-    };
-
-    // If it's an array, use the highest severity category
-    if (Array.isArray(category)) {
-      const severities = category.map(
-        (cat) => categorySeverities[cat] || AlertSeverity.MEDIUM
-      );
-      const severityOrder = [
-        AlertSeverity.CRITICAL,
-        AlertSeverity.HIGH,
-        AlertSeverity.MEDIUM,
-        AlertSeverity.LOW,
-        AlertSeverity.INFO,
-      ];
-      return (
-        severityOrder.find((severity) => severities.includes(severity)) ||
-        AlertSeverity.MEDIUM
-      );
-    }
-
-    return categorySeverities[category] || AlertSeverity.MEDIUM;
-  }
-
-  private applyBusinessRules(filters: any): any {
-    // Business logic: Apply additional filters based on business rules
-    const enhancedFilters = { ...filters };
-
-    // Example: Always exclude deleted alerts unless explicitly requested
-    if (!enhancedFilters.includeDeleted) {
-      enhancedFilters.includeDeleted = false;
-    }
-
-    return enhancedFilters;
-  }
-}