dt-common-device 13.0.7 → 13.0.9

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

@@ -9,6 +9,11 @@ export declare class AdminRepository {
     getZonesByAccessGroups(accessGroupIds: string[], type?: string[]): Promise<any[]>;
     getAccessGroup(accessGroupId: string, propertyId?: string): Promise<IAccessGroup | null>;
     getZoneAccessGroupByZoneId(zoneId: string): Promise<IZoneAccessGroup[] | null>;
+    getAllParentZones(zoneId: string): Promise<string[]>;
+    getDirectChildZones(zoneId: string, propertyId?: string): Promise<string[]>;
+    getAllChildZones(zoneId: string, propertyId?: string): Promise<string[]>;
+    getAccessGroupsByZoneId(zoneId: string): Promise<IAccessGroup[]>;
+    getAccessGroupsByZoneIds(zoneIds: string[]): Promise<IAccessGroup[]>;
     getZone(zoneId: string, propertyId?: string): Promise<IZone | null>;
     getUser(userId: string): Promise<IUser | null>;
     getZoneByDeviceId(deviceId: string): Promise<IZone | null>;

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

@@ -224,10 +224,11 @@ let AdminRepository = (() => {
             // Use default types if not provided
             const zoneTypesToFilter = type || ["Guest Room", "Room"];
             // Fetch zone type IDs for the specified type
+            // Using IN with unnest() for better compatibility with string arrays
             const zoneTypesQuery = `
     SELECT id
     FROM "dt_zoneTypes"
-    WHERE name = ANY($1)
+    WHERE name IN (SELECT unnest($1::text[]))
   `;
             const zoneTypes = await this.postgres.query(zoneTypesQuery, [
                 zoneTypesToFilter,
@@ -277,6 +278,116 @@ let AdminRepository = (() => {
             }
             return null;
         }
+        async getAllParentZones(zoneId) {
+            const allParentZoneIds = [];
+            let currentZoneId = zoneId;
+            while (currentZoneId) {
+                const zone = await this.getZone(currentZoneId);
+                if (!zone || !zone.parentId) {
+                    break;
+                }
+                allParentZoneIds.push(zone.parentId);
+                currentZoneId = zone.parentId;
+            }
+            return allParentZoneIds;
+        }
+        async getDirectChildZones(zoneId, propertyId) {
+            const redisKey = propertyId
+                ? `${propertyId}:childZones:${zoneId}`
+                : `childZones:${zoneId}`;
+            // Try to get from cache first
+            const zonesCache = await this.redisUtils.get(redisKey);
+            let zones = null;
+            if (zonesCache !== null && zonesCache !== undefined) {
+                (0, config_1.getLogger)().info(`Got child zones from redis for zone ${zoneId}`);
+                zones = JSON.parse(zonesCache);
+            }
+            else {
+                const response = await (0, utils_1.getAdminServiceAxiosInstance)().get(`/zones/child?zoneId=${zoneId}`);
+                zones = response?.data?.data;
+                if (zones) {
+                    await this.redisUtils.set(redisKey, JSON.stringify(zones), 86400);
+                }
+            }
+            // Get only direct children (first level), not all descendants
+            if (zones && zones.childZones) {
+                if (Array.isArray(zones.childZones)) {
+                    return zones.childZones
+                        .map((z) => z.id)
+                        .filter((id) => id);
+                }
+                else if (zones.childZones.id) {
+                    return [zones.childZones.id];
+                }
+            }
+            return [];
+        }
+        async getAllChildZones(zoneId, propertyId) {
+            const redisKey = propertyId
+                ? `${propertyId}:childZones:${zoneId}`
+                : `childZones:${zoneId}`;
+            // Try to get from cache first
+            const zonesCache = await this.redisUtils.get(redisKey);
+            let zones = null;
+            if (zonesCache !== null && zonesCache !== undefined) {
+                (0, config_1.getLogger)().info(`Got child zones from redis for zone ${zoneId}`);
+                zones = JSON.parse(zonesCache);
+            }
+            else {
+                const response = await (0, utils_1.getAdminServiceAxiosInstance)().get(`/zones/child?zoneId=${zoneId}`);
+                zones = response?.data?.data;
+                if (zones) {
+                    await this.redisUtils.set(redisKey, JSON.stringify(zones), 86400);
+                }
+            }
+            // Recursively collect all child zone IDs (using the same pattern as getZonesByAccessGroupIds)
+            const _zones = (nestedZones, allZones = []) => {
+                nestedZones.forEach((z) => {
+                    const onlyZone = { ...z };
+                    delete onlyZone.childZones;
+                    allZones.push(onlyZone);
+                    if (!Array.isArray(z.childZones)) {
+                        if (z.childZones && z.childZones.id)
+                            z.childZones = [z.childZones];
+                    }
+                    if (z.childZones && z.childZones.length) {
+                        _zones(z.childZones, allZones);
+                    }
+                });
+                return allZones.map((e) => e.id);
+            };
+            if (zones && zones.childZones && zones.childZones.length > 0) {
+                const childZoneIds = _zones(zones.childZones, []);
+                return childZoneIds;
+            }
+            return [];
+        }
+        async getAccessGroupsByZoneId(zoneId) {
+            const query = `
+      SELECT DISTINCT c.*
+      FROM dt_collections c
+      INNER JOIN dt_zones_collection_map zcm ON c.id = zcm."collectionId"
+      WHERE zcm."zoneId" = $1
+      AND c."isDeleted" = false
+    `;
+            const result = await this.postgres.query(query, [zoneId]);
+            return result.rows;
+        }
+        async getAccessGroupsByZoneIds(zoneIds) {
+            if (zoneIds.length === 0) {
+                return [];
+            }
+            // Get all access groups associated with any of these zones
+            const query = `
+      SELECT DISTINCT c.*
+      FROM dt_collections c
+      INNER JOIN dt_zones_collection_map zcm ON c.id = zcm."collectionId"
+      WHERE zcm."zoneId" = ANY($1)
+      AND c."isDeleted" = false
+    `;
+            const result = await this.postgres.query(query, [zoneIds]);
+            return result.rows;
+        }
         async getZone(zoneId, propertyId) {
             try {
                 let query;

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

@@ -7,6 +7,7 @@ export declare class AdminService {
     getZonesByAccessGroups(accessGroupIds: string[], type?: string[]): Promise<any[]>;
     getAccessGroup(accessGroupId: string, propertyId?: string): Promise<IAccessGroup | null>;
     getAccessGroupByZoneId(zoneId: string): Promise<IAccessGroup[] | []>;
+    getAccessgroupBySubParentZoneId(zoneId: string): Promise<IAccessGroup[]>;
     getZone(zoneId: string, propertyId?: string): Promise<IZone | null>;
     getUser(userId: string): Promise<IUser | null>;
     getZoneByDeviceId(deviceId: string): Promise<IZone | null>;

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

@@ -133,6 +133,84 @@ let AdminService = (() => {
             }
             return accessGroups;
         }
+        async getAccessgroupBySubParentZoneId(zoneId) {
+            if (!zoneId) {
+                throw new Error("Zone ID is required");
+            }
+            try {
+                // Get the zone to retrieve propertyId if needed
+                const zone = await this.adminRepository.getZone(zoneId);
+                if (!zone) {
+                    return [];
+                }
+                // Use Map to collect unique access groups (by ID)
+                const accessGroupsMap = new Map();
+                // Track visited zones to avoid cycles and duplicate checks
+                const visitedZoneIds = new Set();
+                // OPTIMIZATION: Set to true if you only need to check if ANY access group exists
+                // Set to false if you need ALL access groups from entire hierarchy
+                const stopOnFirstFound = true;
+                // Recursive function to traverse hierarchy and collect access groups
+                const traverseZoneHierarchy = async (currentZoneId, propertyId) => {
+                    // Base case 1: if zone already visited, return (prevents cycles)
+                    if (visitedZoneIds.has(currentZoneId)) {
+                        return false;
+                    }
+                    // Base case 2: early exit if we found access group and only need existence check
+                    if (stopOnFirstFound && accessGroupsMap.size > 0) {
+                        return true;
+                    }
+                    // Mark as visited
+                    visitedZoneIds.add(currentZoneId);
+                    // Check access groups for current zone (query as we traverse)
+                    const zoneAccessGroups = await this.adminRepository.getAccessGroupsByZoneId(currentZoneId);
+                    // If we found access groups, add to map
+                    if (zoneAccessGroups.length > 0) {
+                        zoneAccessGroups.forEach((ag) => accessGroupsMap.set(ag.id, ag));
+                        // Early exit optimization: if we only need to know if access group exists
+                        if (stopOnFirstFound) {
+                            return true; // Stop traversal - we found what we need
+                        }
+                    }
+                    // Get current zone details
+                    const currentZone = await this.adminRepository.getZone(currentZoneId);
+                    if (!currentZone) {
+                        return false;
+                    }
+                    // Recursive case 1: Traverse up to parent zone (if exists and not visited)
+                    if (currentZone.parentId && !visitedZoneIds.has(currentZone.parentId)) {
+                        const found = await traverseZoneHierarchy(currentZone.parentId, propertyId);
+                        // Early exit: if we found access group in parent, stop checking children
+                        if (found && stopOnFirstFound) {
+                            return true;
+                        }
+                    }
+                    // Recursive case 2: Traverse down to direct child zones only
+                    // Only check children if we haven't found an access group yet (optimization)
+                    if (!stopOnFirstFound || accessGroupsMap.size === 0) {
+                        const directChildZoneIds = await this.adminRepository.getDirectChildZones(currentZoneId, propertyId);
+                        // Recursively process each direct child zone
+                        for (const childZoneId of directChildZoneIds) {
+                            if (!visitedZoneIds.has(childZoneId)) {
+                                const found = await traverseZoneHierarchy(childZoneId, propertyId);
+                                // Early exit: if we found access group in any child, we can stop
+                                if (found && stopOnFirstFound) {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    return accessGroupsMap.size > 0;
+                };
+                // Start recursive traversal from the given zone
+                await traverseZoneHierarchy(zoneId, zone.propertyId);
+                return Array.from(accessGroupsMap.values());
+            }
+            catch (error) {
+                console.error("Error in getAccessgroupBySubParentZoneId:", error);
+                return [];
+            }
+        }
         async getZone(zoneId, propertyId) {
             if (!zoneId) {
                 throw new Error("Zone ID is required");

package/package.json

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