dt-common-device 7.2.0 → 7.2.4

package/dist/alerts/Alert.model.js

@@ -79,6 +79,11 @@ const AlertSchema = new mongoose_1.Schema({
         enum: Object.values(alert_types_1.AlertSeverity),
         default: alert_types_1.AlertSeverity.LOW,
     },
+    type: {
+        type: String,
+        enum: Object.values(alert_types_1.AlertType),
+        required: true,
+    },
     isRead: {
         type: Boolean,
         default: false,

package/dist/alerts/Alert.repository.js

@@ -68,6 +68,16 @@ let AlertRepository = (() => {
                 query.isRead = filters.isRead;
             if (!filters.includeDeleted)
                 query.isDeleted = false;
+            if (filters.type)
+                query.type = filters.type;
+            // Date filtering
+            if (filters.startDate || filters.endDate) {
+                query.createdAt = {};
+                if (filters.startDate)
+                    query.createdAt.$gte = filters.startDate;
+                if (filters.endDate)
+                    query.createdAt.$lte = filters.endDate;
+            }
             return query;
         }
         /**

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
@@ -521,6 +544,12 @@ let AlertService = (() => {
             if (filters.skip && filters.skip < 0) {
                 throw new Error("Skip must be non-negative");
             }
+            // Validate date filters
+            if (filters.startDate &&
+                filters.endDate &&
+                filters.startDate > filters.endDate) {
+                throw new Error("Start date must be before or equal to end date");
+            }
         }
         validateUpdateData(data) {
             if (data.title && data.title.trim().length < 3) {
@@ -538,7 +567,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",
@@ -12,11 +11,23 @@ export declare enum AlertSeverity {
     HIGH = "HIGH",
     CRITICAL = "CRITICAL"
 }
+export declare enum AlertType {
+    ACCOUNT_NEW_DEVICE = "ACCOUNT_NEW_DEVICE",
+    DEVICE_TAMPER_ATTEMPT = "DEVICE_TAMPER_ATTEMPT",
+    DOOR_LEFT_OPEN = "DOOR_LEFT_OPEN",
+    DOOR_OPEN_FREQUENT = "DOOR_OPEN_FREQUENT",
+    DOOR_OPEN_OUTSIDE_BIZ_HOURS = "DOOR_OPEN_OUTSIDE_BIZ_HOURS",
+    LOCK_ACCESS_EMERGENCY_CODE = "LOCK_ACCESS_EMERGENCY_CODE",
+    LOCK_ACCESS_MASTER_CODE = "LOCK_ACCESS_MASTER_CODE",
+    SPECIFIC_DOOR_ACCESS = "SPECIFIC_DOOR_ACCESS",
+    GUEST_LOCK_FIRST_ACCESS = "GUEST_LOCK_FIRST_ACCESS"
+}
 export interface AlertDocument {
     _id: string;
     category: AlertCategory;
     propertyId: string;
     zoneId: string;
+    type: AlertType;
     title: string;
     description: string;
     entityId?: string;
@@ -62,9 +73,12 @@ export interface IAlertQuery {
     severity?: AlertSeverity;
     entityType?: EntityType;
     entityId?: string;
+    type?: AlertType;
     isActive?: boolean;
     isRead?: boolean;
     includeDeleted?: boolean;
+    startDate?: Date;
+    endDate?: Date;
     sort?: {
         [key: string]: 1 | -1;
     };

package/dist/alerts/alert.types.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityType = exports.AlertSeverity = exports.AlertCategory = void 0;
+exports.EntityType = exports.AlertType = exports.AlertSeverity = exports.AlertCategory = void 0;
 var AlertCategory;
 (function (AlertCategory) {
-    AlertCategory["READINESS"] = "READINESS";
     AlertCategory["OPERATIONS"] = "OPERATIONS";
     AlertCategory["SECURITY"] = "SECURITY";
     AlertCategory["ENERGY"] = "ENERGY";
@@ -16,6 +15,18 @@ var AlertSeverity;
     AlertSeverity["HIGH"] = "HIGH";
     AlertSeverity["CRITICAL"] = "CRITICAL";
 })(AlertSeverity || (exports.AlertSeverity = AlertSeverity = {}));
+var AlertType;
+(function (AlertType) {
+    AlertType["ACCOUNT_NEW_DEVICE"] = "ACCOUNT_NEW_DEVICE";
+    AlertType["DEVICE_TAMPER_ATTEMPT"] = "DEVICE_TAMPER_ATTEMPT";
+    AlertType["DOOR_LEFT_OPEN"] = "DOOR_LEFT_OPEN";
+    AlertType["DOOR_OPEN_FREQUENT"] = "DOOR_OPEN_FREQUENT";
+    AlertType["DOOR_OPEN_OUTSIDE_BIZ_HOURS"] = "DOOR_OPEN_OUTSIDE_BIZ_HOURS";
+    AlertType["LOCK_ACCESS_EMERGENCY_CODE"] = "LOCK_ACCESS_EMERGENCY_CODE";
+    AlertType["LOCK_ACCESS_MASTER_CODE"] = "LOCK_ACCESS_MASTER_CODE";
+    AlertType["SPECIFIC_DOOR_ACCESS"] = "SPECIFIC_DOOR_ACCESS";
+    AlertType["GUEST_LOCK_FIRST_ACCESS"] = "GUEST_LOCK_FIRST_ACCESS";
+})(AlertType || (exports.AlertType = AlertType = {}));
 // Re-export EntityType from issue.types.ts to avoid duplication
 var issue_types_1 = require("../issues/issue.types");
 Object.defineProperty(exports, "EntityType", { enumerable: true, get: function () { return issue_types_1.EntityType; } });

package/dist/constants/Event.d.ts

@@ -41,7 +41,9 @@ export declare const DT_EVENT_TYPES: {
             UNKNOWN: string;
         };
         BATTERY: {
-            REPLACED: string;
+            STATE: {
+                REPLACE: string;
+            };
             LEVEL: {
                 UNKNOWN: string;
                 NORMAL: string;
@@ -172,27 +174,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

@@ -44,7 +44,9 @@ exports.DT_EVENT_TYPES = {
             UNKNOWN: "device.status.unknown",
         },
         BATTERY: {
-            REPLACED: "device.battery.replaced",
+            STATE: {
+                REPLACE: "device.battery.state.replace",
+            },
             LEVEL: {
                 UNKNOWN: "device.battery.level.unknown",
                 NORMAL: "device.battery.level.normal",
@@ -175,27 +177,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/entities/device/local/services/Device.service.d.ts

@@ -26,6 +26,7 @@ export declare class LocalDeviceService {
     getBatteryLevel(deviceId: string): Promise<Record<string, any>>;
     setBatteryLevel(deviceId: string, batteryLevel: number, source: Source, auditBody: IAuditProperties): Promise<void>;
     private shouldUpdateBatteryLevel;
+    updateBatteryState(deviceId: string, batteryState: any): Promise<void>;
     private getPropertyBatteryThreshold;
     private checkForDeviceMalfunctions;
     getMetaData(deviceId: string): Promise<any>;

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

@@ -355,6 +355,17 @@ let LocalDeviceService = (() => {
                     // Save the battery level in the device
                     await this.deviceRepository.setBatteryLevel(deviceId, batteryLevel);
                     await this.eventHandler.onBatteryLevelChange(deviceId, batteryLevel, auditBody);
+                    // Additional condition: if battery level is less than 50, update battery state to "replace"
+                    if (batteryLevel < 50) {
+                        const batteryState = {
+                            batteryState: {
+                                value: "replace",
+                                lastUpdated: new Date().toISOString(),
+                            },
+                        };
+                        await this.updateBatteryState(deviceId, batteryState);
+                        await this.eventHandler.onBatteryStateChange(deviceId, batteryState, auditBody);
+                    }
                     // Get property threshold
                     const propertyThreshold = await this.getPropertyBatteryThreshold(device.propertyId);
                     // Check if battery level is below threshold
@@ -377,6 +388,14 @@ let LocalDeviceService = (() => {
             // Return true if current time is greater than or equal to last updated time + 8 hours
             return currentTime >= lastUpdateTime + eightHoursInMs;
         }
+        async updateBatteryState(deviceId, batteryState) {
+            try {
+                await this.deviceRepository.updateDevice(deviceId, batteryState);
+            }
+            catch (error) {
+                console.error("Error updating battery state:", error);
+            }
+        }
         async getPropertyBatteryThreshold(propertyId) {
             // TODO: Implement property battery threshold retrieval
             // This should return the battery threshold for the specific property

package/dist/events/DeviceEventHandler.js

@@ -90,7 +90,7 @@ let DeviceEventHandler = (() => {
                 Event_1.DT_EVENT_TYPES.DEVICE.STATUS.ONLINE,
                 Event_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE,
                 Event_1.DT_EVENT_TYPES.DEVICE.STATUS.UNKNOWN,
-                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.REPLACED,
+                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.STATE.REPLACE,
                 Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.UNKNOWN,
                 Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.LOW,
                 Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.CRITICAL,

package/dist/events/EventHandler.d.ts

@@ -9,5 +9,6 @@ export declare class EventHandler {
     onStatusChange(deviceId: string, status: any, auditProperties: IAuditProperties, eventType: any): Promise<void>;
     onStatusChangeMany(query: IStatusQuery, status: IStatus, auditProperties: IAuditProperties, eventType: any): Promise<void>;
     onBatteryLevelChange(deviceId: string, batteryLevel: number, auditProperties: IAuditProperties): Promise<void>;
+    onBatteryStateChange(deviceId: string, batteryState: any, auditProperties: IAuditProperties): Promise<void>;
     onDeviceMetaChange(deviceId: string, metaData: Record<string, any>, auditProperties: IAuditProperties): Promise<void>;
 }

package/dist/events/EventHandler.js

@@ -125,6 +125,16 @@ let EventHandler = (() => {
                 },
             });
         }
+        async onBatteryStateChange(deviceId, batteryState, auditProperties) {
+            await (0, audit_1.pushAudit)({
+                auditType: Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.STATE.REPLACE,
+                auditData: {
+                    deviceId,
+                    batteryState,
+                    ...auditProperties,
+                },
+            });
+        }
         async onDeviceMetaChange(deviceId, metaData, auditProperties) {
             await (0, audit_1.pushAudit)({
                 auditType: Event_1.DT_EVENT_TYPES.DEVICE.METADATA.UPDATED,

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.repository.js

@@ -64,10 +64,22 @@ let IssueRepository = (() => {
                 query.category = filters.category;
             if (filters.entityType)
                 query.entityType = filters.entityType;
+            if (filters.entitySubType)
+                query.entitySubType = filters.entitySubType;
             if (filters.entityId)
                 query.entityId = filters.entityId;
+            if (filters.type)
+                query.type = filters.type;
             if (!filters.includeDeleted)
                 query.isDeleted = false;
+            // Date filtering
+            if (filters.startDate || filters.endDate) {
+                query.createdAt = {};
+                if (filters.startDate)
+                    query.createdAt.$gte = filters.startDate;
+                if (filters.endDate)
+                    query.createdAt.$lte = filters.endDate;
+            }
             if (filters.sort)
                 query.sort = filters.sort;
             if (filters.limit)

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
      */
@@ -47,7 +43,6 @@ export declare class IssueService {
      * Create issue for device going offline longer than baseline
      */
     createDeviceOfflineIssue(device: IDevice, source: Source, reason?: string): Promise<IIssueDocument | null>;
-    createDoorLeftOpenIssue(device: IDevice, source: Source, reason?: string): Promise<IIssueDocument | null>;
     /**
      * Create issue for device battery level below threshold (READINESS + OPERATIONAL + ENERGY)
      */
@@ -117,6 +112,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
          */
@@ -267,22 +245,30 @@ let IssueService = (() => {
                 type: issue_types_1.IssueType.DEVICE_OFFLINE,
             });
         }
-        async createDoorLeftOpenIssue(device, source, reason) {
-            const zone = await typedi_1.default.get(Admin_service_1.AdminService).getZone(device.zoneId);
-            return await this.createDeviceIssue({
-                entityId: device.deviceId,
-                entityType: issue_types_1.EntityType.DEVICE,
-                entitySubType: device.deviceType.type,
-                propertyId: device.propertyId,
-                zoneId: device.zoneId,
-                title: "Door Left Open - Requires Attention",
-                description: `${zone?.name} has a door left open, for more than 10 minutes. ${reason ? `Reason: ${reason}.` : ""}`,
-                createdBy: source,
-                category: issue_types_1.IssuesCategory.SECURITY,
-                priority: issue_types_1.IssuePriority.HIGH,
-                type: issue_types_1.IssueType.DOOR_LEFT_OPEN,
-            });
-        }
+        // async createDoorLeftOpenIssue(
+        //   device: IDevice,
+        //   source: Source,
+        //   reason?: string
+        // ): Promise<IIssueDocument | null> {
+        //   const zone = await Container.get(AdminService).getZone(device.zoneId);
+        //   return await this.createDeviceIssue({
+        //     entityId: device.deviceId,
+        //     entityType: EntityType.DEVICE,
+        //     entitySubType: device.deviceType.type as EntitySubType,
+        //     propertyId: device.propertyId,
+        //     zoneId: device.zoneId,
+        //     title: "Door Left Open - Requires Attention",
+        //     description: `${
+        //       zone?.name
+        //     } has a door left open, for more than 10 minutes. ${
+        //       reason ? `Reason: ${reason}.` : ""
+        //     }`,
+        //     createdBy: source,
+        //     category: IssuesCategory.SECURITY,
+        //     priority: IssuePriority.HIGH,
+        //     type: IssueType.DOOR_LEFT_OPEN,
+        //   });
+        // }
         /**
          * Create issue for device battery level below threshold (READINESS + OPERATIONAL + ENERGY)
          */
@@ -356,51 +342,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 +636,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
          */
@@ -721,6 +844,12 @@ let IssueService = (() => {
             if (filters.skip && filters.skip < 0) {
                 throw new Error("Skip must be non-negative");
             }
+            // Validate date filters
+            if (filters.startDate &&
+                filters.endDate &&
+                filters.startDate > filters.endDate) {
+                throw new Error("Start date must be before or equal to end date");
+            }
         }
         validateUpdateData(data) {
             if (data.title && data.title.trim().length < 5) {
@@ -764,7 +893,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",
@@ -53,24 +52,16 @@ export declare enum IssueType {
     DEVICE_OFFLINE = "DEVICE_OFFLINE",
     HUB_OFFLINE = "HUB_OFFLINE",
     ACCOUNT_UNAUTHORIZED = "ACCOUNT_UNAUTHORIZED",
-    ACCOUNT_NEW_DEVICE = "ACCOUNT_NEW_DEVICE",
     ACCOUNT_MISSING_DEVICE = "ACCOUNT_MISSING_DEVICE",
-    DEVICE_TAMPER_ATTEMPT = "DEVICE_TAMPER_ATTEMPT",
     LOCK_JAMMED = "LOCK_JAMMED",
-    DEVICE_MALFUNCTION = "DEVICE_MALFUNCTION",
-    DOOR_LEFT_OPEN = "DOOR_LEFT_OPEN",
-    DOOR_OPEN_FREQUENT = "DOOR_OPEN_FREQUENT",
-    DOOR_OPEN_OUTSIDE_BIZ_HOURS = "DOOR_OPEN_OUTSIDE_BIZ_HOURS",
-    LOCK_ACCESS_EMERGENCY_CODE = "LOCK_ACCESS_EMERGENCY_CODE",
-    LOCK_ACCESS_MASTER_CODE = "LOCK_ACCESS_MASTER_CODE",
-    SPECIFIC_DOOR_ACCESS = "SPECIFIC_DOOR_ACCESS",
-    GUEST_LOCK_FIRST_ACCESS = "GUEST_LOCK_FIRST_ACCESS"
+    DEVICE_MALFUNCTION = "DEVICE_MALFUNCTION"
 }
 export interface IssueDocument {
     _id: string;
     category: IssuesCategory;
     propertyId: string;
     zoneId?: string;
+    zoneName?: string;
     title: string;
     description: string;
     entityId?: string;
@@ -93,6 +84,7 @@ export interface CreateIssueData {
     category: IssuesCategory;
     propertyId: string;
     zoneId?: string;
+    zoneName?: string;
     title: string;
     description: string;
     entityId: string;
@@ -116,6 +108,7 @@ export interface UpdateIssueData {
     priority?: IssuePriority;
     assignedTo?: string;
     updatedBy?: string;
+    updatedAt?: Date;
     resolvedAt?: Date;
     dueDate?: Date;
     isDeleted?: boolean;
@@ -127,6 +120,7 @@ export interface AddCommentData {
 export interface IIssueQuery {
     propertyId?: string;
     zoneId?: string;
+    zoneName?: string;
     assignedTo?: string;
     status?: IssueStatus;
     priority?: IssuePriority;
@@ -136,6 +130,8 @@ export interface IIssueQuery {
     entitySubType?: EntitySubType;
     entityId?: string;
     includeDeleted?: boolean;
+    startDate?: Date;
+    endDate?: Date;
     limit?: number;
     skip?: number;
     sort?: {

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";
@@ -55,16 +54,7 @@ var IssueType;
     IssueType["DEVICE_OFFLINE"] = "DEVICE_OFFLINE";
     IssueType["HUB_OFFLINE"] = "HUB_OFFLINE";
     IssueType["ACCOUNT_UNAUTHORIZED"] = "ACCOUNT_UNAUTHORIZED";
-    IssueType["ACCOUNT_NEW_DEVICE"] = "ACCOUNT_NEW_DEVICE";
     IssueType["ACCOUNT_MISSING_DEVICE"] = "ACCOUNT_MISSING_DEVICE";
-    IssueType["DEVICE_TAMPER_ATTEMPT"] = "DEVICE_TAMPER_ATTEMPT";
     IssueType["LOCK_JAMMED"] = "LOCK_JAMMED";
     IssueType["DEVICE_MALFUNCTION"] = "DEVICE_MALFUNCTION";
-    IssueType["DOOR_LEFT_OPEN"] = "DOOR_LEFT_OPEN";
-    IssueType["DOOR_OPEN_FREQUENT"] = "DOOR_OPEN_FREQUENT";
-    IssueType["DOOR_OPEN_OUTSIDE_BIZ_HOURS"] = "DOOR_OPEN_OUTSIDE_BIZ_HOURS";
-    IssueType["LOCK_ACCESS_EMERGENCY_CODE"] = "LOCK_ACCESS_EMERGENCY_CODE";
-    IssueType["LOCK_ACCESS_MASTER_CODE"] = "LOCK_ACCESS_MASTER_CODE";
-    IssueType["SPECIFIC_DOOR_ACCESS"] = "SPECIFIC_DOOR_ACCESS";
-    IssueType["GUEST_LOCK_FIRST_ACCESS"] = "GUEST_LOCK_FIRST_ACCESS";
 })(IssueType || (exports.IssueType = IssueType = {}));

package/package.json

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