dt-common-device 13.0.9 → 13.0.10

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

@@ -9,12 +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,18 @@ 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;
@@ -416,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

@@ -8,6 +8,7 @@ export declare class AdminService {
     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,7 @@ let AdminService = (() => {
             }
             return accessGroups;
         }
+        //--------------------------USED FOR QUERY RESERVATION-----------------------
         async getAccessgroupBySubParentZoneId(zoneId) {
             if (!zoneId) {
                 throw new Error("Zone ID is required");
@@ -211,6 +212,51 @@ let AdminService = (() => {
                 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.9",
+  "version": "13.0.10",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [