removed unit,floor,building,room modules

src/device/services/device.service.ts

@@ -38,6 +38,7 @@ import { DeviceStatusFirebaseService } from '@app/common/firebase/devices-status
 import { DeviceStatuses } from '@app/common/constants/device-status.enum';
 import { CommonErrorCodes } from '@app/common/constants/error-codes.enum';
 import { BatteryStatus } from '@app/common/constants/battery-status.enum';
+import { SpaceEntity } from '@app/common/modules/space/entities';
 
 @Injectable()
 export class DeviceService {
@@ -836,6 +837,7 @@ export class DeviceService {
           'permission.permissionType',
         ],
       });
+
       const devicesData = await Promise.allSettled(
         devices.map(async (device) => {
           let battery = null;
@@ -880,22 +882,26 @@ export class DeviceService {
               battery = batteryStatus.value;
             }
           }
-          const spaceDevice = device?.spaceDevice;
-          return {
-            space: {
-              uuid: spaceDevice?.uuid,
-              name: spaceDevice?.spaceName,
-            },
 
+          const spaceHierarchy = await this.getFullSpaceHierarchy(
+            device?.spaceDevice,
+          );
+          const orderedHierarchy = spaceHierarchy.reverse();
+
+          return {
+            spaces: orderedHierarchy.map((space) => ({
+              uuid: space.uuid,
+              spaceName: space.spaceName,
+            })),
             productUuid: device.productDevice.uuid,
             productType: device.productDevice.prodType,
-            permissionType: device.permission[0].permissionType.type,
-            ...(await this.getDeviceDetailsByDeviceIdTuya(
+            //   permissionType: device.permission[0].permissionType.type,
+            /*  ...(await this.getDeviceDetailsByDeviceIdTuya(
               device.deviceTuyaUuid,
-            )),
+            )),*/
             uuid: device.uuid,
             ...(battery && { battery }),
-          } as GetDeviceDetailsInterface;
+          };
         }),
       );
 
@@ -969,4 +975,83 @@ export class DeviceService {
       );
     }
   }
+
+  async getFullSpaceHierarchy(
+    space: SpaceEntity,
+  ): Promise<{ uuid: string; spaceName: string }[]> {
+    try {
+      console.log('Fetching hierarchy for space:', space.uuid);
+
+      // Fetch only the relevant spaces, starting with the target space
+      const targetSpace = await this.spaceRepository.findOne({
+        where: { uuid: space.uuid },
+        relations: ['parent', 'children'],
+      });
+
+      // Fetch only the ancestors of the target space
+      const ancestors = await this.fetchAncestors(targetSpace);
+
+      // Optionally, fetch descendants if required
+      const descendants = await this.fetchDescendants(targetSpace);
+
+      const fullHierarchy = [...ancestors, targetSpace, ...descendants].map(
+        (space) => ({
+          uuid: space.uuid,
+          spaceName: space.spaceName,
+        }),
+      );
+
+      return fullHierarchy;
+    } catch (error) {
+      console.error('Error fetching space hierarchy:', error.message);
+      throw new HttpException(
+        'Error fetching space hierarchy',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  private async fetchAncestors(space: SpaceEntity): Promise<SpaceEntity[]> {
+    const ancestors: SpaceEntity[] = [];
+
+    let currentSpace = space;
+    while (currentSpace && currentSpace.parent) {
+      // Fetch the parent space
+      const parent = await this.spaceRepository.findOne({
+        where: { uuid: currentSpace.parent.uuid },
+        relations: ['parent'], // To continue fetching upwards
+      });
+
+      if (parent) {
+        ancestors.push(parent);
+        currentSpace = parent;
+      } else {
+        currentSpace = null;
+      }
+    }
+
+    // Return the ancestors in reverse order to have the root at the start
+    return ancestors.reverse();
+  }
+
+  private async fetchDescendants(space: SpaceEntity): Promise<SpaceEntity[]> {
+    const descendants: SpaceEntity[] = [];
+
+    // Fetch the immediate children of the current space
+    const children = await this.spaceRepository.find({
+      where: { parent: { uuid: space.uuid } },
+      relations: ['children'], // To continue fetching downwards
+    });
+
+    for (const child of children) {
+      // Add the child to the descendants list
+      descendants.push(child);
+
+      // Recursively fetch the child's descendants
+      const childDescendants = await this.fetchDescendants(child);
+      descendants.push(...childDescendants);
+    }
+
+    return descendants;
+  }
 }