dt-common-device 13.0.3 → 13.0.7

package/dist/device/local/services/IssueService.example.d.ts

@@ -0,0 +1,68 @@
+import { IssueService } from "./Issue.service";
+/**
+ * Example usage of the updated IssueService with IssueBuilder integration
+ * This file demonstrates various ways to use the IssueService with the new IssueBuilder
+ */
+export declare class IssueServiceExample {
+    private readonly issueService;
+    constructor(issueService: IssueService);
+    /**
+     * Example 1: Using the updated createIssue method with IssueBuilder
+     */
+    createIssueWithBuilder(): Promise<import("../../../types/issue.types").IssueDocument>;
+    /**
+     * Example 2: Using convenience methods for specific issue types
+     */
+    createSpecificIssues(): Promise<{
+        readinessIssue: import("../../../types/issue.types").IssueDocument;
+        operationsIssue: import("../../../types/issue.types").IssueDocument;
+        securityIssue: import("../../../types/issue.types").IssueDocument;
+        energyIssue: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 3: Using device-specific issue methods
+     */
+    createDeviceIssues(): Promise<{
+        deviceIssue1: import("../../../types/issue.types").IssueDocument;
+        deviceIssue2: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 4: Using hub-specific issue methods
+     */
+    createHubIssues(): Promise<{
+        hubIssue1: import("../../../types/issue.types").IssueDocument;
+        hubIssue2: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 5: Using user-specific issue methods
+     */
+    createUserIssues(): Promise<{
+        userIssue: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 6: Using maintenance and urgent issue methods
+     */
+    createMaintenanceAndUrgentIssues(): Promise<{
+        maintenanceIssue: import("../../../types/issue.types").IssueDocument;
+        urgentIssue: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 7: Using static factory methods with IssueBuilder
+     */
+    createIssuesWithStaticMethods(): Promise<{
+        issue1: import("../../../types/issue.types").IssueDocument;
+        issue2: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 8: Creating multiple issues efficiently
+     */
+    createMultipleIssues(): Promise<import("../../../types/issue.types").IssueDocument[]>;
+    /**
+     * Example 9: Creating issue with due date calculation
+     */
+    createIssueWithDueDate(): Promise<import("../../../types/issue.types").IssueDocument>;
+    /**
+     * Example 10: Backward compatibility - still works with CreateIssueData
+     */
+    createIssueWithLegacyData(): Promise<import("../../../types/issue.types").IssueDocument>;
+}

package/dist/device/local/services/IssueService.example.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueServiceExample = void 0;
+const IssueBuilder_1 = require("../entities/IssueBuilder");
+const issue_types_1 = require("../../../types/issue.types");
+/**
+ * Example usage of the updated IssueService with IssueBuilder integration
+ * This file demonstrates various ways to use the IssueService with the new IssueBuilder
+ */
+class IssueServiceExample {
+    constructor(issueService) {
+        this.issueService = issueService;
+    }
+    /**
+     * Example 1: Using the updated createIssue method with IssueBuilder
+     */
+    async createIssueWithBuilder() {
+        const issueBuilder = new IssueBuilder_1.IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+            .setPropertyId("prop123")
+            .setTitle("Device Maintenance Required")
+            .setDescription("Device requires scheduled maintenance")
+            .setEntityId("device456")
+            .setEntityType(issue_types_1.EntityType.DEVICE)
+            .setPriority(issue_types_1.IssuePriority.HIGH)
+            .setAssignedTo("tech789")
+            .setCreatedBy("user123")
+            .setDueDate(new Date("2024-01-15"));
+        // Pass the IssueBuilder directly to createIssue
+        const issue = await this.issueService.createIssue(issueBuilder);
+        return issue;
+    }
+    /**
+     * Example 2: Using convenience methods for specific issue types
+     */
+    async createSpecificIssues() {
+        // Create a readiness issue
+        const readinessIssue = await this.issueService.createReadinessIssue("prop123", "System Maintenance Required", "System maintenance is scheduled for tonight", "admin", "system456", issue_types_1.EntityType.PROPERTY, "maintenance-team", new Date("2024-01-20"));
+        // Create an operations issue
+        const operationsIssue = await this.issueService.createOperationsIssue("prop123", "Device Temperature High", "Device temperature exceeds normal operating range", "monitor", "device789", issue_types_1.EntityType.DEVICE, "tech-support", new Date("2024-01-10"));
+        // Create a security issue
+        const securityIssue = await this.issueService.createSecurityIssue("prop123", "Unauthorized Access Attempt", "Multiple failed login attempts detected", "security-system", "user123", issue_types_1.EntityType.USER, "security-team", new Date("2024-01-05"));
+        // Create an energy issue
+        const energyIssue = await this.issueService.createEnergyIssue("prop123", "High Energy Consumption", "Energy usage is 20% above normal levels", "energy-monitor", "zone456", issue_types_1.EntityType.COLLECTION, "energy-manager", new Date("2024-01-25"));
+        return { readinessIssue, operationsIssue, securityIssue, energyIssue };
+    }
+    /**
+     * Example 3: Using device-specific issue methods
+     */
+    async createDeviceIssues() {
+        // Create a device issue with default category and priority
+        const deviceIssue1 = await this.issueService.createDeviceIssue("device123", "prop456", "Device Battery Low", "Device battery level is below 20%", "system", undefined, // Use default category
+        undefined, // Use default priority
+        "maintenance-team", new Date("2024-01-12"));
+        // Create a device issue with custom category and priority
+        const deviceIssue2 = await this.issueService.createDeviceIssue("device789", "prop456", "Device Firmware Update Available", "New firmware version is available for installation", "firmware-manager", issue_types_1.IssuesCategory.READINESS, issue_types_1.IssuePriority.MEDIUM, "admin", new Date("2024-01-20"));
+        return { deviceIssue1, deviceIssue2 };
+    }
+    /**
+     * Example 4: Using hub-specific issue methods
+     */
+    async createHubIssues() {
+        // Create a hub issue with default settings
+        const hubIssue1 = await this.issueService.createHubIssue("hub123", "prop456", "Hub Connection Lost", "Hub has lost connection to the network", "network-monitor", undefined, // Use default category
+        undefined, // Use default priority
+        "network-admin", new Date("2024-01-05"));
+        // Create a hub issue with custom settings
+        const hubIssue2 = await this.issueService.createHubIssue("hub789", "prop456", "Hub Maintenance Required", "Hub requires scheduled maintenance", "maintenance-system", issue_types_1.IssuesCategory.READINESS, issue_types_1.IssuePriority.LOW, "technician", new Date("2024-01-15"));
+        return { hubIssue1, hubIssue2 };
+    }
+    /**
+     * Example 5: Using user-specific issue methods
+     */
+    async createUserIssues() {
+        // Create a user issue
+        const userIssue = await this.issueService.createUserIssue("user456", "prop303", "User Access Review Required", "User access permissions need review", "access-control", issue_types_1.IssuesCategory.SECURITY, issue_types_1.IssuePriority.MEDIUM, "hr-admin", new Date("2024-01-30"));
+        return { userIssue };
+    }
+    /**
+     * Example 6: Using maintenance and urgent issue methods
+     */
+    async createMaintenanceAndUrgentIssues() {
+        // Create a maintenance issue
+        const maintenanceIssue = await this.issueService.createMaintenanceIssue("prop505", "Scheduled Device Maintenance", "Regular maintenance is scheduled for this device", "maintenance-scheduler", "device789", issue_types_1.EntityType.DEVICE, "technician", new Date("2024-01-12"));
+        // Create an urgent issue
+        const urgentIssue = await this.issueService.createUrgentIssue("prop606", "Critical Hub Failure", "Hub is experiencing critical failures", "monitoring-system", "hub123", issue_types_1.EntityType.HUB, "emergency-tech", new Date("2024-01-03"));
+        return { maintenanceIssue, urgentIssue };
+    }
+    /**
+     * Example 7: Using static factory methods with IssueBuilder
+     */
+    async createIssuesWithStaticMethods() {
+        // Create a device issue using static factory method
+        const deviceIssue = IssueBuilder_1.IssueBuilder.createDeviceIssue("device123", "prop456")
+            .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+            .setTitle("Device Offline")
+            .setDescription("Device has been offline for more than 5 minutes")
+            .setPriority(issue_types_1.IssuePriority.HIGH)
+            .setAssignedTo("tech-support")
+            .setCreatedBy("monitor")
+            .setDueDate(new Date("2024-01-10"));
+        const issue1 = await this.issueService.createIssue(deviceIssue);
+        // Create a hub issue using static factory method
+        const hubIssue = IssueBuilder_1.IssueBuilder.createHubIssue("hub789", "prop202")
+            .setCategory(issue_types_1.IssuesCategory.SECURITY)
+            .setTitle("Hub Security Breach")
+            .setDescription("Unauthorized access attempt detected on hub")
+            .setPriority(issue_types_1.IssuePriority.CRITICAL)
+            .setAssignedTo("security-team")
+            .setCreatedBy("security-system")
+            .setDueDate(new Date("2024-01-05"));
+        const issue2 = await this.issueService.createIssue(hubIssue);
+        return { issue1, issue2 };
+    }
+    /**
+     * Example 8: Creating multiple issues efficiently
+     */
+    async createMultipleIssues() {
+        const issues = [];
+        // Create multiple device issues efficiently
+        const deviceIds = ["device1", "device2", "device3"];
+        const propertyId = "prop123";
+        for (const deviceId of deviceIds) {
+            const issueBuilder = IssueBuilder_1.IssueBuilder.createDeviceIssue(deviceId, propertyId)
+                .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+                .setTitle(`Device ${deviceId} Status`)
+                .setDescription(`Status check for device ${deviceId}`)
+                .setPriority(issue_types_1.IssuePriority.MEDIUM)
+                .setAssignedTo("batch-processor")
+                .setCreatedBy("batch-processor")
+                .setDueDate(new Date("2024-01-15"));
+            const issue = await this.issueService.createIssue(issueBuilder);
+            issues.push(issue);
+        }
+        return issues;
+    }
+    /**
+     * Example 9: Creating issue with due date calculation
+     */
+    async createIssueWithDueDate() {
+        const dueDate = new Date();
+        dueDate.setDate(dueDate.getDate() + 7); // Due in 7 days
+        const issueBuilder = new IssueBuilder_1.IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.READINESS)
+            .setPropertyId("prop808")
+            .setTitle("System Update Required")
+            .setDescription("System requires critical security update")
+            .setEntityType(issue_types_1.EntityType.PROPERTY)
+            .setPriority(issue_types_1.IssuePriority.HIGH)
+            .setAssignedTo("system-admin")
+            .setCreatedBy("update-manager")
+            .setDueDate(dueDate);
+        const issue = await this.issueService.createIssue(issueBuilder);
+        return issue;
+    }
+    /**
+     * Example 10: Backward compatibility - still works with CreateIssueData
+     */
+    async createIssueWithLegacyData() {
+        const issueData = {
+            category: issue_types_1.IssuesCategory.OPERATIONS,
+            propertyId: "prop123",
+            title: "Legacy Issue",
+            description: "This issue was created using the old CreateIssueData format",
+            entityId: "device456",
+            entityType: issue_types_1.EntityType.DEVICE,
+            priority: issue_types_1.IssuePriority.MEDIUM,
+            assignedTo: "tech-support",
+            createdBy: "legacy-system",
+            dueDate: new Date("2024-01-20")
+        };
+        // This still works with the updated createIssue method
+        const issue = await this.issueService.createIssue(issueData);
+        return issue;
+    }
+}
+exports.IssueServiceExample = IssueServiceExample;

package/dist/device/local/services/Property.service.d.ts

@@ -0,0 +1,8 @@
+export declare class LocalPropertyService {
+    private readonly propertyRepository;
+    constructor();
+    getPropertyPreferences(propertyId: string): Promise<import("../interfaces").IPropertySettings | null>;
+    getProperty(propertyId: string): Promise<import("../interfaces").IProperty | null>;
+    getPropertyTimeZone(propertyId: string): Promise<string>;
+    getAllProperties(): Promise<any[]>;
+}

package/dist/device/local/services/Property.service.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalPropertyService = void 0;
+const Property_repository_1 = require("../repository/Property.repository");
+class LocalPropertyService {
+    constructor() {
+        this.propertyRepository = new Property_repository_1.PropertyRepository();
+    }
+    async getPropertyPreferences(propertyId) {
+        if (!propertyId) {
+            throw new Error("Property ID is required");
+        }
+        return await this.propertyRepository.getPropertyPreferences(propertyId);
+    }
+    async getProperty(propertyId) {
+        if (!propertyId) {
+            throw new Error("Property ID is required");
+        }
+        return await this.propertyRepository.getProperty(propertyId);
+    }
+    async getPropertyTimeZone(propertyId) {
+        if (!propertyId) {
+            throw new Error("Property ID is required");
+        }
+        const property = await this.propertyRepository.getProperty(propertyId);
+        if (!property) {
+            throw new Error("Property not found");
+        }
+        return property.timezone;
+    }
+    async getAllProperties() {
+        const properties = await this.propertyRepository.getAllProperties();
+        return properties;
+    }
+}
+exports.LocalPropertyService = LocalPropertyService;

package/dist/device/local/services/Schedule.service.d.ts

@@ -0,0 +1,9 @@
+import { ISchedule } from "../interfaces/ISchedule";
+export declare class LocalScheduleService {
+    private readonly scheduleRepository;
+    constructor();
+    getSchedule(scheduleId: string): Promise<any>;
+    setSchedule(scheduleId: string, schedule: ISchedule): Promise<any>;
+    getScheduleByZone(zoneId: string): Promise<any>;
+    deleteSchedule(scheduleId: string): Promise<any>;
+}

package/dist/device/local/services/Schedule.service.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalScheduleService = void 0;
+const typedi_1 = __importDefault(require("typedi"));
+const Schedule_repository_1 = require("../repository/Schedule.repository");
+class LocalScheduleService {
+    constructor() {
+        this.scheduleRepository = typedi_1.default.get(Schedule_repository_1.ScheduleRepository);
+    }
+    async getSchedule(scheduleId) {
+        return await this.scheduleRepository.getSchedule(scheduleId);
+    }
+    async setSchedule(scheduleId, schedule) {
+        return await this.scheduleRepository.setSchedule(scheduleId, schedule);
+    }
+    async getScheduleByZone(zoneId) {
+        return await this.scheduleRepository.getScheduleByZone(zoneId);
+    }
+    async deleteSchedule(scheduleId) {
+        return await this.scheduleRepository.deleteSchedule(scheduleId);
+    }
+}
+exports.LocalScheduleService = LocalScheduleService;

package/dist/device/local/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Device.service";
+export * from "./Hub.service";
+export * from "./Schedule.service";

package/dist/device/local/services/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Device.service"), exports);
+__exportStar(require("./Hub.service"), exports);
+__exportStar(require("./Schedule.service"), exports);

package/dist/entities/accessGroup/AccessGroup.repository.d.ts

@@ -0,0 +1,5 @@
+export declare class AccessGroupRepository {
+    private readonly postgres;
+    constructor();
+    getAccessGroup(accessGroupId: string): Promise<any>;
+}

package/dist/entities/accessGroup/AccessGroup.repository.js

@@ -0,0 +1,72 @@
+"use strict";
+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";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+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.AccessGroupRepository = void 0;
+const typedi_1 = require("typedi");
+const db_1 = require("../../db");
+let AccessGroupRepository = (() => {
+    let _classDecorators = [(0, typedi_1.Service)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var AccessGroupRepository = _classThis = class {
+        constructor() {
+            this.postgres = (0, db_1.getPostgresClient)();
+        }
+        async getAccessGroup(accessGroupId) {
+            const query = `
+      SELECT * FROM dt_collections
+      WHERE "id" = $1
+    `;
+            const result = await this.postgres.query(query, [accessGroupId]);
+            return result.rows[0];
+        }
+    };
+    __setFunctionName(_classThis, "AccessGroupRepository");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        AccessGroupRepository = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return AccessGroupRepository = _classThis;
+})();
+exports.AccessGroupRepository = AccessGroupRepository;

package/dist/entities/accessGroup/AccessGroup.service.d.ts

@@ -0,0 +1,5 @@
+export declare class AccessGroupService {
+    private readonly accessGroupRepository;
+    constructor();
+    getAccessGroup(accessGroupId: string): Promise<any>;
+}

package/dist/entities/accessGroup/AccessGroup.service.js

@@ -0,0 +1,105 @@
+"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";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    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.AccessGroupService = void 0;
+const typedi_1 = __importStar(require("typedi"));
+const AccessGroup_repository_1 = require("./AccessGroup.repository");
+let AccessGroupService = (() => {
+    let _classDecorators = [(0, typedi_1.Service)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var AccessGroupService = _classThis = class {
+        constructor() {
+            this.accessGroupRepository = typedi_1.default.get(AccessGroup_repository_1.AccessGroupRepository);
+        }
+        async getAccessGroup(accessGroupId) {
+            if (!accessGroupId) {
+                throw new Error("Access Group ID is required");
+            }
+            return await this.accessGroupRepository.getAccessGroup(accessGroupId);
+        }
+    };
+    __setFunctionName(_classThis, "AccessGroupService");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        AccessGroupService = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return AccessGroupService = _classThis;
+})();
+exports.AccessGroupService = AccessGroupService;
+// Accessgroup.getAccessGroup(accessGroupId)
+// GetAccessGroup()

package/dist/entities/accessGroup/IAccessGroup.d.ts

@@ -0,0 +1,14 @@
+export interface IAccessGroup {
+    id: string;
+    propertyId: string;
+    name: string;
+    displayName: string;
+    type: string;
+    externalId?: string;
+    refId?: string;
+    isDeleted: boolean;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+    accessibleBy: string[];
+}

package/dist/entities/accessGroup/IAccessGroup.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/entities/accessGroup/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./AccessGroup.service";
+export * from "./IAccessGroup";

package/dist/entities/accessGroup/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AccessGroup.service"), exports);
+__exportStar(require("./IAccessGroup"), exports);

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

@@ -6,7 +6,7 @@ export declare class AdminRepository {
     private readonly redisUtils;
     constructor();
     getZonesByAccessGroupIds(accessGroupIds: string[], propertyId: string): Promise<any[]>;
-    getZonesByAccessGroups(accessGroupIds: string[]): Promise<any[]>;
+    getZonesByAccessGroups(accessGroupIds: string[], type?: string[]): Promise<any[]>;
     getAccessGroup(accessGroupId: string, propertyId?: string): Promise<IAccessGroup | null>;
     getZoneAccessGroupByZoneId(zoneId: string): Promise<IZoneAccessGroup[] | null>;
     getZone(zoneId: string, propertyId?: string): Promise<IZone | null>;

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

@@ -207,7 +207,7 @@ let AdminRepository = (() => {
             // );
             return collectionZoneDevices;
         }
-        async getZonesByAccessGroups(accessGroupIds) {
+        async getZonesByAccessGroups(accessGroupIds, type) {
             // Fetch zone IDs associated with these access groups
             const zonesIdsQuery = `
     SELECT DISTINCT z."zoneId"
@@ -221,13 +221,17 @@ let AdminRepository = (() => {
             if (zonesIds.length === 0) {
                 return [];
             }
-            // Fetch zone type IDs for guest rooms and rooms
+            // Use default types if not provided
+            const zoneTypesToFilter = type || ["Guest Room", "Room"];
+            // Fetch zone type IDs for the specified type
             const zoneTypesQuery = `
     SELECT id
     FROM "dt_zoneTypes"
-    WHERE name IN ('Guest Room', 'Room')
+    WHERE name = ANY($1)
   `;
-            const zoneTypes = await this.postgres.query(zoneTypesQuery);
+            const zoneTypes = await this.postgres.query(zoneTypesQuery, [
+                zoneTypesToFilter,
+            ]);
             const guestRoomZoneTypeIds = zoneTypes.rows.map((e) => e.id);
             // Fetch zones matching both sets of IDs
             const zonesQuery = `

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

@@ -3,8 +3,8 @@ export declare class AdminService {
     private readonly adminRepository;
     private readonly redisUtils;
     constructor();
-    getZonesByAccessGroupIds(accessGroupIds: string[], propertyId: string): Promise<any[] | undefined>;
-    getZonesByAccessGroups(accessGroupIds: string[]): Promise<any[] | undefined>;
+    getZonesByAccessGroupIds(accessGroupIds: string[], propertyId: string): Promise<any[]>;
+    getZonesByAccessGroups(accessGroupIds: string[], type?: string[]): Promise<any[]>;
     getAccessGroup(accessGroupId: string, propertyId?: string): Promise<IAccessGroup | null>;
     getAccessGroupByZoneId(zoneId: string): Promise<IAccessGroup[] | []>;
     getZone(zoneId: string, propertyId?: string): Promise<IZone | null>;