dt-common-device 3.0.2 → 3.0.4

package/dist/device/local/services/Device.service.js

@@ -4,14 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalDeviceService = void 0;
-const EventHandler_1 = require("src/events/EventHandler");
+const EventHandler_1 = require("../../../events/EventHandler");
 const lodash_1 = require("lodash");
 const Device_repository_1 = require("../repository/Device.repository");
 const typedi_1 = __importDefault(require("typedi"));
+const Alert_service_1 = require("../../../alerts/Alert.service");
+const Issue_service_1 = require("../../../issues/Issue.service");
+const config_1 = require("../../../config/config");
 class LocalDeviceService {
     constructor() {
         this.eventHandler = new EventHandler_1.EventHandler();
         this.deviceRepository = typedi_1.default.get(Device_repository_1.DeviceRepository);
+        this.alertService = typedi_1.default.get(Alert_service_1.AlertService);
+        this.issueService = typedi_1.default.get(Issue_service_1.IssueService);
+        this.logger = (0, config_1.getConfig)().LOGGER;
     }
     async createDevice(body) {
         const device = await this.deviceRepository.createDevice(body);
@@ -80,50 +86,164 @@ class LocalDeviceService {
         }
         return await this.deviceRepository.getStatus(deviceId);
     }
-    async setStatus(deviceId, newStatus) {
+    async setStatus(deviceId, newStatus, source, reason) {
         if (!deviceId || !newStatus) {
             throw new Error("Device ID and new status are required");
         }
-        const oldStatus = await this.getStatus(deviceId);
-        const isStatusChanged = !(0, lodash_1.isEqual)(oldStatus, newStatus);
-        if (isStatusChanged) {
+        const device = await this.getDevice(deviceId);
+        const oldStatus = device.status;
+        const currentTime = new Date().toISOString();
+        // Determine if the new status is ONLINE or OFFLINE
+        const isNewStatusOnline = newStatus.liveStatus === "ONLINE";
+        const isNewStatusOffline = newStatus.liveStatus === "OFFLINE";
+        if (isNewStatusOffline) {
+            // New Status = OFFLINE
+            await this.handleOfflineStatus(deviceId, device, oldStatus, newStatus, source, reason, currentTime);
+        }
+        else if (isNewStatusOnline) {
+            // New Status = ONLINE
+            await this.handleOnlineStatus(deviceId, device, oldStatus, newStatus, source, reason, currentTime);
+        }
+        else {
+            // For any other status, just update normally
+            await this.deviceRepository.setStatus(deviceId, newStatus);
+            await this.eventHandler.onStatusChange(deviceId, newStatus);
+        }
+    }
+    async handleOfflineStatus(deviceId, device, oldStatus, newStatus, source, reason, currentTime) {
+        const isExistingStatusOnline = oldStatus?.online === true;
+        const isExistingStatusOffline = oldStatus?.online === false;
+        if (isExistingStatusOnline) {
+            // Existing status is Online
+            newStatus.online = true;
+            newStatus.liveStatus = "OFFLINE";
+            newStatus.lastUpdated = currentTime;
+            newStatus.error = {
+                type: "offline",
+                message: reason || "Device went offline",
+                default: {},
+            };
             await this.deviceRepository.setStatus(deviceId, newStatus);
             await this.eventHandler.onStatusChange(deviceId, newStatus);
         }
-        const isBothOffline = oldStatus?.online === false && newStatus?.online === false;
-        if (isBothOffline && oldStatus?.lastUpdated) {
-            const timeDifference = Date.now() - new Date(oldStatus.lastUpdated).getTime();
-            if (timeDifference > 86400000) {
-                //return await this.alertService.raiseOperationsAlert();
+        else if (isExistingStatusOffline) {
+            // Existing status is Offline
+            const timeLapsed = oldStatus?.lastUpdated
+                ? Date.now() - new Date(oldStatus.lastUpdated).getTime()
+                : 0;
+            const baselineTime = await this.getDeviceBaseline(deviceId);
+            if (timeLapsed > baselineTime) {
+                // When the time lapsed is higher than the baseline time
+                newStatus.online = false;
+                newStatus.liveStatus = "OFFLINE";
+                newStatus.lastUpdated = currentTime;
+                newStatus.error = {
+                    type: "offline",
+                    message: reason || "Device has been offline for longer than baseline",
+                    default: {},
+                };
+                await this.deviceRepository.setStatus(deviceId, newStatus);
+                await this.eventHandler.onStatusChange(deviceId, newStatus);
+                // Raise alert
+                await this.alertService.raiseDeviceOfflineAlert(device, source, reason);
+                // Raise issue when the device goes offline if longer than the baseline
+                await this.issueService.createDeviceOfflineIssue(device, source, reason);
+            }
+        }
+    }
+    async handleOnlineStatus(deviceId, device, oldStatus, newStatus, source, reason, currentTime) {
+        const isExistingStatusOnline = oldStatus?.online === true;
+        const isExistingStatusOffline = oldStatus?.online === false;
+        if (isExistingStatusOnline) {
+            // Existing status is Online
+            if (oldStatus?.liveStatus === "ONLINE") {
+                // liveStatus = Online → Do nothing
                 return;
             }
+            else if (oldStatus?.liveStatus === "OFFLINE") {
+                // liveStatus = Offline → Follow the step #2 (same as existing status is Offline)
+                newStatus.online = true;
+                newStatus.liveStatus = "ONLINE";
+                newStatus.lastUpdated = currentTime;
+                newStatus.error = {}; // Clear the error
+                await this.deviceRepository.setStatus(deviceId, newStatus);
+                await this.eventHandler.onStatusChange(deviceId, newStatus);
+                //TODO: ALERT NEEDED?
+                //  Raise alert
+                await this.alertService.raiseDeviceOnlineAlert(device, source, reason);
+            }
+        }
+        else if (isExistingStatusOffline) {
+            // Existing status is Offline
+            newStatus.online = true;
+            newStatus.liveStatus = "ONLINE";
+            newStatus.lastUpdated = currentTime;
+            newStatus.error = undefined; // Clear the error
+            await this.deviceRepository.setStatus(deviceId, newStatus);
+            await this.eventHandler.onStatusChange(deviceId, newStatus);
+            //TODO: ALERT NEEDED?
+            //  Raise alert
+            await this.alertService.raiseDeviceOnlineAlert(device, source, reason);
         }
     }
+    async getDeviceBaseline(deviceId) {
+        // TODO: Implement device baseline retrieval
+        // This should return the baseline time in milliseconds for the specific device
+        // For now, returning a default value of 5 minutes (300000ms)
+        // In a real implementation, this would fetch from device configuration or settings
+        return 3600000; // 1 hour in milliseconds
+    }
     async getBatteryLevel(deviceId) {
         if (!deviceId) {
             throw new Error("Device ID is required");
         }
         return await this.deviceRepository.getBatteryLevel(deviceId);
     }
-    async setBatteryLevel(deviceId, batteryLevel) {
+    async setBatteryLevel(deviceId, batteryLevel, source) {
+        if (!deviceId || batteryLevel === undefined || batteryLevel === null) {
+            throw new Error("Device ID and battery level are required");
+        }
+        // Get device information
+        const device = await this.getDevice(deviceId);
         // Fetch the old battery level state
-        const oldBatteryLevel = await this.getBatteryLevel(deviceId);
+        const oldBatteryLevel = device.state?.batteryPercentage;
+        // Check if battery level has changed
         const isDifferent = !(0, lodash_1.isEqual)(oldBatteryLevel?.value, batteryLevel);
         if (isDifferent) {
-            await this.deviceRepository.setBatteryLevel(deviceId, batteryLevel);
-            await this.eventHandler.onBatteryLevelChange(deviceId, batteryLevel);
-        }
-        // Check if battery is low and not updated for 8 hours
-        if (batteryLevel < 20 &&
-            oldBatteryLevel?.value < 20 &&
-            oldBatteryLevel?.lastUpdated &&
-            new Date(oldBatteryLevel.lastUpdated).getTime() <
-                Date.now() - 1000 * 60 * 60 * 8 // 8 hours in ms
-        ) {
-            // TODO: Raise an energy alert
-            // await this.alertService.raiseEnergyAlert();
-            return;
+            // Check if current time is greater than or equal to last updated time (8-hour logic)
+            const shouldUpdate = this.shouldUpdateBatteryLevel(oldBatteryLevel?.lastUpdated);
+            if (shouldUpdate) {
+                // Save the battery level in the device
+                await this.deviceRepository.setBatteryLevel(deviceId, batteryLevel);
+                await this.eventHandler.onBatteryLevelChange(deviceId, batteryLevel);
+                // Get property threshold
+                const propertyThreshold = await this.getPropertyBatteryThreshold(device.propertyId);
+                // Check if battery level is below threshold
+                if (batteryLevel < propertyThreshold) {
+                    // Raise alert
+                    await this.alertService.raiseDeviceBatteryAlert(device, batteryLevel, propertyThreshold, source);
+                    // Raise issue when the level is below threshold
+                    await this.issueService.createDeviceBatteryIssue(device, batteryLevel, propertyThreshold, source);
+                }
+            }
+        }
+    }
+    shouldUpdateBatteryLevel(lastUpdated) {
+        if (!lastUpdated) {
+            return true; // No previous update, so we should update
         }
+        const lastUpdateTime = new Date(lastUpdated).getTime();
+        const currentTime = Date.now();
+        const eightHoursInMs = 8 * 60 * 60 * 1000; // 8 hours in milliseconds
+        // Return true if current time is greater than or equal to last updated time + 8 hours
+        return currentTime >= lastUpdateTime + eightHoursInMs;
+    }
+    async getPropertyBatteryThreshold(propertyId) {
+        // TODO: Implement property battery threshold retrieval
+        // This should return the battery threshold for the specific property
+        // For now, returning a default value of 20%
+        // In a real implementation, this would fetch from property configuration or settings
+        return 20; // 20% default threshold
     }
     async getMetaData(deviceId) {
         if (!deviceId) {

package/dist/events/BaseEventHandler.d.ts

@@ -1,7 +1,7 @@
 import { DeviceEvent } from "./interfaces/DeviceEvent";
 import { IEventHandler } from "./interfaces/IEventHandler";
-import { ILogger } from "src/config/config.types";
-import { LocalDeviceService } from "src/device/local/services/Device.service";
+import { ILogger } from "../config/config.types";
+import { LocalDeviceService } from "../device/local/services/Device.service";
 export declare abstract class BaseEventHandler implements IEventHandler {
     protected readonly supportedEventTypes: string[];
     protected readonly priority: number;

package/dist/events/BaseEventHandler.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseEventHandler = void 0;
-const config_1 = require("src/config/config");
-const Device_service_1 = require("src/device/local/services/Device.service");
+const config_1 = require("../config/config");
+const Device_service_1 = require("../device/local/services/Device.service");
 class BaseEventHandler {
     constructor(supportedEventTypes, priority = 100) {
         this.supportedEventTypes = supportedEventTypes;

package/dist/events/BaseEventTransformer.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from "src/config/config.types";
+import { ILogger } from "../config/config.types";
 import { DeviceEvent } from "./interfaces/DeviceEvent";
 import { IEventTransformer } from "./interfaces/IEventTransformer";
 export declare abstract class BaseEventTransformer implements IEventTransformer {

package/dist/events/BaseEventTransformer.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseEventTransformer = void 0;
-const config_1 = require("src/config/config");
+const config_1 = require("../config/config");
 class BaseEventTransformer {
     constructor(deviceType, rawData) {
         this.deviceType = deviceType;

package/dist/events/DeviceEventHandler.d.ts

@@ -1,4 +1,4 @@
-import { IDevice } from "src/device/local/interfaces";
+import { IDevice } from "../device/local/interfaces";
 import { BaseEventHandler } from "./BaseEventHandler";
 import { DeviceEvent, DeviceEventEntity, EventConstructionOptions } from "./interfaces/DeviceEvent";
 export declare class DeviceEventHandler extends BaseEventHandler {

package/dist/events/DeviceEventHandler.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceEventHandler = void 0;
-const Event_1 = require("src/constants/Event");
-const services_1 = require("src/device/local/services");
+const constants_1 = require("../constants");
+const Event_1 = require("../constants/Event");
+const services_1 = require("../device/local/services");
 const BaseEventHandler_1 = require("./BaseEventHandler");
 class DeviceEventHandler extends BaseEventHandler_1.BaseEventHandler {
     constructor() {
@@ -57,7 +58,7 @@ class DeviceEventHandler extends BaseEventHandler_1.BaseEventHandler {
                 });
                 break;
             case Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED:
-                await this.localDeviceService.setBatteryLevel(deviceData.deviceId, event?.data?.batteryLevel ?? 0);
+                await this.localDeviceService.setBatteryLevel(deviceData.deviceId, event?.data?.batteryLevel ?? 0, constants_1.Source.CLOUD_EVENT);
                 break;
         }
     }

package/dist/events/EventHandler.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventHandler = void 0;
 const dt_pub_sub_1 = require("dt-pub-sub");
 const dt_audit_library_1 = require("dt-audit-library");
-const Event_1 = require("src/constants/Event");
+const Event_1 = require("../constants/Event");
 class EventHandler {
     constructor() {
         this.source = "dt-common-device";

package/dist/events/EventHandlerOrchestrator.js

@@ -40,7 +40,7 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventHandlerOrchestrator = void 0;
 const typedi_1 = require("typedi");
-const config_1 = require("src/config/config");
+const config_1 = require("../config/config");
 let EventHandlerOrchestrator = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;

package/dist/events/EventProcessingService.js

@@ -41,7 +41,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventProcessingService = void 0;
 const typedi_1 = require("typedi");
 const DeviceEventHandler_1 = require("./DeviceEventHandler");
-const config_1 = require("src/config/config");
+const config_1 = require("../config/config");
 const EventHandlerOrchestrator_1 = require("./EventHandlerOrchestrator");
 let EventProcessingService = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];

package/dist/events/InternalEventSubscription.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalEventSubscription = exports.InternalEventType = void 0;
 const dt_pub_sub_1 = require("dt-pub-sub");
-const config_1 = require("src/config/config");
+const config_1 = require("../config/config");
 // Event types enum for better type safety
 var InternalEventType;
 (function (InternalEventType) {

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./constants";
 export { CloudDevice, CloudDeviceService, DeviceFactory, } from "./device/cloud/entities";
 export { LocalDeviceService, LocalHubService, LocalScheduleService, } from "./device/local/services";
 export * from "./device/local/interfaces";

package/dist/index.js

@@ -16,6 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shutdown = exports.getConfig = exports.initialize = exports.LocalScheduleService = exports.LocalHubService = exports.LocalDeviceService = exports.DeviceFactory = exports.CloudDeviceService = exports.CloudDevice = void 0;
+// CONSTANTS EXPORTS
+__exportStar(require("./constants"), exports);
 // DEVICE EXPORTS
 var entities_1 = require("./device/cloud/entities");
 Object.defineProperty(exports, "CloudDevice", { enumerable: true, get: function () { return entities_1.CloudDevice; } });

package/dist/issues/Issue.service.d.ts

@@ -2,6 +2,8 @@ import { IssueRepository } from "./Issue.repository";
 import { IIssueDocument } from "./Issue.model";
 import { CreateIssueData, UpdateIssueData, AddCommentData, IssueStatus, IssuePriority, IssuesCategory, EntityType } from "./issue.types";
 import { IssueBuilder } from "./IssueBuilder";
+import { Source } from "../constants/Service";
+import { IDevice } from "../device/local/interfaces";
 export declare class IssueService {
     private readonly issueRepository;
     constructor(issueRepository: IssueRepository);
@@ -24,7 +26,7 @@ export declare class IssueService {
     /**
      * Create a device-specific issue using IssueBuilder
      */
-    createDeviceIssue(deviceId: string, propertyId: string, title: string, description: string, createdBy: string, category?: IssuesCategory, priority?: IssuePriority, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    createDeviceIssue(deviceId: string, propertyId: string, title: string, description: string, source: Source, category?: IssuesCategory, priority?: IssuePriority, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
     /**
      * Create a hub-specific issue using IssueBuilder
      */
@@ -33,6 +35,14 @@ export declare class IssueService {
      * Create a user-specific issue using IssueBuilder
      */
     createUserIssue(userId: string, propertyId: string, title: string, description: string, createdBy: string, category?: IssuesCategory, priority?: IssuePriority, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    /**
+     * Create issue for device going offline longer than baseline
+     */
+    createDeviceOfflineIssue(device: IDevice, source: Source, reason?: string): Promise<IIssueDocument>;
+    /**
+     * Create issue for device battery level below threshold
+     */
+    createDeviceBatteryIssue(device: IDevice, batteryLevel: number, threshold: number, source: Source): Promise<IIssueDocument>;
     /**
      * Create a maintenance issue using IssueBuilder
      */

package/dist/issues/Issue.service.js

@@ -131,11 +131,11 @@ let IssueService = (() => {
         /**
          * Create a device-specific issue using IssueBuilder
          */
-        async createDeviceIssue(deviceId, propertyId, title, description, createdBy, category, priority, assignedTo, dueDate) {
+        async createDeviceIssue(deviceId, propertyId, title, description, source, category, priority, assignedTo, dueDate) {
             const issueBuilder = IssueBuilder_1.IssueBuilder.createDeviceIssue(deviceId, propertyId)
                 .setTitle(title)
                 .setDescription(description)
-                .setCreatedBy(createdBy);
+                .setCreatedBy(source);
             if (category)
                 issueBuilder.setCategory(category);
             if (priority)
@@ -182,6 +182,18 @@ let IssueService = (() => {
                 issueBuilder.setDueDate(dueDate);
             return await this.createIssue(issueBuilder);
         }
+        /**
+         * Create issue for device going offline longer than baseline
+         */
+        async createDeviceOfflineIssue(device, source, reason) {
+            return await this.createDeviceIssue(device.deviceId, device.propertyId, "Device Offline - Requires Attention", `Device ${device.name} (${device.deviceId}) has been offline for longer than the baseline time. ${reason ? `Reason: ${reason}` : ""} This requires immediate attention to restore device functionality.`, source, issue_types_1.IssuesCategory.OPERATIONS, issue_types_1.IssuePriority.HIGH);
+        }
+        /**
+         * Create issue for device battery level below threshold
+         */
+        async createDeviceBatteryIssue(device, batteryLevel, threshold, source) {
+            return await this.createDeviceIssue(device.deviceId, device.propertyId, "Device Battery Low - Requires Attention", `Device ${device.name} (${device.deviceId}) battery level is ${batteryLevel}%, which is below the property threshold of ${threshold}%. This requires immediate attention to replace or charge the device battery.`, source, issue_types_1.IssuesCategory.ENERGY, issue_types_1.IssuePriority.MEDIUM);
+        }
         /**
          * Create a maintenance issue using IssueBuilder
          */
@@ -230,7 +242,8 @@ let IssueService = (() => {
                 processedIssueData.priority = this.determineDefaultPriority(processedIssueData.category);
             }
             // Business logic: Validate due date is in the future
-            if (processedIssueData.dueDate && processedIssueData.dueDate <= new Date()) {
+            if (processedIssueData.dueDate &&
+                processedIssueData.dueDate <= new Date()) {
                 throw new Error("Due date must be in the future");
             }
             return await this.issueRepository.create(processedIssueData);

package/dist/issues/IssueService.example.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IssueServiceExample = void 0;
+const constants_1 = require("../constants");
 const IssueBuilder_1 = require("./IssueBuilder");
 const issue_types_1 = require("./issue.types");
 /**
@@ -49,11 +50,11 @@ class IssueServiceExample {
      */
     async createDeviceIssues() {
         // Create a device issue with default category and priority
-        const deviceIssue1 = await this.issueService.createDeviceIssue("device123", "prop456", "Device Battery Low", "Device battery level is below 20%", "system", undefined, // Use default category
+        const deviceIssue1 = await this.issueService.createDeviceIssue("device123", "prop456", "Device Battery Low", "Device battery level is below 20%", constants_1.Source.CLOUD_EVENT, undefined, // Use default category
         undefined, // Use default priority
         "maintenance-team", new Date("2024-01-12"));
         // Create a device issue with custom category and priority
-        const deviceIssue2 = await this.issueService.createDeviceIssue("device789", "prop456", "Device Firmware Update Available", "New firmware version is available for installation", "firmware-manager", issue_types_1.IssuesCategory.READINESS, issue_types_1.IssuePriority.MEDIUM, "admin", new Date("2024-01-20"));
+        const deviceIssue2 = await this.issueService.createDeviceIssue("device789", "prop456", "Device Firmware Update Available", "New firmware version is available for installation", constants_1.Source.CLOUD_EVENT, issue_types_1.IssuesCategory.READINESS, issue_types_1.IssuePriority.MEDIUM, "admin", new Date("2024-01-20"));
         return { deviceIssue1, deviceIssue2 };
     }
     /**
@@ -168,6 +169,7 @@ class IssueServiceExample {
             assignedTo: "tech-support",
             createdBy: "legacy-system",
             dueDate: new Date("2024-01-20"),
+            source: constants_1.Source.CLOUD_EVENT,
         };
         // This still works with the updated createIssue method
         const issue = await this.issueService.createIssue(issueData);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-common-device",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/alerts/Alert.model.ts

@@ -47,9 +47,15 @@ interface IAlertModel extends Model<IAlertDocument, {}, IAlertMethods> {
 const AlertSchema = new Schema<IAlertDocument, IAlertModel, IAlertMethods>(
   {
     category: {
-      type: String,
+      type: [String],
       enum: Object.values(AlertCategory),
       required: true,
+      validate: {
+        validator: function (categories: string[]) {
+          return categories && categories.length > 0;
+        },
+        message: "At least one category is required",
+      },
     },
     propertyId: {
       type: String,
@@ -198,7 +204,7 @@ AlertSchema.statics.findByCategory = function (
   category: AlertCategory,
   includeDeleted = false
 ) {
-  const query: any = { category };
+  const query: any = { category: { $in: [category] } };
   if (!includeDeleted) {
     query.isDeleted = false;
   }

package/src/alerts/Alert.repository.ts

@@ -61,7 +61,7 @@ export class AlertRepository {
   async findAll(
     filters: {
       propertyId?: string;
-      category?: AlertCategory;
+      category?: AlertCategory | AlertCategory[];
       severity?: AlertSeverity;
       entityType?: EntityType;
       entityId?: string;
@@ -77,7 +77,13 @@ export class AlertRepository {
       const query: any = {};
 
       if (filters.propertyId) query.propertyId = filters.propertyId;
-      if (filters.category) query.category = filters.category;
+      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;
@@ -170,7 +176,7 @@ export class AlertRepository {
   async count(
     filters: {
       propertyId?: string;
-      category?: AlertCategory;
+      category?: AlertCategory | AlertCategory[];
       severity?: AlertSeverity;
       entityType?: EntityType;
       entityId?: string;
@@ -183,7 +189,13 @@ export class AlertRepository {
       const query: any = {};
 
       if (filters.propertyId) query.propertyId = filters.propertyId;
-      if (filters.category) query.category = filters.category;
+      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;
@@ -246,11 +258,20 @@ export class AlertRepository {
    * Find alerts by category
    */
   async findByCategory(
-    category: AlertCategory,
+    category: AlertCategory | AlertCategory[],
     includeDeleted = false
   ): Promise<IAlertDocument[]> {
     try {
-      return await AlertModel.findByCategory(category, includeDeleted);
+      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: ${
@@ -368,6 +389,7 @@ export class AlertRepository {
           ]),
           AlertModel.aggregate([
             { $match: query },
+            { $unwind: "$category" },
             { $group: { _id: "$category", count: { $sum: 1 } } },
           ]),
         ]);