disabling space

src/space/services/space.service.ts

@@ -24,6 +24,9 @@ import { ValidationService } from './space-validation.service';
 import { ORPHAN_SPACE_NAME } from '@app/common/constants/orphan-constant';
 import { TagService } from './tag';
 import { SpaceModelService } from 'src/space-model/services';
+import { UserSpaceService } from 'src/users/services';
+import { DeviceService } from 'src/device/services';
+import { SpaceSceneService } from './space-scene.service';
 
 @Injectable()
 export class SpaceService {
@@ -35,6 +38,9 @@ export class SpaceService {
     private readonly validationService: ValidationService,
     private readonly tagService: TagService,
     private readonly spaceModelService: SpaceModelService,
+    private readonly userService: UserSpaceService,
+    private readonly deviceService: DeviceService,
+    private readonly sceneService: SpaceSceneService,
   ) {}
 
   async createSpace(
@@ -363,33 +369,70 @@ export class SpaceService {
   }
 
   async deleteSpace(params: GetSpaceParam) {
+    const queryRunner = this.dataSource.createQueryRunner();
+    const { spaceUuid } = params;
+
     try {
-      const { communityUuid, spaceUuid, projectUuid } = params;
-      const space =
-        await this.validationService.validateSpaceWithinCommunityAndProject(
-          communityUuid,
-          projectUuid,
-          spaceUuid,
-        );
+      await queryRunner.connect();
+      await queryRunner.startTransaction();
+
       const spaces = await this.spaceRepository.find({
         where: { parent: { uuid: spaceUuid }, disabled: false },
-        relations: ['parent', 'children'], // Include parent and children relations
+        relations: [
+          'parent',
+          'children',
+          'subspaces',
+          'tags',
+          'subspaces.tags',
+          'devices',
+        ], // Include parent and children relations
       });
-      console.log(spaces);
-      // space.disabled = true;
-      await this.spaceRepository.update({ uuid: space.uuid }, space);
+      //this.disableSpace(space, orphanSpace);
+      return spaces;
     } catch (error) {
       if (error instanceof HttpException) {
         throw error;
       }
 
       throw new HttpException(
-        'An error occurred while deleting the space',
+        `An error occurred while deleting the space ${error}`,
         HttpStatus.INTERNAL_SERVER_ERROR,
       );
     }
   }
 
+  async disableSpace(space: SpaceEntity, orphanSpace: SpaceEntity) {
+    const queryRunner = this.dataSource.createQueryRunner();
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+    try {
+      const deleteSubspaceDtos = space.subspaces?.map((subspace) => ({
+        subspaceUuid: subspace.uuid,
+      }));
+      const deleteSpaceTagsDtos = space.tags?.map((tag) => tag.uuid);
+
+      await this.userService.deleteUserSpace(space.uuid);
+      await this.subSpaceService.deleteSubspaces(
+        deleteSubspaceDtos,
+        queryRunner,
+      );
+
+      await this.tagService.deleteTags(deleteSpaceTagsDtos, queryRunner);
+
+      await this.deviceService.deleteDevice(
+        space.devices,
+        orphanSpace,
+        queryRunner,
+      );
+      await this.spaceLinkService.deleteSpaceLink(space, queryRunner);
+      await this.sceneService.deleteScenes(space, queryRunner);
+    } catch (error) {
+      await queryRunner.rollbackTransaction();
+    } finally {
+      await queryRunner.release();
+    }
+  }
+
   private updateSpaceProperties(
     space: SpaceEntity,
     updateSpaceDto: UpdateSpaceDto,