dt-common-device 7.1.13 → 7.2.1

package/dist/entities/guest/Guest.repository.js

@@ -52,8 +52,11 @@ let GuestRepository = (() => {
         }
         async getGuest(guestId) {
             try {
-                const guest = await this.pmsPostgres.query(`SELECT * FROM dt_guests WHERE "id" = $1`, [guestId]);
-                return guest.rows[0];
+                const guest = await this.pmsPostgres.query(`SELECT * FROM dt_guest WHERE "id" = $1`, [guestId]);
+                if (guest.rows.length > 0) {
+                    return guest.rows[0];
+                }
+                return null;
             }
             catch (error) {
                 console.error("Error in getGuest:", error);

package/dist/entities/guest/Guest.service.d.ts

@@ -2,5 +2,5 @@ import { IGuest } from "./IGuest";
 export declare class GuestService {
     private readonly guestRepository;
     constructor();
-    getGuest(guestId: string): Promise<IGuest>;
+    getGuest(guestId: string): Promise<IGuest | null>;
 }

package/dist/entities/guest/Guest.service.js

@@ -88,7 +88,10 @@ let GuestService = (() => {
             if (!guestId) {
                 throw new Error("Guest ID is required");
             }
-            return await this.guestRepository.getGuest(guestId);
+            const guest = await this.guestRepository.getGuest(guestId);
+            if (!guest)
+                return null;
+            return guest;
         }
     };
     __setFunctionName(_classThis, "GuestService");

package/dist/entities/schedules/Schedule.repository.d.ts

@@ -2,5 +2,5 @@ import { ISchedule } from "./ISchedule";
 export declare class ScheduleRepository {
     private readonly pmsPostgres;
     constructor();
-    getSchedule(scheduleId: string): Promise<ISchedule>;
+    getSchedule(scheduleId: string): Promise<ISchedule | null>;
 }

package/dist/entities/schedules/Schedule.repository.js

@@ -52,8 +52,11 @@ let ScheduleRepository = (() => {
         }
         async getSchedule(scheduleId) {
             try {
-                const schedule = await this.pmsPostgres.query(`SELECT * FROM dt_schedules WHERE "id" = $1`, [scheduleId]);
-                return schedule.rows[0];
+                const schedule = await this.pmsPostgres.query(`SELECT * FROM dt_schedule WHERE "id" = $1`, [scheduleId]);
+                if (schedule.rows.length > 0) {
+                    return schedule.rows[0];
+                }
+                return null;
             }
             catch (error) {
                 console.error("Error in getSchedule:", error);

package/dist/entities/schedules/Schedule.service.d.ts

@@ -2,5 +2,5 @@ import { ISchedule } from "./ISchedule";
 export declare class ScheduleService {
     private readonly scheduleRepository;
     constructor();
-    getSchedule(scheduleId: string): Promise<ISchedule>;
+    getSchedule(scheduleId: string): Promise<ISchedule | null>;
 }

package/dist/entities/schedules/Schedule.service.js

@@ -88,7 +88,10 @@ let ScheduleService = (() => {
             if (!scheduleId) {
                 throw new Error("Schedule ID is required");
             }
-            return await this.scheduleRepository.getSchedule(scheduleId);
+            const schedule = await this.scheduleRepository.getSchedule(scheduleId);
+            if (!schedule)
+                return null;
+            return schedule;
         }
     };
     __setFunctionName(_classThis, "ScheduleService");

package/dist/entities/user/User.repository.js

@@ -52,7 +52,10 @@ let UserRepository = (() => {
         }
         async getUser(userId) {
             const user = await this.postgres.query(`SELECT * FROM dt_users WHERE "id" = $1`, [userId]);
-            return user.rows[0];
+            if (user.rows.length > 0) {
+                return user.rows[0];
+            }
+            return null;
         }
     };
     __setFunctionName(_classThis, "UserRepository");

package/dist/entities/user/User.service.d.ts

@@ -2,5 +2,5 @@ import { IUser } from "./IUser";
 export declare class UserService {
     private readonly userRepository;
     constructor();
-    getUser(userId: string): Promise<IUser>;
+    getUser(userId: string): Promise<IUser | null>;
 }

package/dist/entities/user/User.service.js

@@ -87,7 +87,10 @@ let UserService = (() => {
             if (!userId) {
                 throw new Error("User ID is required");
             }
-            return await this.userRepository.getUser(userId);
+            const user = await this.userRepository.getUser(userId);
+            if (!user)
+                return null;
+            return user;
         }
     };
     __setFunctionName(_classThis, "UserService");

package/dist/entities/zone/Zone.service.js

@@ -88,7 +88,10 @@ let ZoneService = (() => {
             if (!zoneId) {
                 throw new Error("Zone ID is required");
             }
-            return await this.zoneRepository.getZone(zoneId);
+            const zone = await this.zoneRepository.getZone(zoneId);
+            if (!zone)
+                return null;
+            return zone;
         }
     };
     __setFunctionName(_classThis, "ZoneService");

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

@@ -14,7 +14,7 @@ interface IIssueModel extends Model<IIssueDocument, {}, IIssueMethods> {
     findOverdue(includeDeleted?: boolean): Promise<IIssueDocument[]>;
     findUpcoming(days?: number, includeDeleted?: boolean): Promise<IIssueDocument[]>;
 }
-declare const IssueSchema: mongoose.Schema<IIssueDocument, IIssueModel, IIssueMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IIssueDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IIssueDocument>, {}> & Omit<mongoose.FlatRecord<IIssueDocument> & Required<{
+declare const IssueSchema: mongoose.Schema<IIssueDocument, IIssueModel, IIssueMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IIssueDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IIssueDocument>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & Omit<mongoose.FlatRecord<IIssueDocument> & Required<{
     _id: string;
 }> & {
     __v: number;

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,34 +6,30 @@ 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>;
     /**
      * Create an operations issue using IssueBuilder
      */
-    createOperationsIssue(data: CreateIssueData): Promise<IIssueDocument>;
+    createOperationsIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
     /**
      * Create a security issue using IssueBuilder
      */
-    createSecurityIssue(data: CreateIssueData): Promise<IIssueDocument>;
+    createSecurityIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
     /**
      * Create an energy issue using IssueBuilder
      */
-    createEnergyIssue(data: CreateIssueData): Promise<IIssueDocument>;
+    createEnergyIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
     /**
      * Create a device-specific issue using IssueBuilder
      */
-    createDeviceIssue(data: CreateIssueData): Promise<IIssueDocument>;
+    createDeviceIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
     /**
      * Create a hub-specific issue using IssueBuilder
      */
-    createHubIssue(data: CreateIssueData): Promise<IIssueDocument>;
+    createHubIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
     /**
      * Create a user-specific issue using IssueBuilder
      */
-    createUserIssue(data: CreateIssueData): Promise<IIssueDocument>;
+    createUserIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
     createCloudAccountAuthorizationIssue(data: {
         propertyId: string;
         entityId: string;
@@ -42,33 +38,33 @@ export declare class IssueService {
         description: string;
         createdBy: string;
         type: IssueType;
-    }): Promise<IIssueDocument>;
+    }): Promise<IIssueDocument | null>;
     /**
      * Create issue for device going offline longer than baseline
      */
-    createDeviceOfflineIssue(device: IDevice, source: Source, reason?: string): Promise<IIssueDocument>;
-    createDoorLeftOpenIssue(device: IDevice, source: Source, reason?: string): Promise<IIssueDocument>;
+    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)
      */
-    createDeviceBatteryIssue(device: IDevice, batteryLevel: number, threshold: number, source: Source): Promise<IIssueDocument>;
+    createDeviceBatteryIssue(device: IDevice, batteryLevel: number, threshold: number, priority: IssuePriority, source: Source): Promise<IIssueDocument | null>;
     /**
      * Create issue for device malfunction (jammed or not accepting codes) (READINESS + OPERATIONAL)
      */
-    createDeviceMalfunctionIssue(device: IDevice, source: Source, reason?: string): Promise<IIssueDocument>;
+    createDeviceMalfunctionIssue(device: IDevice, source: Source, reason?: string): Promise<IIssueDocument | null>;
     /**
      * Create a maintenance issue using IssueBuilder
      */
-    createMaintenanceIssue(data: CreateIssueData): Promise<IIssueDocument>;
+    createMaintenanceIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
     /**
      * Create a high priority issue using IssueBuilder
      */
-    createHighPriorityIssue(data: CreateIssueData): Promise<IIssueDocument>;
+    createHighPriorityIssue(data: CreateIssueData): Promise<IIssueDocument | null>;
     /**
      * Create a new issue with business logic validation
      * Accepts either a CreateIssueData object or an IssueBuilder instance
      */
-    createIssue(issueData: CreateIssueData | IssueBuilder): Promise<IIssueDocument>;
+    createIssue(issueData: CreateIssueData | IssueBuilder): Promise<IIssueDocument | null>;
     /**
      * Get issue by ID with business logic
      */
@@ -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,7 +77,11 @@ 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");
+const dt_pub_sub_1 = require("dt-pub-sub");
 let IssueService = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;
@@ -87,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
          */
@@ -257,7 +238,7 @@ let IssueService = (() => {
                 propertyId: device.propertyId,
                 zoneId: device.zoneId,
                 title: "Device Offline - Requires Attention",
-                description: `${device.name} has been offline for longer than the threshold time. ${reason ? `Reason: ${reason}` : ""}.`,
+                description: `${device.name} has been offline for longer than the threshold time. ${reason ? `Reason: ${reason}.` : ""}`,
                 createdBy: source,
                 category: issue_types_1.IssuesCategory.OPERATIONS,
                 priority: issue_types_1.IssuePriority.CRITICAL,
@@ -273,7 +254,7 @@ let IssueService = (() => {
                 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}` : ""}.`,
+                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,
@@ -283,7 +264,7 @@ let IssueService = (() => {
         /**
          * Create issue for device battery level below threshold (READINESS + OPERATIONAL + ENERGY)
          */
-        async createDeviceBatteryIssue(device, batteryLevel, threshold, source) {
+        async createDeviceBatteryIssue(device, batteryLevel, threshold, priority, source) {
             return await this.createDeviceIssue({
                 entityId: device.deviceId,
                 entityType: issue_types_1.EntityType.DEVICE,
@@ -294,7 +275,7 @@ let IssueService = (() => {
                 description: `${device.name} battery level is ${batteryLevel}%, which is below the property threshold of ${threshold}%.`,
                 createdBy: source,
                 category: issue_types_1.IssuesCategory.ENERGY,
-                priority: issue_types_1.IssuePriority.CRITICAL,
+                priority: priority,
                 type: issue_types_1.IssueType.BATTERY_LOW,
             });
         }
@@ -309,7 +290,7 @@ let IssueService = (() => {
                 propertyId: device.propertyId,
                 zoneId: device.zoneId,
                 title: `Device Malfunction - Requires Attention`,
-                description: `${device.name} is malfunctioning. ${reason ? `Reason: ${reason}` : ""}.`,
+                description: `${device.name} is malfunctioning. ${reason ? `Reason: ${reason}.` : ""}`,
                 createdBy: source,
                 category: issue_types_1.IssuesCategory.OPERATIONS,
                 priority: issue_types_1.IssuePriority.HIGH,
@@ -353,26 +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");
+            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.SUCCESS,
+                    auditData: {
+                        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: Service_1.Source.USER,
+                        propertyId: issueData?.propertyId || "",
+                        zoneId: issueData?.zoneId || "",
+                        errorMessage: error.message,
+                        error: error,
+                        createdBy: issueData?.createdBy || "",
+                    },
+                });
+                throw error;
             }
-            return await this.issueRepository.create(processedIssueData);
         }
         /**
          * Get issue by ID with business logic
@@ -585,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
          */
@@ -736,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.1.13",
+  "version": "7.2.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [

package/dist/admin/Admin.repository.d.ts

@@ -1,7 +0,0 @@
-export declare class AdminRepository {
-    private readonly axiosInstance;
-    private readonly deviceRepository;
-    private readonly postgres;
-    constructor();
-    getZonesByAccessGroupIds(accessGroupIds: string[]): Promise<any[]>;
-}