dt-common-device 5.1.7 → 6.1.0

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

@@ -1,5 +1,5 @@
 import mongoose, { Model } from "mongoose";
-import { AlertCategory, AlertSeverity, EntityType, AlertDocument as IAlertDocument, CreateAlertData, UpdateAlertData } from "./alert.types";
+import { AlertCategory, AlertDocument as IAlertDocument, CreateAlertData, UpdateAlertData } from "./alert.types";
 interface IAlertMethods {
     markAsRead(updatedBy: string): void;
     markAsUnread(updatedBy: string): void;
@@ -9,12 +9,7 @@ interface IAlertMethods {
     unsnooze(updatedBy: string): void;
 }
 interface IAlertModel extends Model<IAlertDocument, {}, IAlertMethods> {
-    findByProperty(propertyId: string, includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    findByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IAlertDocument[]>;
     findByCategory(category: AlertCategory, includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    findBySeverity(severity: AlertSeverity, includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    findActive(includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    findUnread(includeDeleted?: boolean): Promise<IAlertDocument[]>;
     findSnoozed(includeDeleted?: boolean): Promise<IAlertDocument[]>;
     findExpiredSnooze(includeDeleted?: boolean): Promise<IAlertDocument[]>;
 }

package/dist/alerts/Alert.model.js

@@ -67,6 +67,7 @@ const AlertSchema = new mongoose_1.Schema({
     entityId: {
         type: String,
         index: true,
+        required: true,
     },
     entityType: {
         type: String,
@@ -155,20 +156,6 @@ AlertSchema.methods.unsnooze = function (updatedBy) {
     this.updatedBy = updatedBy;
 };
 // Static methods
-AlertSchema.statics.findByProperty = function (propertyId, includeDeleted = false) {
-    const query = { propertyId };
-    if (!includeDeleted) {
-        query.isDeleted = false;
-    }
-    return this.find(query).sort({ createdAt: -1 });
-};
-AlertSchema.statics.findByEntity = function (entityId, entityType, includeDeleted = false) {
-    const query = { entityId, entityType };
-    if (!includeDeleted) {
-        query.isDeleted = false;
-    }
-    return this.find(query).sort({ createdAt: -1 });
-};
 AlertSchema.statics.findByCategory = function (category, includeDeleted = false) {
     const query = { category: { $in: [category] } };
     if (!includeDeleted) {
@@ -176,27 +163,6 @@ AlertSchema.statics.findByCategory = function (category, includeDeleted = false)
     }
     return this.find(query).sort({ createdAt: -1 });
 };
-AlertSchema.statics.findBySeverity = function (severity, includeDeleted = false) {
-    const query = { severity };
-    if (!includeDeleted) {
-        query.isDeleted = false;
-    }
-    return this.find(query).sort({ severity: -1, createdAt: -1 });
-};
-AlertSchema.statics.findActive = function (includeDeleted = false) {
-    const query = { isActive: true };
-    if (!includeDeleted) {
-        query.isDeleted = false;
-    }
-    return this.find(query).sort({ severity: -1, createdAt: -1 });
-};
-AlertSchema.statics.findUnread = function (includeDeleted = false) {
-    const query = { isRead: false };
-    if (!includeDeleted) {
-        query.isDeleted = false;
-    }
-    return this.find(query).sort({ severity: -1, createdAt: -1 });
-};
 AlertSchema.statics.findSnoozed = function (includeDeleted = false) {
     const query = { snoozeUntil: { $exists: true, $ne: null } };
     if (!includeDeleted) {

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

@@ -1,6 +1,7 @@
 import { IAlertDocument } from "./Alert.model";
-import { CreateAlertData, UpdateAlertData, AlertCategory, AlertSeverity, EntityType } from "./alert.types";
+import { CreateAlertData, UpdateAlertData, AlertCategory, AlertSeverity, IAlertQuery } from "./alert.types";
 export declare class AlertRepository {
+    private buildQuery;
     /**
      * Create a new alert
      */
@@ -12,21 +13,7 @@ export declare class AlertRepository {
     /**
      * Find all alerts with filters
      */
-    findAll(filters?: {
-        propertyId?: string;
-        category?: AlertCategory | AlertCategory[];
-        severity?: AlertSeverity;
-        entityType?: EntityType;
-        entityId?: string;
-        isActive?: boolean;
-        isRead?: boolean;
-        includeDeleted?: boolean;
-        limit?: number;
-        skip?: number;
-        sort?: {
-            [key: string]: 1 | -1;
-        };
-    }): Promise<IAlertDocument[]>;
+    query(filters?: IAlertQuery): Promise<IAlertDocument[]>;
     /**
      * Update an alert
      */
@@ -42,40 +29,11 @@ export declare class AlertRepository {
     /**
      * Count alerts with filters
      */
-    count(filters?: {
-        propertyId?: string;
-        category?: AlertCategory | AlertCategory[];
-        severity?: AlertSeverity;
-        entityType?: EntityType;
-        entityId?: string;
-        isActive?: boolean;
-        isRead?: boolean;
-        includeDeleted?: boolean;
-    }): Promise<number>;
-    /**
-     * Find alerts by property
-     */
-    findByProperty(propertyId: string, includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Find alerts by entity
-     */
-    findByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    count(filters?: IAlertQuery): Promise<number>;
     /**
      * Find alerts by category
      */
     findByCategory(category: AlertCategory | AlertCategory[], includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Find alerts by severity
-     */
-    findBySeverity(severity: AlertSeverity, includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Find active alerts
-     */
-    findActive(includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Find unread alerts
-     */
-    findUnread(includeDeleted?: boolean): Promise<IAlertDocument[]>;
     /**
      * Find snoozed alerts
      */

package/dist/alerts/Alert.repository.js

@@ -48,6 +48,32 @@ let AlertRepository = (() => {
     let _classExtraInitializers = [];
     let _classThis;
     var AlertRepository = _classThis = class {
+        async buildQuery(filters = {}) {
+            const query = {};
+            if (filters.propertyId)
+                query.propertyId = filters.propertyId;
+            if (filters.category) {
+                if (Array.isArray(filters.category)) {
+                    query.category = { $in: filters.category };
+                }
+                else {
+                    query.category = { $in: [filters.category] };
+                }
+            }
+            if (filters.severity)
+                query.severity = filters.severity;
+            if (filters.entityType)
+                query.entityType = filters.entityType;
+            if (filters.entityId)
+                query.entityId = filters.entityId;
+            if (filters.isActive !== undefined)
+                query.isActive = filters.isActive;
+            if (filters.isRead !== undefined)
+                query.isRead = filters.isRead;
+            if (!filters.includeDeleted)
+                query.isDeleted = false;
+            return query;
+        }
         /**
          * Create a new alert
          */
@@ -84,31 +110,9 @@ let AlertRepository = (() => {
         /**
          * Find all alerts with filters
          */
-        async findAll(filters = {}) {
+        async query(filters = {}) {
             try {
-                const query = {};
-                if (filters.propertyId)
-                    query.propertyId = filters.propertyId;
-                if (filters.category) {
-                    if (Array.isArray(filters.category)) {
-                        query.category = { $in: filters.category };
-                    }
-                    else {
-                        query.category = { $in: [filters.category] };
-                    }
-                }
-                if (filters.severity)
-                    query.severity = filters.severity;
-                if (filters.entityType)
-                    query.entityType = filters.entityType;
-                if (filters.entityId)
-                    query.entityId = filters.entityId;
-                if (filters.isActive !== undefined)
-                    query.isActive = filters.isActive;
-                if (filters.isRead !== undefined)
-                    query.isRead = filters.isRead;
-                if (!filters.includeDeleted)
-                    query.isDeleted = false;
+                const query = await this.buildQuery(filters);
                 const queryBuilder = Alert_model_1.AlertModel.find(query);
                 if (filters.sort) {
                     queryBuilder.sort(filters.sort);
@@ -170,57 +174,13 @@ let AlertRepository = (() => {
          */
         async count(filters = {}) {
             try {
-                const query = {};
-                if (filters.propertyId)
-                    query.propertyId = filters.propertyId;
-                if (filters.category) {
-                    if (Array.isArray(filters.category)) {
-                        query.category = { $in: filters.category };
-                    }
-                    else {
-                        query.category = { $in: [filters.category] };
-                    }
-                }
-                if (filters.severity)
-                    query.severity = filters.severity;
-                if (filters.entityType)
-                    query.entityType = filters.entityType;
-                if (filters.entityId)
-                    query.entityId = filters.entityId;
-                if (filters.isActive !== undefined)
-                    query.isActive = filters.isActive;
-                if (filters.isRead !== undefined)
-                    query.isRead = filters.isRead;
-                if (!filters.includeDeleted)
-                    query.isDeleted = false;
+                const query = await this.buildQuery(filters);
                 return await Alert_model_1.AlertModel.countDocuments(query);
             }
             catch (error) {
                 throw new Error(`Failed to count alerts: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
-        /**
-         * Find alerts by property
-         */
-        async findByProperty(propertyId, includeDeleted = false) {
-            try {
-                return await Alert_model_1.AlertModel.findByProperty(propertyId, includeDeleted);
-            }
-            catch (error) {
-                throw new Error(`Failed to find alerts by property: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
-        /**
-         * Find alerts by entity
-         */
-        async findByEntity(entityId, entityType, includeDeleted = false) {
-            try {
-                return await Alert_model_1.AlertModel.findByEntity(entityId, entityType, includeDeleted);
-            }
-            catch (error) {
-                throw new Error(`Failed to find alerts by entity: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
         /**
          * Find alerts by category
          */
@@ -242,39 +202,6 @@ let AlertRepository = (() => {
                 throw new Error(`Failed to find alerts by category: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
-        /**
-         * Find alerts by severity
-         */
-        async findBySeverity(severity, includeDeleted = false) {
-            try {
-                return await Alert_model_1.AlertModel.findBySeverity(severity, includeDeleted);
-            }
-            catch (error) {
-                throw new Error(`Failed to find alerts by severity: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
-        /**
-         * Find active alerts
-         */
-        async findActive(includeDeleted = false) {
-            try {
-                return await Alert_model_1.AlertModel.findActive(includeDeleted);
-            }
-            catch (error) {
-                throw new Error(`Failed to find active alerts: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
-        /**
-         * Find unread alerts
-         */
-        async findUnread(includeDeleted = false) {
-            try {
-                return await Alert_model_1.AlertModel.findUnread(includeDeleted);
-            }
-            catch (error) {
-                throw new Error(`Failed to find unread alerts: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
         /**
          * Find snoozed alerts
          */

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

@@ -1,12 +1,11 @@
-import { AlertRepository } from "./Alert.repository";
 import { IAlertDocument } from "./Alert.model";
-import { CreateAlertData, UpdateAlertData, AlertCategory, AlertSeverity, EntityType } from "./alert.types";
+import { CreateAlertData, UpdateAlertData, AlertCategory, AlertSeverity, EntityType, 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(alertRepository: AlertRepository);
+    constructor();
     /**
      * Create a readiness alert using AlertBuilder
      */
@@ -59,18 +58,7 @@ export declare class AlertService {
     /**
      * Get all alerts with business logic filtering
      */
-    getAlerts(filters?: {
-        propertyId?: string;
-        category?: AlertCategory | AlertCategory[];
-        severity?: AlertSeverity;
-        entityType?: EntityType;
-        entityId?: string;
-        isActive?: boolean;
-        isRead?: boolean;
-        includeDeleted?: boolean;
-        limit?: number;
-        skip?: number;
-    }): Promise<IAlertDocument[]>;
+    queryAlerts(filters?: IAlertQuery): Promise<IAlertDocument[]>;
     /**
      * Update an alert with business logic validation
      */
@@ -103,30 +91,10 @@ export declare class AlertService {
      * Unsnooze an alert with business logic
      */
     unsnoozeAlert(id: string, updatedBy: string): Promise<IAlertDocument | null>;
-    /**
-     * Get alerts by property with business logic
-     */
-    getAlertsByProperty(propertyId: string, includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get alerts by entity with business logic
-     */
-    getAlertsByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IAlertDocument[]>;
     /**
      * Get alerts by category with business logic
      */
     getAlertsByCategory(category: AlertCategory | AlertCategory[], includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get alerts by severity with business logic
-     */
-    getAlertsBySeverity(severity: AlertSeverity, includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get active alerts with business logic
-     */
-    getActiveAlerts(includeDeleted?: boolean): Promise<IAlertDocument[]>;
-    /**
-     * Get unread alerts with business logic
-     */
-    getUnreadAlerts(includeDeleted?: boolean): Promise<IAlertDocument[]>;
     /**
      * Get snoozed alerts with business logic
      */

package/dist/alerts/Alert.service.js

@@ -1,4 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
     function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
     var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
@@ -33,13 +49,31 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
     if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AlertService = void 0;
-const typedi_1 = require("typedi");
+const typedi_1 = __importStar(require("typedi"));
+const Alert_repository_1 = require("./Alert.repository");
 const Alert_model_1 = require("./Alert.model");
 const alert_types_1 = require("./alert.types");
 const AlertBuilder_1 = require("./AlertBuilder");
@@ -49,8 +83,8 @@ let AlertService = (() => {
     let _classExtraInitializers = [];
     let _classThis;
     var AlertService = _classThis = class {
-        constructor(alertRepository) {
-            this.alertRepository = alertRepository;
+        constructor() {
+            this.alertRepository = typedi_1.default.get(Alert_repository_1.AlertRepository);
         }
         /**
          * Create a readiness alert using AlertBuilder
@@ -213,12 +247,12 @@ let AlertService = (() => {
         /**
          * Get all alerts with business logic filtering
          */
-        async getAlerts(filters = {}) {
+        async queryAlerts(filters = {}) {
             // Business logic: Validate filters
             this.validateFilters(filters);
             // Business logic: Apply business rules to filters
             const enhancedFilters = this.applyBusinessRules(filters);
-            return await this.alertRepository.findAll(enhancedFilters);
+            return await this.alertRepository.query(enhancedFilters);
         }
         /**
          * Update an alert with business logic validation
@@ -338,24 +372,6 @@ let AlertService = (() => {
             alertModel.unsnooze(updatedBy);
             return await alertModel.save();
         }
-        /**
-         * Get alerts by property with business logic
-         */
-        async getAlertsByProperty(propertyId, includeDeleted = false) {
-            if (!propertyId) {
-                throw new Error("Property ID is required");
-            }
-            return await this.alertRepository.findByProperty(propertyId, includeDeleted);
-        }
-        /**
-         * Get alerts by entity with business logic
-         */
-        async getAlertsByEntity(entityId, entityType, includeDeleted = false) {
-            if (!entityId || !entityType) {
-                throw new Error("Entity ID and entity type are required");
-            }
-            return await this.alertRepository.findByEntity(entityId, entityType, includeDeleted);
-        }
         /**
          * Get alerts by category with business logic
          */
@@ -365,37 +381,6 @@ let AlertService = (() => {
             }
             return await this.alertRepository.findByCategory(category, includeDeleted);
         }
-        /**
-         * Get alerts by severity with business logic
-         */
-        async getAlertsBySeverity(severity, includeDeleted = false) {
-            if (!severity) {
-                throw new Error("Alert severity is required");
-            }
-            return await this.alertRepository.findBySeverity(severity, includeDeleted);
-        }
-        /**
-         * Get active alerts with business logic
-         */
-        async getActiveAlerts(includeDeleted = false) {
-            const activeAlerts = await this.alertRepository.findActive(includeDeleted);
-            // Business logic: Log active alerts for monitoring
-            if (activeAlerts.length > 0) {
-                console.log(`Found ${activeAlerts.length} active alerts`);
-            }
-            return activeAlerts;
-        }
-        /**
-         * Get unread alerts with business logic
-         */
-        async getUnreadAlerts(includeDeleted = false) {
-            const unreadAlerts = await this.alertRepository.findUnread(includeDeleted);
-            // Business logic: Log unread alerts for monitoring
-            if (unreadAlerts.length > 0) {
-                console.warn(`Found ${unreadAlerts.length} unread alerts`);
-            }
-            return unreadAlerts;
-        }
         /**
          * Get snoozed alerts with business logic
          */

package/dist/alerts/AlertBuilder.d.ts

@@ -23,39 +23,39 @@ export declare class AlertBuilder {
     /**
      * Sets the alert category
      */
-    setCategory(category: AlertCategory | AlertCategory[]): AlertBuilder;
+    setCategory(category: AlertCategory | AlertCategory[]): this;
     /**
      * Sets the property ID
      */
-    setPropertyId(propertyId: string): AlertBuilder;
+    setPropertyId(propertyId: string): this;
     /**
      * Sets the alert title
      */
-    setTitle(title: string): AlertBuilder;
+    setTitle(title: string): this;
     /**
      * Sets the alert description
      */
-    setDescription(description: string): AlertBuilder;
+    setDescription(description: string): this;
     /**
      * Sets the entity ID (optional)
      */
-    setEntityId(entityId?: string): AlertBuilder;
+    setEntityId(entityId?: string): this;
     /**
      * Sets the entity type
      */
-    setEntityType(entityType: EntityType): AlertBuilder;
+    setEntityType(entityType: EntityType): this;
     /**
      * Sets the alert severity (optional, defaults to MEDIUM)
      */
-    setSeverity(severity?: AlertSeverity): AlertBuilder;
+    setSeverity(severity?: AlertSeverity): this;
     /**
      * Sets the user who created the alert (optional)
      */
-    setCreatedBy(createdBy?: string): AlertBuilder;
+    setCreatedBy(createdBy?: string): this;
     /**
      * Sets the snooze until date (optional)
      */
-    setSnoozeUntil(snoozeUntil?: Date): AlertBuilder;
+    setSnoozeUntil(snoozeUntil?: Date): this;
     /**
      * Validates that all required fields are present
      */
@@ -68,7 +68,7 @@ export declare class AlertBuilder {
     /**
      * Resets the builder to its initial state
      */
-    reset(): AlertBuilder;
+    reset(): this;
     /**
      * Creates a new builder instance with predefined values for common alert types
      */

package/dist/alerts/AlertBuilder.js

@@ -115,6 +115,7 @@ class AlertBuilder {
             "title",
             "description",
             "entityType",
+            "entityId",
         ];
         const missingFields = requiredFields.filter((field) => !this.data[field]);
         if (missingFields.length > 0) {

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

@@ -54,4 +54,19 @@ export interface UpdateAlertData {
     snoozeUntil?: Date;
     updatedBy?: string;
 }
+export interface IAlertQuery {
+    propertyId?: string;
+    category?: AlertCategory | AlertCategory[];
+    severity?: AlertSeverity;
+    entityType?: EntityType;
+    entityId?: string;
+    isActive?: boolean;
+    isRead?: boolean;
+    includeDeleted?: boolean;
+    sort?: {
+        [key: string]: 1 | -1;
+    };
+    limit?: number;
+    skip?: number;
+}
 export { EntityType } from "../issues/issue.types";

package/dist/audit/AuditUtils.js

@@ -74,13 +74,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuditUtils = void 0;
 const property_1 = require("../entities/property");
 const redis_utils_1 = require("../utils/redis.utils");
-const User_service_1 = require("../entities/user/User.service");
 const services_1 = require("../entities/device/local/services");
-const accessGroup_1 = require("../entities/accessGroup");
-const zone_1 = require("../entities/zone");
-const schedules_1 = require("../entities/schedules");
-const guest_1 = require("../entities/guest");
 const typedi_1 = __importStar(require("typedi"));
+const pms_1 = require("../entities/pms");
+const admin_1 = require("../entities/admin");
 let AuditUtils = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;
@@ -209,7 +206,7 @@ let AuditUtils = (() => {
         }
         async getUserName(userId) {
             return this.getCachedEntityData("user", userId, async () => {
-                const user = await typedi_1.default.get(User_service_1.UserService).getUser(userId);
+                const user = await typedi_1.default.get(admin_1.AdminService).getUser(userId);
                 if (!user)
                     return "";
                 return `${user?.firstName || ""} ${user?.lastName || ""}`.trim();
@@ -217,7 +214,7 @@ let AuditUtils = (() => {
         }
         async getGuestName(guestId) {
             return this.getCachedEntityData("guest", guestId, async () => {
-                const guest = await typedi_1.default.get(guest_1.GuestService).getGuest(guestId);
+                const guest = await typedi_1.default.get(pms_1.PmsService).getGuest(guestId);
                 if (!guest)
                     return "";
                 return `${guest?.firstName || ""} ${guest?.lastName || ""}`.trim();
@@ -233,7 +230,7 @@ let AuditUtils = (() => {
         }
         async getZoneName(zoneId) {
             return this.getCachedEntityData("zone", zoneId, async () => {
-                const zone = await typedi_1.default.get(zone_1.ZoneService).getZone(zoneId);
+                const zone = await typedi_1.default.get(admin_1.AdminService).getZone(zoneId);
                 if (!zone)
                     return "";
                 return zone?.name || "";
@@ -241,7 +238,7 @@ let AuditUtils = (() => {
         }
         async getAccessGroupName(accessGroupId) {
             return this.getCachedEntityData("accessGroup", accessGroupId, async () => {
-                const accessGroup = await typedi_1.default.get(accessGroup_1.AccessGroupService).getAccessGroup(accessGroupId);
+                const accessGroup = await typedi_1.default.get(admin_1.AdminService).getAccessGroup(accessGroupId);
                 if (!accessGroup)
                     return "";
                 return accessGroup?.name || "";
@@ -249,7 +246,7 @@ let AuditUtils = (() => {
         }
         async getScheduleDetails(scheduleId) {
             return this.getCachedEntityData("schedule", scheduleId, async () => {
-                const schedule = await typedi_1.default.get(schedules_1.ScheduleService).getSchedule(scheduleId);
+                const schedule = await typedi_1.default.get(pms_1.PmsService).getSchedule(scheduleId);
                 if (!schedule) {
                     return {
                         scheduleStartDate: "",