dt-common-device 7.2.0 → 7.2.1

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

@@ -1,35 +1,31 @@
 import { IAlertDocument } from "./Alert.model";
-import { CreateAlertData, UpdateAlertData, AlertCategory, AlertSeverity, EntityType, IAlertQuery } from "./alert.types";
+import { CreateAlertData, UpdateAlertData, AlertCategory, AlertSeverity, IAlertQuery } from "./alert.types";
 import { Source } from "../constants/Service";
 import { AlertBuilder } from "./AlertBuilder";
 import { IDevice } from "../entities/device/local/interfaces";
 export declare class AlertService {
     private readonly alertRepository;
     constructor();
-    /**
-     * Create a readiness alert using AlertBuilder
-     */
-    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, zoneId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
+    raiseOperationsAlert(data: CreateAlertData): Promise<IAlertDocument>;
     /**
      * Create a security alert using AlertBuilder
      */
-    raiseSecurityAlert(propertyId: string, zoneId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
+    raiseSecurityAlert(data: CreateAlertData): Promise<IAlertDocument>;
     /**
      * Create an energy alert using AlertBuilder
      */
-    raiseEnergyAlert(propertyId: string, zoneId: string, title: string, description: string, entityId?: string, entityType?: EntityType, createdBy?: string): Promise<IAlertDocument>;
+    raiseEnergyAlert(data: CreateAlertData): Promise<IAlertDocument>;
     /**
      * Create a device-specific alert using AlertBuilder
      */
-    raiseDeviceAlert(deviceId: string, propertyId: string, zoneId: string, title: string, description: string, category?: AlertCategory, severity?: AlertSeverity, source?: Source): Promise<IAlertDocument>;
+    raiseDeviceAlert(data: CreateAlertData): Promise<IAlertDocument>;
     /**
      * Create a hub-specific alert using AlertBuilder
      */
-    raiseHubAlert(hubId: string, propertyId: string, zoneId: string, title: string, description: string, category?: AlertCategory, severity?: AlertSeverity, createdBy?: string): Promise<IAlertDocument>;
+    raiseHubAlert(data: CreateAlertData): Promise<IAlertDocument>;
     /**
      * Raise alert for device going offline (OPERATIONAL only)
      */

package/dist/alerts/Alert.service.js

@@ -86,127 +86,150 @@ let AlertService = (() => {
         constructor() {
             this.alertRepository = typedi_1.default.get(Alert_repository_1.AlertRepository);
         }
-        /**
-         * Create a readiness alert using AlertBuilder
-         */
-        async raiseReadinessAlert(propertyId, zoneId, title, description, entityId, entityType, createdBy) {
-            const alertBuilder = AlertBuilder_1.AlertBuilder.createReadinessAlert()
-                .setPropertyId(propertyId)
-                .setZoneId(zoneId)
-                .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, zoneId, title, description, entityId, entityType, createdBy) {
+        async raiseOperationsAlert(data) {
             const alertBuilder = AlertBuilder_1.AlertBuilder.createOperationsAlert()
-                .setPropertyId(propertyId)
-                .setZoneId(zoneId)
-                .setTitle(title)
-                .setDescription(description);
-            if (entityId)
-                alertBuilder.setEntityId(entityId);
-            if (entityType)
-                alertBuilder.setEntityType(entityType);
-            if (createdBy)
-                alertBuilder.setCreatedBy(createdBy);
+                .setPropertyId(data.propertyId)
+                .setZoneId(data.zoneId)
+                .setTitle(data.title)
+                .setDescription(data.description);
+            if (data.entityId)
+                alertBuilder.setEntityId(data.entityId);
+            if (data.entityType)
+                alertBuilder.setEntityType(data.entityType);
+            if (data.createdBy)
+                alertBuilder.setCreatedBy(data.createdBy);
             return await this.createAlert(alertBuilder);
         }
         /**
          * Create a security alert using AlertBuilder
          */
-        async raiseSecurityAlert(propertyId, zoneId, title, description, entityId, entityType, createdBy) {
+        async raiseSecurityAlert(data) {
             const alertBuilder = AlertBuilder_1.AlertBuilder.createSecurityAlert()
-                .setPropertyId(propertyId)
-                .setZoneId(zoneId)
-                .setTitle(title)
-                .setDescription(description);
-            if (entityId)
-                alertBuilder.setEntityId(entityId);
-            if (entityType)
-                alertBuilder.setEntityType(entityType);
-            if (createdBy)
-                alertBuilder.setCreatedBy(createdBy);
+                .setPropertyId(data.propertyId)
+                .setZoneId(data.zoneId)
+                .setTitle(data.title)
+                .setDescription(data.description);
+            if (data.entityId)
+                alertBuilder.setEntityId(data.entityId);
+            if (data.entityType)
+                alertBuilder.setEntityType(data.entityType);
+            if (data.createdBy)
+                alertBuilder.setCreatedBy(data.createdBy);
             return await this.createAlert(alertBuilder);
         }
         /**
          * Create an energy alert using AlertBuilder
          */
-        async raiseEnergyAlert(propertyId, zoneId, title, description, entityId, entityType, createdBy) {
+        async raiseEnergyAlert(data) {
             const alertBuilder = AlertBuilder_1.AlertBuilder.createEnergyAlert()
-                .setPropertyId(propertyId)
-                .setZoneId(zoneId)
-                .setTitle(title)
-                .setDescription(description);
-            if (entityId)
-                alertBuilder.setEntityId(entityId);
-            if (entityType)
-                alertBuilder.setEntityType(entityType);
-            if (createdBy)
-                alertBuilder.setCreatedBy(createdBy);
+                .setPropertyId(data.propertyId)
+                .setZoneId(data.zoneId)
+                .setTitle(data.title)
+                .setDescription(data.description);
+            if (data.entityId)
+                alertBuilder.setEntityId(data.entityId);
+            if (data.entityType)
+                alertBuilder.setEntityType(data.entityType);
+            if (data.createdBy)
+                alertBuilder.setCreatedBy(data.createdBy);
             return await this.createAlert(alertBuilder);
         }
         /**
          * Create a device-specific alert using AlertBuilder
          */
-        async raiseDeviceAlert(deviceId, propertyId, zoneId, title, description, category, severity, source) {
-            const alertBuilder = AlertBuilder_1.AlertBuilder.createDeviceAlert(deviceId, propertyId, zoneId)
-                .setTitle(title)
-                .setDescription(description);
-            if (category)
-                alertBuilder.setCategory(category);
-            if (severity)
-                alertBuilder.setSeverity(severity);
-            if (source)
-                alertBuilder.setCreatedBy(source);
+        async raiseDeviceAlert(data) {
+            const alertBuilder = AlertBuilder_1.AlertBuilder.createDeviceAlert(data.entityId || "", data.propertyId, data.zoneId)
+                .setTitle(data.title)
+                .setDescription(data.description);
+            if (data.category)
+                alertBuilder.setCategory(data.category);
+            if (data.severity)
+                alertBuilder.setSeverity(data.severity);
+            if (data.createdBy)
+                alertBuilder.setCreatedBy(data.createdBy);
             return await this.createAlert(alertBuilder);
         }
         /**
          * Create a hub-specific alert using AlertBuilder
          */
-        async raiseHubAlert(hubId, propertyId, zoneId, title, description, category, severity, createdBy) {
-            const alertBuilder = AlertBuilder_1.AlertBuilder.createHubAlert(hubId, propertyId, zoneId)
-                .setTitle(title)
-                .setDescription(description);
-            if (category)
-                alertBuilder.setCategory(category);
-            if (severity)
-                alertBuilder.setSeverity(severity);
-            if (createdBy)
-                alertBuilder.setCreatedBy(createdBy);
+        async raiseHubAlert(data) {
+            const alertBuilder = AlertBuilder_1.AlertBuilder.createHubAlert(data.entityId || "", data.propertyId, data.zoneId)
+                .setTitle(data.title)
+                .setDescription(data.description);
+            if (data.category)
+                alertBuilder.setCategory(data.category);
+            if (data.severity)
+                alertBuilder.setSeverity(data.severity);
+            if (data.createdBy)
+                alertBuilder.setCreatedBy(data.createdBy);
             return await this.createAlert(alertBuilder);
         }
         /**
          * Raise alert for device going offline (OPERATIONAL only)
          */
         async raiseDeviceOfflineAlert(device, source, reason) {
-            return await this.raiseDeviceAlert(device.deviceId, device.propertyId, device.zoneId, "Device Offline", `Device ${device.name} (${device.deviceId}) has gone offline. ${reason ? `Reason: ${reason}` : ""}`, alert_types_1.AlertCategory.OPERATIONS, alert_types_1.AlertSeverity.HIGH, source);
+            return await this.raiseDeviceAlert({
+                entityId: device.deviceId,
+                propertyId: device.propertyId,
+                zoneId: device.zoneId,
+                title: "Device Offline",
+                description: `Device ${device.name} has gone offline. ${reason ? `Reason: ${reason}` : ""}`,
+                category: alert_types_1.AlertCategory.OPERATIONS,
+                severity: alert_types_1.AlertSeverity.HIGH,
+                createdBy: source,
+                entityType: alert_types_1.EntityType.DEVICE,
+            });
         }
         /**
          * Raise alert for device coming online (OPERATIONAL only)
          */
         async raiseDeviceOnlineAlert(device, source, reason) {
-            return await this.raiseDeviceAlert(device.deviceId, device.propertyId, device.zoneId, "Device Online", `Device ${device.name} (${device.deviceId}) is now online. ${reason ? `Reason: ${reason}` : ""}`, alert_types_1.AlertCategory.OPERATIONS, alert_types_1.AlertSeverity.INFO, source);
+            return await this.raiseDeviceAlert({
+                entityId: device.deviceId,
+                propertyId: device.propertyId,
+                zoneId: device.zoneId,
+                title: "Device Online",
+                description: `Device ${device.name} is now online. ${reason ? `Reason: ${reason}` : ""}`,
+                category: alert_types_1.AlertCategory.OPERATIONS,
+                severity: alert_types_1.AlertSeverity.INFO,
+                createdBy: source,
+                entityType: alert_types_1.EntityType.DEVICE,
+            });
         }
         /**
          * Raise alert for device battery level below threshold (READINESS + OPERATIONAL + ENERGY)
          */
         async raiseDeviceBatteryAlert(device, batteryLevel, threshold, source) {
-            return await this.raiseDeviceAlert(device.deviceId, device.propertyId, device.zoneId, "Device Battery Low", `Device ${device.name} (${device.deviceId}) battery level is ${batteryLevel}%, which is below the property threshold of ${threshold}%.`, alert_types_1.AlertCategory.ENERGY, alert_types_1.AlertSeverity.HIGH, source);
+            return await this.raiseDeviceAlert({
+                entityId: device.deviceId,
+                propertyId: device.propertyId,
+                zoneId: device.zoneId,
+                title: "Device Battery Low",
+                description: `Device ${device.name} (${device.deviceId}) battery level is ${batteryLevel}%, which is below the property threshold of ${threshold}%.`,
+                category: alert_types_1.AlertCategory.ENERGY,
+                severity: alert_types_1.AlertSeverity.HIGH,
+                createdBy: source,
+                entityType: alert_types_1.EntityType.DEVICE,
+            });
         }
         /**
          * Raise alert for device issue (jammed or malfunctioned) (READINESS + OPERATIONAL)
          */
         async raiseDeviceIssueAlert(device, issueType, source, reason) {
-            return await this.raiseDeviceAlert(device.deviceId, device.propertyId, device.zoneId, `Device Issue - ${issueType}`, `Device ${device.name} (${device.deviceId}) has an issue: ${issueType}. ${reason ? `Reason: ${reason}` : ""}`, alert_types_1.AlertCategory.READINESS, alert_types_1.AlertSeverity.HIGH, source);
+            return await this.raiseDeviceAlert({
+                entityId: device.deviceId,
+                propertyId: device.propertyId,
+                zoneId: device.zoneId,
+                title: `Device Issue - ${issueType}`,
+                description: `Device ${device.name} has an issue: ${issueType}. ${reason ? `Reason: ${reason}` : ""}`,
+                category: alert_types_1.AlertCategory.OPERATIONS,
+                severity: alert_types_1.AlertSeverity.HIGH,
+                createdBy: source,
+                entityType: alert_types_1.EntityType.DEVICE,
+            });
         }
         /**
          * Create a new alert with business logic validation
@@ -538,7 +561,6 @@ let AlertService = (() => {
         determineDefaultSeverity(category) {
             // Business logic: Determine default severity based on category
             const categorySeverities = {
-                [alert_types_1.AlertCategory.READINESS]: alert_types_1.AlertSeverity.LOW,
                 [alert_types_1.AlertCategory.OPERATIONS]: alert_types_1.AlertSeverity.HIGH,
                 [alert_types_1.AlertCategory.SECURITY]: alert_types_1.AlertSeverity.CRITICAL,
                 [alert_types_1.AlertCategory.ENERGY]: alert_types_1.AlertSeverity.LOW,

package/dist/alerts/AlertBuilder.d.ts

@@ -73,10 +73,6 @@ export declare class AlertBuilder {
      * Resets the builder to its initial state
      */
     reset(): this;
-    /**
-     * Creates a new builder instance with predefined values for common alert types
-     */
-    static createReadinessAlert(): AlertBuilder;
     static createOperationsAlert(): AlertBuilder;
     static createSecurityAlert(): AlertBuilder;
     static createEnergyAlert(): AlertBuilder;

package/dist/alerts/AlertBuilder.js

@@ -152,14 +152,6 @@ class AlertBuilder {
         this.data = {};
         return this;
     }
-    /**
-     * Creates a new builder instance with predefined values for common alert types
-     */
-    static createReadinessAlert() {
-        return new AlertBuilder()
-            .setCategory(alert_types_1.AlertCategory.READINESS)
-            .setSeverity(alert_types_1.AlertSeverity.LOW);
-    }
     static createOperationsAlert() {
         return new AlertBuilder()
             .setCategory(alert_types_1.AlertCategory.OPERATIONS)

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

@@ -1,6 +1,5 @@
 import { EntityType } from "../issues/issue.types";
 export declare enum AlertCategory {
-    READINESS = "READINESS",
     OPERATIONS = "OPERATIONS",
     SECURITY = "SECURITY",
     ENERGY = "ENERGY",

package/dist/alerts/alert.types.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityType = exports.AlertSeverity = exports.AlertCategory = void 0;
 var AlertCategory;
 (function (AlertCategory) {
-    AlertCategory["READINESS"] = "READINESS";
     AlertCategory["OPERATIONS"] = "OPERATIONS";
     AlertCategory["SECURITY"] = "SECURITY";
     AlertCategory["ENERGY"] = "ENERGY";

package/dist/constants/Event.d.ts

@@ -172,27 +172,26 @@ export declare const DT_EVENT_TYPES: {
         };
         UPDATE: {
             SUCCESS: string;
+            FAILED: string;
         };
         DELETE: {
             SUCCESS: string;
-        };
-        CANCEL: {
-            SUCCESS: string;
-        };
-        RESOLVE: {
-            SUCCESS: string;
+            FAILED: string;
         };
     };
     ALERT: {
         CREATE: {
             SUCCESS: string;
+            FAILED: string;
             SKIPPED: string;
         };
         UPDATE: {
             SUCCESS: string;
+            FAILED: string;
         };
         DELETE: {
             SUCCESS: string;
+            FAILED: string;
         };
     };
 };

package/dist/constants/Event.js

@@ -175,27 +175,26 @@ exports.DT_EVENT_TYPES = {
         },
         UPDATE: {
             SUCCESS: "issue.update.success",
+            FAILED: "issue.update.failed",
         },
         DELETE: {
             SUCCESS: "issue.delete.success",
+            FAILED: "issue.delete.failed",
         },
-        CANCEL: {
-            SUCCESS: "issue.cancel.success",
-        },
-        RESOLVE: {
-            SUCCESS: "issue.resolve.success",
-        }
     },
     ALERT: {
         CREATE: {
             SUCCESS: "alert.create.success",
+            FAILED: "alert.create.failed",
             SKIPPED: "alert.create.skipped",
         },
         UPDATE: {
             SUCCESS: "alert.update.success",
+            FAILED: "alert.update.failed",
         },
         DELETE: {
             SUCCESS: "alert.delete.success",
+            FAILED: "alert.delete.failed",
         },
     },
 };

package/dist/db/db.js

@@ -44,10 +44,10 @@ const connectDatabase = async () => {
     try {
         const URI = (0, config_1.getMongoUri)();
         await mongoose_1.default.connect(URI);
-        console.log(`Connected to MongoDB at ${URI.split("/").at(-1)}`);
+        (0, config_1.getLogger)().info(`Connected to MongoDB at ${URI.split("/").at(-1)}`);
     }
     catch (error) {
-        console.error("Error connecting to MongoDB:", error);
+        (0, config_1.getLogger)().error("Error connecting to MongoDB:", error);
     }
 };
 exports.connectDatabase = connectDatabase;

package/dist/entities/admin/Admin.service.d.ts

@@ -1,6 +1,7 @@
 import { IAccessGroup, IUser, IZone } from "./IAdmin";
 export declare class AdminService {
     private readonly adminRepository;
+    private readonly redisUtils;
     constructor();
     getZonesByAccessGroupIds(accessGroupIds: string[]): Promise<any[] | undefined>;
     getZonesByAccessGroups(accessGroupIds: string[]): Promise<any[] | undefined>;

package/dist/entities/admin/Admin.service.js

@@ -74,6 +74,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminService = void 0;
 const typedi_1 = __importStar(require("typedi"));
 const Admin_repository_1 = require("./Admin.repository");
+const redis_utils_1 = require("../../utils/redis.utils");
 let AdminService = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;
@@ -82,6 +83,7 @@ let AdminService = (() => {
     var AdminService = _classThis = class {
         constructor() {
             this.adminRepository = typedi_1.default.get(Admin_repository_1.AdminRepository);
+            this.redisUtils = typedi_1.default.get(redis_utils_1.RedisUtils);
         }
         async getZonesByAccessGroupIds(accessGroupIds) {
             try {
@@ -124,6 +126,10 @@ let AdminService = (() => {
             if (!zoneId) {
                 throw new Error("Zone ID is required");
             }
+            const cachedZone = await this.redisUtils.get(`zone:${zoneId}`);
+            if (cachedZone)
+                return JSON.parse(cachedZone);
+            // Do Not Cache Zone if not found in Redis Here! Its being cached in Smart-Cloud
             const zone = await this.adminRepository.getZone(zoneId);
             if (!zone)
                 return null;

package/dist/issues/Issue.model.js

@@ -61,6 +61,10 @@ const IssueSchema = new mongoose_1.Schema({
         required: false,
         index: true,
     },
+    zoneName: {
+        type: String,
+        required: false,
+    },
     title: {
         type: String,
         required: true,

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

@@ -6,10 +6,6 @@ import { IDevice } from "../entities/device/local/interfaces";
 export declare class IssueService {
     private readonly issueRepository;
     constructor();
-    /**
-     * Create a readiness issue using IssueBuilder
-     */
-    createReadinessIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
     /**
      * Create an operations issue using IssueBuilder
      */
@@ -117,6 +113,11 @@ export declare class IssueService {
      * Unassign an issue
      */
     unassignIssue(id: string, unassignedBy: string): Promise<IIssueDocument | null>;
+    /**
+     * Cancel/Close/Resolve an issue based on query
+     * This method will find an issue matching the query and update its status
+     */
+    performIssueAction(query: IIssueQuery, action: "cancel" | "close" | "resolve" | "ignore" | "in_progress" | "on_hold", updatedBy: string): Promise<IIssueDocument | null>;
     /**
      * Get issues assigned to a user with business logic
      */

package/dist/issues/Issue.service.js

@@ -77,6 +77,7 @@ const Issue_repository_1 = require("./Issue.repository");
 const Issue_model_1 = require("./Issue.model");
 const issue_types_1 = require("./issue.types");
 const IssueBuilder_1 = require("./IssueBuilder");
+const Service_1 = require("../constants/Service");
 const Admin_service_1 = require("../entities/admin/Admin.service");
 const audit_1 = require("../audit");
 const constants_1 = require("../constants");
@@ -90,29 +91,6 @@ let IssueService = (() => {
         constructor() {
             this.issueRepository = typedi_1.default.get(Issue_repository_1.IssueRepository);
         }
-        /**
-         * Create a readiness issue using IssueBuilder
-         */
-        async createReadinessIssue(data) {
-            const issueBuilder = IssueBuilder_1.IssueBuilder.createReadinessIssue()
-                .setPropertyId(data.propertyId)
-                .setTitle(data.title)
-                .setDescription(data.description)
-                .setCreatedBy(data.createdBy);
-            if (data.entityId)
-                issueBuilder.setEntityId(data.entityId);
-            if (data.entityType)
-                issueBuilder.setEntityType(data.entityType);
-            if (data.assignedTo)
-                issueBuilder.setAssignedTo(data.assignedTo);
-            if (data.dueDate)
-                issueBuilder.setDueDate(data.dueDate);
-            if (data.zoneId)
-                issueBuilder.setZoneId(data.zoneId);
-            if (data.type)
-                issueBuilder.setType(data.type);
-            return await this.createIssue(issueBuilder);
-        }
         /**
          * Create an operations issue using IssueBuilder
          */
@@ -356,51 +334,88 @@ let IssueService = (() => {
          * Accepts either a CreateIssueData object or an IssueBuilder instance
          */
         async createIssue(issueData) {
-            let processedIssueData;
-            // Handle IssueBuilder instance
-            if (issueData instanceof IssueBuilder_1.IssueBuilder) {
-                processedIssueData = issueData.build();
-            }
-            else {
-                processedIssueData = issueData;
-            }
-            // Business logic: Validate issue data
-            this.validateIssueData(processedIssueData);
-            // Business logic: Set default priority if not provided
-            if (!processedIssueData.priority) {
-                processedIssueData.priority = this.determineDefaultPriority(processedIssueData.category);
-            }
-            // Business logic: Validate due date is in the future
-            if (processedIssueData.dueDate &&
-                processedIssueData.dueDate <= new Date()) {
-                throw new Error("Due date must be in the future");
-            }
-            const existingIssue = await this.issueRepository.query({
-                propertyId: processedIssueData.propertyId,
-                entityId: processedIssueData.entityId,
-                entityType: processedIssueData.entityType,
-                entitySubType: processedIssueData.entitySubType,
-                type: processedIssueData.type,
-            });
-            if (existingIssue.length > 0) {
+            try {
+                let processedIssueData;
+                // Handle IssueBuilder instance
+                if (issueData instanceof IssueBuilder_1.IssueBuilder) {
+                    processedIssueData = issueData.build();
+                }
+                else {
+                    processedIssueData = issueData;
+                }
+                // Business logic: Validate issue data
+                this.validateIssueData(processedIssueData);
+                // Business logic: Set default priority if not provided
+                if (!processedIssueData.priority) {
+                    processedIssueData.priority = this.determineDefaultPriority(processedIssueData.category);
+                }
+                // Business logic: Validate due date is in the future
+                if (processedIssueData.dueDate &&
+                    processedIssueData.dueDate <= new Date()) {
+                    throw new Error("Due date must be in the future");
+                }
+                if (processedIssueData?.zoneId && !processedIssueData?.zoneName) {
+                    const zone = await typedi_1.default.get(Admin_service_1.AdminService).getZone(processedIssueData.zoneId);
+                    processedIssueData.zoneName = zone?.name || "";
+                }
+                const existingIssue = await this.query({
+                    propertyId: processedIssueData.propertyId,
+                    zoneId: processedIssueData.zoneId,
+                    entityId: processedIssueData.entityId,
+                    entityType: processedIssueData.entityType,
+                    entitySubType: processedIssueData.entitySubType,
+                    type: processedIssueData.type,
+                });
+                if (existingIssue.length > 0) {
+                    await (0, audit_1.pushAudit)({
+                        auditType: constants_1.DT_EVENT_TYPES.ISSUE.CREATE.SKIPPED,
+                        auditData: {
+                            reason: "Issue already exists",
+                            propertyId: processedIssueData.propertyId,
+                            entityId: processedIssueData.entityId,
+                            entityType: processedIssueData.entityType,
+                            entitySubType: processedIssueData.entitySubType,
+                            type: processedIssueData.type,
+                            resource: audit_1.Resource.ISSUE,
+                            source: processedIssueData.createdBy,
+                        },
+                    });
+                    return null;
+                }
+                const issue = await this.issueRepository.create(processedIssueData);
                 await (0, audit_1.pushAudit)({
-                    auditType: constants_1.DT_EVENT_TYPES.ISSUE.CREATE.SKIPPED,
+                    auditType: constants_1.DT_EVENT_TYPES.ISSUE.CREATE.SUCCESS,
                     auditData: {
-                        reason: "Issue already exists",
+                        resource: audit_1.Resource.ISSUE,
+                        source: Service_1.Source.USER,
                         propertyId: processedIssueData.propertyId,
+                        zoneId: processedIssueData.zoneId,
                         entityId: processedIssueData.entityId,
                         entityType: processedIssueData.entityType,
                         entitySubType: processedIssueData.entitySubType,
                         type: processedIssueData.type,
+                        createdBy: processedIssueData.createdBy,
+                        createdAt: new Date(),
+                    },
+                });
+                await dt_pub_sub_1.eventDispatcher.publishEvent(constants_1.DT_EVENT_TYPES.ISSUE.CREATE.SUCCESS, issue, "dt-common-device");
+                return issue;
+            }
+            catch (error) {
+                await (0, audit_1.pushAudit)({
+                    auditType: constants_1.DT_EVENT_TYPES.ISSUE.CREATE.FAILED,
+                    auditData: {
                         resource: audit_1.Resource.ISSUE,
-                        source: processedIssueData.createdBy,
+                        source: Service_1.Source.USER,
+                        propertyId: issueData?.propertyId || "",
+                        zoneId: issueData?.zoneId || "",
+                        errorMessage: error.message,
+                        error: error,
+                        createdBy: issueData?.createdBy || "",
                     },
                 });
-                return null;
+                throw error;
             }
-            const issue = await this.issueRepository.create(processedIssueData);
-            await dt_pub_sub_1.eventDispatcher.publishEvent(constants_1.DT_EVENT_TYPES.ISSUE.CREATE.SUCCESS, issue, "dt-common-device");
-            return issue;
         }
         /**
          * Get issue by ID with business logic
@@ -613,6 +628,106 @@ let IssueService = (() => {
             issueModel.unassign(unassignedBy);
             return await issueModel.save();
         }
+        /**
+         * Cancel/Close/Resolve an issue based on query
+         * This method will find an issue matching the query and update its status
+         */
+        async performIssueAction(query, action, updatedBy) {
+            try {
+                if (!updatedBy) {
+                    throw new Error("Updated by user is required");
+                }
+                // Find the issue based on the query
+                const issues = await this.query(query);
+                if (issues.length === 0) {
+                    return null; // No issue found matching the query
+                }
+                if (issues.length > 1) {
+                    throw new Error(`Multiple issues found matching the query. Please provide more specific criteria.`);
+                }
+                const issue = issues[0];
+                // Check if issue can be cancelled/closed/resolved
+                if (issue.status === issue_types_1.IssueStatus.CANCELLED) {
+                    throw new Error("Issue is already cancelled");
+                }
+                if (issue.status === issue_types_1.IssueStatus.CLOSED) {
+                    throw new Error("Issue is already closed");
+                }
+                if (issue.status === issue_types_1.IssueStatus.RESOLVED) {
+                    throw new Error("Issue is already resolved");
+                }
+                if (issue.status === issue_types_1.IssueStatus.IGNORED) {
+                    throw new Error("Issue is already ignored");
+                }
+                // Determine the new status based on the action
+                let newStatus;
+                let updateData = {
+                    updatedBy,
+                    updatedAt: new Date(),
+                };
+                switch (action) {
+                    case "in_progress":
+                        newStatus = issue_types_1.IssueStatus.IN_PROGRESS;
+                        break;
+                    case "resolve":
+                        newStatus = issue_types_1.IssueStatus.RESOLVED;
+                        updateData.resolvedAt = new Date();
+                        break;
+                    case "close":
+                        newStatus = issue_types_1.IssueStatus.CLOSED;
+                        break;
+                    case "cancel":
+                        newStatus = issue_types_1.IssueStatus.CANCELLED;
+                        break;
+                    case "on_hold":
+                        newStatus = issue_types_1.IssueStatus.ON_HOLD;
+                        break;
+                    case "ignore":
+                        newStatus = issue_types_1.IssueStatus.IGNORED;
+                        break;
+                    default:
+                        throw new Error("Invalid action. Must be 'cancel', 'close', or 'resolve'");
+                }
+                updateData.status = newStatus;
+                // Update the issue
+                const updatedIssue = await this.updateIssue(issue._id, updateData);
+                if (updatedIssue) {
+                    // Log the action for audit purposes
+                    console.log(`Issue ${issue._id} has been ${action}ed by ${updatedBy}`);
+                    await (0, audit_1.pushAudit)({
+                        auditType: constants_1.DT_EVENT_TYPES.ISSUE.UPDATE.SUCCESS,
+                        auditData: {
+                            resource: audit_1.Resource.ISSUE,
+                            source: Service_1.Source.USER,
+                            propertyId: issue.propertyId,
+                            zoneId: issue.zoneId,
+                            oldStatus: issue.status,
+                            newStatus,
+                            action,
+                            updatedBy,
+                            updatedAt: new Date(),
+                        },
+                    });
+                }
+                return updatedIssue;
+            }
+            catch (error) {
+                await (0, audit_1.pushAudit)({
+                    auditType: constants_1.DT_EVENT_TYPES.ISSUE.UPDATE.FAILED,
+                    auditData: {
+                        resource: audit_1.Resource.ISSUE,
+                        source: Service_1.Source.USER,
+                        propertyId: query.propertyId || "",
+                        zoneId: query.zoneId || "",
+                        errorMessage: error.message,
+                        error: error,
+                        updatedBy,
+                        updatedAt: new Date(),
+                    },
+                });
+                throw error;
+            }
+        }
         /**
          * Get issues assigned to a user with business logic
          */
@@ -764,7 +879,6 @@ let IssueService = (() => {
         determineDefaultPriority(category) {
             // Business logic: Determine default priority based on category
             const categoryPriorities = {
-                [issue_types_1.IssuesCategory.READINESS]: issue_types_1.IssuePriority.LOW,
                 [issue_types_1.IssuesCategory.OPERATIONS]: issue_types_1.IssuePriority.HIGH,
                 [issue_types_1.IssuesCategory.SECURITY]: issue_types_1.IssuePriority.CRITICAL,
                 [issue_types_1.IssuesCategory.ENERGY]: issue_types_1.IssuePriority.HIGH,

package/dist/issues/IssueBuilder.d.ts

@@ -87,10 +87,6 @@ export declare class IssueBuilder {
      * Resets the builder to its initial state
      */
     reset(): this;
-    /**
-     * Creates a new builder instance with predefined values for common issue types
-     */
-    static createReadinessIssue(): IssueBuilder;
     static createOperationsIssue(): IssueBuilder;
     static createSecurityIssue(): IssueBuilder;
     static createEnergyIssue(): IssueBuilder;

package/dist/issues/IssueBuilder.js

@@ -182,14 +182,6 @@ class IssueBuilder {
         this.data = {};
         return this;
     }
-    /**
-     * Creates a new builder instance with predefined values for common issue types
-     */
-    static createReadinessIssue() {
-        return new IssueBuilder()
-            .setCategory(issue_types_1.IssuesCategory.READINESS)
-            .setPriority(issue_types_1.IssuePriority.LOW);
-    }
     static createOperationsIssue() {
         return new IssueBuilder()
             .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
@@ -255,7 +247,7 @@ class IssueBuilder {
      */
     static createMaintenanceIssue(propertyId, type, entityId, entityType) {
         const builder = new IssueBuilder()
-            .setCategory(issue_types_1.IssuesCategory.READINESS)
+            .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
             .setPropertyId(propertyId)
             .setType(type)
             .setPriority(issue_types_1.IssuePriority.LOW);

package/dist/issues/issue.types.d.ts

@@ -1,5 +1,4 @@
 export declare enum IssuesCategory {
-    READINESS = "READINESS",
     OPERATIONS = "OPERATIONS",
     SECURITY = "SECURITY",
     ENERGY = "ENERGY",
@@ -71,6 +70,7 @@ export interface IssueDocument {
     category: IssuesCategory;
     propertyId: string;
     zoneId?: string;
+    zoneName?: string;
     title: string;
     description: string;
     entityId?: string;
@@ -93,6 +93,7 @@ export interface CreateIssueData {
     category: IssuesCategory;
     propertyId: string;
     zoneId?: string;
+    zoneName?: string;
     title: string;
     description: string;
     entityId: string;
@@ -116,6 +117,7 @@ export interface UpdateIssueData {
     priority?: IssuePriority;
     assignedTo?: string;
     updatedBy?: string;
+    updatedAt?: Date;
     resolvedAt?: Date;
     dueDate?: Date;
     isDeleted?: boolean;
@@ -127,6 +129,7 @@ export interface AddCommentData {
 export interface IIssueQuery {
     propertyId?: string;
     zoneId?: string;
+    zoneName?: string;
     assignedTo?: string;
     status?: IssueStatus;
     priority?: IssuePriority;

package/dist/issues/issue.types.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IssueType = exports.IssuePriority = exports.IssueStatus = exports.EntitySubType = exports.EntityType = exports.IssuesCategory = void 0;
 var IssuesCategory;
 (function (IssuesCategory) {
-    IssuesCategory["READINESS"] = "READINESS";
     IssuesCategory["OPERATIONS"] = "OPERATIONS";
     IssuesCategory["SECURITY"] = "SECURITY";
     IssuesCategory["ENERGY"] = "ENERGY";

package/package.json

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