dt-common-device 13.0.8 → 13.0.10

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

@@ -9,7 +9,14 @@ 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>;
+    getZoneIdsByAccessGroupIds(accessGroupIds: string[]): Promise<string[]>;
+    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>;
+    getZonesByIds(zoneIds: string[]): Promise<IZone[]>;
     getUser(userId: string): Promise<IUser | null>;
     getZoneByDeviceId(deviceId: string): Promise<IZone | null>;
     getAccessGroups(propertyId: string, accessibleBy?: string): Promise<IAccessGroup[]>;

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

@@ -278,6 +278,128 @@ let AdminRepository = (() => {
             }
             return null;
         }
+        async getZoneIdsByAccessGroupIds(accessGroupIds) {
+            if (accessGroupIds.length === 0) {
+                return [];
+            }
+            const query = `
+      SELECT DISTINCT "zoneId"
+      FROM dt_zones_collection_map
+      WHERE "collectionId" = ANY($1)
+    `;
+            const result = await this.postgres.query(query, [accessGroupIds]);
+            return result.rows.map((row) => row.zoneId);
+        }
+        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;
@@ -306,6 +428,40 @@ let AdminRepository = (() => {
                 throw new Error("Failed to get zone");
             }
         }
+        async getZonesByIds(zoneIds) {
+            if (zoneIds.length === 0) {
+                return [];
+            }
+            try {
+                // Batch query to get all zones at once
+                const query = `SELECT * FROM dt_zones WHERE "id" = ANY($1)`;
+                const result = await this.postgres.query(query, [zoneIds]);
+                // Get all unique zone type IDs
+                const zoneTypeIds = [
+                    ...new Set(result.rows.map((row) => row.zoneTypeId)),
+                ];
+                // Batch query for zone types
+                let zoneTypesMap = new Map();
+                if (zoneTypeIds.length > 0) {
+                    const zoneTypesQuery = `SELECT * FROM "dt_zoneTypes" WHERE "id" = ANY($1)`;
+                    const zoneTypesResult = await this.postgres.query(zoneTypesQuery, [
+                        zoneTypeIds,
+                    ]);
+                    zoneTypesResult.rows.forEach((zt) => {
+                        zoneTypesMap.set(zt.id, { id: zt.id, name: zt.name });
+                    });
+                }
+                // Map zone types to zones
+                return result.rows.map((zoneData) => {
+                    zoneData.zoneType = zoneTypesMap.get(zoneData.zoneTypeId) || {};
+                    return zoneData;
+                });
+            }
+            catch (error) {
+                console.error("Error in getZonesByIds:", error);
+                return [];
+            }
+        }
         async getUser(userId) {
             const user = await this.postgres.query(`SELECT * FROM dt_users WHERE "id" = $1`, [userId]);
             if (user.rows.length > 0) {

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

@@ -7,6 +7,8 @@ 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[]>;
+    getAllParentSubZonesByAccessGroupIds(accessGroupIds: string[]): Promise<string[]>;
     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,130 @@ let AdminService = (() => {
             }
             return accessGroups;
         }
+        //--------------------------USED FOR QUERY RESERVATION-----------------------
+        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 [];
+            }
+        }
+        // used for query reservation to find all the zones mapped with the access groups
+        async getAllParentSubZonesByAccessGroupIds(accessGroupIds) {
+            if (!accessGroupIds || accessGroupIds.length === 0) {
+                throw new Error("Access Group IDs are required");
+            }
+            try {
+                // Step 1: Find all zones mapped with these access groups
+                const mappedZoneIds = await this.adminRepository.getZoneIdsByAccessGroupIds(accessGroupIds);
+                if (mappedZoneIds.length === 0) {
+                    return [];
+                }
+                // OPTIMIZATION 1: Batch get all zones at once (reduces DB calls from O(n) to O(1))
+                const zones = await this.adminRepository.getZonesByIds(mappedZoneIds);
+                const zoneMap = new Map();
+                zones.forEach((zone) => zoneMap.set(zone.id, zone));
+                // Use Set to collect unique zone IDs from the start
+                const allZoneIds = new Set(mappedZoneIds);
+                // OPTIMIZATION 2: Process all zones in parallel (reduces time from O(n) sequential to O(1) parallel)
+                const zoneProcessingPromises = mappedZoneIds.map(async (zoneId) => {
+                    const zone = zoneMap.get(zoneId);
+                    if (!zone) {
+                        return { parentIds: [], childIds: [] };
+                    }
+                    // OPTIMIZATION 3: Get parents and children in parallel for each zone
+                    const [parentZoneIds, childZoneIds] = await Promise.all([
+                        this.adminRepository.getAllParentZones(zoneId),
+                        this.adminRepository.getAllChildZones(zoneId, zone.propertyId),
+                    ]);
+                    return { parentIds: parentZoneIds, childIds: childZoneIds };
+                });
+                // Wait for all zone processing to complete
+                const results = await Promise.all(zoneProcessingPromises);
+                // OPTIMIZATION 4: Batch add all IDs to Set (O(n) operation)
+                results.forEach(({ parentIds, childIds }) => {
+                    parentIds.forEach((id) => allZoneIds.add(id));
+                    childIds.forEach((id) => allZoneIds.add(id));
+                });
+                return Array.from(allZoneIds);
+            }
+            catch (error) {
+                console.error("Error in getAllParentSubZonesByAccessGroupIds:", 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.8",
+  "version": "13.0.10",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [