Merge branch 'dev' into test/prevent-server-block-on-rate-limit

Add queue event handler

.eslintrc.js

@@ -21,6 +21,7 @@ module.exports = {
     '@typescript-eslint/explicit-function-return-type': 'off',
     '@typescript-eslint/explicit-module-boundary-types': 'off',
     '@typescript-eslint/no-explicit-any': 'off',
+    "@typescript-eslint/no-unused-vars": 'warn',
   },
   settings: {
     'import/resolver': {

libs/common/src/database/database.module.ts

@@ -25,6 +25,7 @@ import {
   InviteUserEntity,
   InviteUserSpaceEntity,
 } from '../modules/Invite-user/entities';
+import { SpaceDailyOccupancyDurationEntity } from '../modules/occupancy/entities';
 import {
   PowerClampDailyEntity,
   PowerClampHourlyEntity,
@@ -46,7 +47,6 @@ import {
   SubspaceModelProductAllocationEntity,
 } from '../modules/space-model/entities';
 import { InviteSpaceEntity } from '../modules/space/entities/invite-space.entity';
-import { SpaceLinkEntity } from '../modules/space/entities/space-link.entity';
 import { SpaceProductAllocationEntity } from '../modules/space/entities/space-product-allocation.entity';
 import { SpaceEntity } from '../modules/space/entities/space.entity';
 import { SubspaceProductAllocationEntity } from '../modules/space/entities/subspace/subspace-product-allocation.entity';
@@ -58,7 +58,6 @@ import {
   UserSpaceEntity,
 } from '../modules/user/entities';
 import { VisitorPasswordEntity } from '../modules/visitor-password/entities';
-import { SpaceDailyOccupancyDurationEntity } from '../modules/occupancy/entities';
 @Module({
   imports: [
     TypeOrmModule.forRootAsync({
@@ -87,7 +86,6 @@ import { SpaceDailyOccupancyDurationEntity } from '../modules/occupancy/entities
             PermissionTypeEntity,
             CommunityEntity,
             SpaceEntity,
-            SpaceLinkEntity,
             SubspaceEntity,
             UserSpaceEntity,
             DeviceUserPermissionEntity,
@@ -127,7 +125,7 @@ import { SpaceDailyOccupancyDurationEntity } from '../modules/occupancy/entities
           logger: typeOrmLogger,
           extra: {
             charset: 'utf8mb4',
-            max: 20, // set pool max size
+            max: 100, // set pool max size
             idleTimeoutMillis: 5000, // close idle clients after 5 second
             connectionTimeoutMillis: 12_000, // return an error after 11 second if connection could not be established
             maxUses: 7500, // close (and replace) a connection after it has been used 7500 times (see below for discussion)

libs/common/src/dto/pagination.request.dto.ts

@@ -1,10 +1,9 @@
-import { IsBoolean, IsDate, IsOptional } from 'class-validator';
-import { IsPageRequestParam } from '../validators/is-page-request-param.validator';
 import { ApiProperty } from '@nestjs/swagger';
-import { IsSizeRequestParam } from '../validators/is-size-request-param.validator';
 import { Transform } from 'class-transformer';
-import { parseToDate } from '../util/parseToDate';
+import { IsBoolean, IsOptional } from 'class-validator';
 import { BooleanValues } from '../constants/boolean-values.enum';
+import { IsPageRequestParam } from '../validators/is-page-request-param.validator';
+import { IsSizeRequestParam } from '../validators/is-size-request-param.validator';
 
 export class PaginationRequestGetListDto {
   @ApiProperty({
@@ -19,6 +18,7 @@ export class PaginationRequestGetListDto {
     return value.obj.includeSpaces === BooleanValues.TRUE;
   })
   public includeSpaces?: boolean = false;
+
   @IsOptional()
   @IsPageRequestParam({
     message: 'Page must be bigger than 0',
@@ -40,40 +40,4 @@ export class PaginationRequestGetListDto {
     description: 'Size request',
   })
   size?: number;
-
-  @IsOptional()
-  @ApiProperty({
-    name: 'name',
-    required: false,
-    description: 'Name to be filtered',
-  })
-  name?: string;
-
-  @ApiProperty({
-    name: 'from',
-    required: false,
-    type: Number,
-    description: `Start time in UNIX timestamp format to filter`,
-    example: 1674172800000,
-  })
-  @IsOptional()
-  @Transform(({ value }) => parseToDate(value))
-  @IsDate({
-    message: `From must be in UNIX timestamp format in order to parse to Date instance`,
-  })
-  from?: Date;
-
-  @ApiProperty({
-    name: 'to',
-    required: false,
-    type: Number,
-    description: `End time in UNIX timestamp format to filter`,
-    example: 1674259200000,
-  })
-  @IsOptional()
-  @Transform(({ value }) => parseToDate(value))
-  @IsDate({
-    message: `To must be in UNIX timestamp format in order to parse to Date instance`,
-  })
-  to?: Date;
 }

libs/common/src/firebase/devices-status/services/devices-status.service.ts

@@ -76,6 +76,28 @@ export class DeviceStatusFirebaseService {
       );
     }
   }
+  async addDeviceStatusToOurDb(
+    addDeviceStatusDto: AddDeviceStatusDto,
+  ): Promise<AddDeviceStatusDto | null> {
+    try {
+      const device = await this.getDeviceByDeviceTuyaUuid(
+        addDeviceStatusDto.deviceTuyaUuid,
+      );
+
+      if (device?.uuid) {
+        return await this.createDeviceStatusInOurDb({
+          deviceUuid: device.uuid,
+          ...addDeviceStatusDto,
+          productType: device.productDevice.prodType,
+        });
+      }
+      // Return null if device not found or no UUID
+      return null;
+    } catch (error) {
+      // Handle the error silently, perhaps log it internally or ignore it
+      return null;
+    }
+  }
   async addDeviceStatusToFirebase(
     addDeviceStatusDto: AddDeviceStatusDto,
   ): Promise<AddDeviceStatusDto | null> {
@@ -211,6 +233,13 @@ export class DeviceStatusFirebaseService {
       return existingData;
     });
 
+    // Return the updated data
+    const snapshot: DataSnapshot = await get(dataRef);
+    return snapshot.val();
+  }
+  async createDeviceStatusInOurDb(
+    addDeviceStatusDto: AddDeviceStatusDto,
+  ): Promise<any> {
     // Save logs to your repository
     const newLogs = addDeviceStatusDto.log.properties.map((property) => {
       return this.deviceStatusLogRepository.create({
@@ -269,8 +298,5 @@ export class DeviceStatusFirebaseService {
         addDeviceStatusDto.deviceUuid,
       );
     }
-    // Return the updated data
-    const snapshot: DataSnapshot = await get(dataRef);
-    return snapshot.val();
   }
 }

libs/common/src/helper/services/sos.handler.service.ts

@@ -16,7 +16,7 @@ export class SosHandlerService {
     );
   }
 
-  async handleSosEvent(devId: string, logData: any): Promise<void> {
+  async handleSosEventFirebase(devId: string, logData: any): Promise<void> {
     try {
       await this.deviceStatusFirebaseService.addDeviceStatusToFirebase({
         deviceTuyaUuid: devId,
@@ -39,4 +39,28 @@ export class SosHandlerService {
       this.logger.error('Failed to send SOS true value', err);
     }
   }
+
+  async handleSosEventOurDb(devId: string, logData: any): Promise<void> {
+    try {
+      await this.deviceStatusFirebaseService.addDeviceStatusToOurDb({
+        deviceTuyaUuid: devId,
+        status: [{ code: 'sos', value: true }],
+        log: logData,
+      });
+
+      setTimeout(async () => {
+        try {
+          await this.deviceStatusFirebaseService.addDeviceStatusToOurDb({
+            deviceTuyaUuid: devId,
+            status: [{ code: 'sos', value: false }],
+            log: logData,
+          });
+        } catch (err) {
+          this.logger.error('Failed to send SOS false value', err);
+        }
+      }, 2000);
+    } catch (err) {
+      this.logger.error('Failed to send SOS true value', err);
+    }
+  }
 }

libs/common/src/helper/services/tuya.web.socket.service.ts

@@ -9,6 +9,14 @@ export class TuyaWebSocketService {
   private client: any;
   private readonly isDevEnv: boolean;
 
+  private messageQueue: {
+    devId: string;
+    status: any;
+    logData: any;
+  }[] = [];
+
+  private isProcessing = false;
+
   constructor(
     private readonly configService: ConfigService,
     private readonly deviceStatusFirebaseService: DeviceStatusFirebaseService,
@@ -26,12 +34,12 @@ export class TuyaWebSocketService {
     });
 
     if (this.configService.get<string>('tuya-config.TRUN_ON_TUYA_SOCKET')) {
-      // Set up event handlers
       this.setupEventHandlers();
-
-      // Start receiving messages
       this.client.start();
     }
+
+    // Trigger the queue processor every 2 seconds
+    setInterval(() => this.processQueue(), 10000);
   }
 
   private setupEventHandlers() {
@@ -43,10 +51,10 @@ export class TuyaWebSocketService {
     this.client.message(async (ws: WebSocket, message: any) => {
       try {
         const { devId, status, logData } = this.extractMessageData(message);
-
         if (this.sosHandlerService.isSosTriggered(status)) {
-          await this.sosHandlerService.handleSosEvent(devId, logData);
+          await this.sosHandlerService.handleSosEventFirebase(devId, logData);
         } else {
+          // Firebase real-time update
           await this.deviceStatusFirebaseService.addDeviceStatusToFirebase({
             deviceTuyaUuid: devId,
             status: status,
@@ -54,9 +62,13 @@ export class TuyaWebSocketService {
           });
         }
 
+        // Push to internal queue
+        this.messageQueue.push({ devId, status, logData });
+
+        // Acknowledge the message
         this.client.ackMessage(message.messageId);
       } catch (error) {
-        console.error('Error processing message:', error);
+        console.error('Error receiving message:', error);
       }
     });
 
@@ -80,6 +92,38 @@ export class TuyaWebSocketService {
       console.error('WebSocket error:', error);
     });
   }
+  private async processQueue() {
+    if (this.isProcessing || this.messageQueue.length === 0) return;
+
+    this.isProcessing = true;
+
+    const batch = [...this.messageQueue];
+    this.messageQueue = [];
+
+    try {
+      for (const item of batch) {
+        if (this.sosHandlerService.isSosTriggered(item.status)) {
+          await this.sosHandlerService.handleSosEventOurDb(
+            item.devId,
+            item.logData,
+          );
+        } else {
+          await this.deviceStatusFirebaseService.addDeviceStatusToOurDb({
+            deviceTuyaUuid: item.devId,
+            status: item.status,
+            log: item.logData,
+          });
+        }
+      }
+    } catch (error) {
+      console.error('Error processing batch:', error);
+      // Re-add the batch to the queue for retry
+      this.messageQueue.unshift(...batch);
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+
   private extractMessageData(message: any): {
     devId: string;
     status: any;

libs/common/src/modules/space/entities/space-link.entity.ts

@@ -1,32 +1,3 @@
-import { Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
 import { AbstractEntity } from '../../abstract/entities/abstract.entity';
-import { SpaceEntity } from './space.entity';
-import { Direction } from '@app/common/constants/direction.enum';
 
-@Entity({ name: 'space-link' })
-export class SpaceLinkEntity extends AbstractEntity {
-  @ManyToOne(() => SpaceEntity, { nullable: false, onDelete: 'CASCADE' })
-  @JoinColumn({ name: 'start_space_id' })
-  public startSpace: SpaceEntity;
-
-  @ManyToOne(() => SpaceEntity, { nullable: false, onDelete: 'CASCADE' })
-  @JoinColumn({ name: 'end_space_id' })
-  public endSpace: SpaceEntity;
-
-  @Column({
-    nullable: false,
-    default: false,
-  })
-  public disabled: boolean;
-
-  @Column({
-    nullable: false,
-    enum: Object.values(Direction),
-  })
-  direction: string;
-
-  constructor(partial: Partial<SpaceLinkEntity>) {
-    super();
-    Object.assign(this, partial);
-  }
-}
+export class SpaceLinkEntity extends AbstractEntity {}

libs/common/src/modules/space/entities/space.entity.ts

@@ -1,18 +1,17 @@
 import { Column, Entity, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
-import { SpaceDto } from '../dtos';
 import { AbstractEntity } from '../../abstract/entities/abstract.entity';
-import { UserSpaceEntity } from '../../user/entities';
-import { DeviceEntity } from '../../device/entities';
+import { AqiSpaceDailyPollutantStatsEntity } from '../../aqi/entities';
 import { CommunityEntity } from '../../community/entities';
-import { SpaceLinkEntity } from './space-link.entity';
+import { DeviceEntity } from '../../device/entities';
+import { InviteUserSpaceEntity } from '../../Invite-user/entities';
+import { SpaceDailyOccupancyDurationEntity } from '../../occupancy/entities';
+import { PresenceSensorDailySpaceEntity } from '../../presence-sensor/entities';
 import { SceneEntity } from '../../scene/entities';
 import { SpaceModelEntity } from '../../space-model';
-import { InviteUserSpaceEntity } from '../../Invite-user/entities';
+import { UserSpaceEntity } from '../../user/entities';
+import { SpaceDto } from '../dtos';
 import { SpaceProductAllocationEntity } from './space-product-allocation.entity';
 import { SubspaceEntity } from './subspace/subspace.entity';
-import { PresenceSensorDailySpaceEntity } from '../../presence-sensor/entities';
-import { AqiSpaceDailyPollutantStatsEntity } from '../../aqi/entities';
-import { SpaceDailyOccupancyDurationEntity } from '../../occupancy/entities';
 
 @Entity({ name: 'space' })
 export class SpaceEntity extends AbstractEntity<SpaceDto> {
@@ -75,16 +74,6 @@ export class SpaceEntity extends AbstractEntity<SpaceDto> {
   )
   devices: DeviceEntity[];
 
-  @OneToMany(() => SpaceLinkEntity, (connection) => connection.startSpace, {
-    nullable: true,
-  })
-  public outgoingConnections: SpaceLinkEntity[];
-
-  @OneToMany(() => SpaceLinkEntity, (connection) => connection.endSpace, {
-    nullable: true,
-  })
-  public incomingConnections: SpaceLinkEntity[];
-
   @Column({
     nullable: true,
     type: 'text',

libs/common/src/modules/space/repositories/space.repository.ts

@@ -1,7 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { DataSource, Repository } from 'typeorm';
 import { InviteSpaceEntity } from '../entities/invite-space.entity';
-import { SpaceLinkEntity } from '../entities/space-link.entity';
 import { SpaceProductAllocationEntity } from '../entities/space-product-allocation.entity';
 import { SpaceEntity } from '../entities/space.entity';
 
@@ -13,11 +12,7 @@ export class SpaceRepository extends Repository<SpaceEntity> {
 }
 
 @Injectable()
-export class SpaceLinkRepository extends Repository<SpaceLinkEntity> {
-  constructor(private dataSource: DataSource) {
-    super(SpaceLinkEntity, dataSource.createEntityManager());
-  }
-}
+export class SpaceLinkRepository {}
 
 @Injectable()
 export class InviteSpaceRepository extends Repository<InviteSpaceEntity> {

src/app.module.ts

@@ -1,7 +1,7 @@
 import { SeederModule } from '@app/common/seed/seeder.module';
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
-import { APP_INTERCEPTOR } from '@nestjs/core';
+import { APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
 import { WinstonModule } from 'nest-winston';
 import { AuthenticationModule } from './auth/auth.module';
 import { AutomationModule } from './automation/automation.module';
@@ -35,6 +35,9 @@ import { UserNotificationModule } from './user-notification/user-notification.mo
 import { UserModule } from './users/user.module';
 import { VisitorPasswordModule } from './vistor-password/visitor-password.module';
 
+import { ThrottlerGuard } from '@nestjs/throttler';
+import { ThrottlerModule } from '@nestjs/throttler/dist/throttler.module';
+import { isArray } from 'class-validator';
 import { winstonLoggerOptions } from '../libs/common/src/logger/services/winston.logger';
 import { AqiModule } from './aqi/aqi.module';
 import { OccupancyModule } from './occupancy/occupancy.module';
@@ -44,9 +47,18 @@ import { WeatherModule } from './weather/weather.module';
     ConfigModule.forRoot({
       load: config,
     }),
-    /*   ThrottlerModule.forRoot({
-      throttlers: [{ ttl: 100000, limit: 30 }],
-    }), */
+    ThrottlerModule.forRoot({
+      throttlers: [{ ttl: 60000, limit: 30 }],
+      generateKey: (context) => {
+        const req = context.switchToHttp().getRequest();
+        console.log('Real IP:', req.headers['x-forwarded-for']);
+        return req.headers['x-forwarded-for']
+          ? isArray(req.headers['x-forwarded-for'])
+            ? req.headers['x-forwarded-for'][0].split(':')[0]
+            : req.headers['x-forwarded-for'].split(':')[0]
+          : req.ip;
+      },
+    }),
     WinstonModule.forRoot(winstonLoggerOptions),
     ClientModule,
     AuthenticationModule,
@@ -88,10 +100,10 @@ import { WeatherModule } from './weather/weather.module';
       provide: APP_INTERCEPTOR,
       useClass: LoggingInterceptor,
     },
-    /*  {
+    {
       provide: APP_GUARD,
       useClass: ThrottlerGuard,
-    }, */
+    },
   ],
 })
 export class AppModule {}

src/community/community.module.ts

@@ -78,6 +78,7 @@ import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
     ProjectRepository,
     SpaceService,
     InviteSpaceRepository,
+    // Todo: find out why this is needed
     SpaceLinkService,
     SubSpaceService,
     ValidationService,

src/community/controllers/community.controller.ts

@@ -1,4 +1,3 @@
-import { CommunityService } from '../services/community.service';
 import {
   Body,
   Controller,
@@ -10,17 +9,18 @@ import {
   Query,
   UseGuards,
 } from '@nestjs/common';
-import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { AddCommunityDto } from '../dtos/add.community.dto';
 import { GetCommunityParams } from '../dtos/get.community.dto';
 import { UpdateCommunityNameDto } from '../dtos/update.community.dto';
+import { CommunityService } from '../services/community.service';
 // import { CheckUserCommunityGuard } from 'src/guards/user.community.guard';
 import { ControllerRoute } from '@app/common/constants/controller-route';
 import { BaseResponseDto } from '@app/common/dto/base.response.dto';
-import { ProjectParam } from '../dtos';
-import { PermissionsGuard } from 'src/guards/permissions.guard';
-import { Permissions } from 'src/decorators/permissions.decorator';
 import { PaginationRequestWithSearchGetListDto } from '@app/common/dto/pagination-with-search.request.dto';
+import { Permissions } from 'src/decorators/permissions.decorator';
+import { PermissionsGuard } from 'src/guards/permissions.guard';
+import { ProjectParam } from '../dtos';
 
 @ApiTags('Community Module')
 @Controller({
@@ -45,6 +45,21 @@ export class CommunityController {
     return await this.communityService.createCommunity(param, addCommunityDto);
   }
 
+  @ApiBearerAuth()
+  @UseGuards(PermissionsGuard)
+  @Permissions('COMMUNITY_VIEW')
+  @ApiOperation({
+    summary: ControllerRoute.COMMUNITY.ACTIONS.LIST_COMMUNITY_SUMMARY,
+    description: ControllerRoute.COMMUNITY.ACTIONS.LIST_COMMUNITY_DESCRIPTION,
+  })
+  @Get('v2')
+  async getCommunitiesV2(
+    @Param() param: ProjectParam,
+    @Query() query: PaginationRequestWithSearchGetListDto,
+  ): Promise<any> {
+    return this.communityService.getCommunitiesV2(param, query);
+  }
+
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
   @Permissions('COMMUNITY_VIEW')

src/community/services/community.service.ts

@@ -1,4 +1,7 @@
-import { ORPHAN_COMMUNITY_NAME } from '@app/common/constants/orphan-constant';
+import {
+  ORPHAN_COMMUNITY_NAME,
+  ORPHAN_SPACE_NAME,
+} from '@app/common/constants/orphan-constant';
 import { BaseResponseDto } from '@app/common/dto/base.response.dto';
 import { PageResponse } from '@app/common/dto/pagination.response.dto';
 import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
@@ -22,7 +25,7 @@ import {
   NotFoundException,
 } from '@nestjs/common';
 import { SpaceService } from 'src/space/services';
-import { SelectQueryBuilder } from 'typeorm';
+import { QueryRunner, SelectQueryBuilder } from 'typeorm';
 import { AddCommunityDto, GetCommunityParams, ProjectParam } from '../dtos';
 import { UpdateCommunityNameDto } from '../dtos/update.community.dto';
 
@@ -69,12 +72,18 @@ export class CommunityService {
     }
   }
 
-  async getCommunityById(params: GetCommunityParams): Promise<BaseResponseDto> {
+  async getCommunityById(
+    params: GetCommunityParams,
+    queryRunner?: QueryRunner,
+  ): Promise<BaseResponseDto> {
     const { communityUuid, projectUuid } = params;
 
     await this.validateProject(projectUuid);
 
-    const community = await this.communityRepository.findOneBy({
+    const communityRepository =
+      queryRunner?.manager.getRepository(CommunityEntity) ||
+      this.communityRepository;
+    const community = await communityRepository.findOneBy({
       uuid: communityUuid,
     });
 
@@ -161,6 +170,75 @@ export class CommunityService {
     }
   }
 
+  async getCommunitiesV2(
+    { projectUuid }: ProjectParam,
+    {
+      search,
+      includeSpaces,
+      ...pageable
+    }: Partial<ExtendedTypeORMCustomModelFindAllQuery>,
+  ) {
+    try {
+      const project = await this.validateProject(projectUuid);
+
+      let qb: undefined | SelectQueryBuilder<CommunityEntity> = undefined;
+
+      qb = this.communityRepository
+        .createQueryBuilder('c')
+        .where('c.project = :projectUuid', { projectUuid })
+        .andWhere(`c.name != '${ORPHAN_COMMUNITY_NAME}-${project.name}'`)
+        .distinct(true);
+
+      if (includeSpaces) {
+        qb.leftJoinAndSelect(
+          'c.spaces',
+          'space',
+          'space.disabled = :disabled AND space.spaceName != :orphanSpaceName',
+          { disabled: false, orphanSpaceName: ORPHAN_SPACE_NAME },
+        )
+          .leftJoinAndSelect('space.parent', 'parent')
+          .leftJoinAndSelect(
+            'space.children',
+            'children',
+            'children.disabled = :disabled',
+            { disabled: false },
+          );
+        // .leftJoinAndSelect('space.spaceModel', 'spaceModel')
+      }
+
+      if (search) {
+        qb.andWhere(
+          `c.name ILIKE :search ${includeSpaces ? 'OR space.space_name ILIKE :search' : ''}`,
+          { search },
+        );
+      }
+
+      const customModel = TypeORMCustomModel(this.communityRepository);
+
+      const { baseResponseDto, paginationResponseDto } =
+        await customModel.findAll({ ...pageable, modelName: 'community' }, qb);
+      if (includeSpaces) {
+        baseResponseDto.data = baseResponseDto.data.map((community) => ({
+          ...community,
+          spaces: this.spaceService.buildSpaceHierarchy(community.spaces || []),
+        }));
+      }
+      return new PageResponse<CommunityDto>(
+        baseResponseDto,
+        paginationResponseDto,
+      );
+    } catch (error) {
+      // Generic error handling
+      if (error instanceof HttpException) {
+        throw error;
+      }
+      throw new HttpException(
+        error.message || 'An error occurred while fetching communities.',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
   async updateCommunity(
     params: GetCommunityParams,
     updateCommunityDto: UpdateCommunityNameDto,

src/device/controllers/device-project.controller.ts

@@ -1,11 +1,11 @@
-import { DeviceService } from '../services/device.service';
-import { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
-import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
-import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
 import { ControllerRoute } from '@app/common/constants/controller-route';
-import { PermissionsGuard } from 'src/guards/permissions.guard';
+import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
+import { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { Permissions } from 'src/decorators/permissions.decorator';
-import { GetDoorLockDevices, ProjectParam } from '../dtos';
+import { PermissionsGuard } from 'src/guards/permissions.guard';
+import { GetDevicesFilterDto, ProjectParam } from '../dtos';
+import { DeviceService } from '../services/device.service';
 
 @ApiTags('Device Module')
 @Controller({
@@ -25,7 +25,7 @@ export class DeviceProjectController {
   })
   async getAllDevices(
     @Param() param: ProjectParam,
-    @Query() query: GetDoorLockDevices,
+    @Query() query: GetDevicesFilterDto,
   ) {
     return await this.deviceService.getAllDevices(param, query);
   }

src/device/dtos/get.device.dto.ts

@@ -1,6 +1,7 @@
 import { DeviceTypeEnum } from '@app/common/constants/device-type.enum';
 import { ApiProperty } from '@nestjs/swagger';
 import {
+  IsArray,
   IsEnum,
   IsNotEmpty,
   IsOptional,
@@ -41,16 +42,7 @@ export class GetDeviceLogsDto {
   @IsOptional()
   public endTime: string;
 }
-export class GetDoorLockDevices {
-  @ApiProperty({
-    description: 'Device Type',
-    enum: DeviceTypeEnum,
-    required: false,
-  })
-  @IsEnum(DeviceTypeEnum)
-  @IsOptional()
-  public deviceType: DeviceTypeEnum;
-}
+
 export class GetDevicesBySpaceOrCommunityDto {
   @ApiProperty({
     description: 'Device Product Type',
@@ -72,3 +64,23 @@ export class GetDevicesBySpaceOrCommunityDto {
   @IsNotEmpty({ message: 'Either spaceUuid or communityUuid must be provided' })
   requireEither?: never; // This ensures at least one of them is provided
 }
+
+export class GetDevicesFilterDto {
+  @ApiProperty({
+    description: 'Device Type',
+    enum: DeviceTypeEnum,
+    required: false,
+  })
+  @IsEnum(DeviceTypeEnum)
+  @IsOptional()
+  public deviceType: DeviceTypeEnum;
+  @ApiProperty({
+    description: 'List of Space IDs to filter devices',
+    required: false,
+    example: ['60d21b4667d0d8992e610c85', '60d21b4967d0d8992e610c86'],
+  })
+  @IsOptional()
+  @IsArray()
+  @IsUUID('4', { each: true })
+  public spaces?: string[];
+}

src/device/services/device.service.ts

@@ -53,7 +53,7 @@ import { DeviceSceneParamDto } from '../dtos/device.param.dto';
 import {
   GetDeviceLogsDto,
   GetDevicesBySpaceOrCommunityDto,
-  GetDoorLockDevices,
+  GetDevicesFilterDto,
 } from '../dtos/get.device.dto';
 import {
   controlDeviceInterface,
@@ -955,19 +955,20 @@ export class DeviceService {
 
   async getAllDevices(
     param: ProjectParam,
-    query: GetDoorLockDevices,
+    { deviceType, spaces }: GetDevicesFilterDto,
   ): Promise<BaseResponseDto> {
     try {
       await this.validateProject(param.projectUuid);
-      if (query.deviceType === DeviceTypeEnum.DOOR_LOCK) {
-        return await this.getDoorLockDevices(param.projectUuid);
-      } else if (!query.deviceType) {
+      if (deviceType === DeviceTypeEnum.DOOR_LOCK) {
+        return await this.getDoorLockDevices(param.projectUuid, spaces);
+      } else if (!deviceType) {
         const devices = await this.deviceRepository.find({
           where: {
             isActive: true,
             spaceDevice: {
-              community: { project: { uuid: param.projectUuid } },
+              uuid: spaces && spaces.length ? In(spaces) : undefined,
               spaceName: Not(ORPHAN_SPACE_NAME),
+              community: { project: { uuid: param.projectUuid } },
             },
           },
           relations: [
@@ -1563,7 +1564,7 @@ export class DeviceService {
     }
   }
 
-  async getDoorLockDevices(projectUuid: string) {
+  async getDoorLockDevices(projectUuid: string, spaces?: string[]) {
     await this.validateProject(projectUuid);
 
     const devices = await this.deviceRepository.find({
@@ -1573,6 +1574,7 @@ export class DeviceService {
         },
         spaceDevice: {
           spaceName: Not(ORPHAN_SPACE_NAME),
+          uuid: spaces && spaces.length ? In(spaces) : undefined,
           community: {
             project: {
               uuid: projectUuid,

src/invite-user/invite-user.module.ts

@@ -71,7 +71,6 @@ import {
 import { SpaceModelProductAllocationService } from 'src/space-model/services/space-model-product-allocation.service';
 import { SubspaceModelProductAllocationService } from 'src/space-model/services/subspace/subspace-model-product-allocation.service';
 import {
-  SpaceLinkService,
   SpaceService,
   SpaceUserService,
   SubspaceDeviceService,
@@ -115,7 +114,6 @@ import { UserService, UserSpaceService } from 'src/users/services';
     TimeZoneRepository,
     SpaceService,
     InviteSpaceRepository,
-    SpaceLinkService,
     SubSpaceService,
     ValidationService,
     NewTagService,

src/main.ts

@@ -1,15 +1,13 @@
-import { NestFactory } from '@nestjs/core';
-import { AppModule } from './app.module';
-import rateLimit from 'express-rate-limit';
-import helmet from 'helmet';
-import { setupSwaggerAuthentication } from '../libs/common/src/util/user-auth.swagger.utils';
-import { ValidationPipe } from '@nestjs/common';
-import { json, urlencoded } from 'body-parser';
-import { SeederService } from '@app/common/seed/services/seeder.service';
-import { HttpExceptionFilter } from './common/filters/http-exception/http-exception.filter';
-import { Logger } from '@nestjs/common';
-import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
 import { RequestContextMiddleware } from '@app/common/middleware/request-context.middleware';
+import { SeederService } from '@app/common/seed/services/seeder.service';
+import { Logger, ValidationPipe } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+import { json, urlencoded } from 'body-parser';
+import helmet from 'helmet';
+import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
+import { setupSwaggerAuthentication } from '../libs/common/src/util/user-auth.swagger.utils';
+import { AppModule } from './app.module';
+import { HttpExceptionFilter } from './common/filters/http-exception/http-exception.filter';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
@@ -23,13 +21,6 @@ async function bootstrap() {
 
   app.use(new RequestContextMiddleware().use);
 
-  app.use(
-    rateLimit({
-      windowMs: 5 * 60 * 1000,
-      max: 500,
-    }),
-  );
-
   app.use(
     helmet({
       contentSecurityPolicy: false,

src/power-clamp/power-clamp.module.ts

@@ -1,4 +1,5 @@
 import { DeviceStatusFirebaseService } from '@app/common/firebase/devices-status/services/devices-status.service';
+import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
 import { OccupancyService } from '@app/common/helper/services/occupancy.service';
 import { PowerClampService } from '@app/common/helper/services/power.clamp.service';
 import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service';
@@ -49,7 +50,6 @@ import { SpaceModelProductAllocationService } from 'src/space-model/services/spa
 import { SubspaceModelProductAllocationService } from 'src/space-model/services/subspace/subspace-model-product-allocation.service';
 import {
   SpaceDeviceService,
-  SpaceLinkService,
   SpaceService,
   SubspaceDeviceService,
   SubSpaceService,
@@ -60,7 +60,6 @@ import { SubspaceProductAllocationService } from 'src/space/services/subspace/su
 import { TagService } from 'src/tags/services';
 import { PowerClampController } from './controllers';
 import { PowerClampService as PowerClamp } from './services/power-clamp.service';
-import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
 @Module({
   imports: [ConfigModule],
   controllers: [PowerClampController],
@@ -90,7 +89,6 @@ import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
     SceneRepository,
     AutomationRepository,
     InviteSpaceRepository,
-    SpaceLinkService,
     SubSpaceService,
     TagService,
     SpaceModelService,

src/project/project.module.ts

@@ -54,7 +54,6 @@ import {
 import { SpaceModelProductAllocationService } from 'src/space-model/services/space-model-product-allocation.service';
 import { SubspaceModelProductAllocationService } from 'src/space-model/services/subspace/subspace-model-product-allocation.service';
 import {
-  SpaceLinkService,
   SpaceService,
   SubspaceDeviceService,
   SubSpaceService,
@@ -87,7 +86,6 @@ const CommandHandlers = [CreateOrphanSpaceHandler];
     UserRepository,
     SpaceService,
     InviteSpaceRepository,
-    SpaceLinkService,
     SubSpaceService,
     ValidationService,
     TagService,

src/project/services/project.service.ts

@@ -24,6 +24,7 @@ import { SpaceService } from 'src/space/services';
 import { PassThrough } from 'stream';
 import { CreateOrphanSpaceCommand } from '../command/create-orphan-space-command';
 import { CreateProjectDto, GetProjectParam } from '../dto';
+import { QueryRunner } from 'typeorm';
 
 @Injectable()
 export class ProjectService {
@@ -212,8 +213,14 @@ export class ProjectService {
     }
   }
 
-  async findOne(uuid: string): Promise<ProjectEntity> {
-    const project = await this.projectRepository.findOne({ where: { uuid } });
+  async findOne(
+    uuid: string,
+    queryRunner?: QueryRunner,
+  ): Promise<ProjectEntity> {
+    const projectRepository = queryRunner
+      ? queryRunner.manager.getRepository(ProjectEntity)
+      : this.projectRepository;
+    const project = await projectRepository.findOne({ where: { uuid } });
     if (!project) {
       throw new HttpException(
         `Invalid project with uuid ${uuid}`,

src/space-model/services/subspace/subspace-model.service.ts

@@ -51,8 +51,12 @@ export class SubSpaceModelService {
       for (const [index, dto] of dtos.entries()) {
         const subspaceModel = savedSubspaces[index];
 
-        const processedTags = await this.tagService.processTags(
-          dto.tags,
+        const processedTags = await this.tagService.upsertTags(
+          dto.tags.map((tag) => ({
+            tagName: tag.name,
+            productUuid: tag.productUuid,
+            tagUuid: tag.uuid,
+          })),
           spaceModel.project.uuid,
           queryRunner,
         );

src/space-model/space-model.module.ts

@@ -46,7 +46,6 @@ import { CommunityService } from 'src/community/services';
 import { DeviceService } from 'src/device/services';
 import { SceneService } from 'src/scene/services';
 import {
-  SpaceLinkService,
   SpaceService,
   SubspaceDeviceService,
   SubSpaceService,
@@ -92,7 +91,6 @@ const CommandHandlers = [
     DeviceRepository,
     TuyaService,
     CommunityRepository,
-    SpaceLinkService,
     SpaceLinkRepository,
     InviteSpaceRepository,
     NewTagService,

src/space/dtos/add.space.dto.ts

@@ -3,7 +3,8 @@ import { ApiProperty } from '@nestjs/swagger';
 import { Type } from 'class-transformer';
 import {
   ArrayUnique,
-  IsBoolean,
+  IsArray,
+  IsMongoId,
   IsNotEmpty,
   IsNumber,
   IsOptional,
@@ -12,7 +13,7 @@ import {
   NotEquals,
   ValidateNested,
 } from 'class-validator';
-import { ProcessTagDto } from 'src/tags/dtos';
+import { CreateProductAllocationDto } from './create-product-allocation.dto';
 import { AddSubspaceDto } from './subspace';
 
 export class AddSpaceDto {
@@ -47,14 +48,6 @@ export class AddSpaceDto {
   @IsOptional()
   public icon?: string;
 
-  @ApiProperty({
-    description: 'Indicates whether the space is private or public',
-    example: false,
-    default: false,
-  })
-  @IsBoolean()
-  isPrivate: boolean;
-
   @ApiProperty({ description: 'X position on canvas', example: 120 })
   @IsNumber()
   x: number;
@@ -64,23 +57,19 @@ export class AddSpaceDto {
   y: number;
 
   @ApiProperty({
-    description: 'UUID of the Space',
+    description: 'UUID of the Space Model',
     example: 'd290f1ee-6c54-4b01-90e6-d701748f0851',
   })
-  @IsString()
+  @IsMongoId()
   @IsOptional()
   spaceModelUuid?: string;
 
-  @ApiProperty({ description: 'Y position on canvas', example: 200 })
-  @IsString()
-  @IsOptional()
-  direction?: string;
-
   @ApiProperty({
     description: 'List of subspaces included in the model',
     type: [AddSubspaceDto],
   })
   @IsOptional()
+  @IsArray()
   @ValidateNested({ each: true })
   @ArrayUnique((subspace) => subspace.subspaceName, {
     message(validationArguments) {
@@ -100,51 +89,21 @@ export class AddSpaceDto {
   subspaces?: AddSubspaceDto[];
 
   @ApiProperty({
-    description: 'List of tags associated with the space model',
-    type: [ProcessTagDto],
+    description: 'List of allocations associated with the space',
+    type: [CreateProductAllocationDto],
   })
+  @IsOptional()
+  @IsArray()
   @ValidateNested({ each: true })
-  @Type(() => ProcessTagDto)
-  tags?: ProcessTagDto[];
-}
+  @Type(() => CreateProductAllocationDto)
+  productAllocations?: CreateProductAllocationDto[];
 
-export class AddUserSpaceDto {
   @ApiProperty({
-    description: 'spaceUuid',
-    required: true,
+    description: 'List of children spaces associated with the space',
+    type: [AddSpaceDto],
   })
-  @IsString()
-  @IsNotEmpty()
-  public spaceUuid: string;
-  @ApiProperty({
-    description: 'userUuid',
-    required: true,
-  })
-  @IsString()
-  @IsNotEmpty()
-  public userUuid: string;
-  constructor(dto: Partial<AddUserSpaceDto>) {
-    Object.assign(this, dto);
-  }
-}
-
-export class AddUserSpaceUsingCodeDto {
-  @ApiProperty({
-    description: 'userUuid',
-    required: true,
-  })
-  @IsString()
-  @IsNotEmpty()
-  public userUuid: string;
-  @ApiProperty({
-    description: 'inviteCode',
-    required: true,
-  })
-  @IsString()
-  @IsNotEmpty()
-  public inviteCode: string;
-
-  constructor(dto: Partial<AddUserSpaceDto>) {
-    Object.assign(this, dto);
-  }
+  @IsOptional()
+  @ValidateNested({ each: true })
+  @Type(() => AddSpaceDto)
+  children?: AddSpaceDto[];
 }

src/space/dtos/create-allocations.dto.ts

@@ -1,14 +1,14 @@
 import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
 import { SubspaceEntity } from '@app/common/modules/space/entities/subspace/subspace.entity';
-import { ProcessTagDto } from 'src/tags/dtos';
 import { QueryRunner } from 'typeorm';
+import { CreateProductAllocationDto } from './create-product-allocation.dto';
 
 export enum AllocationsOwnerType {
   SPACE = 'space',
   SUBSPACE = 'subspace',
 }
 export class BaseCreateAllocationsDto {
-  tags: ProcessTagDto[];
+  productAllocations: CreateProductAllocationDto[];
   projectUuid: string;
   queryRunner: QueryRunner;
   type: AllocationsOwnerType;

src/space/dtos/create-product-allocation.dto.ts

@@ -0,0 +1,36 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+  ValidateIf,
+} from 'class-validator';
+
+export class CreateProductAllocationDto {
+  @ApiProperty({
+    description: 'The name of the tag (if creating a new tag)',
+    example: 'New Tag',
+  })
+  @IsString()
+  @IsNotEmpty()
+  @ValidateIf((o) => !o.tagUuid)
+  tagName: string;
+
+  @ApiProperty({
+    description: 'UUID of the tag (if selecting an existing tag)',
+    example: '123e4567-e89b-12d3-a456-426614174000',
+  })
+  @IsUUID()
+  @IsNotEmpty()
+  @ValidateIf((o) => !o.tagName)
+  tagUuid: string;
+
+  @ApiProperty({
+    description: 'UUID of the product',
+    example: '550e8400-e29b-41d4-a716-446655440000',
+  })
+  @IsUUID()
+  @IsOptional()
+  productUuid: string;
+}

src/space/dtos/index.ts

@@ -1,8 +1,10 @@
 export * from './add.space.dto';
 export * from './community-space.param';
+export * from './create-allocations.dto';
+export * from './create-product-allocation.dto';
 export * from './get.space.param';
-export * from './user-space.param';
-export * from './subspace';
 export * from './project.param.dto';
-export * from './update.space.dto';
+export * from './subspace';
 export * from './tag';
+export * from './update.space.dto';
+export * from './user-space.param';

src/space/dtos/subspace/add.subspace.dto.ts

@@ -1,4 +1,5 @@
 import { ApiProperty } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
 import {
   IsArray,
   IsNotEmpty,
@@ -6,8 +7,8 @@ import {
   IsString,
   ValidateNested,
 } from 'class-validator';
-import { Type } from 'class-transformer';
 import { ProcessTagDto } from 'src/tags/dtos';
+import { CreateProductAllocationDto } from '../create-product-allocation.dto';
 
 export class AddSubspaceDto {
   @ApiProperty({
@@ -24,7 +25,7 @@ export class AddSubspaceDto {
   })
   @IsArray()
   @ValidateNested({ each: true })
-  @Type(() => ProcessTagDto)
+  @Type(() => CreateProductAllocationDto)
   @IsOptional()
-  tags?: ProcessTagDto[];
+  productAllocations?: CreateProductAllocationDto[];
 }

src/space/dtos/subspace/index.ts

@@ -1,6 +1,5 @@
-export * from './add.subspace.dto';
-export * from './get.subspace.param';
 export * from './add.subspace-device.param';
-export * from './update.subspace.dto';
+export * from './add.subspace.dto';
 export * from './delete.subspace.dto';
-export * from './modify.subspace.dto';
+export * from './get.subspace.param';
+export * from './update.subspace.dto';

src/space/dtos/subspace/modify.subspace.dto.ts

@@ -1,14 +0,0 @@
-import { ApiPropertyOptional, PartialType } from '@nestjs/swagger';
-import { IsOptional, IsUUID } from 'class-validator';
-import { AddSubspaceDto } from './add.subspace.dto';
-
-export class ModifySubspaceDto extends PartialType(AddSubspaceDto) {
-  @ApiPropertyOptional({
-    description:
-      'UUID of the subspace (will present if updating an existing subspace)',
-    example: '123e4567-e89b-12d3-a456-426614174000',
-  })
-  @IsOptional()
-  @IsUUID()
-  uuid?: string;
-}

src/space/dtos/subspace/update.subspace.dto.ts

@@ -1,16 +1,14 @@
-import { ApiProperty } from '@nestjs/swagger';
-import { IsNotEmpty, IsString } from 'class-validator';
+import { ApiPropertyOptional, PartialType } from '@nestjs/swagger';
+import { IsOptional, IsUUID } from 'class-validator';
+import { AddSubspaceDto } from './add.subspace.dto';
 
-export class UpdateSubspaceDto {
-  @ApiProperty({
-    description: 'Name of the subspace',
-    example: 'Living Room',
+export class UpdateSubspaceDto extends PartialType(AddSubspaceDto) {
+  @ApiPropertyOptional({
+    description:
+      'UUID of the subspace (will present if updating an existing subspace)',
+    example: '123e4567-e89b-12d3-a456-426614174000',
   })
-  @IsNotEmpty()
-  @IsString()
-  subspaceName?: string;
-
-  @IsNotEmpty()
-  @IsString()
-  subspaceUuid: string;
+  @IsOptional()
+  @IsUUID()
+  uuid?: string;
 }

src/space/dtos/update.space.dto.ts

@@ -9,8 +9,8 @@ import {
   NotEquals,
   ValidateNested,
 } from 'class-validator';
-import { ModifySubspaceDto } from './subspace';
-import { ModifyTagDto } from './tag/modify-tag.dto';
+import { CreateProductAllocationDto } from './create-product-allocation.dto';
+import { UpdateSubspaceDto } from './subspace';
 
 export class UpdateSpaceDto {
   @ApiProperty({
@@ -46,25 +46,24 @@ export class UpdateSpaceDto {
   y?: number;
 
   @ApiPropertyOptional({
-    description: 'List of subspace modifications (add/update/delete)',
-    type: [ModifySubspaceDto],
+    description: 'List of subspace modifications',
+    type: [UpdateSubspaceDto],
   })
   @IsOptional()
   @IsArray()
   @ValidateNested({ each: true })
-  @Type(() => ModifySubspaceDto)
-  subspaces?: ModifySubspaceDto[];
+  @Type(() => UpdateSubspaceDto)
+  subspaces?: UpdateSubspaceDto[];
 
   @ApiPropertyOptional({
-    description:
-      'List of tag modifications (add/update/delete) for the space model',
-    type: [ModifyTagDto],
+    description: 'List of allocations modifications',
+    type: [CreateProductAllocationDto],
   })
   @IsOptional()
   @IsArray()
   @ValidateNested({ each: true })
-  @Type(() => ModifyTagDto)
-  tags?: ModifyTagDto[];
+  @Type(() => CreateProductAllocationDto)
+  productAllocations?: CreateProductAllocationDto[];
 
   @ApiProperty({
     description: 'UUID of the Space',

src/space/handlers/disable-space.handler.ts

@@ -5,11 +5,7 @@ import { DeviceService } from 'src/device/services';
 import { UserSpaceService } from 'src/users/services';
 import { DataSource } from 'typeorm';
 import { DisableSpaceCommand } from '../commands';
-import {
-  SpaceLinkService,
-  SpaceSceneService,
-  SubSpaceService,
-} from '../services';
+import { SpaceSceneService, SubSpaceService } from '../services';
 
 @CommandHandler(DisableSpaceCommand)
 export class DisableSpaceHandler
@@ -19,7 +15,6 @@ export class DisableSpaceHandler
     private readonly subSpaceService: SubSpaceService,
     private readonly userService: UserSpaceService,
     private readonly deviceService: DeviceService,
-    private readonly spaceLinkService: SpaceLinkService,
     private readonly sceneService: SpaceSceneService,
     private readonly dataSource: DataSource,
   ) {}
@@ -39,8 +34,6 @@ export class DisableSpaceHandler
           'subspaces',
           'parent',
           'devices',
-          'outgoingConnections',
-          'incomingConnections',
           'scenes',
           'children',
           'userSpaces',
@@ -79,7 +72,6 @@ export class DisableSpaceHandler
           orphanSpace,
           queryRunner,
         ),
-        this.spaceLinkService.deleteSpaceLink(space, queryRunner),
         this.sceneService.deleteScenes(space, queryRunner),
       ];
 

src/space/services/product-allocation/product-allocation.service.ts

@@ -16,10 +16,10 @@ export class ProductAllocationService {
   ) {}
 
   async createAllocations(dto: CreateAllocationsDto): Promise<void> {
-    const { projectUuid, queryRunner, tags, type } = dto;
+    const { projectUuid, queryRunner, productAllocations, type } = dto;
 
-    const allocationsData = await this.tagService.processTags(
-      tags,
+    const allocationsData = await this.tagService.upsertTags(
+      productAllocations,
       projectUuid,
       queryRunner,
     );
@@ -29,15 +29,17 @@ export class ProductAllocationService {
     const createdTagsByName = new Map(allocationsData.map((t) => [t.name, t]));
 
     // Create the product-tag mapping based on the processed tags
-    const productTagMapping = tags.map(({ uuid, name, productUuid }) => {
-      const inputTag = uuid
-        ? createdTagsByUUID.get(uuid)
-        : createdTagsByName.get(name);
-      return {
-        tag: inputTag?.uuid,
-        product: productUuid,
-      };
-    });
+    const productTagMapping = productAllocations.map(
+      ({ tagUuid, tagName, productUuid }) => {
+        const inputTag = tagUuid
+          ? createdTagsByUUID.get(tagUuid)
+          : createdTagsByName.get(tagName);
+        return {
+          tag: inputTag?.uuid,
+          product: productUuid,
+        };
+      },
+    );
 
     switch (type) {
       case AllocationsOwnerType.SPACE: {

src/space/services/space-link/space-link.service.ts

@@ -1,121 +1,6 @@
-import { SpaceLinkEntity } from '@app/common/modules/space/entities/space-link.entity';
-import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
-import { SpaceLinkRepository } from '@app/common/modules/space/repositories';
-import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
-import { QueryRunner } from 'typeorm';
+import { Injectable } from '@nestjs/common';
 
+// todo: find out why we need to import this
+// in community module in order for the whole system to work
 @Injectable()
-export class SpaceLinkService {
-  constructor(private readonly spaceLinkRepository: SpaceLinkRepository) {}
-
-  async saveSpaceLink(
-    startSpaceId: string,
-    endSpaceId: string,
-    direction: string,
-    queryRunner: QueryRunner,
-  ): Promise<void> {
-    try {
-      // Check if a link between the startSpace and endSpace already exists
-      const existingLink = await queryRunner.manager.findOne(SpaceLinkEntity, {
-        where: {
-          startSpace: { uuid: startSpaceId },
-          endSpace: { uuid: endSpaceId },
-          disabled: false,
-        },
-      });
-
-      if (existingLink) {
-        // Update the direction if the link exists
-        existingLink.direction = direction;
-        await queryRunner.manager.save(SpaceLinkEntity, existingLink);
-        return;
-      }
-
-      const existingEndSpaceLink = await queryRunner.manager.findOne(
-        SpaceLinkEntity,
-        {
-          where: { endSpace: { uuid: endSpaceId } },
-        },
-      );
-
-      if (
-        existingEndSpaceLink &&
-        existingEndSpaceLink.startSpace.uuid !== startSpaceId
-      ) {
-        throw new Error(
-          `Space with ID ${endSpaceId} is already an endSpace in another link and cannot be reused.`,
-        );
-      }
-
-      // Find start space
-      const startSpace = await queryRunner.manager.findOne(SpaceEntity, {
-        where: { uuid: startSpaceId },
-      });
-
-      if (!startSpace) {
-        throw new HttpException(
-          `Start space with ID ${startSpaceId} not found.`,
-          HttpStatus.NOT_FOUND,
-        );
-      }
-
-      // Find end space
-      const endSpace = await queryRunner.manager.findOne(SpaceEntity, {
-        where: { uuid: endSpaceId },
-      });
-
-      if (!endSpace) {
-        throw new HttpException(
-          `End space with ID ${endSpaceId} not found.`,
-          HttpStatus.NOT_FOUND,
-        );
-      }
-
-      // Create and save the space link
-      const spaceLink = this.spaceLinkRepository.create({
-        startSpace,
-        endSpace,
-        direction,
-      });
-
-      await queryRunner.manager.save(SpaceLinkEntity, spaceLink);
-    } catch (error) {
-      throw new HttpException(
-        error.message ||
-          `Failed to save space link. Internal Server Error: ${error.message}`,
-        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
-  async deleteSpaceLink(
-    space: SpaceEntity,
-    queryRunner: QueryRunner,
-  ): Promise<void> {
-    try {
-      const spaceLinks = await queryRunner.manager.find(SpaceLinkEntity, {
-        where: [
-          { startSpace: space, disabled: false },
-          { endSpace: space, disabled: false },
-        ],
-      });
-
-      if (spaceLinks.length === 0) {
-        return;
-      }
-
-      const linkIds = spaceLinks.map((link) => link.uuid);
-
-      await queryRunner.manager
-        .createQueryBuilder()
-        .update(SpaceLinkEntity)
-        .set({ disabled: true })
-        .whereInIds(linkIds)
-        .execute();
-    } catch (error) {
-      throw new HttpException(
-        `Failed to disable space links for the given space: ${error.message}`,
-        HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
-}
+export class SpaceLinkService {}

src/space/services/space-validation.service.ts

@@ -16,7 +16,7 @@ import {
   Inject,
   Injectable,
 } from '@nestjs/common';
-import { In } from 'typeorm';
+import { In, QueryRunner } from 'typeorm';
 import { CommunityService } from '../../community/services';
 import { ProjectService } from '../../project/services';
 import { ProjectParam } from '../dtos';
@@ -69,12 +69,17 @@ export class ValidationService {
   async validateCommunityAndProject(
     communityUuid: string,
     projectUuid: string,
+    queryRunner?: QueryRunner,
   ) {
-    const project = await this.projectService.findOne(projectUuid);
-    const community = await this.communityService.getCommunityById({
-      communityUuid,
-      projectUuid,
-    });
+    const project = await this.projectService.findOne(projectUuid, queryRunner);
+
+    const community = await this.communityService.getCommunityById(
+      {
+        communityUuid,
+        projectUuid,
+      },
+      queryRunner,
+    );
 
     return { community: community.data, project: project };
   }
@@ -170,8 +175,14 @@ export class ValidationService {
     return space;
   }
 
-  async validateSpaceModel(spaceModelUuid: string): Promise<SpaceModelEntity> {
-    const queryBuilder = this.spaceModelRepository
+  async validateSpaceModel(
+    spaceModelUuid: string,
+    queryRunner?: QueryRunner,
+  ): Promise<SpaceModelEntity> {
+    const queryBuilder = (
+      queryRunner.manager.getRepository(SpaceModelEntity) ||
+      this.spaceModelRepository
+    )
       .createQueryBuilder('spaceModel')
       .leftJoinAndSelect(
         'spaceModel.subspaceModels',

src/space/services/space.service.ts

@@ -22,7 +22,6 @@ import {
 import { CommandBus } from '@nestjs/cqrs';
 import { DeviceService } from 'src/device/services';
 import { SpaceModelService } from 'src/space-model/services';
-import { ProcessTagDto } from 'src/tags/dtos';
 import { TagService } from 'src/tags/services/tags.service';
 import { DataSource, In, Not, QueryRunner } from 'typeorm';
 import { DisableSpaceCommand } from '../commands';
@@ -32,9 +31,9 @@ import {
   GetSpaceParam,
   UpdateSpaceDto,
 } from '../dtos';
+import { CreateProductAllocationDto } from '../dtos/create-product-allocation.dto';
 import { GetSpaceDto } from '../dtos/get.space.dto';
 import { SpaceWithParentsDto } from '../dtos/space.parents.dto';
-import { SpaceLinkService } from './space-link';
 import { SpaceProductAllocationService } from './space-product-allocation.service';
 import { ValidationService } from './space-validation.service';
 import { SubSpaceService } from './subspace';
@@ -44,7 +43,6 @@ export class SpaceService {
     private readonly dataSource: DataSource,
     private readonly spaceRepository: SpaceRepository,
     private readonly inviteSpaceRepository: InviteSpaceRepository,
-    private readonly spaceLinkService: SpaceLinkService,
     private readonly subSpaceService: SubSpaceService,
     private readonly validationService: ValidationService,
     private readonly tagService: TagService,
@@ -57,50 +55,72 @@ export class SpaceService {
   async createSpace(
     addSpaceDto: AddSpaceDto,
     params: CommunitySpaceParam,
+    queryRunner?: QueryRunner,
+    recursiveCallParentEntity?: SpaceEntity,
   ): Promise<BaseResponseDto> {
-    const { parentUuid, direction, spaceModelUuid, subspaces, tags } =
-      addSpaceDto;
+    const isRecursiveCall = !!queryRunner;
+
+    const {
+      parentUuid,
+      spaceModelUuid,
+      subspaces,
+      productAllocations,
+      children,
+    } = addSpaceDto;
     const { communityUuid, projectUuid } = params;
 
-    const queryRunner = this.dataSource.createQueryRunner();
-
-    await queryRunner.connect();
-    await queryRunner.startTransaction();
+    if (!queryRunner) {
+      queryRunner = this.dataSource.createQueryRunner();
+      await queryRunner.connect();
+      await queryRunner.startTransaction();
+    }
 
     const { community } =
       await this.validationService.validateCommunityAndProject(
         communityUuid,
         projectUuid,
+        queryRunner,
       );
 
-    this.validateSpaceCreationCriteria({ spaceModelUuid, subspaces, tags });
+    this.validateSpaceCreationCriteria({
+      spaceModelUuid,
+      subspaces,
+      productAllocations,
+    });
 
-    const parent = parentUuid
-      ? await this.validationService.validateSpace(parentUuid)
-      : null;
+    const parent =
+      parentUuid && !isRecursiveCall
+        ? await this.validationService.validateSpace(parentUuid)
+        : null;
 
     const spaceModel = spaceModelUuid
       ? await this.validationService.validateSpaceModel(spaceModelUuid)
       : null;
-
     try {
       const space = queryRunner.manager.create(SpaceEntity, {
-        ...addSpaceDto,
+        // todo: find a better way to handle this instead of naming every key
+        spaceName: addSpaceDto.spaceName,
+        icon: addSpaceDto.icon,
+        x: addSpaceDto.x,
+        y: addSpaceDto.y,
         spaceModel,
-        parent: parentUuid ? parent : null,
+        parent: isRecursiveCall
+          ? recursiveCallParentEntity
+          : parentUuid
+            ? parent
+            : null,
         community,
       });
 
       const newSpace = await queryRunner.manager.save(space);
-
-      const subspaceTags =
-        subspaces?.flatMap((subspace) => subspace.tags || []) || [];
-
-      this.checkDuplicateTags([...tags, ...subspaceTags]);
+      this.checkDuplicateTags([
+        ...(productAllocations || []),
+        ...(subspaces?.flatMap(
+          (subspace) => subspace.productAllocations || [],
+        ) || []),
+      ]);
 
       if (spaceModelUuid) {
-        // no need to check for existing dependencies here as validateSpaceCreationCriteria
-        // ensures no tags or subspaces are present along with spaceModelUuid
         await this.spaceModelService.linkToSpace(
           newSpace,
           spaceModel,
@@ -109,15 +129,6 @@ export class SpaceService {
       }
 
       await Promise.all([
-        // todo: remove this logic as we are not using space links anymore
-        direction && parent
-          ? this.spaceLinkService.saveSpaceLink(
-              parent.uuid,
-              newSpace.uuid,
-              direction,
-              queryRunner,
-            )
-          : Promise.resolve(),
         subspaces?.length
           ? this.subSpaceService.createSubspacesFromDto(
               subspaces,
@@ -126,12 +137,32 @@ export class SpaceService {
               projectUuid,
             )
           : Promise.resolve(),
-        tags?.length
-          ? this.createAllocations(tags, projectUuid, queryRunner, newSpace)
+        productAllocations?.length
+          ? this.createAllocations(
+              productAllocations,
+              projectUuid,
+              queryRunner,
+              newSpace,
+            )
           : Promise.resolve(),
       ]);
 
-      await queryRunner.commitTransaction();
+      if (children?.length) {
+        await Promise.all(
+          children.map((child) =>
+            this.createSpace(
+              { ...child, parentUuid: newSpace.uuid },
+              { communityUuid, projectUuid },
+              queryRunner,
+              newSpace,
+            ),
+          ),
+        );
+      }
+
+      if (!isRecursiveCall) {
+        await queryRunner.commitTransaction();
+      }
 
       return new SuccessResponseDto({
         statusCode: HttpStatus.CREATED,
@@ -139,34 +170,34 @@ export class SpaceService {
         message: 'Space created successfully',
       });
     } catch (error) {
-      await queryRunner.rollbackTransaction();
+      !isRecursiveCall ? await queryRunner.rollbackTransaction() : null;
 
       if (error instanceof HttpException) {
         throw error;
       }
       throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
     } finally {
-      await queryRunner.release();
+      !isRecursiveCall ? await queryRunner.release() : null;
     }
   }
-  private checkDuplicateTags(allTags: ProcessTagDto[]) {
+  private checkDuplicateTags(allocations: CreateProductAllocationDto[]) {
     const tagUuidSet = new Set<string>();
     const tagNameProductSet = new Set<string>();
 
-    for (const tag of allTags) {
-      if (tag.uuid) {
-        if (tagUuidSet.has(tag.uuid)) {
+    for (const allocation of allocations) {
+      if (allocation.tagUuid) {
+        if (tagUuidSet.has(allocation.tagUuid)) {
           throw new HttpException(
-            `Duplicate tag UUID found: ${tag.uuid}`,
+            `Duplicate tag UUID found: ${allocation.tagUuid}`,
             HttpStatus.BAD_REQUEST,
           );
         }
-        tagUuidSet.add(tag.uuid);
+        tagUuidSet.add(allocation.tagUuid);
       } else {
-        const tagKey = `${tag.name}-${tag.productUuid}`;
+        const tagKey = `${allocation.tagName}-${allocation.productUuid}`;
         if (tagNameProductSet.has(tagKey)) {
           throw new HttpException(
-            `Duplicate tag found with name "${tag.name}" and product "${tag.productUuid}".`,
+            `Duplicate tag found with name "${allocation.tagName}" and product "${allocation.productUuid}".`,
             HttpStatus.BAD_REQUEST,
           );
         }
@@ -195,12 +226,7 @@ export class SpaceService {
           'children.disabled = :disabled',
           { disabled: false },
         )
-        .leftJoinAndSelect(
-          'space.incomingConnections',
-          'incomingConnections',
-          'incomingConnections.disabled = :incomingConnectionDisabled',
-          { incomingConnectionDisabled: false },
-        )
+
         .leftJoinAndSelect('space.productAllocations', 'productAllocations')
         .leftJoinAndSelect('productAllocations.tag', 'tag')
         .leftJoinAndSelect('productAllocations.product', 'product')
@@ -271,7 +297,6 @@ export class SpaceService {
     }
   }
 
-  // todo refactor this method to eliminate wrong use of tags
   async findOne(params: GetSpaceParam): Promise<BaseResponseDto> {
     const { communityUuid, spaceUuid, projectUuid } = params;
     try {
@@ -282,19 +307,6 @@ export class SpaceService {
 
       const queryBuilder = this.spaceRepository
         .createQueryBuilder('space')
-        .leftJoinAndSelect('space.parent', 'parent')
-        .leftJoinAndSelect(
-          'space.children',
-          'children',
-          'children.disabled = :disabled',
-          { disabled: false },
-        )
-        .leftJoinAndSelect(
-          'space.incomingConnections',
-          'incomingConnections',
-          'incomingConnections.disabled = :incomingConnectionDisabled',
-          { incomingConnectionDisabled: false },
-        )
         .leftJoinAndSelect('space.productAllocations', 'productAllocations')
         .leftJoinAndSelect('productAllocations.tag', 'spaceTag')
         .leftJoinAndSelect('productAllocations.product', 'spaceProduct')
@@ -423,7 +435,7 @@ export class SpaceService {
 
     const queryRunner = this.dataSource.createQueryRunner();
     const hasSubspace = updateSpaceDto.subspaces?.length > 0;
-    const hasTags = updateSpaceDto.tags?.length > 0;
+    const hasAllocations = updateSpaceDto.productAllocations?.length > 0;
 
     try {
       await queryRunner.connect();
@@ -448,7 +460,7 @@ export class SpaceService {
 
       await this.updateSpaceProperties(space, updateSpaceDto, queryRunner);
 
-      if (hasSubspace || hasTags) {
+      if (hasSubspace || hasAllocations) {
         await queryRunner.manager.update(SpaceEntity, space.uuid, {
           spaceModel: null,
         });
@@ -492,7 +504,7 @@ export class SpaceService {
         await this.subSpaceService.unlinkModels(space.subspaces, queryRunner);
       }
 
-      if (hasTags && space.productAllocations && space.spaceModel) {
+      if (hasAllocations && space.productAllocations && space.spaceModel) {
         await this.spaceProductAllocationService.unlinkModels(
           space,
           queryRunner,
@@ -508,13 +520,13 @@ export class SpaceService {
         );
       }
 
-      if (updateSpaceDto.tags) {
+      if (updateSpaceDto.productAllocations) {
         await queryRunner.manager.delete(SpaceProductAllocationEntity, {
           space: { uuid: space.uuid },
           tag: {
             uuid: Not(
               In(
-                updateSpaceDto.tags
+                updateSpaceDto.productAllocations
                   .filter((tag) => tag.tagUuid)
                   .map((tag) => tag.tagUuid),
               ),
@@ -522,11 +534,7 @@ export class SpaceService {
           },
         });
         await this.createAllocations(
-          updateSpaceDto.tags.map((tag) => ({
-            name: tag.name,
-            uuid: tag.tagUuid,
-            productUuid: tag.productUuid,
-          })),
+          updateSpaceDto.productAllocations,
           projectUuid,
           queryRunner,
           space,
@@ -673,7 +681,7 @@ export class SpaceService {
     }
   }
 
-  private buildSpaceHierarchy(spaces: SpaceEntity[]): SpaceEntity[] {
+  buildSpaceHierarchy(spaces: SpaceEntity[]): SpaceEntity[] {
     const map = new Map<string, SpaceEntity>();
 
     // Step 1: Create a map of spaces by UUID
@@ -702,13 +710,17 @@ export class SpaceService {
 
   private validateSpaceCreationCriteria({
     spaceModelUuid,
-    tags,
+    productAllocations,
     subspaces,
-  }: Pick<AddSpaceDto, 'spaceModelUuid' | 'tags' | 'subspaces'>): void {
-    const hasTagsOrSubspaces =
-      (tags && tags.length > 0) || (subspaces && subspaces.length > 0);
+  }: Pick<
+    AddSpaceDto,
+    'spaceModelUuid' | 'productAllocations' | 'subspaces'
+  >): void {
+    const hasProductsOrSubspaces =
+      (productAllocations && productAllocations.length > 0) ||
+      (subspaces && subspaces.length > 0);
 
-    if (spaceModelUuid && hasTagsOrSubspaces) {
+    if (spaceModelUuid && hasProductsOrSubspaces) {
       throw new HttpException(
         'For space creation choose either space model or products and subspace',
         HttpStatus.CONFLICT,
@@ -717,13 +729,13 @@ export class SpaceService {
   }
 
   private async createAllocations(
-    tags: ProcessTagDto[],
+    productAllocations: CreateProductAllocationDto[],
     projectUuid: string,
     queryRunner: QueryRunner,
     space: SpaceEntity,
   ): Promise<void> {
-    const allocationsData = await this.tagService.processTags(
-      tags,
+    const allocationsData = await this.tagService.upsertTags(
+      productAllocations,
       projectUuid,
       queryRunner,
     );
@@ -733,15 +745,17 @@ export class SpaceService {
     const createdTagsByName = new Map(allocationsData.map((t) => [t.name, t]));
 
     // Create the product-tag mapping based on the processed tags
-    const productTagMapping = tags.map(({ uuid, name, productUuid }) => {
-      const inputTag = uuid
-        ? createdTagsByUUID.get(uuid)
-        : createdTagsByName.get(name);
-      return {
-        tag: inputTag?.uuid,
-        product: productUuid,
-      };
-    });
+    const productTagMapping = productAllocations.map(
+      ({ tagUuid, tagName, productUuid }) => {
+        const inputTag = tagUuid
+          ? createdTagsByUUID.get(tagUuid)
+          : createdTagsByName.get(tagName);
+        return {
+          tag: inputTag?.uuid,
+          product: productUuid,
+        };
+      },
+    );
 
     await this.spaceProductAllocationService.createProductAllocations(
       space,

src/space/services/subspace/subspace-product-allocation.service.ts

@@ -3,7 +3,7 @@ import { SubspaceProductAllocationEntity } from '@app/common/modules/space/entit
 import { SubspaceEntity } from '@app/common/modules/space/entities/subspace/subspace.entity';
 import { SubspaceProductAllocationRepository } from '@app/common/modules/space/repositories/subspace.repository';
 import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
-import { UpdateSpaceAllocationDto } from 'src/space/interfaces/update-subspace-allocation.dto';
+import { UpdateSubspaceDto } from 'src/space/dtos';
 import { TagService as NewTagService } from 'src/tags/services';
 import { In, Not, QueryRunner } from 'typeorm';
 
@@ -60,31 +60,46 @@ export class SubspaceProductAllocationService {
   }
 
   async updateSubspaceProductAllocationsV2(
-    subSpaces: UpdateSpaceAllocationDto[],
+    subSpaces: UpdateSubspaceDto[],
     projectUuid: string,
     queryRunner: QueryRunner,
   ) {
     await Promise.all(
       subSpaces.map(async (subspace) => {
         await queryRunner.manager.delete(SubspaceProductAllocationEntity, {
-          subspace: { uuid: subspace.uuid },
-          tag: {
-            uuid: Not(
-              In(
-                subspace.tags.filter((tag) => tag.uuid).map((tag) => tag.uuid),
-              ),
-            ),
-          },
+          subspace: subspace.uuid ? { uuid: subspace.uuid } : undefined,
+          tag: subspace.productAllocations
+            ? {
+                uuid: Not(
+                  In(
+                    subspace.productAllocations
+                      .filter((allocation) => allocation.tagUuid)
+                      .map((allocation) => allocation.tagUuid),
+                  ),
+                ),
+              }
+            : undefined,
+          product: subspace.productAllocations
+            ? {
+                uuid: Not(
+                  In(
+                    subspace.productAllocations
+                      .filter((allocation) => allocation.productUuid)
+                      .map((allocation) => allocation.productUuid),
+                  ),
+                ),
+              }
+            : undefined,
         });
+
         const subspaceEntity = await queryRunner.manager.findOne(
           SubspaceEntity,
           {
             where: { uuid: subspace.uuid },
           },
         );
-
-        const processedTags = await this.tagService.processTags(
-          subspace.tags,
+        const processedTags = await this.tagService.upsertTags(
+          subspace.productAllocations,
           projectUuid,
           queryRunner,
         );
@@ -97,11 +112,11 @@ export class SubspaceProductAllocationService {
         );
 
         // Create the product-tag mapping based on the processed tags
-        const productTagMapping = subspace.tags.map(
-          ({ uuid, name, productUuid }) => {
-            const inputTag = uuid
-              ? createdTagsByUUID.get(uuid)
-              : createdTagsByName.get(name);
+        const productTagMapping = subspace.productAllocations.map(
+          ({ tagUuid, tagName, productUuid }) => {
+            const inputTag = tagUuid
+              ? createdTagsByUUID.get(tagUuid)
+              : createdTagsByName.get(tagName);
             return {
               tag: inputTag?.uuid,
               product: productUuid,
@@ -118,71 +133,6 @@ export class SubspaceProductAllocationService {
     );
   }
 
-  // async processDeleteActions(dtos: ModifyTagDto[], queryRunner: QueryRunner) {
-  //   // : Promise<SubspaceProductAllocationEntity[]>
-  //   try {
-  //     // if (!dtos || dtos.length === 0) {
-  //     //   throw new Error('No DTOs provided for deletion.');
-  //     // }
-  //     // const tagUuidsToDelete = dtos
-  //     //   .filter((dto) => dto.action === ModifyAction.DELETE && dto.tagUuid)
-  //     //   .map((dto) => dto.tagUuid);
-  //     // if (tagUuidsToDelete.length === 0) return [];
-  //     // const allocationsToUpdate = await queryRunner.manager.find(
-  //     //   SubspaceProductAllocationEntity,
-  //     //   {
-  //     //     where: { tag: In(tagUuidsToDelete) },
-  //     //   },
-  //     // );
-  //     // if (!allocationsToUpdate || allocationsToUpdate.length === 0) return [];
-  //     // const deletedAllocations: SubspaceProductAllocationEntity[] = [];
-  //     // const allocationUpdates: SubspaceProductAllocationEntity[] = [];
-  //     // for (const allocation of allocationsToUpdate) {
-  //     //   const updatedTags = allocation.tags.filter(
-  //     //     (tag) => !tagUuidsToDelete.includes(tag.uuid),
-  //     //   );
-  //     //   if (updatedTags.length === allocation.tags.length) {
-  //     //     continue;
-  //     //   }
-  //     //   if (updatedTags.length === 0) {
-  //     //     deletedAllocations.push(allocation);
-  //     //   } else {
-  //     //     allocation.tags = updatedTags;
-  //     //     allocationUpdates.push(allocation);
-  //     //   }
-  //     // }
-  //     // if (allocationUpdates.length > 0) {
-  //     //   await queryRunner.manager.save(
-  //     //     SubspaceProductAllocationEntity,
-  //     //     allocationUpdates,
-  //     //   );
-  //     // }
-  //     // if (deletedAllocations.length > 0) {
-  //     //   await queryRunner.manager.remove(
-  //     //     SubspaceProductAllocationEntity,
-  //     //     deletedAllocations,
-  //     //   );
-  //     // }
-  //     // await queryRunner.manager
-  //     //   .createQueryBuilder()
-  //     //   .delete()
-  //     //   .from('subspace_product_tags')
-  //     //   .where(
-  //     //     'subspace_product_allocation_uuid NOT IN ' +
-  //     //       queryRunner.manager
-  //     //         .createQueryBuilder()
-  //     //         .select('allocation.uuid')
-  //     //         .from(SubspaceProductAllocationEntity, 'allocation')
-  //     //         .getQuery() +
-  //     //       ')',
-  //     //   )
-  //     //   .execute();
-  //     // return deletedAllocations;
-  //   } catch (error) {
-  //     throw this.handleError(error, `Failed to delete tags in subspace`);
-  //   }
-  // }
-
   async unlinkModels(
     allocations: SubspaceProductAllocationEntity[],
     queryRunner: QueryRunner,
@@ -205,67 +155,6 @@ export class SubspaceProductAllocationService {
     }
   }
 
-  // private async validateTagWithinSubspace(
-  //   queryRunner: QueryRunner | undefined,
-  //   tag: NewTagEntity & { product: string },
-  //   subspace: SubspaceEntity,
-  //   spaceAllocationsToExclude?: SpaceProductAllocationEntity[],
-  // ): Promise<void> {
-  //   // const existingTagInSpace = await (queryRunner
-  //   //   ? queryRunner.manager.findOne(SpaceProductAllocationEntity, {
-  //   //       where: {
-  //   //         product: { uuid: tag.product },
-  //   //         space: { uuid: subspace.space.uuid },
-  //   //         tag: { uuid: tag.uuid },
-  //   //       },
-  //   //     })
-  //   //   : this.spaceProductAllocationRepository.findOne({
-  //   //       where: {
-  //   //         product: { uuid: tag.product },
-  //   //         space: { uuid: subspace.space.uuid },
-  //   //         tag: { uuid: tag.uuid },
-  //   //       },
-  //   //     }));
-  //   // const isExcluded = spaceAllocationsToExclude?.some(
-  //   //   (excludedAllocation) =>
-  //   //     excludedAllocation.product.uuid === tag.product &&
-  //   //     excludedAllocation.tags.some((t) => t.uuid === tag.uuid),
-  //   // );
-  //   // if (!isExcluded && existingTagInSpace) {
-  //   //   throw new HttpException(
-  //   //     `Tag ${tag.uuid} (Product: ${tag.product}) is already allocated at the space level (${subspace.space.uuid}). Cannot allocate the same tag in a subspace.`,
-  //   //     HttpStatus.BAD_REQUEST,
-  //   //   );
-  //   // }
-  //   // // ?: Check if the tag is already allocated in another "subspace" within the same space
-  //   // const existingTagInSameSpace = await (queryRunner
-  //   //   ? queryRunner.manager.findOne(SubspaceProductAllocationEntity, {
-  //   //       where: {
-  //   //         product: { uuid: tag.product },
-  //   //         subspace: { space: subspace.space },
-  //   //         tag: { uuid: tag.uuid },
-  //   //       },
-  //   //       relations: ['subspace'],
-  //   //     })
-  //   //   : this.subspaceProductAllocationRepository.findOne({
-  //   //       where: {
-  //   //         product: { uuid: tag.product },
-  //   //         subspace: { space: subspace.space },
-  //   //         tag: { uuid: tag.uuid },
-  //   //       },
-  //   //       relations: ['subspace'],
-  //   //     }));
-  //   // if (
-  //   //   existingTagInSameSpace &&
-  //   //   existingTagInSameSpace.subspace.uuid !== subspace.uuid
-  //   // ) {
-  //   //   throw new HttpException(
-  //   //     `Tag ${tag.uuid} (Product: ${tag.product}) is already allocated in another subspace (${existingTagInSameSpace.subspace.uuid}) within the same space (${subspace.space.uuid}).`,
-  //   //     HttpStatus.BAD_REQUEST,
-  //   //   );
-  //   // }
-  // }
-
   private createNewSubspaceAllocation(
     subspace: SubspaceEntity,
     allocationData: { product: string; tag: string },

src/space/services/subspace/subspace.service.ts

@@ -12,7 +12,7 @@ import {
   AddSubspaceDto,
   GetSpaceParam,
   GetSubSpaceParam,
-  ModifySubspaceDto,
+  UpdateSubspaceDto,
 } from '../../dtos';
 
 import { SubspaceModelEntity } from '@app/common/modules/space-model';
@@ -103,13 +103,13 @@ export class SubSpaceService {
         queryRunner,
       );
       await Promise.all(
-        addSubspaceDtos.map(async ({ tags }, index) => {
+        addSubspaceDtos.map(async ({ productAllocations }, index) => {
           // map the dto to the corresponding subspace
           const subspace = createdSubspaces[index];
           await this.createAllocations({
             projectUuid,
             queryRunner,
-            tags,
+            productAllocations,
             type: AllocationsOwnerType.SUBSPACE,
             subspace,
           });
@@ -145,7 +145,7 @@ export class SubSpaceService {
         space,
       );
       const newSubspace = this.subspaceRepository.create({
-        ...addSubspaceDto,
+        subspaceName: addSubspaceDto.subspaceName,
         space,
       });
 
@@ -305,7 +305,7 @@ export class SubSpaceService {
   } */
 
   async updateSubspaceInSpace(
-    subspaceDtos: ModifySubspaceDto[],
+    subspaceDtos: UpdateSubspaceDto[],
     queryRunner: QueryRunner,
     space: SpaceEntity,
     projectUuid: string,
@@ -324,42 +324,52 @@ export class SubSpaceService {
           disabled: true,
         },
       );
-
       await queryRunner.manager.delete(SubspaceProductAllocationEntity, {
-        subspace: { uuid: Not(In(subspaceDtos.map((dto) => dto.uuid))) },
+        subspace: {
+          uuid: Not(
+            In(subspaceDtos.filter(({ uuid }) => uuid).map(({ uuid }) => uuid)),
+          ),
+        },
       });
 
       // create or update subspaces provided in the list
       const newSubspaces = this.subspaceRepository.create(
-        subspaceDtos.filter((dto) => !dto.uuid),
+        subspaceDtos
+          .filter((dto) => !dto.uuid)
+          .map((dto) => ({
+            subspaceName: dto.subspaceName,
+            space,
+          })),
       );
 
       const updatedSubspaces: SubspaceEntity[] = await queryRunner.manager.save(
         SubspaceEntity,
-        [...newSubspaces, ...subspaceDtos.filter((dto) => dto.uuid)].map(
-          (subspace) => ({ ...subspace, space }),
-        ),
+        [
+          ...newSubspaces,
+          ...subspaceDtos
+            .filter((dto) => dto.uuid)
+            .map((dto) => ({
+              subspaceName: dto.subspaceName,
+              space,
+            })),
+        ],
       );
-
       // create or update allocations for the subspaces
       if (updatedSubspaces.length > 0) {
         await this.subspaceProductAllocationService.updateSubspaceProductAllocationsV2(
-          subspaceDtos.map((dto) => {
-            if (!dto.uuid) {
-              dto.uuid = updatedSubspaces.find(
-                (subspace) => subspace.subspaceName === dto.subspaceName,
-              )?.uuid;
-            }
-            return {
-              tags: dto.tags || [],
-              uuid: dto.uuid,
-            };
-          }),
+          subspaceDtos.map((dto) => ({
+            ...dto,
+            uuid:
+              dto.uuid ||
+              updatedSubspaces.find((s) => s.subspaceName === dto.subspaceName)
+                ?.uuid,
+          })),
           projectUuid,
           queryRunner,
         );
       }
     } catch (error) {
+      console.log(error);
       throw new HttpException(
         `An error occurred while modifying subspaces: ${error.message}`,
         HttpStatus.INTERNAL_SERVER_ERROR,
@@ -478,10 +488,10 @@ export class SubSpaceService {
   }
 
   async createAllocations(dto: CreateAllocationsDto): Promise<void> {
-    const { projectUuid, queryRunner, tags, type } = dto;
-
-    const allocationsData = await this.newTagService.processTags(
-      tags,
+    const { projectUuid, queryRunner, productAllocations, type } = dto;
+    if (!productAllocations) return;
+    const allocationsData = await this.newTagService.upsertTags(
+      productAllocations,
       projectUuid,
       queryRunner,
     );
@@ -491,15 +501,17 @@ export class SubSpaceService {
     const createdTagsByName = new Map(allocationsData.map((t) => [t.name, t]));
 
     // Create the product-tag mapping based on the processed tags
-    const productTagMapping = tags.map(({ uuid, name, productUuid }) => {
-      const inputTag = uuid
-        ? createdTagsByUUID.get(uuid)
-        : createdTagsByName.get(name);
-      return {
-        tag: inputTag?.uuid,
-        product: productUuid,
-      };
-    });
+    const productTagMapping = productAllocations.map(
+      ({ tagUuid, tagName, productUuid }) => {
+        const inputTag = tagUuid
+          ? createdTagsByUUID.get(tagUuid)
+          : createdTagsByName.get(tagName);
+        return {
+          tag: inputTag?.uuid,
+          product: productUuid,
+        };
+      },
+    );
 
     switch (type) {
       case AllocationsOwnerType.SUBSPACE: {

src/space/space.module.ts

@@ -79,7 +79,6 @@ import { SpaceValidationController } from './controllers/space-validation.contro
 import { DisableSpaceHandler } from './handlers';
 import {
   SpaceDeviceService,
-  SpaceLinkService,
   SpaceSceneService,
   SpaceService,
   SpaceUserService,
@@ -110,7 +109,6 @@ export const CommandHandlers = [DisableSpaceHandler];
     ProductRepository,
     SubSpaceService,
     SpaceDeviceService,
-    SpaceLinkService,
     SubspaceDeviceService,
     SpaceRepository,
     SubspaceRepository,

src/tags/services/tags.service.ts

@@ -14,8 +14,8 @@ import {
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
+import { CreateProductAllocationDto } from 'src/space/dtos';
 import { In, QueryRunner } from 'typeorm';
-import { ProcessTagDto } from '../dtos';
 import { CreateTagDto } from '../dtos/tags.dto';
 
 @Injectable()
@@ -68,13 +68,13 @@ export class TagService {
 
   /**
    * Processes an array of tag DTOs, creating or updating tags in the database.
-   * @param tagDtos - The array of tag DTOs to process.
+   * @param allocationDtos - The array of allocations DTOs to process.
    * @param projectUuid - The UUID of the project to associate the tags with.
    * @param queryRunner - Optional TypeORM query runner for transaction management.
    * @returns An array of the processed tag entities.
    */
-  async processTags(
-    tagDtos: ProcessTagDto[],
+  async upsertTags(
+    allocationDtos: CreateProductAllocationDto[],
     projectUuid: string,
     queryRunner?: QueryRunner,
   ): Promise<NewTagEntity[]> {
@@ -82,20 +82,22 @@ export class TagService {
       const dbManager = queryRunner
         ? queryRunner.manager
         : this.tagRepository.manager;
-      if (!tagDtos || tagDtos.length === 0) {
+      if (!allocationDtos || allocationDtos.length === 0) {
         return [];
       }
 
-      const [tagsWithUuid, tagsWithoutUuid]: [
-        Pick<ProcessTagDto, 'uuid' | 'productUuid'>[],
-        Omit<ProcessTagDto, 'uuid'>[],
-      ] = this.splitTagsByUuid(tagDtos);
+      const [allocationsWithTagUuid, allocationsWithoutTagUuid]: [
+        Pick<CreateProductAllocationDto, 'tagUuid' | 'productUuid'>[],
+        Omit<CreateProductAllocationDto, 'tagUuid'>[],
+      ] = this.splitTagsByUuid(allocationDtos);
 
       // create a set of unique existing tag names for the project
       const upsertedTagsByNameResult = await dbManager.upsert(
         NewTagEntity,
         Array.from(
-          new Set<string>(tagsWithoutUuid.map((tag) => tag.name)).values(),
+          new Set<string>(
+            allocationsWithoutTagUuid.map((allocation) => allocation.tagName),
+          ).values(),
         ).map((name) => ({
           name,
           project: { uuid: projectUuid },
@@ -111,20 +113,22 @@ export class TagService {
 
       let foundByUuidTags: NewTagEntity[] = [];
       // Fetch existing tags using UUIDs
-      if (tagsWithUuid.length) {
+      if (allocationsWithTagUuid.length) {
         foundByUuidTags = await dbManager.find(NewTagEntity, {
           where: {
-            uuid: In([...tagsWithUuid.map((tag) => tag.uuid)]),
+            uuid: In([
+              ...allocationsWithTagUuid.map((allocation) => allocation.tagUuid),
+            ]),
             project: { uuid: projectUuid },
           },
         });
       }
 
       // Ensure all provided UUIDs exist in the database
-      if (foundByUuidTags.length !== tagsWithUuid.length) {
+      if (foundByUuidTags.length !== allocationsWithTagUuid.length) {
         const foundUuids = new Set(foundByUuidTags.map((tag) => tag.uuid));
-        const missingUuids = tagsWithUuid.filter(
-          ({ uuid }) => !foundUuids.has(uuid),
+        const missingUuids = allocationsWithTagUuid.filter(
+          ({ tagUuid }) => !foundUuids.has(tagUuid),
         );
 
         throw new HttpException(
@@ -179,20 +183,22 @@ export class TagService {
   }
 
   private splitTagsByUuid(
-    tagDtos: ProcessTagDto[],
-  ): [ProcessTagDto[], ProcessTagDto[]] {
-    return tagDtos.reduce<[ProcessTagDto[], ProcessTagDto[]]>(
-      ([withUuid, withoutUuid], tag) => {
-        if (tag.uuid) {
-          withUuid.push(tag);
+    allocationsDtos: CreateProductAllocationDto[],
+  ): [CreateProductAllocationDto[], CreateProductAllocationDto[]] {
+    return allocationsDtos.reduce<
+      [CreateProductAllocationDto[], CreateProductAllocationDto[]]
+    >(
+      ([withUuid, withoutUuid], allocation) => {
+        if (allocation.tagUuid) {
+          withUuid.push(allocation);
         } else {
-          if (!tag.name || !tag.productUuid) {
+          if (!allocation.tagName || !allocation.productUuid) {
             throw new HttpException(
               `Tag name or product UUID is missing`,
               HttpStatus.BAD_REQUEST,
             );
           }
-          withoutUuid.push(tag);
+          withoutUuid.push(allocation);
         }
         return [withUuid, withoutUuid];
       },

src/users/dtos/add.space.dto.ts

@@ -1,38 +1,5 @@
 import { ApiProperty } from '@nestjs/swagger';
-import {
-  IsBoolean,
-  IsNotEmpty,
-  IsOptional,
-  IsString,
-  IsUUID,
-} from 'class-validator';
-
-export class AddSpaceDto {
-  @ApiProperty({
-    description: 'Name of the space (e.g., Floor 1, Unit 101)',
-    example: 'Unit 101',
-  })
-  @IsString()
-  @IsNotEmpty()
-  spaceName: string;
-
-  @ApiProperty({
-    description: 'UUID of the parent space (if any, for hierarchical spaces)',
-    example: 'f5d7e9c3-44bc-4b12-88f1-1b3cda84752e',
-    required: false,
-  })
-  @IsUUID()
-  @IsOptional()
-  parentUuid?: string;
-
-  @ApiProperty({
-    description: 'Indicates whether the space is private or public',
-    example: false,
-    default: false,
-  })
-  @IsBoolean()
-  isPrivate: boolean;
-}
+import { IsNotEmpty, IsString } from 'class-validator';
 
 export class AddUserSpaceDto {
   @ApiProperty({