dt-common-device 6.2.0 → 7.0.0

package/dist/alerts/Alert.model.js

@@ -39,21 +39,20 @@ const alert_types_1 = require("./alert.types");
 // Main Alert schema
 const AlertSchema = new mongoose_1.Schema({
     category: {
-        type: [String],
+        type: String,
         enum: Object.values(alert_types_1.AlertCategory),
         required: true,
-        validate: {
-            validator: function (categories) {
-                return categories && categories.length > 0;
-            },
-            message: "At least one category is required",
-        },
     },
     propertyId: {
         type: String,
         required: true,
         index: true,
     },
+    zoneId: {
+        type: String,
+        required: true,
+        index: true,
+    },
     title: {
         type: String,
         required: true,
@@ -102,6 +101,7 @@ const AlertSchema = new mongoose_1.Schema({
     },
     updatedBy: {
         type: String,
+        index: true,
     },
     createdAt: {
         type: Date,
@@ -114,10 +114,14 @@ const AlertSchema = new mongoose_1.Schema({
 }, {
     timestamps: true,
     collection: "dt_alerts",
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true },
+    id: false, // Disable the virtual id field since we're handling it manually
 });
 exports.AlertSchema = AlertSchema;
 // Compound indexes to match Prisma schema
 AlertSchema.index({ propertyId: 1, isActive: 1, isRead: 1 });
+AlertSchema.index({ zoneId: 1, category: 1 });
 AlertSchema.index({ entityId: 1, entityType: 1 });
 AlertSchema.index({ createdAt: 1 });
 // Pre-save middleware to update the updatedAt field
@@ -157,7 +161,7 @@ AlertSchema.methods.unsnooze = function (updatedBy) {
 };
 // Static methods
 AlertSchema.statics.findByCategory = function (category, includeDeleted = false) {
-    const query = { category: { $in: [category] } };
+    const query = { category: category };
     if (!includeDeleted) {
         query.isDeleted = false;
     }
@@ -187,8 +191,57 @@ AlertSchema.virtual("isSnoozed").get(function () {
 AlertSchema.virtual("isSnoozeExpired").get(function () {
     return this.snoozeUntil && this.snoozeUntil <= new Date();
 });
-// Ensure virtuals are serialized
-AlertSchema.set("toJSON", { virtuals: true });
-AlertSchema.set("toObject", { virtuals: true });
+// Virtual for soft delete status (different name to avoid conflict)
+AlertSchema.virtual("isNotDeleted").get(function () {
+    return !this.isDeleted;
+});
+// Post middleware to transform all find results to plain objects
+AlertSchema.post(/^find/, function (result) {
+    if (!result)
+        return;
+    // Handle array results (find)
+    if (Array.isArray(result)) {
+        result.forEach((doc) => {
+            if (doc && typeof doc.toObject === "function") {
+                const plainDoc = doc.toObject();
+                // Transform _id to id and remove __v
+                plainDoc.id = plainDoc._id ? plainDoc._id.toString() : plainDoc._id;
+                delete plainDoc._id;
+                delete plainDoc.__v;
+                // Replace the document with plain object
+                Object.assign(doc, plainDoc);
+            }
+        });
+    }
+    // Handle single document results (findOne, findById, etc.)
+    else if (result && typeof result.toObject === "function") {
+        const plainDoc = result.toObject();
+        // Transform _id to id and remove __v
+        plainDoc.id = plainDoc._id ? plainDoc._id.toString() : plainDoc._id;
+        delete plainDoc._id;
+        delete plainDoc.__v;
+        // Replace the document with plain object
+        Object.assign(result, plainDoc);
+    }
+});
+// Ensure virtuals are serialized and transform to plain objects
+AlertSchema.set("toJSON", {
+    virtuals: true,
+    transform: function (doc, ret) {
+        ret.id = ret._id ? ret._id.toString() : ret._id;
+        delete ret._id;
+        delete ret.__v;
+        return ret;
+    },
+});
+AlertSchema.set("toObject", {
+    virtuals: true,
+    transform: function (doc, ret) {
+        ret.id = ret._id ? ret._id.toString() : ret._id;
+        delete ret._id;
+        delete ret.__v;
+        return ret;
+    },
+});
 // Create and export the model
 exports.AlertModel = mongoose_1.default.model("Alert", AlertSchema);

package/dist/alerts/Alert.repository.d.ts

@@ -33,7 +33,7 @@ export declare class AlertRepository {
     /**
      * Find alerts by category
      */
-    findByCategory(category: AlertCategory | AlertCategory[], includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findByCategory(category: AlertCategory, includeDeleted?: boolean): Promise<IAlertDocument[]>;
     /**
      * Find snoozed alerts
      */
@@ -45,7 +45,7 @@ export declare class AlertRepository {
     /**
      * Get alert statistics
      */
-    getStatistics(propertyId?: string): Promise<{
+    getStatistics(propertyId?: string, zoneId?: string): Promise<{
         total: number;
         active: number;
         unread: number;
@@ -61,4 +61,38 @@ export declare class AlertRepository {
      * Bulk soft delete alerts
      */
     bulkSoftDelete(ids: string[], deletedBy: string): Promise<number>;
+    /**
+     * Find alerts by zone ID
+     */
+    findByZoneId(zoneId: string, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find alerts by zone ID and category
+     */
+    findByZoneIdAndCategory(zoneId: string, category: AlertCategory, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find alerts by zone ID and severity
+     */
+    findByZoneIdAndSeverity(zoneId: string, severity: AlertSeverity, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find alerts by zone ID and active status
+     */
+    findByZoneIdAndActiveStatus(zoneId: string, isActive: boolean, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find alerts by zone ID and read status
+     */
+    findByZoneIdAndReadStatus(zoneId: string, isRead: boolean, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find alerts by multiple zone IDs
+     */
+    findByZoneIds(zoneIds: string[], includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Get alert statistics by zone ID and severity
+     */
+    getStatisticsByZoneAndSeverity(zoneId: string, severity?: AlertSeverity): Promise<{
+        total: number;
+        active: number;
+        unread: number;
+        snoozed: number;
+        byCategory: Record<AlertCategory, number>;
+    }>;
 }

package/dist/alerts/Alert.repository.js

@@ -52,14 +52,10 @@ let AlertRepository = (() => {
             const query = {};
             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.zoneId)
+                query.zoneId = filters.zoneId;
+            if (filters.category)
+                query.category = filters.category;
             if (filters.severity)
                 query.severity = filters.severity;
             if (filters.entityType)
@@ -86,7 +82,8 @@ let AlertRepository = (() => {
                     isActive: true,
                     isDeleted: false,
                 });
-                return await alert.save();
+                const savedAlert = await alert.save();
+                return savedAlert.toObject();
             }
             catch (error) {
                 throw new Error(`Failed to create alert: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -101,7 +98,8 @@ let AlertRepository = (() => {
                 if (!includeDeleted) {
                     query.isDeleted = false;
                 }
-                return await Alert_model_1.AlertModel.findOne(query);
+                const result = await Alert_model_1.AlertModel.findOne(query);
+                return result ? result.toObject() : null;
             }
             catch (error) {
                 throw new Error(`Failed to find alert by ID: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -124,7 +122,8 @@ let AlertRepository = (() => {
                     queryBuilder.skip(filters.skip);
                 if (filters.limit)
                     queryBuilder.limit(filters.limit);
-                return await queryBuilder.exec();
+                const results = await queryBuilder.exec();
+                return results.map((result) => result.toObject());
             }
             catch (error) {
                 throw new Error(`Failed to find alerts: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -135,7 +134,8 @@ let AlertRepository = (() => {
          */
         async update(id, updateData) {
             try {
-                return await Alert_model_1.AlertModel.findByIdAndUpdate(id, { ...updateData, updatedAt: new Date() }, { new: true, runValidators: true });
+                const result = await Alert_model_1.AlertModel.findByIdAndUpdate(id, { ...updateData, updatedAt: new Date() }, { new: true, runValidators: true });
+                return result ? result.toObject() : null;
             }
             catch (error) {
                 throw new Error(`Failed to update alert: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -186,17 +186,7 @@ let AlertRepository = (() => {
          */
         async findByCategory(category, includeDeleted = false) {
             try {
-                if (Array.isArray(category)) {
-                    // Use $in operator for array of categories
-                    const query = { category: { $in: category } };
-                    if (!includeDeleted) {
-                        query.isDeleted = false;
-                    }
-                    return await Alert_model_1.AlertModel.find(query).sort({ createdAt: -1 });
-                }
-                else {
-                    return await Alert_model_1.AlertModel.findByCategory(category, includeDeleted);
-                }
+                return await Alert_model_1.AlertModel.findByCategory(category, includeDeleted);
             }
             catch (error) {
                 throw new Error(`Failed to find alerts by category: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -227,11 +217,13 @@ let AlertRepository = (() => {
         /**
          * Get alert statistics
          */
-        async getStatistics(propertyId) {
+        async getStatistics(propertyId, zoneId) {
             try {
                 const query = { isDeleted: false };
                 if (propertyId)
                     query.propertyId = propertyId;
+                if (zoneId)
+                    query.zoneId = zoneId;
                 const [total, active, unread, snoozed, severityStats, categoryStats] = await Promise.all([
                     Alert_model_1.AlertModel.countDocuments(query),
                     Alert_model_1.AlertModel.countDocuments({ ...query, isActive: true }),
@@ -246,7 +238,6 @@ let AlertRepository = (() => {
                     ]),
                     Alert_model_1.AlertModel.aggregate([
                         { $match: query },
-                        { $unwind: "$category" },
                         { $group: { _id: "$category", count: { $sum: 1 } } },
                     ]),
                 ]);
@@ -310,6 +301,147 @@ let AlertRepository = (() => {
                 throw new Error(`Failed to bulk soft delete alerts: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
+        /**
+         * Find alerts by zone ID
+         */
+        async findByZoneId(zoneId, includeDeleted = false) {
+            try {
+                const query = { zoneId };
+                if (!includeDeleted) {
+                    query.isDeleted = false;
+                }
+                const results = await Alert_model_1.AlertModel.find(query).sort({ createdAt: -1 });
+                return results.map((result) => result.toObject());
+            }
+            catch (error) {
+                throw new Error(`Failed to find alerts by zone ID: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        }
+        /**
+         * Find alerts by zone ID and category
+         */
+        async findByZoneIdAndCategory(zoneId, category, includeDeleted = false) {
+            try {
+                const query = { zoneId, category };
+                if (!includeDeleted) {
+                    query.isDeleted = false;
+                }
+                const results = await Alert_model_1.AlertModel.find(query).sort({ createdAt: -1 });
+                return results.map((result) => result.toObject());
+            }
+            catch (error) {
+                throw new Error(`Failed to find alerts by zone ID and category: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        }
+        /**
+         * Find alerts by zone ID and severity
+         */
+        async findByZoneIdAndSeverity(zoneId, severity, includeDeleted = false) {
+            try {
+                const query = { zoneId, severity };
+                if (!includeDeleted) {
+                    query.isDeleted = false;
+                }
+                const results = await Alert_model_1.AlertModel.find(query).sort({ createdAt: -1 });
+                return results.map((result) => result.toObject());
+            }
+            catch (error) {
+                throw new Error(`Failed to find alerts by zone ID and severity: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        }
+        /**
+         * Find alerts by zone ID and active status
+         */
+        async findByZoneIdAndActiveStatus(zoneId, isActive, includeDeleted = false) {
+            try {
+                const query = { zoneId, isActive };
+                if (!includeDeleted) {
+                    query.isDeleted = false;
+                }
+                const results = await Alert_model_1.AlertModel.find(query).sort({ createdAt: -1 });
+                return results.map((result) => result.toObject());
+            }
+            catch (error) {
+                throw new Error(`Failed to find alerts by zone ID and active status: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        }
+        /**
+         * Find alerts by zone ID and read status
+         */
+        async findByZoneIdAndReadStatus(zoneId, isRead, includeDeleted = false) {
+            try {
+                const query = { zoneId, isRead };
+                if (!includeDeleted) {
+                    query.isDeleted = false;
+                }
+                const results = await Alert_model_1.AlertModel.find(query).sort({ createdAt: -1 });
+                return results.map((result) => result.toObject());
+            }
+            catch (error) {
+                throw new Error(`Failed to find alerts by zone ID and read status: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        }
+        /**
+         * Find alerts by multiple zone IDs
+         */
+        async findByZoneIds(zoneIds, includeDeleted = false) {
+            try {
+                if (!zoneIds || zoneIds.length === 0) {
+                    throw new Error("Zone IDs array is required and cannot be empty");
+                }
+                const query = { zoneId: { $in: zoneIds } };
+                if (!includeDeleted) {
+                    query.isDeleted = false;
+                }
+                const results = await Alert_model_1.AlertModel.find(query).sort({ createdAt: -1 });
+                return results.map((result) => result.toObject());
+            }
+            catch (error) {
+                throw new Error(`Failed to find alerts by zone IDs: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        }
+        /**
+         * Get alert statistics by zone ID and severity
+         */
+        async getStatisticsByZoneAndSeverity(zoneId, severity) {
+            try {
+                const query = { isDeleted: false, zoneId };
+                if (severity)
+                    query.severity = severity;
+                const [total, active, unread, snoozed, categoryStats] = await Promise.all([
+                    Alert_model_1.AlertModel.countDocuments(query),
+                    Alert_model_1.AlertModel.countDocuments({ ...query, isActive: true }),
+                    Alert_model_1.AlertModel.countDocuments({ ...query, isRead: false }),
+                    Alert_model_1.AlertModel.countDocuments({
+                        ...query,
+                        snoozeUntil: { $exists: true, $ne: null },
+                    }),
+                    Alert_model_1.AlertModel.aggregate([
+                        { $match: query },
+                        { $group: { _id: "$category", count: { $sum: 1 } } },
+                    ]),
+                ]);
+                const byCategory = Object.values(alert_types_1.AlertCategory).reduce((acc, category) => {
+                    acc[category] = 0;
+                    return acc;
+                }, {});
+                categoryStats.forEach((stat) => {
+                    if (stat._id in byCategory) {
+                        byCategory[stat._id] = stat.count;
+                    }
+                });
+                return {
+                    total,
+                    active,
+                    unread,
+                    snoozed,
+                    byCategory,
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to get alert statistics by zone and severity: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        }
     };
     __setFunctionName(_classThis, "AlertRepository");
     (() => {

package/dist/alerts/Alert.service.d.ts

@@ -9,27 +9,27 @@ export declare class AlertService {
     /**
      * Create a readiness alert using AlertBuilder
      */
-    raiseReadinessAlert(propertyId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
+    raiseReadinessAlert(propertyId: string, zoneId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
     /**
      * Create an operations alert using AlertBuilder
      */
-    raiseOperationsAlert(propertyId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
+    raiseOperationsAlert(propertyId: string, zoneId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
     /**
      * Create a security alert using AlertBuilder
      */
-    raiseSecurityAlert(propertyId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
+    raiseSecurityAlert(propertyId: string, zoneId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
     /**
      * Create an energy alert using AlertBuilder
      */
-    raiseEnergyAlert(propertyId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
+    raiseEnergyAlert(propertyId: string, zoneId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
     /**
      * Create a device-specific alert using AlertBuilder
      */
-    raiseDeviceAlert(deviceId: string, propertyId: string, title: string, description: string, category?: AlertCategory | AlertCategory[], severity?: AlertSeverity, source?: Source): Promise<IAlertDocument>;
+    raiseDeviceAlert(deviceId: string, propertyId: string, zoneId: string, title: string, description: string, category?: AlertCategory, severity?: AlertSeverity, source?: Source): Promise<IAlertDocument>;
     /**
      * Create a hub-specific alert using AlertBuilder
      */
-    raiseHubAlert(hubId: string, propertyId: string, title: string, description: string, category?: AlertCategory | AlertCategory[], severity?: AlertSeverity, createdBy?: string): Promise<IAlertDocument>;
+    raiseHubAlert(hubId: string, propertyId: string, zoneId: string, title: string, description: string, category?: AlertCategory, severity?: AlertSeverity, createdBy?: string): Promise<IAlertDocument>;
     /**
      * Raise alert for device going offline (OPERATIONAL only)
      */
@@ -94,7 +94,7 @@ export declare class AlertService {
     /**
      * Get alerts by category with business logic
      */
-    getAlertsByCategory(category: AlertCategory | AlertCategory[], includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    getAlertsByCategory(category: AlertCategory, includeDeleted?: boolean): Promise<IAlertDocument[]>;
     /**
      * Get snoozed alerts with business logic
      */
@@ -106,7 +106,7 @@ export declare class AlertService {
     /**
      * Get alert statistics with business logic
      */
-    getAlertStatistics(propertyId?: string): Promise<{
+    getAlertStatistics(propertyId?: string, zoneId?: string): Promise<{
         total: number;
         active: number;
         unread: number;
@@ -114,6 +114,40 @@ export declare class AlertService {
         bySeverity: Record<AlertSeverity, number>;
         byCategory: Record<AlertCategory, number>;
     }>;
+    /**
+     * Get alerts by zone ID
+     */
+    getAlertsByZoneId(zoneId: string, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Get alerts by zone ID and category
+     */
+    getAlertsByZoneIdAndCategory(zoneId: string, category: AlertCategory, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Get alerts by zone ID and severity
+     */
+    getAlertsByZoneIdAndSeverity(zoneId: string, severity: AlertSeverity, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Get alerts by multiple zone IDs
+     */
+    getAlertsByZoneIds(zoneIds: string[], includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Get alert statistics by zone ID and severity
+     */
+    getAlertStatisticsByZoneAndSeverity(zoneId: string, severity?: AlertSeverity): Promise<{
+        total: number;
+        active: number;
+        unread: number;
+        snoozed: number;
+        byCategory: Record<AlertCategory, number>;
+    }>;
+    /**
+     * Get alerts by zone ID and active status
+     */
+    getAlertsByZoneIdAndActiveStatus(zoneId: string, isActive: boolean, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Get alerts by zone ID and read status
+     */
+    getAlertsByZoneIdAndReadStatus(zoneId: string, isRead: boolean, includeDeleted?: boolean): Promise<IAlertDocument[]>;
     private validateAlertData;
     private validateFilters;
     private validateUpdateData;