dt-common-device 7.10.9 → 7.10.11

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

@@ -25,13 +25,10 @@ export declare class AlertService {
         startDate: string;
         endDate: string;
     }): Promise<IAlertDocument | null>;
-    raiseNewDeviceAlert(device: {
-        deviceId: string;
-        deviceType: string;
-        name: string;
-    }, connection: {
+    raiseNewDeviceAlert(connection: {
         id: string;
         provider: string;
+        deviceCount: number;
         type?: string;
     }, propertyId: string, source: Source): Promise<IAlertDocument | null>;
     raiseDoorOpenFrequentAlert(device: IDevice, zone: any, accessTimes: number, openThreshold: number, source: Source): Promise<IAlertDocument | null>;
@@ -65,6 +62,7 @@ export declare class AlertService {
      * Update an alert with business logic validation
      */
     updateAlert(id: string, updateData: UpdateAlertData): Promise<IAlertDocument | null>;
+    deleteAlerts(filters: IAlertQuery, deletedBy: string, softDelete?: boolean): Promise<boolean>;
     /**
      * Soft delete an alert with business logic
      */

package/dist/alerts/Alert.service.js

@@ -95,7 +95,6 @@ let AlertService = (() => {
         async raiseOperationsAlert(data) {
             const alertBuilder = AlertBuilder_1.AlertBuilder.createOperationsAlert()
                 .setPropertyId(data.propertyId)
-                .setZoneId(data.zoneId || "")
                 .setTitle(data.title)
                 .setDescription(data.description);
             if (data.entityId)
@@ -106,6 +105,8 @@ let AlertService = (() => {
                 alertBuilder.setEntitySubType(data.entitySubType);
             if (data.createdBy)
                 alertBuilder.setCreatedBy(data.createdBy);
+            if (data.zoneId)
+                alertBuilder.setZoneId(data.zoneId);
             return await this.createAlert(alertBuilder);
         }
         /**
@@ -114,7 +115,6 @@ let AlertService = (() => {
         async raiseSecurityAlert(data) {
             const alertBuilder = AlertBuilder_1.AlertBuilder.createSecurityAlert()
                 .setPropertyId(data.propertyId)
-                .setZoneId(data.zoneId || "")
                 .setTitle(data.title)
                 .setDescription(data.description);
             if (data.entityId)
@@ -125,10 +125,12 @@ let AlertService = (() => {
                 alertBuilder.setEntitySubType(data.entitySubType);
             if (data.createdBy)
                 alertBuilder.setCreatedBy(data.createdBy);
+            if (data.zoneId)
+                alertBuilder.setZoneId(data.zoneId);
             return await this.createAlert(alertBuilder);
         }
         async raiseDeviceAlert(data) {
-            const alertBuilder = AlertBuilder_1.AlertBuilder.createDeviceAlert(data.entityId || "", data.propertyId, data.zoneId || "")
+            const alertBuilder = AlertBuilder_1.AlertBuilder.createDeviceAlert(data.entityId || "", data.propertyId)
                 .setTitle(data.title)
                 .setDescription(data.description);
             if (data.category)
@@ -141,13 +143,15 @@ let AlertService = (() => {
                 alertBuilder.setCreatedBy(data.createdBy);
             if (data.entitySubType)
                 alertBuilder.setEntitySubType(data.entitySubType);
+            if (data.zoneId)
+                alertBuilder.setZoneId(data.zoneId);
             return await this.createAlert(alertBuilder);
         }
         /**
          * Create a hub-specific alert using AlertBuilder
          */
         async raiseHubAlert(data) {
-            const alertBuilder = AlertBuilder_1.AlertBuilder.createHubAlert(data.entityId || "", data.propertyId, data.zoneId || "")
+            const alertBuilder = AlertBuilder_1.AlertBuilder.createHubAlert(data.entityId || "", data.propertyId)
                 .setTitle(data.title)
                 .setDescription(data.description);
             if (data.category)
@@ -160,6 +164,8 @@ let AlertService = (() => {
                 alertBuilder.setCreatedBy(data.createdBy);
             if (data.entitySubType)
                 alertBuilder.setEntitySubType(data.entitySubType);
+            if (data.zoneId)
+                alertBuilder.setZoneId(data.zoneId);
             return await this.createAlert(alertBuilder);
         }
         async raiseDeviceTamperAttemptAlert(device, zone, source) {
@@ -207,14 +213,14 @@ let AlertService = (() => {
                 type: alert_types_1.AlertType.INCORRECT_CODE_USED,
             });
         }
-        async raiseNewDeviceAlert(device, connection, propertyId, source) {
+        async raiseNewDeviceAlert(connection, propertyId, source) {
             return await this.createAlert({
                 entityId: connection.id,
                 entityType: alert_types_1.EntityType.CLOUD_DEVICE_ACCOUNT,
                 entitySubType: connection.provider,
                 propertyId: propertyId,
                 title: "New Device Detected",
-                description: `New device ${device.name} has been detected on the ${connection.provider} account.`,
+                description: `${connection.deviceCount} new device(s), have been detected on the ${connection.provider} account.`,
                 createdBy: source,
                 category: alert_types_1.AlertCategory.OPERATIONS,
                 severity: alert_types_1.AlertSeverity.INFO,
@@ -506,6 +512,31 @@ let AlertService = (() => {
             }
             return await this.alertRepository.update(id, updateData);
         }
+        async deleteAlerts(filters, deletedBy, softDelete = true) {
+            try {
+                if (!filters || Object.keys(filters).length === 0) {
+                    throw new Error("Filters are required");
+                }
+                if (!deletedBy) {
+                    throw new Error("Deleted by user is required");
+                }
+                const alerts = await this.queryAlerts(filters);
+                if (softDelete) {
+                    for (const alert of alerts) {
+                        await this.alertRepository.softDelete(alert.id || alert._id, deletedBy);
+                    }
+                }
+                else {
+                    for (const alert of alerts) {
+                        await this.alertRepository.hardDelete(alert.id || alert._id);
+                    }
+                }
+                return true;
+            }
+            catch (error) {
+                throw new Error(`Failed to delete alerts: ${error instanceof Error ? error.message : error}`);
+            }
+        }
         /**
          * Soft delete an alert with business logic
          */
@@ -743,9 +774,6 @@ let AlertService = (() => {
             if (!data.propertyId) {
                 throw new Error("Property ID is required");
             }
-            if (!data.zoneId) {
-                throw new Error("Zone ID is required");
-            }
             if (!data.entityType) {
                 throw new Error("Entity type is required");
             }

package/dist/alerts/AlertBuilder.d.ts

@@ -88,9 +88,9 @@ export declare class AlertBuilder {
     /**
      * Creates a device-specific alert builder
      */
-    static createDeviceAlert(deviceId: string, propertyId: string, zoneId: string): AlertBuilder;
+    static createDeviceAlert(deviceId: string, propertyId: string): AlertBuilder;
     /**
      * Creates a hub-specific alert builder
      */
-    static createHubAlert(hubId: string, propertyId: string, zoneId: string): AlertBuilder;
+    static createHubAlert(hubId: string, propertyId: string): AlertBuilder;
 }

package/dist/alerts/AlertBuilder.js

@@ -187,22 +187,20 @@ class AlertBuilder {
     /**
      * Creates a device-specific alert builder
      */
-    static createDeviceAlert(deviceId, propertyId, zoneId) {
+    static createDeviceAlert(deviceId, propertyId) {
         return new AlertBuilder()
             .setEntityType(alert_types_1.EntityType.DEVICE)
             .setEntityId(deviceId)
-            .setPropertyId(propertyId)
-            .setZoneId(zoneId);
+            .setPropertyId(propertyId);
     }
     /**
      * Creates a hub-specific alert builder
      */
-    static createHubAlert(hubId, propertyId, zoneId) {
+    static createHubAlert(hubId, propertyId) {
         return new AlertBuilder()
             .setEntityType(alert_types_1.EntityType.HUB)
             .setEntityId(hubId)
-            .setPropertyId(propertyId)
-            .setZoneId(zoneId);
+            .setPropertyId(propertyId);
     }
 }
 exports.AlertBuilder = AlertBuilder;

package/dist/alerts/alert.types.d.ts

@@ -29,6 +29,7 @@ export declare enum AlertType {
 }
 export interface AlertDocument {
     _id: string;
+    id: string;
     category: AlertCategory;
     propertyId: string;
     zoneId?: string;

package/dist/constants/Event.d.ts

@@ -239,6 +239,25 @@ export declare const DT_EVENT_TYPES: {
     HEARTBEAT: {
         DISABLED: string;
         STARTED: string;
+        DEVICE: {
+            IN_ACTIVE: string;
+            OFFLINE: string;
+            OFFLINE_HUB: string;
+            FURTHER_CHECKS_SKIPPED: string;
+        };
+        HUB: {
+            IN_ACTIVE: string;
+            OFFLINE: string;
+        };
+        LOCK: {
+            LOCAL_CODES_EXCLUDING_SET: string;
+            CLOUD_CODES: string;
+            MISSING_CODES: string;
+            ADDITIONAL_CODES: string;
+            SCHEDULE_CODES: string;
+            MARKED_TO_DELETE_CODES: string;
+            UNSET_CODES: string;
+        };
         STOPPED: string;
         COMPLETED: string;
         FAILED: string;

package/dist/constants/Event.js

@@ -240,19 +240,38 @@ exports.DT_EVENT_TYPES = {
         },
     },
     HEARTBEAT: {
-        DISABLED: 'heartbeat.disabled',
-        STARTED: 'heartbeat.started',
-        STOPPED: 'heartbeat.stopped',
-        COMPLETED: 'heartbeat.completed',
-        FAILED: 'heartbeat.failed',
-        EVENT_PUBLISHED: 'heartbeat.event_published',
-        EVENT_RECEIVED: 'heartbeat.event_received',
-        ERROR: 'heartbeat.error',
+        DISABLED: "heartbeat.disabled",
+        STARTED: "heartbeat.started",
+        DEVICE: {
+            IN_ACTIVE: "heartbeat.device.in_active",
+            OFFLINE: "heartbeat.device.offline",
+            OFFLINE_HUB: "heartbeat.device.offline_hub",
+            FURTHER_CHECKS_SKIPPED: "heartbeat.device.further_checks_skipped",
+        },
+        HUB: {
+            IN_ACTIVE: "heartbeat.hub.in_active",
+            OFFLINE: "heartbeat.hub.offline",
+        },
+        LOCK: {
+            LOCAL_CODES_EXCLUDING_SET: "heartbeat.lock.local_codes_excluding_set",
+            CLOUD_CODES: "heartbeat.lock.cloud_codes",
+            MISSING_CODES: "heartbeat.lock.missing_codes",
+            ADDITIONAL_CODES: "heartbeat.lock.additional_codes",
+            SCHEDULE_CODES: "heartbeat.lock.schedule_codes",
+            MARKED_TO_DELETE_CODES: "heartbeat.lock.marked_to_delete_codes",
+            UNSET_CODES: "heartbeat.lock.unset_codes",
+        },
+        STOPPED: "heartbeat.stopped",
+        COMPLETED: "heartbeat.completed",
+        FAILED: "heartbeat.failed",
+        EVENT_PUBLISHED: "heartbeat.event_published",
+        EVENT_RECEIVED: "heartbeat.event_received",
+        ERROR: "heartbeat.error",
     },
     ACCOUNT: {
         DEVICE: {
-            NEW: 'account.device.new',
-            MISSING: 'account.device.missing',
-        }
-    }
+            NEW: "account.device.new",
+            MISSING: "account.device.missing",
+        },
+    },
 };

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

@@ -38,13 +38,10 @@ export declare class IssueService {
      * Create issue for device battery level below threshold (READINESS + OPERATIONAL + ENERGY)
      */
     createDeviceBatteryIssue(device: IDevice, batteryLevel: number, threshold: number, priority: IssuePriority, source: Source): Promise<IIssueDocument | null>;
-    createAccountMissingDeviceIssue(device: {
-        deviceId: string;
-        deviceType: string;
-        name: string;
-    }, connection: {
+    createAccountMissingDeviceIssue(connection: {
         id: string;
         provider: string;
+        deviceCount: number;
         type?: string;
     }, propertyId: string, source: Source): Promise<IIssueDocument | null>;
     createAccountUnauthorizedIssue(account: {
@@ -85,6 +82,7 @@ export declare class IssueService {
      * Update an issue with business logic validation
      */
     updateIssue(id: string, updateData: UpdateIssueData): Promise<IIssueDocument | null>;
+    deleteIssues(filters: IIssueQuery, deletedBy: string, softDelete?: boolean): Promise<boolean>;
     /**
      * Soft delete an issue with business logic
      */

package/dist/issues/Issue.service.js

@@ -266,14 +266,14 @@ let IssueService = (() => {
                 type: issue_types_1.IssueType.BATTERY_LOW,
             });
         }
-        async createAccountMissingDeviceIssue(device, connection, propertyId, source) {
+        async createAccountMissingDeviceIssue(connection, propertyId, source) {
             return await this.createIssue({
                 entityId: connection.id,
                 entityType: issue_types_1.EntityType.CLOUD_DEVICE_ACCOUNT,
                 entitySubType: connection.provider,
                 propertyId: propertyId,
                 title: "Device Missing",
-                description: `${device.name} is missing from the ${connection.provider} account.`,
+                description: `${connection.deviceCount} device(s), missing from the ${connection.provider} account.`,
                 createdBy: source,
                 category: issue_types_1.IssuesCategory.OPERATIONS,
                 priority: issue_types_1.IssuePriority.CRITICAL,
@@ -507,6 +507,31 @@ let IssueService = (() => {
             }
             return await this.issueRepository.update(id, updateData);
         }
+        async deleteIssues(filters, deletedBy, softDelete = true) {
+            try {
+                if (!filters || Object.keys(filters).length === 0) {
+                    throw new Error("Filters are required");
+                }
+                if (!deletedBy) {
+                    throw new Error("Deleted by user is required");
+                }
+                const issues = await this.issueRepository.query(filters);
+                if (softDelete) {
+                    for (const issue of issues) {
+                        await this.issueRepository.softDelete(issue.id, deletedBy);
+                    }
+                }
+                else {
+                    for (const issue of issues) {
+                        await this.issueRepository.hardDelete(issue.id);
+                    }
+                }
+                return true;
+            }
+            catch (error) {
+                throw new Error(`Failed to delete issues: ${error instanceof Error ? error.message : error}`);
+            }
+        }
         /**
          * Soft delete an issue with business logic
          */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-common-device",
-  "version": "7.10.9",
+  "version": "7.10.11",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [