dt-common-device 1.3.0 → 2.0.0

package/src/device/local/services/Alert.service.ts

@@ -1,8 +1,620 @@
+import { Service } from "typedi";
+import { AlertRepository } from "../repository/Alert.repository";
+import { AlertModel, IAlertDocument } from "../models/Alert.model";
+import {
+  CreateAlertData,
+  UpdateAlertData,
+  AlertCategory,
+  AlertSeverity,
+  EntityType,
+} from "../../../types/alert.types";
+import { AlertBuilder } from "../entities/AlertBuilder";
+
+@Service()
 export class AlertService {
-  constructor() {}
+  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,
+    severity?: AlertSeverity,
+    createdBy?: string
+  ): Promise<IAlertDocument> {
+    const alertBuilder = AlertBuilder.createDeviceAlert(deviceId, 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);
+  }
+
+  /**
+   * Create a hub-specific alert using AlertBuilder
+   */
+  async raiseHubAlert(
+    hubId: string,
+    propertyId: string,
+    title: string,
+    description: string,
+    category?: 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);
+  }
+
+  /**
+   * 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;
+      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,
+    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): 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,
+    };
+
+    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;
+    }
 
-  raiseReadinessAlert() {}
-  raiseOperationsAlert() {}
-  raiseSecurityAlert() {}
-  raiseEnergyAlert() {}
+    return enhancedFilters;
+  }
 }