remove duplication code

src/device/controllers/device.controller.ts

@@ -232,20 +232,14 @@ export class DeviceController {
   }
   @ApiBearerAuth()
   @UseGuards(JwtAuthGuard, CheckFourAndSixSceneDeviceTypeGuard)
-  @Get(':deviceUuid/scenes/switch')
+  @Get(':deviceUuid/scenes')
-  async getSceneBySceneDevice(
+  async getScenesBySceneDevice(
     @Param('deviceUuid') deviceUuid: string,
     @Query() getSceneFourSceneDeviceDto: GetSceneFourSceneDeviceDto,
   ) {
-    return await this.deviceService.getSceneBySceneDevice(
+    return await this.deviceService.getScenesBySceneDevice(
       deviceUuid,
       getSceneFourSceneDeviceDto,
     );
   }
-  @ApiBearerAuth()
-  @UseGuards(JwtAuthGuard, CheckFourAndSixSceneDeviceTypeGuard)
-  @Get(':deviceUuid/scenes')
-  async getScenesBySceneDevice(@Param('deviceUuid') deviceUuid: string) {
-    return await this.deviceService.getScenesBySceneDevice(deviceUuid);
-  }
 }

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

@@ -1,5 +1,5 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { IsArray, IsNotEmpty, IsString } from 'class-validator';
+import { IsArray, IsNotEmpty, IsOptional, IsString } from 'class-validator';
 
 export class ControlDeviceDto {
   @ApiProperty({
@@ -57,9 +57,9 @@ export class BatchFactoryResetDevicesDto {
 export class GetSceneFourSceneDeviceDto {
   @ApiProperty({
     description: 'switchName',
-    required: true,
+    required: false,
   })
   @IsString()
-  @IsNotEmpty()
+  @IsOptional()
-  public switchName: string;
+  public switchName?: string;
 }

src/device/services/device.service.ts

@@ -1319,42 +1319,43 @@ export class DeviceService {
     }
   }
 
-  async getSceneBySceneDevice(
+  async getScenesBySceneDevice(
     deviceUuid: string,
     getSceneFourSceneDeviceDto: GetSceneFourSceneDeviceDto,
-  ) {
+  ): Promise<any> {
     try {
-      const sceneDevice = await this.sceneDeviceRepository.findOne({
+      if (getSceneFourSceneDeviceDto.switchName) {
-        where: {
+        // Query for a single record directly when switchName is provided
-          device: { uuid: deviceUuid },
+        const sceneDevice = await this.sceneDeviceRepository.findOne({
-          switchName:
+          where: {
-            getSceneFourSceneDeviceDto.switchName as SceneSwitchesTypeEnum,
+            device: { uuid: deviceUuid },
-        },
+            switchName:
-        relations: ['device', 'scene'],
+              getSceneFourSceneDeviceDto.switchName as SceneSwitchesTypeEnum,
-      });
+          },
-      if (sceneDevice.uuid) {
+          relations: ['device', 'scene'],
-        const SceneDetails = await this.sceneService.getSceneByUuid(
+        });
+
+        if (!sceneDevice) {
+          throw new HttpException(
+            `No scene found for device with UUID ${deviceUuid} and switch name ${getSceneFourSceneDeviceDto.switchName}`,
+            HttpStatus.NOT_FOUND,
+          );
+        }
+
+        const sceneDetails = await this.sceneService.getSceneByUuid(
           sceneDevice.scene.uuid,
         );
+
         return {
           switchName: sceneDevice.switchName,
           createdAt: sceneDevice.createdAt,
           updatedAt: sceneDevice.updatedAt,
           deviceUuid: sceneDevice.device.uuid,
-          scene: {
+          scene: sceneDetails.data,
-            ...SceneDetails.data,
-          },
         };
       }
-    } catch (error) {
+
-      throw new HttpException(
+      // Query for multiple records if switchName is not provided
-        error.message || 'Scene device not found',
-        error.status || HttpStatus.NOT_FOUND,
-      );
-    }
-  }
-  async getScenesBySceneDevice(deviceUuid: string): Promise<any[]> {
-    try {
       const sceneDevices = await this.sceneDeviceRepository.find({
         where: { device: { uuid: deviceUuid } },
         relations: ['device', 'scene'],
@@ -1362,37 +1363,28 @@ export class DeviceService {
 
       if (!sceneDevices.length) {
         throw new HttpException(
-          'No scenes found for the device',
+          `No scenes found for device with UUID ${deviceUuid}`,
           HttpStatus.NOT_FOUND,
         );
       }
 
       const results = await Promise.all(
         sceneDevices.map(async (sceneDevice) => {
-          if (!sceneDevice.scene?.uuid) return null;
+          const sceneDetails = await this.sceneService.getSceneByUuid(
+            sceneDevice.scene.uuid,
+          );
 
-          try {
+          return {
-            const sceneDetails = await this.sceneService.getSceneByUuid(
+            switchName: sceneDevice.switchName,
-              sceneDevice.scene.uuid,
+            createdAt: sceneDevice.createdAt,
-            );
+            updatedAt: sceneDevice.updatedAt,
-
+            deviceUuid: sceneDevice.device.uuid,
-            return {
+            scene: sceneDetails.data,
-              switchName: sceneDevice.switchName,
+          };
-              createdAt: sceneDevice.createdAt,
-              updatedAt: sceneDevice.updatedAt,
-              deviceUuid: sceneDevice.device.uuid,
-              scene: sceneDetails.data,
-            };
-          } catch (error) {
-            throw new HttpException(
-              'Failed to fetch scene details',
-              HttpStatus.INTERNAL_SERVER_ERROR,
-            );
-          }
         }),
       );
 
-      return results.filter(Boolean);
+      return results;
     } catch (error) {
       throw new HttpException(
         error.message || 'Failed to fetch scenes for device',