finished refactor devices module

libs/common/src/constants/batch-device.enum.ts

@@ -0,0 +1,4 @@
+export enum BatchDeviceTypeEnum {
+  RESET = 'RESET',
+  COMMAND = 'COMMAND',
+}

libs/common/src/constants/controller-route.ts

@@ -473,14 +473,9 @@ export class ControllerRoute {
     public static readonly ROUTE = 'device';
 
     static ACTIONS = class {
-      public static readonly ADD_DEVICE_TO_USER_SUMMARY = 'Add device to user';
+      public static readonly ADD_DEVICE_SUMMARY = 'Add new device';
-      public static readonly ADD_DEVICE_TO_USER_DESCRIPTION =
+      public static readonly ADD_DEVICE_DESCRIPTION =
-        'This endpoint adds a device to a user in the system.';
+        'This endpoint adds a new device in the system.';
-
-      public static readonly GET_DEVICES_BY_USER_SUMMARY =
-        'Get devices by user UUID';
-      public static readonly GET_DEVICES_BY_USER_DESCRIPTION =
-        'This endpoint retrieves all devices associated with a specific user.';
 
       public static readonly GET_DEVICES_BY_SPACE_UUID_SUMMARY =
         'Get devices by space UUID';
@@ -552,16 +547,16 @@ export class ControllerRoute {
         'This endpoint retrieves the status of a specific power clamp device.';
 
       public static readonly ADD_SCENE_TO_DEVICE_SUMMARY =
-        'Add scene to device (4 Scene and 6 Scene devices only)';
+        'Add scene to device';
       public static readonly ADD_SCENE_TO_DEVICE_DESCRIPTION =
         'This endpoint adds a scene to a specific switch device.';
 
       public static readonly GET_SCENES_BY_DEVICE_SUMMARY =
-        'Get scenes by device (4 Scene and 6 Scene devices only)';
+        'Get scenes by device';
       public static readonly GET_SCENES_BY_DEVICE_DESCRIPTION =
         'This endpoint retrieves all scenes associated with a specific switch device.';
       public static readonly DELETE_SCENES_BY_SWITCH_NAME_SUMMARY =
-        'Delete scenes by device uuid and switch name (4 Scene and 6 Scene devices only)';
+        'Delete scenes by device uuid and switch name';
       public static readonly DELETE_SCENES_BY_SWITCH_NAME_DESCRIPTION =
         'This endpoint deletes all scenes associated with a specific switch device.';
     };

src/automation/services/automation.service.ts

@@ -123,6 +123,7 @@ export class AutomationService {
       );
       const formattedCondition = await this.prepareConditions(
         params.conditions,
+        projectUuid,
       );
 
       const response = await this.tuyaService.createAutomation(
@@ -585,7 +586,10 @@ export class AutomationService {
       updateAutomationDto;
     try {
       const formattedActions = await this.prepareActions(actions, projectUuid);
-      const formattedCondition = await this.prepareConditions(conditions);
+      const formattedCondition = await this.prepareConditions(
+        conditions,
+        projectUuid,
+      );
       const response = await this.tuyaService.updateAutomation(
         automationUuid,
         spaceTuyaUuid,
@@ -722,6 +726,7 @@ export class AutomationService {
           const device = await this.deviceService.getDeviceByDeviceUuid(
             action.entity_id,
             false,
+            projectUuid,
           );
           if (device) {
             action.entity_id = device.deviceTuyaUuid;
@@ -759,7 +764,10 @@ export class AutomationService {
     return convertedData;
   }
 
-  private async prepareConditions(conditions: Condition[]) {
+  private async prepareConditions(
+    conditions: Condition[],
+    projectUuid: string,
+  ) {
     const convertedData = convertKeysToSnakeCase(conditions);
     await Promise.all(
       convertedData.map(async (condition) => {
@@ -767,6 +775,7 @@ export class AutomationService {
           const device = await this.deviceService.getDeviceByDeviceUuid(
             condition.entity_id,
             false,
+            projectUuid,
           );
           if (device) {
             condition.entity_id = device.deviceTuyaUuid;

src/device/controllers/device.controller.ts

@@ -6,25 +6,23 @@ import {
   Post,
   Query,
   Param,
-  HttpStatus,
   UseGuards,
-  Req,
   Put,
   Delete,
+  Req,
 } from '@nestjs/common';
 import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
 import {
   AddDeviceDto,
   AddSceneToFourSceneDeviceDto,
+  AssignDeviceToSpaceDto,
   UpdateDeviceDto,
-  UpdateDeviceInSpaceDto,
 } from '../dtos/add.device.dto';
 import { GetDeviceLogsDto } from '../dtos/get.device.dto';
 import {
   ControlDeviceDto,
   BatchControlDevicesDto,
   BatchStatusDevicesDto,
-  BatchFactoryResetDevicesDto,
   GetSceneFourSceneDeviceDto,
 } from '../dtos/control.device.dto';
 import { CheckRoomGuard } from 'src/guards/room.guard';
@@ -50,65 +48,35 @@ export class DeviceController {
   @Permissions('SPACE_DEVICE_ASSIGN_DEVICE_TO_SPACE')
   @Post()
   @ApiOperation({
-    summary: ControllerRoute.DEVICE.ACTIONS.ADD_DEVICE_TO_USER_SUMMARY,
+    summary: ControllerRoute.DEVICE.ACTIONS.ADD_DEVICE_SUMMARY,
-    description: ControllerRoute.DEVICE.ACTIONS.ADD_DEVICE_TO_USER_DESCRIPTION,
+    description: ControllerRoute.DEVICE.ACTIONS.ADD_DEVICE_DESCRIPTION,
   })
-  async addDeviceUser(@Body() addDeviceDto: AddDeviceDto) {
+  async addNewDevice(
-    const device = await this.deviceService.addDeviceUser(addDeviceDto);
+    @Body() addDeviceDto: AddDeviceDto,
-
+    @Req() req: any,
-    return {
+  ): Promise<BaseResponseDto> {
-      statusCode: HttpStatus.CREATED,
+    const projectUuid = req.user.project.uuid;
-      success: true,
+    return await this.deviceService.addNewDevice(addDeviceDto, projectUuid);
-      message: 'device added successfully',
-      data: device,
-    };
-  }
-  @ApiBearerAuth()
-  @UseGuards(PermissionsGuard)
-  @Permissions('DEVICE_VIEW')
-  @Get('user/:userUuid')
-  @ApiOperation({
-    summary: ControllerRoute.DEVICE.ACTIONS.GET_DEVICES_BY_USER_SUMMARY,
-    description: ControllerRoute.DEVICE.ACTIONS.GET_DEVICES_BY_USER_DESCRIPTION,
-  })
-  async getDevicesByUser(@Param('userUuid') userUuid: string) {
-    return await this.deviceService.getDevicesByUser(userUuid);
   }
 
-  @ApiBearerAuth()
-  @UseGuards(PermissionsGuard)
-  @Permissions('SPACE_DEVICE_VIEW_DEVICE_IN_SPACE')
-  @Get('space/:spaceUuid')
-  @ApiOperation({
-    summary: ControllerRoute.DEVICE.ACTIONS.GET_DEVICES_BY_SPACE_UUID_SUMMARY,
-    description:
-      ControllerRoute.DEVICE.ACTIONS.GET_DEVICES_BY_SPACE_UUID_DESCRIPTION,
-  })
-  async getDevicesByUnitId(@Param('spaceUuid') spaceUuid: string) {
-    return await this.deviceService.getDevicesBySpaceUuid(spaceUuid);
-  }
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard, CheckRoomGuard)
   @Permissions('SUBSPACE_DEVICE_UPDATE_DEVICE_IN_SUBSPACE')
-  @Put('space')
+  @Post(':deviceUuid/space/:spaceUuid')
   @ApiOperation({
     summary: ControllerRoute.DEVICE.ACTIONS.UPDATE_DEVICE_IN_ROOM_SUMMARY,
     description:
       ControllerRoute.DEVICE.ACTIONS.UPDATE_DEVICE_IN_ROOM_DESCRIPTION,
   })
-  async updateDeviceInRoom(
+  async transferDeviceInSpaces(
-    @Body() updateDeviceInSpaceDto: UpdateDeviceInSpaceDto,
+    @Param() updateDeviceInSpaceDto: AssignDeviceToSpaceDto,
-  ) {
+    @Req() req: any,
-    const device = await this.deviceService.updateDeviceInSpace(
+  ): Promise<BaseResponseDto> {
+    const projectUuid = req.user.project.uuid;
+    return await this.deviceService.transferDeviceInSpaces(
       updateDeviceInSpaceDto,
+      projectUuid,
     );
-
-    return {
-      statusCode: HttpStatus.CREATED,
-      success: true,
-      message: 'device updated in room successfully',
-      data: device,
-    };
   }
 
   @ApiBearerAuth()
@@ -122,11 +90,11 @@ export class DeviceController {
   async getDeviceDetailsByDeviceId(
     @Param('deviceUuid') deviceUuid: string,
     @Req() req: any,
-  ) {
+  ): Promise<BaseResponseDto> {
-    const userUuid = req.user.uuid;
+    const projectUuid = req.user.project.uuid;
     return await this.deviceService.getDeviceDetailsByDeviceId(
       deviceUuid,
-      userUuid,
+      projectUuid,
     );
   }
   @ApiBearerAuth()
@@ -140,18 +108,14 @@ export class DeviceController {
   async updateDevice(
     @Param('deviceUuid') deviceUuid: string,
     @Body() updateDeviceDto: UpdateDeviceDto,
-  ) {
+    @Req() req: any,
-    const device = await this.deviceService.updateDevice(
+  ): Promise<BaseResponseDto> {
+    const projectUuid = req.user.project.uuid;
+    return await this.deviceService.updateDevice(
       deviceUuid,
       updateDeviceDto,
+      projectUuid,
     );
-
-    return {
-      statusCode: HttpStatus.CREATED,
-      success: true,
-      message: 'device updated successfully',
-      data: device,
-    };
   }
 
   @ApiBearerAuth()
@@ -165,8 +129,13 @@ export class DeviceController {
   })
   async getDeviceInstructionByDeviceId(
     @Param('deviceUuid') deviceUuid: string,
+    @Req() req: any,
   ) {
-    return await this.deviceService.getDeviceInstructionByDeviceId(deviceUuid);
+    const projectUuid = req.user.project.uuid;
+    return await this.deviceService.getDeviceInstructionByDeviceId(
+      deviceUuid,
+      projectUuid,
+    );
   }
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
@@ -176,14 +145,18 @@ export class DeviceController {
     summary: ControllerRoute.DEVICE.ACTIONS.GET_DEVICE_STATUS_SUMMARY,
     description: ControllerRoute.DEVICE.ACTIONS.GET_DEVICE_STATUS_DESCRIPTION,
   })
-  async getDevicesInstructionStatus(@Param('deviceUuid') deviceUuid: string) {
+  async getDevicesInstructionStatus(
-    return await this.deviceService.getDevicesInstructionStatus(deviceUuid);
+    @Param('deviceUuid') deviceUuid: string,
+    @Req() req: any,
+  ): Promise<BaseResponseDto> {
+    const projectUuid = req.user.project.uuid;
+    return await this.deviceService.getDevicesStatus(deviceUuid, projectUuid);
   }
 
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
   @Permissions('DEVICE_SINGLE_CONTROL')
-  @Post(':deviceUuid/control')
+  @Post(':deviceUuid/command')
   @ApiOperation({
     summary: ControllerRoute.DEVICE.ACTIONS.CONTROL_DEVICE_SUMMARY,
     description: ControllerRoute.DEVICE.ACTIONS.CONTROL_DEVICE_DESCRIPTION,
@@ -191,8 +164,14 @@ export class DeviceController {
   async controlDevice(
     @Body() controlDeviceDto: ControlDeviceDto,
     @Param('deviceUuid') deviceUuid: string,
-  ) {
+    @Req() req: any,
-    return await this.deviceService.controlDevice(controlDeviceDto, deviceUuid);
+  ): Promise<BaseResponseDto> {
+    const projectUuid = req.user.project.uuid;
+    return await this.deviceService.controlDevice(
+      controlDeviceDto,
+      deviceUuid,
+      projectUuid,
+    );
   }
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
@@ -206,10 +185,13 @@ export class DeviceController {
   async updateDeviceFirmware(
     @Param('deviceUuid') deviceUuid: string,
     @Param('firmwareVersion') firmwareVersion: number,
-  ) {
+    @Req() req: any,
+  ): Promise<BaseResponseDto> {
+    const projectUuid = req.user.project.uuid;
     return await this.deviceService.updateDeviceFirmware(
       deviceUuid,
       firmwareVersion,
+      projectUuid,
     );
   }
   @ApiBearerAuth()
@@ -221,14 +203,21 @@ export class DeviceController {
     description:
       ControllerRoute.DEVICE.ACTIONS.GET_DEVICES_IN_GATEWAY_DESCRIPTION,
   })
-  async getDevicesInGateway(@Param('gatewayUuid') gatewayUuid: string) {
+  async getDevicesInGateway(
-    return await this.deviceService.getDevicesInGateway(gatewayUuid);
+    @Param('gatewayUuid') gatewayUuid: string,
+    @Req() req: any,
+  ): Promise<BaseResponseDto> {
+    const projectUuid = req.user.project.uuid;
+    return await this.deviceService.getDevicesInGateway(
+      gatewayUuid,
+      projectUuid,
+    );
   }
 
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
   @Permissions('DEVICE_VIEW')
-  @Get('report-logs/:deviceUuid')
+  @Get(':deviceUuid/report-logs')
   @ApiOperation({
     summary: ControllerRoute.DEVICE.ACTIONS.GET_DEVICE_LOGS_SUMMARY,
     description: ControllerRoute.DEVICE.ACTIONS.GET_DEVICE_LOGS_DESCRIPTION,
@@ -236,13 +225,19 @@ export class DeviceController {
   async getBuildingChildByUuid(
     @Param('deviceUuid') deviceUuid: string,
     @Query() query: GetDeviceLogsDto,
-  ) {
+    @Req() req: any,
-    return await this.deviceService.getDeviceLogs(deviceUuid, query);
+  ): Promise<BaseResponseDto> {
+    const projectUuid = req.user.project.uuid;
+    return await this.deviceService.getDeviceLogs(
+      deviceUuid,
+      query,
+      projectUuid,
+    );
   }
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
   @Permissions('DEVICE_BATCH_CONTROL')
-  @Post('control/batch')
+  @Post('batch')
   @ApiOperation({
     summary: ControllerRoute.DEVICE.ACTIONS.BATCH_CONTROL_DEVICES_SUMMARY,
     description:
@@ -250,13 +245,18 @@ export class DeviceController {
   })
   async batchControlDevices(
     @Body() batchControlDevicesDto: BatchControlDevicesDto,
+    @Req() req: any,
   ) {
-    return await this.deviceService.batchControlDevices(batchControlDevicesDto);
+    const projectUuid = req.user.project.uuid;
+    return await this.deviceService.batchControlDevices(
+      batchControlDevicesDto,
+      projectUuid,
+    );
   }
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
   @Permissions('DEVICE_BATCH_CONTROL')
-  @Get('status/batch')
+  @Get('batch')
   @ApiOperation({
     summary: ControllerRoute.DEVICE.ACTIONS.BATCH_STATUS_DEVICES_SUMMARY,
     description:
@@ -264,41 +264,15 @@ export class DeviceController {
   })
   async batchStatusDevices(
     @Query() batchStatusDevicesDto: BatchStatusDevicesDto,
-  ) {
+    @Req() req: any,
-    return await this.deviceService.batchStatusDevices(batchStatusDevicesDto);
+  ): Promise<BaseResponseDto> {
-  }
+    const projectUuid = req.user.project.uuid;
-  @ApiBearerAuth()
+    return await this.deviceService.batchStatusDevices(
-  @UseGuards(PermissionsGuard)
+      batchStatusDevicesDto,
-  @Permissions('DEVICE_DELETE')
+      projectUuid,
-  @Post('factory/reset/:deviceUuid')
-  @ApiOperation({
-    summary: ControllerRoute.DEVICE.ACTIONS.BATCH_FACTORY_RESET_DEVICES_SUMMARY,
-    description:
-      ControllerRoute.DEVICE.ACTIONS.BATCH_FACTORY_RESET_DEVICES_DESCRIPTION,
-  })
-  async batchFactoryResetDevices(
-    @Body() batchFactoryResetDevicesDto: BatchFactoryResetDevicesDto,
-  ) {
-    return await this.deviceService.batchFactoryResetDevices(
-      batchFactoryResetDevicesDto,
-    );
-  }
-  @ApiBearerAuth()
-  @UseGuards(PermissionsGuard)
-  @Permissions('DEVICE_VIEW')
-  @Get(':powerClampUuid/power-clamp/status')
-  @ApiOperation({
-    summary: ControllerRoute.DEVICE.ACTIONS.GET_POWER_CLAMP_STATUS_SUMMARY,
-    description:
-      ControllerRoute.DEVICE.ACTIONS.GET_POWER_CLAMP_STATUS_DESCRIPTION,
-  })
-  async getPowerClampInstructionStatus(
-    @Param('powerClampUuid') powerClampUuid: string,
-  ) {
-    return await this.deviceService.getPowerClampInstructionStatus(
-      powerClampUuid,
     );
   }
+
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard, CheckFourAndSixSceneDeviceTypeGuard)
   @Permissions('DEVICE_SINGLE_CONTROL')
@@ -310,18 +284,14 @@ export class DeviceController {
   async addSceneToSceneDevice(
     @Param('deviceUuid') deviceUuid: string,
     @Body() addSceneToFourSceneDeviceDto: AddSceneToFourSceneDeviceDto,
-  ) {
+    @Req() req: any,
-    const device = await this.deviceService.addSceneToSceneDevice(
+  ): Promise<BaseResponseDto> {
+    const projectUuid = req.user.project.uuid;
+    return await this.deviceService.addSceneToSceneDevice(
       deviceUuid,
       addSceneToFourSceneDeviceDto,
+      projectUuid,
     );
-
-    return {
-      statusCode: HttpStatus.CREATED,
-      success: true,
-      message: `scene added successfully to device ${deviceUuid}`,
-      data: device,
-    };
   }
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard, CheckFourAndSixSceneDeviceTypeGuard)
@@ -335,10 +305,13 @@ export class DeviceController {
   async getScenesBySceneDevice(
     @Param('deviceUuid') deviceUuid: string,
     @Query() getSceneFourSceneDeviceDto: GetSceneFourSceneDeviceDto,
-  ) {
+    @Req() req: any,
+  ): Promise<BaseResponseDto> {
+    const projectUuid = req.user.project.uuid;
     return await this.deviceService.getScenesBySceneDevice(
       deviceUuid,
       getSceneFourSceneDeviceDto,
+      projectUuid,
     );
   }
   @ApiBearerAuth()
@@ -354,7 +327,13 @@ export class DeviceController {
   async deleteSceneFromSceneDevice(
     @Param() param: DeviceSceneParamDto,
     @Query() query: DeleteSceneFromSceneDeviceDto,
+    @Req() req: any,
   ): Promise<BaseResponseDto> {
-    return await this.deviceService.deleteSceneFromSceneDevice(param, query);
+    const projectUuid = req.user.project.uuid;
+    return await this.deviceService.deleteSceneFromSceneDevice(
+      param,
+      query,
+      projectUuid,
+    );
   }
 }

src/device/dtos/add.device.dto.ts

@@ -10,16 +10,8 @@ export class AddDeviceDto {
   @IsString()
   @IsNotEmpty()
   public deviceTuyaUuid: string;
-
-  @ApiProperty({
-    description: 'userUuid',
-    required: true,
-  })
-  @IsString()
-  @IsNotEmpty()
-  public userUuid: string;
 }
-export class UpdateDeviceInSpaceDto {
+export class AssignDeviceToSpaceDto {
   @ApiProperty({
     description: 'deviceUuid',
     required: true,

src/device/dtos/control.device.dto.ts

@@ -1,5 +1,12 @@
+import { BatchDeviceTypeEnum } from '@app/common/constants/batch-device.enum';
 import { ApiProperty } from '@nestjs/swagger';
-import { IsArray, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+import {
+  IsArray,
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+} from 'class-validator';
 
 export class ControlDeviceDto {
   @ApiProperty({
@@ -17,6 +24,15 @@ export class ControlDeviceDto {
   public value: any;
 }
 export class BatchControlDevicesDto {
+  @ApiProperty({
+    description: 'Operation type',
+    enum: BatchDeviceTypeEnum,
+    required: true,
+  })
+  @IsEnum(BatchDeviceTypeEnum)
+  @IsNotEmpty()
+  public operationType: BatchDeviceTypeEnum;
+
   @ApiProperty({
     description: 'devicesUuid',
     required: true,

src/device/interfaces/get.device.interface.ts

@@ -64,6 +64,7 @@ export interface GetDeviceDetailsFunctionsStatusInterface {
 }
 
 export interface DeviceInstructionResponse {
+  data: {
     productUuid: string;
     productType: string;
     functions: {
@@ -71,6 +72,7 @@ export interface DeviceInstructionResponse {
       values: any[];
       dataType: string;
     }[];
+  };
 }
 export interface updateDeviceFirmwareInterface {
   success: boolean;

src/device/services/device.service.ts

@@ -1,3 +1,4 @@
+import { ORPHAN_SPACE_NAME } from './../../../libs/common/src/constants/orphan-constant';
 import { ProductRepository } from './../../../libs/common/src/modules/product/repositories/product.repository';
 import {
   Injectable,
@@ -14,7 +15,7 @@ import {
   AddDeviceDto,
   AddSceneToFourSceneDeviceDto,
   UpdateDeviceDto,
-  UpdateDeviceInSpaceDto,
+  AssignDeviceToSpaceDto,
 } from '../dtos/add.device.dto';
 import {
   DeviceInstructionResponse,
@@ -40,8 +41,7 @@ import {
 } from '../dtos/control.device.dto';
 import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
 import { DeviceRepository } from '@app/common/modules/device/repositories';
-import { PermissionType } from '@app/common/constants/permission-type.enum';
+import { In, Not, QueryRunner } from 'typeorm';
-import { In, QueryRunner } from 'typeorm';
 import { ProductType } from '@app/common/constants/product-type.enum';
 import { SpaceRepository } from '@app/common/modules/space/repositories';
 import { DeviceStatusFirebaseService } from '@app/common/firebase/devices-status/services/devices-status.service';
@@ -62,6 +62,7 @@ import { DeviceEntity } from '@app/common/modules/device/entities';
 import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
 import { ProjectRepository } from '@app/common/modules/project/repositiories';
 import { ProjectParam } from '../dtos';
+import { BatchDeviceTypeEnum } from '@app/common/constants/batch-device.enum';
 
 @Injectable()
 export class DeviceService {
@@ -91,6 +92,7 @@ export class DeviceService {
   async getDeviceByDeviceUuid(
     deviceUuid: string,
     withProductDevice: boolean = true,
+    projectUuid: string,
   ) {
     const relations = ['subspace'];
 
@@ -99,7 +101,13 @@ export class DeviceService {
     }
 
     return this.deviceRepository.findOne({
-      where: { uuid: deviceUuid },
+      where: {
+        uuid: deviceUuid,
+        spaceDevice: {
+          community: { project: { uuid: projectUuid } },
+          spaceName: Not(ORPHAN_SPACE_NAME),
+        },
+      },
       relations,
     });
   }
@@ -136,7 +144,7 @@ export class DeviceService {
     });
   }
 
-  async addDeviceUser(addDeviceDto: AddDeviceDto) {
+  async addNewDevice(addDeviceDto: AddDeviceDto, projectUuid: string) {
     try {
       const device = await this.getDeviceDetailsByDeviceIdTuya(
         addDeviceDto.deviceTuyaUuid,
@@ -148,25 +156,25 @@ export class DeviceService {
       const deviceSaved = await this.deviceRepository.save({
         deviceTuyaUuid: addDeviceDto.deviceTuyaUuid,
         productDevice: { uuid: device.productUuid },
-        user: {
-          uuid: addDeviceDto.userUuid,
-        },
       });
       if (deviceSaved.uuid) {
-        const deviceStatus = await this.getDevicesInstructionStatus(
+        const deviceStatus: BaseResponseDto =
-          deviceSaved.uuid,
+          await this.getDevicesInstructionStatus(deviceSaved.uuid, projectUuid);
-        );
+        if (deviceStatus.data.productUuid) {
-        if (deviceStatus.productUuid) {
           await this.deviceStatusFirebaseService.addDeviceStatusToFirebase({
             deviceUuid: deviceSaved.uuid,
             deviceTuyaUuid: addDeviceDto.deviceTuyaUuid,
-            status: deviceStatus.status,
+            status: deviceStatus.data.status,
-            productUuid: deviceStatus.productUuid,
+            productUuid: deviceStatus.data.productUuid,
-            productType: deviceStatus.productType,
+            productType: deviceStatus.data.productType,
           });
         }
       }
-      return deviceSaved;
+      return new SuccessResponseDto({
+        message: `Device added successfully`,
+        data: deviceSaved,
+        statusCode: HttpStatus.CREATED,
+      });
     } catch (error) {
       if (error.code === CommonErrorCodes.DUPLICATE_ENTITY) {
         throw new HttpException(
@@ -182,77 +190,14 @@ export class DeviceService {
     }
   }
 
-  async getDevicesByUser(
-    userUuid: string,
-  ): Promise<GetDeviceDetailsInterface[]> {
-    try {
-      const devices = await this.deviceRepository.find({
-        where: {
-          user: { uuid: userUuid },
-          isActive: true,
-          permission: {
-            userUuid,
-            permissionType: {
-              type: In([PermissionType.READ, PermissionType.CONTROLLABLE]),
-            },
-          },
-        },
-        relations: [
-          'spaceDevice',
-          'productDevice',
-          'permission',
-          'permission.permissionType',
-        ],
-      });
-      const safeFetchDeviceDetails = async (device: any) => {
-        try {
-          const tuyaDetails = await this.getDeviceDetailsByDeviceIdTuya(
-            device.deviceTuyaUuid,
-          );
-
-          return {
-            haveRoom: !!device.spaceDevice,
-            productUuid: device.productDevice.uuid,
-            productType: device.productDevice.prodType,
-            permissionType: device.permission[0].permissionType.type,
-            ...tuyaDetails,
-            uuid: device.uuid,
-          } as GetDeviceDetailsInterface;
-        } catch (error) {
-          console.warn(
-            `Skipping device with deviceTuyaUuid: ${device.deviceTuyaUuid} due to error.`,
-          );
-          return null;
-        }
-      };
-      const devicesData = await Promise.all(
-        devices.map(safeFetchDeviceDetails),
-      );
-
-      return devicesData.filter(Boolean); // Remove null or undefined entries
-    } catch (error) {
-      console.error('Error fetching devices by user:', error);
-      throw new HttpException(
-        'User does not have any devices',
-        HttpStatus.NOT_FOUND,
-      );
-    }
-  }
   async getDevicesBySpaceId(
     getDeviceBySpaceUuidDto: GetDeviceBySpaceUuidDto,
-    userUuid: string,
   ): Promise<GetDeviceDetailsInterface[]> {
     try {
       const devices = await this.deviceRepository.find({
         where: {
           spaceDevice: { uuid: getDeviceBySpaceUuidDto.spaceUuid },
           isActive: true,
-          permission: {
-            userUuid,
-            permissionType: {
-              type: In([PermissionType.READ, PermissionType.CONTROLLABLE]),
-            },
-          },
         },
         relations: [
           'spaceDevice',
@@ -285,17 +230,26 @@ export class DeviceService {
       );
     }
   }
-  async updateDeviceInSpace(updateDeviceInSpaceDto: UpdateDeviceInSpaceDto) {
+  async transferDeviceInSpaces(
+    assignDeviceToSpaceDto: AssignDeviceToSpaceDto,
+    projectUuid: string,
+  ) {
     try {
       await this.deviceRepository.update(
-        { uuid: updateDeviceInSpaceDto.deviceUuid },
         {
-          spaceDevice: { uuid: updateDeviceInSpaceDto.spaceUuid },
+          uuid: assignDeviceToSpaceDto.deviceUuid,
+          spaceDevice: {
+            community: { project: { uuid: projectUuid } },
+            spaceName: Not(ORPHAN_SPACE_NAME),
+          },
+        },
+        {
+          spaceDevice: { uuid: assignDeviceToSpaceDto.spaceUuid },
         },
       );
       const device = await this.deviceRepository.findOne({
         where: {
-          uuid: updateDeviceInSpaceDto.deviceUuid,
+          uuid: assignDeviceToSpaceDto.deviceUuid,
         },
         relations: ['spaceDevice', 'spaceDevice.parent'],
       });
@@ -306,10 +260,14 @@ export class DeviceService {
         );
       }
 
-      return {
+      return new SuccessResponseDto({
+        message: `Device transferred successfully to spaceUuid: ${assignDeviceToSpaceDto.spaceUuid}`,
+        data: {
           uuid: device.uuid,
           spaceUuid: device.spaceDevice.uuid,
-      };
+        },
+        statusCode: HttpStatus.CREATED,
+      });
     } catch (error) {
       throw new HttpException(
         'Failed to add device in space',
@@ -358,9 +316,17 @@ export class DeviceService {
       );
     }
   }
-  async controlDevice(controlDeviceDto: ControlDeviceDto, deviceUuid: string) {
+  async controlDevice(
+    controlDeviceDto: ControlDeviceDto,
+    deviceUuid: string,
+    projectUuid: string,
+  ) {
     try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid, false);
+      const deviceDetails = await this.getDeviceByDeviceUuid(
+        deviceUuid,
+        false,
+        projectUuid,
+      );
 
       if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
         throw new NotFoundException('Device Not Found');
@@ -371,7 +337,11 @@ export class DeviceService {
       );
 
       if (response.success) {
-        return response;
+        return new SuccessResponseDto({
+          message: `Device controlled successfully`,
+          data: response,
+          statusCode: HttpStatus.CREATED,
+        });
       } else {
         throw new HttpException(
           response.msg || 'Unknown error',
@@ -429,9 +399,18 @@ export class DeviceService {
     }
   }
 
-  async batchControlDevices(batchControlDevicesDto: BatchControlDevicesDto) {
+  async batchControlDevices(
-    const { devicesUuid } = batchControlDevicesDto;
+    batchControlDevicesDto: BatchControlDevicesDto,
+    projectUuid: string,
+  ) {
+    const { devicesUuid, operationType } = batchControlDevicesDto;
 
+    if (operationType === BatchDeviceTypeEnum.RESET) {
+      return await this.batchFactoryResetDevices(
+        batchControlDevicesDto,
+        projectUuid,
+      );
+    } else if (operationType === BatchDeviceTypeEnum.COMMAND) {
       try {
         // Check if all devices have the same product UUID
         await this.checkAllDevicesHaveSameProductUuid(devicesUuid);
@@ -439,7 +418,11 @@ export class DeviceService {
         // Perform all operations concurrently
         const results = await Promise.allSettled(
           devicesUuid.map(async (deviceUuid) => {
-          const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+            const deviceDetails = await this.getDeviceByDeviceUuid(
+              deviceUuid,
+              true,
+              projectUuid,
+            );
             const result = await this.controlDeviceTuya(
               deviceDetails.deviceTuyaUuid,
               batchControlDevicesDto,
@@ -472,7 +455,11 @@ export class DeviceService {
           }
         }
 
-      return { successResults, failedResults };
+        return new SuccessResponseDto({
+          message: `Devices controlled successfully`,
+          data: { successResults, failedResults },
+          statusCode: HttpStatus.CREATED,
+        });
       } catch (error) {
         throw new HttpException(
           error.message || 'Device Not Found',
@@ -480,7 +467,11 @@ export class DeviceService {
         );
       }
     }
-  async batchStatusDevices(batchStatusDevicesDto: BatchStatusDevicesDto) {
+  }
+  async batchStatusDevices(
+    batchStatusDevicesDto: BatchStatusDevicesDto,
+    projectUuid: string,
+  ) {
     const { devicesUuid } = batchStatusDevicesDto;
     const devicesUuidArray = devicesUuid.split(',');
 
@@ -488,14 +479,22 @@ export class DeviceService {
       await this.checkAllDevicesHaveSameProductUuid(devicesUuidArray);
       const statuses = await Promise.all(
         devicesUuidArray.map(async (deviceUuid) => {
-          const result = await this.getDevicesInstructionStatus(deviceUuid);
+          const result = await this.getDevicesInstructionStatus(
+            deviceUuid,
+            projectUuid,
+          );
           return { deviceUuid, result };
         }),
       );
-      return {
+
+      return new SuccessResponseDto({
+        message: `Devices status fetched successfully`,
+        data: {
           status: statuses[0].result,
           devices: statuses,
-      };
+        },
+        statusCode: HttpStatus.OK,
+      });
     } catch (error) {
       throw new HttpException(
         error.message || 'Device Not Found',
@@ -532,6 +531,7 @@ export class DeviceService {
   }
   async batchFactoryResetDevices(
     batchFactoryResetDevicesDto: BatchFactoryResetDevicesDto,
+    projectUuid: string,
   ) {
     const { devicesUuid } = batchFactoryResetDevicesDto;
 
@@ -542,7 +542,11 @@ export class DeviceService {
       // Perform all operations concurrently
       const results = await Promise.allSettled(
         devicesUuid.map(async (deviceUuid) => {
-          const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+          const deviceDetails = await this.getDeviceByDeviceUuid(
+            deviceUuid,
+            true,
+            projectUuid,
+          );
           const result = await this.factoryResetDeviceTuya(
             deviceDetails.deviceTuyaUuid,
           );
@@ -587,15 +591,14 @@ export class DeviceService {
       );
     }
   }
-  async getDeviceDetailsByDeviceId(deviceUuid: string, userUuid: string) {
+  async getDeviceDetailsByDeviceId(deviceUuid: string, projectUuid: string) {
     try {
-      const userDevicePermission = await this.getUserDevicePermission(
+      const deviceDetails = await this.getDeviceByDeviceUuid(
-        userUuid,
         deviceUuid,
+        true,
+        projectUuid,
       );
 
-      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
-
       if (!deviceDetails) {
         throw new NotFoundException('Device Not Found');
       }
@@ -607,15 +610,18 @@ export class DeviceService {
         deviceDetails.deviceTuyaUuid,
       );
 
-      return {
+      return new SuccessResponseDto({
+        message: `Device details fetched successfully`,
+        data: {
           ...response,
           uuid: deviceDetails.uuid,
           productUuid: deviceDetails.productDevice.uuid,
           productType: deviceDetails.productDevice.prodType,
-        permissionType: userDevicePermission,
           macAddress: macAddress.mac,
           subspace: deviceDetails.subspace ? deviceDetails.subspace : {},
-      };
+        },
+        statusCode: HttpStatus.OK,
+      });
     } catch (error) {
       throw new HttpException(
         error.message || 'Device Not Found',
@@ -623,9 +629,17 @@ export class DeviceService {
       );
     }
   }
-  async updateDevice(deviceUuid: string, updateDeviceDto: UpdateDeviceDto) {
+  async updateDevice(
+    deviceUuid: string,
+    updateDeviceDto: UpdateDeviceDto,
+    projectUuid: string,
+  ) {
     try {
-      const device = await this.getDeviceByDeviceUuid(deviceUuid);
+      const device = await this.getDeviceByDeviceUuid(
+        deviceUuid,
+        true,
+        projectUuid,
+      );
       if (device.deviceTuyaUuid) {
         await this.updateDeviceNameTuya(
           device.deviceTuyaUuid,
@@ -633,10 +647,14 @@ export class DeviceService {
         );
       }
 
-      return {
+      return new SuccessResponseDto({
+        message: `Device updated successfully`,
+        data: {
           uuid: device.uuid,
           deviceName: updateDeviceDto.deviceName,
-      };
+        },
+        statusCode: HttpStatus.CREATED,
+      });
     } catch (error) {
       throw new HttpException(
         'Error updating device',
@@ -696,8 +714,13 @@ export class DeviceService {
   }
   async getDeviceInstructionByDeviceId(
     deviceUuid: string,
+    projectUuid: string,
   ): Promise<DeviceInstructionResponse> {
-    const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+    const deviceDetails = await this.getDeviceByDeviceUuid(
+      deviceUuid,
+      true,
+      projectUuid,
+    );
 
     if (!deviceDetails) {
       throw new NotFoundException('Device Not Found');
@@ -707,7 +730,9 @@ export class DeviceService {
         deviceDetails.deviceTuyaUuid,
       );
 
-      return {
+      return new SuccessResponseDto({
+        message: `Device instructions fetched successfully`,
+        data: {
           productUuid: deviceDetails.productDevice.uuid,
           productType: deviceDetails.productDevice.prodType,
           functions: response.result.functions.map((fun: any) => {
@@ -717,7 +742,9 @@ export class DeviceService {
               dataType: fun.type,
             };
           }),
-      };
+        },
+        statusCode: HttpStatus.CREATED,
+      });
     } catch (error) {
       throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
     }
@@ -740,9 +767,13 @@ export class DeviceService {
       );
     }
   }
-  async getDevicesInstructionStatus(deviceUuid: string) {
+  async getDevicesInstructionStatus(deviceUuid: string, projectUuid: string) {
     try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+      const deviceDetails = await this.getDeviceByDeviceUuid(
+        deviceUuid,
+        true,
+        projectUuid,
+      );
 
       if (!deviceDetails) {
         throw new NotFoundException('Device Not Found');
@@ -751,11 +782,38 @@ export class DeviceService {
         deviceDetails.deviceTuyaUuid,
       );
 
-      return {
+      return new SuccessResponseDto({
+        message: `Device instructions status fetched successfully`,
+        data: {
           productUuid: deviceDetails.productDevice.uuid,
           productType: deviceDetails.productDevice.prodType,
           status: deviceStatus.result[0].status,
-      };
+        },
+        statusCode: HttpStatus.OK,
+      });
+    } catch (error) {
+      throw new HttpException(
+        'Error fetching device functions status',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  async getDevicesStatus(deviceUuid: string, projectUuid: string) {
+    try {
+      const deviceDetails = await this.getDeviceByDeviceUuid(
+        deviceUuid,
+        true,
+        projectUuid,
+      );
+
+      if (!deviceDetails) {
+        throw new NotFoundException('Device Not Found');
+      }
+      if (deviceDetails.productDevice.prodType === ProductType.PC) {
+        return await this.getPowerClampInstructionStatus(deviceDetails);
+      } else {
+        return await this.getDevicesInstructionStatus(deviceUuid, projectUuid);
+      }
     } catch (error) {
       throw new HttpException(
         'Error fetching device functions status',
@@ -784,21 +842,14 @@ export class DeviceService {
       );
     }
   }
-  private async getUserDevicePermission(userUuid: string, deviceUuid: string) {
+
-    const device = await this.deviceRepository.findOne({
+  async getDevicesInGateway(gatewayUuid: string, projectUuid: string) {
-      where: {
-        uuid: deviceUuid,
-        permission: {
-          userUuid: userUuid,
-        },
-      },
-      relations: ['permission', 'permission.permissionType'],
-    });
-    return device.permission[0].permissionType.type;
-  }
-  async getDevicesInGateway(gatewayUuid: string) {
     try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(gatewayUuid);
+      const deviceDetails = await this.getDeviceByDeviceUuid(
+        gatewayUuid,
+        true,
+        projectUuid,
+      );
 
       if (!deviceDetails) {
         throw new NotFoundException('Device Not Found');
@@ -834,12 +885,16 @@ export class DeviceService {
         }),
       );
 
-      return {
+      return new SuccessResponseDto({
+        message: `Devices fetched successfully`,
+        data: {
           uuid: deviceDetails.uuid,
           productUuid: deviceDetails.productDevice.uuid,
           productType: deviceDetails.productDevice.prodType,
           devices: devices.filter((device) => device !== null),
-      };
+        },
+        statusCode: HttpStatus.OK,
+      });
     } catch (error) {
       throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
     }
@@ -869,9 +924,17 @@ export class DeviceService {
       );
     }
   }
-  async updateDeviceFirmware(deviceUuid: string, firmwareVersion: number) {
+  async updateDeviceFirmware(
+    deviceUuid: string,
+    firmwareVersion: number,
+    projectUuid: string,
+  ) {
     try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid, false);
+      const deviceDetails = await this.getDeviceByDeviceUuid(
+        deviceUuid,
+        false,
+        projectUuid,
+      );
 
       if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
         throw new NotFoundException('Device Not Found');
@@ -882,7 +945,11 @@ export class DeviceService {
       );
 
       if (response.success) {
-        return response;
+        return new SuccessResponseDto({
+          message: `Device firmware updated successfully`,
+          data: response,
+          statusCode: HttpStatus.CREATED,
+        });
       } else {
         throw new HttpException(
           response.msg || 'Unknown error',
@@ -912,50 +979,8 @@ export class DeviceService {
       );
     }
   }
-  async getDevicesBySpaceUuid(SpaceUuid: string) {
-    try {
-      const spaces = await this.spaceRepository.find({
-        where: {
-          parent: {
-            uuid: SpaceUuid,
-          },
-          devices: {
-            isActive: true,
-          },
-        },
-        relations: ['devices', 'devices.productDevice'],
-      });
 
-      const devices = spaces.flatMap((space) => {
+  async getAllDevices(param: ProjectParam): Promise<BaseResponseDto> {
-        return space.devices.map((device) => device);
-      });
-
-      const devicesData = await Promise.all(
-        devices.map(async (device) => {
-          return {
-            haveRoom: true,
-            productUuid: device.productDevice.uuid,
-            productType: device.productDevice.prodType,
-            permissionType: PermissionType.CONTROLLABLE,
-            ...(await this.getDeviceDetailsByDeviceIdTuya(
-              device.deviceTuyaUuid,
-            )),
-            uuid: device.uuid,
-          } as GetDeviceDetailsInterface;
-        }),
-      );
-
-      return devicesData;
-    } catch (error) {
-      throw new HttpException(
-        'This space does not have any devices',
-        HttpStatus.NOT_FOUND,
-      );
-    }
-  }
-  async getAllDevices(
-    param: ProjectParam,
-  ): Promise<GetDeviceDetailsInterface[]> {
     try {
       await this.validateProject(param.projectUuid);
 
@@ -964,6 +989,7 @@ export class DeviceService {
           isActive: true,
           spaceDevice: {
             community: { project: { uuid: param.projectUuid } },
+            spaceName: Not(ORPHAN_SPACE_NAME),
           },
         },
         relations: [
@@ -982,10 +1008,14 @@ export class DeviceService {
 
           // Check if the device is a door lock (DL)
           if (device.productDevice.prodType === ProductType.DL) {
-            const doorLockInstructionsStatus =
+            const doorLockInstructionsStatus: BaseResponseDto =
-              await this.getDevicesInstructionStatus(device.uuid);
+              await this.getDevicesInstructionStatus(
+                device.uuid,
+                param.projectUuid,
+              );
 
-            const batteryStatus: any = doorLockInstructionsStatus.status.find(
+            const batteryStatus: any =
+              doorLockInstructionsStatus.data.status.find(
                 (status: any) =>
                   status.code === BatteryStatus.RESIDUAL_ELECTRICITY,
               );
@@ -996,11 +1026,16 @@ export class DeviceService {
           }
           // Check if the device is a door sensor (DS)
           if (device.productDevice.prodType === ProductType.DS) {
-            const doorSensorInstructionsStatus =
+            const doorSensorInstructionsStatus: BaseResponseDto =
-              await this.getDevicesInstructionStatus(device.uuid);
+              await this.getDevicesInstructionStatus(
+                device.uuid,
+                param.projectUuid,
+              );
 
-            const batteryStatus: any = doorSensorInstructionsStatus.status.find(
+            const batteryStatus: any =
-              (status: any) => status.code === BatteryStatus.BATTERY_PERCENTAGE,
+              doorSensorInstructionsStatus.data.status.find(
+                (status: any) =>
+                  status.code === BatteryStatus.BATTERY_PERCENTAGE,
               );
 
             if (batteryStatus) {
@@ -1009,11 +1044,16 @@ export class DeviceService {
           }
           // Check if the device is a water leak sensor (WL)
           if (device.productDevice.prodType === ProductType.WL) {
-            const doorSensorInstructionsStatus =
+            const doorSensorInstructionsStatus: BaseResponseDto =
-              await this.getDevicesInstructionStatus(device.uuid);
+              await this.getDevicesInstructionStatus(
+                device.uuid,
+                param.projectUuid,
+              );
 
-            const batteryStatus: any = doorSensorInstructionsStatus.status.find(
+            const batteryStatus: any =
-              (status: any) => status.code === BatteryStatus.BATTERY_PERCENTAGE,
+              doorSensorInstructionsStatus.data.status.find(
+                (status: any) =>
+                  status.code === BatteryStatus.BATTERY_PERCENTAGE,
               );
 
             if (batteryStatus) {
@@ -1060,7 +1100,11 @@ export class DeviceService {
             (result as PromiseFulfilledResult<GetDeviceDetailsInterface>).value,
         );
 
-      return fulfilledDevices;
+      return new SuccessResponseDto({
+        message: `Devices fetched successfully`,
+        data: fulfilledDevices,
+        statusCode: HttpStatus.OK,
+      });
     } catch (error) {
       throw new HttpException(
         error.message || 'Internal server error',
@@ -1069,9 +1113,17 @@ export class DeviceService {
     }
   }
 
-  async getDeviceLogs(deviceUuid: string, query: GetDeviceLogsDto) {
+  async getDeviceLogs(
+    deviceUuid: string,
+    query: GetDeviceLogsDto,
+    projectUuid: string,
+  ): Promise<BaseResponseDto> {
     try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+      const deviceDetails = await this.getDeviceByDeviceUuid(
+        deviceUuid,
+        true,
+        projectUuid,
+      );
 
       if (!deviceDetails) {
         throw new NotFoundException('Device Not Found');
@@ -1084,10 +1136,14 @@ export class DeviceService {
         query.endTime,
       );
 
-      return {
+      return new SuccessResponseDto({
+        message: `Device logs fetched successfully`,
+        data: {
           deviceUuid,
           ...response,
-      };
+        },
+        statusCode: HttpStatus.OK,
+      });
     } catch (error) {
       throw new HttpException(
         error.message || 'Device Not Found',
@@ -1156,14 +1212,8 @@ export class DeviceService {
     }
   }
 
-  async getPowerClampInstructionStatus(powerClampUuid: string) {
+  async getPowerClampInstructionStatus(deviceDetails: any) {
     try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(powerClampUuid);
-      if (!deviceDetails) {
-        throw new NotFoundException('Device Not Found');
-      } else if (deviceDetails.productDevice.prodType !== ProductType.PC) {
-        throw new BadRequestException('This is not a power clamp device');
-      }
       const deviceStatus = await this.getPowerClampInstructionStatusTuya(
         deviceDetails.deviceTuyaUuid,
       );
@@ -1195,7 +1245,9 @@ export class DeviceService {
         },
       );
 
-      return {
+      return new SuccessResponseDto({
+        message: `Power clamp functions status fetched successfully`,
+        data: {
           productUuid: deviceDetails.productDevice.uuid,
           productType: deviceDetails.productDevice.prodType,
           status: {
@@ -1204,7 +1256,9 @@ export class DeviceService {
             phaseC: groupedStatus.phaseC,
             general: groupedStatus.general,
           },
-      };
+        },
+        statusCode: HttpStatus.OK,
+      });
     } catch (error) {
       throw new HttpException(
         error.message || 'Error fetching power clamp functions status',
@@ -1281,6 +1335,7 @@ export class DeviceService {
   async addSceneToSceneDevice(
     deviceUuid: string,
     addSceneToFourSceneDeviceDto: AddSceneToFourSceneDeviceDto,
+    projectUuid: string,
   ) {
     try {
       const { spaceUuid, sceneUuid, switchName } = addSceneToFourSceneDeviceDto;
@@ -1292,7 +1347,7 @@ export class DeviceService {
       const [sceneData, spaceData, deviceData] = await Promise.all([
         this.sceneService.findScene(sceneUuid),
         this.sceneService.getSpaceByUuid(spaceUuid),
-        this.getDeviceByDeviceUuid(deviceUuid),
+        this.getDeviceByDeviceUuid(deviceUuid, true, projectUuid),
       ]);
 
       const shortUuid = deviceUuid.slice(0, 6); // First 6 characters of the UUID
@@ -1357,7 +1412,13 @@ export class DeviceService {
           existingSceneDevice.device = deviceData;
           existingSceneDevice.switchName = switchName;
 
-          return await this.sceneDeviceRepository.save(existingSceneDevice);
+          const updatedSceneDevice =
+            await this.sceneDeviceRepository.save(existingSceneDevice);
+          return new SuccessResponseDto({
+            message: `Successfully updated scene device with uuid ${updatedSceneDevice.uuid}`,
+            data: updatedSceneDevice,
+            statusCode: HttpStatus.CREATED,
+          });
         } else {
           const sceneDevice = await this.sceneDeviceRepository.save({
             scene: sceneData,
@@ -1365,7 +1426,11 @@ export class DeviceService {
             automationTuyaUuid: automation.result.id,
             switchName: switchName,
           });
-          return sceneDevice;
+          return new SuccessResponseDto({
+            message: `Successfully created scene device with uuid ${sceneDevice.uuid}`,
+            data: sceneDevice,
+            statusCode: HttpStatus.CREATED,
+          });
         }
       }
     } catch (err) {
@@ -1378,13 +1443,24 @@ export class DeviceService {
   async getScenesBySceneDevice(
     deviceUuid: string,
     getSceneFourSceneDeviceDto: GetSceneFourSceneDeviceDto,
+    projectUuid: string,
   ): Promise<any> {
     try {
       if (getSceneFourSceneDeviceDto.switchName) {
         // Query for a single record directly when switchName is provided
         const sceneDevice = await this.sceneDeviceRepository.findOne({
           where: {
-            device: { uuid: deviceUuid },
+            device: {
+              uuid: deviceUuid,
+              spaceDevice: {
+                spaceName: Not(ORPHAN_SPACE_NAME),
+                community: {
+                  project: {
+                    uuid: projectUuid,
+                  },
+                },
+              },
+            },
             switchName:
               getSceneFourSceneDeviceDto.switchName as SceneSwitchesTypeEnum,
           },
@@ -1436,7 +1512,11 @@ export class DeviceService {
         }),
       );
 
-      return results;
+      return new SuccessResponseDto({
+        message: `Successfully fetched scenes for device with uuid ${deviceUuid}`,
+        data: results,
+        statusCode: HttpStatus.OK,
+      });
     } catch (error) {
       throw new HttpException(
         error.message || 'Failed to fetch scenes for device',
@@ -1447,6 +1527,7 @@ export class DeviceService {
   async deleteSceneFromSceneDevice(
     params: DeviceSceneParamDto,
     query: DeleteSceneFromSceneDeviceDto,
+    projectUuid: string,
   ): Promise<BaseResponseDto> {
     const { deviceUuid } = params;
     const { switchName } = query;
@@ -1454,7 +1535,13 @@ export class DeviceService {
     try {
       const existingSceneDevice = await this.sceneDeviceRepository.findOne({
         where: {
-          device: { uuid: deviceUuid },
+          device: {
+            uuid: deviceUuid,
+            spaceDevice: {
+              spaceName: Not(ORPHAN_SPACE_NAME),
+              community: { project: { uuid: projectUuid } },
+            },
+          },
           switchName: switchName as SceneSwitchesTypeEnum,
         },
         relations: ['scene.space.community'],

src/guards/scene.device.type.guard.ts

@@ -15,14 +15,17 @@ export class CheckFourAndSixSceneDeviceTypeGuard implements CanActivate {
   async canActivate(context: ExecutionContext): Promise<boolean> {
     const request = context.switchToHttp().getRequest();
     const deviceUuid = request.params.deviceUuid;
-
+    const projectUuid = request.user.project.uuid;
     if (!deviceUuid) {
       throw new BadRequestException('Device UUID is required');
     }
 
     try {
-      const deviceDetails =
+      const deviceDetails = await this.deviceService.getDeviceByDeviceUuid(
-        await this.deviceService.getDeviceByDeviceUuid(deviceUuid);
+        deviceUuid,
+        true,
+        projectUuid,
+      );
 
       if (
         deviceDetails.productDevice.prodType !== ProductType.FOUR_S &&

src/scene/controllers/scene.controller.ts

@@ -8,6 +8,7 @@ import {
   Param,
   Post,
   Put,
+  Req,
   UseGuards,
 } from '@nestjs/common';
 import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
@@ -42,8 +43,13 @@ export class SceneController {
   })
   async addTapToRunScene(
     @Body() addSceneTapToRunDto: AddSceneTapToRunDto,
+    @Req() req: any,
   ): Promise<BaseResponseDto> {
-    return await this.sceneService.createScene(addSceneTapToRunDto);
+    const projectUuid = req.user.project.uuid;
+    return await this.sceneService.createScene(
+      addSceneTapToRunDto,
+      projectUuid,
+    );
   }
 
   @ApiBearerAuth()
@@ -100,10 +106,13 @@ export class SceneController {
   async updateTapToRunScene(
     @Body() updateSceneTapToRunDto: UpdateSceneTapToRunDto,
     @Param() param: SceneParamDto,
+    @Req() req: any,
   ) {
+    const projectUuid = req.user.project.uuid;
     return await this.sceneService.updateTapToRunScene(
       updateSceneTapToRunDto,
       param.sceneUuid,
+      projectUuid,
     );
   }
 

src/scene/services/scene.service.ts

@@ -60,13 +60,18 @@ export class SceneService {
 
   async createScene(
     addSceneTapToRunDto: AddSceneTapToRunDto,
+    projectUuid: string,
   ): Promise<BaseResponseDto> {
     try {
       const { spaceUuid } = addSceneTapToRunDto;
 
       const space = await this.getSpaceByUuid(spaceUuid);
 
-      const scene = await this.create(space.spaceTuyaUuid, addSceneTapToRunDto);
+      const scene = await this.create(
+        space.spaceTuyaUuid,
+        addSceneTapToRunDto,
+        projectUuid,
+      );
 
       return new SuccessResponseDto({
         message: `Successfully created new scene with uuid ${scene.uuid}`,
@@ -90,6 +95,7 @@ export class SceneService {
   async create(
     spaceTuyaUuid: string,
     addSceneTapToRunDto: AddSceneTapToRunDto,
+    projectUuid: string,
   ): Promise<SceneEntity> {
     const { iconUuid, showInHomePage, spaceUuid } = addSceneTapToRunDto;
 
@@ -107,6 +113,7 @@ export class SceneService {
       const response = await this.createSceneExternalService(
         spaceTuyaUuid,
         addSceneTapToRunDto,
+        projectUuid,
       );
 
       const scene = await this.sceneRepository.save({
@@ -137,10 +144,11 @@ export class SceneService {
     spaceTuyaUuid: string,
     sceneTuyaUuid: string,
     updateSceneTapToRunDto: UpdateSceneTapToRunDto,
+    projectUuid: string,
   ) {
     const { sceneName, decisionExpr, actions } = updateSceneTapToRunDto;
     try {
-      const formattedActions = await this.prepareActions(actions);
+      const formattedActions = await this.prepareActions(actions, projectUuid);
 
       const response = (await this.tuyaService.updateTapToRunScene(
         sceneTuyaUuid,
@@ -178,10 +186,11 @@ export class SceneService {
   async createSceneExternalService(
     spaceTuyaUuid: string,
     addSceneTapToRunDto: AddSceneTapToRunDto,
+    projectUuid: string,
   ) {
     const { sceneName, decisionExpr, actions } = addSceneTapToRunDto;
     try {
-      const formattedActions = await this.prepareActions(actions);
+      const formattedActions = await this.prepareActions(actions, projectUuid);
 
       const response = (await this.tuyaService.addTapToRunScene(
         spaceTuyaUuid,
@@ -324,6 +333,7 @@ export class SceneService {
   async updateTapToRunScene(
     updateSceneTapToRunDto: UpdateSceneTapToRunDto,
     sceneUuid: string,
+    projectUuid: string,
   ) {
     try {
       const scene = await this.findScene(sceneUuid);
@@ -340,6 +350,7 @@ export class SceneService {
         space.spaceTuyaUuid,
         scene.sceneTuyaUuid,
         addSceneTapToRunDto,
+        projectUuid,
       );
 
       if (!updateTuyaSceneResponse.success) {
@@ -573,7 +584,10 @@ export class SceneService {
     }
   }
 
-  private async prepareActions(actions: Action[]): Promise<ConvertedAction[]> {
+  private async prepareActions(
+    actions: Action[],
+    projectUuid: string,
+  ): Promise<ConvertedAction[]> {
     const convertedData = convertKeysToSnakeCase(actions) as ConvertedAction[];
 
     await Promise.all(
@@ -582,6 +596,7 @@ export class SceneService {
           const device = await this.deviceService.getDeviceByDeviceUuid(
             action.entity_id,
             false,
+            projectUuid,
           );
           if (device) {
             action.entity_id = device.deviceTuyaUuid;