adjusted procedures

* task: add Cur new device configuration

libs/common/src/constants/product-type.enum.ts

@@ -15,6 +15,7 @@ export enum ProductType {
   WL = 'WL',
   GD = 'GD',
   CUR = 'CUR',
+  CUR_2 = 'CUR_2',
   PC = 'PC',
   FOUR_S = '4S',
   SIX_S = '6S',

libs/common/src/sql/procedures/fact_device_energy_consumed/fact_daily_device_energy_consumed_procedure.sql

@@ -1,6 +1,5 @@
 WITH params AS (
     SELECT 
-        $1::uuid AS device_id,
         $2::date AS target_date
 ),
 total_energy AS (
@@ -14,8 +13,7 @@ total_energy AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumed'
-      AND log.device_id = params.device_id
+    AND log.event_time::date = params.target_date
-      AND log.event_time::date = params.target_date
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_A AS (
@@ -29,8 +27,7 @@ energy_phase_A AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedA'
-      AND log.device_id = params.device_id
+    AND log.event_time::date = params.target_date
-      AND log.event_time::date = params.target_date
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_B AS (
@@ -44,8 +41,7 @@ energy_phase_B AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedB'
-      AND log.device_id = params.device_id
+    AND log.event_time::date = params.target_date
-      AND log.event_time::date = params.target_date
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_C AS (
@@ -59,8 +55,7 @@ energy_phase_C AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedC'
-      AND log.device_id = params.device_id
+    AND log.event_time::date = params.target_date
-      AND log.event_time::date = params.target_date
     GROUP BY 1,2,3,4,5
 ),
 final_data AS (

libs/common/src/sql/procedures/fact_device_energy_consumed/fact_hourly_device_energy_consumed_procedure.sql

@@ -1,8 +1,6 @@
 WITH params AS (
     SELECT 
-        $1::uuid AS device_id,
+        $2::date AS target_date
-        $2::date AS target_date,
-        $3::text AS target_hour
 ),
 total_energy AS (
     SELECT 
@@ -15,9 +13,7 @@ total_energy AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumed'
-      AND log.device_id = params.device_id
       AND log.event_time::date = params.target_date
-      AND EXTRACT(HOUR FROM log.event_time)::text = params.target_hour
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_A AS (
@@ -31,9 +27,7 @@ energy_phase_A AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedA'
-      AND log.device_id = params.device_id
       AND log.event_time::date = params.target_date
-      AND EXTRACT(HOUR FROM log.event_time)::text = params.target_hour
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_B AS (
@@ -47,9 +41,7 @@ energy_phase_B AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedB'
-      AND log.device_id = params.device_id
       AND log.event_time::date = params.target_date
-      AND EXTRACT(HOUR FROM log.event_time)::text = params.target_hour
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_C AS (
@@ -63,9 +55,7 @@ energy_phase_C AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedC'
-      AND log.device_id = params.device_id
       AND log.event_time::date = params.target_date
-      AND EXTRACT(HOUR FROM log.event_time)::text = params.target_hour
     GROUP BY 1,2,3,4,5
 ),
 final_data AS (

libs/common/src/sql/procedures/fact_device_energy_consumed/fact_monthly_device_energy_consumed_procedure.sql

@@ -1,6 +1,5 @@
 WITH params AS (
     SELECT 
-        $1::uuid AS device_id,
         $2::text AS target_month  -- Format should match 'MM-YYYY'
 ),
 total_energy AS (
@@ -14,7 +13,6 @@ total_energy AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumed'
-      AND log.device_id = params.device_id
       AND TO_CHAR(log.event_time, 'MM-YYYY') = params.target_month
     GROUP BY 1,2,3,4,5
 ),
@@ -29,7 +27,6 @@ energy_phase_A AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedA'
-      AND log.device_id = params.device_id
       AND TO_CHAR(log.event_time, 'MM-YYYY') = params.target_month
     GROUP BY 1,2,3,4,5
 ),
@@ -44,7 +41,6 @@ energy_phase_B AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedB'
-      AND log.device_id = params.device_id
       AND TO_CHAR(log.event_time, 'MM-YYYY') = params.target_month
     GROUP BY 1,2,3,4,5
 ),
@@ -59,7 +55,6 @@ energy_phase_C AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedC'
-      AND log.device_id = params.device_id
       AND TO_CHAR(log.event_time, 'MM-YYYY') = params.target_month
     GROUP BY 1,2,3,4,5
 ),

src/app.module.ts

@@ -37,7 +37,6 @@ 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';
@@ -51,12 +50,7 @@ import { WeatherModule } from './weather/weather.module';
       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'] || req.ip;
-        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),

src/device/commands/cur2-commands.ts

@@ -0,0 +1,28 @@
+interface BaseCommand {
+  code: string;
+  value: any;
+}
+export interface ControlCur2Command extends BaseCommand {
+  code: 'control';
+  value: 'open' | 'close' | 'stop';
+}
+export interface ControlCur2PercentCommand extends BaseCommand {
+  code: 'percent_control';
+  value: 10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 | 100;
+}
+export interface ControlCur2AccurateCalibrationCommand extends BaseCommand {
+  code: 'accurate_calibration';
+  value: 'start' | 'end'; // Assuming this is a numeric value for calibration
+}
+export interface ControlCur2TDirectionConCommand extends BaseCommand {
+  code: 'control_t_direction_con';
+  value: 'forward' | 'back';
+}
+export interface ControlCur2QuickCalibrationCommand extends BaseCommand {
+  code: 'tr_timecon';
+  value: number; // between 10 and 120
+}
+export interface ControlCur2MotorModeCommand extends BaseCommand {
+  code: 'elec_machinery_mode';
+  value: 'strong_power' | 'dry_contact';
+}

src/main.ts

@@ -21,6 +21,18 @@ async function bootstrap() {
 
   app.use(new RequestContextMiddleware().use);
 
+  app.use((req, res, next) => {
+    console.log(
+      'Real IP:',
+      req.ip,
+      req.headers['x-forwarded-for'],
+      req.connection.remoteAddress,
+    );
+    next();
+  });
+
+  // app.getHttpAdapter().getInstance().set('trust proxy', 1);
+
   app.use(
     helmet({
       contentSecurityPolicy: false,

src/schedule/constants/device-function-map.ts

@@ -0,0 +1,32 @@
+import {
+  ControlCur2AccurateCalibrationCommand,
+  ControlCur2Command,
+  ControlCur2PercentCommand,
+  ControlCur2QuickCalibrationCommand,
+  ControlCur2TDirectionConCommand,
+} from 'src/device/commands/cur2-commands';
+
+export enum ScheduleProductType {
+  CUR_2 = 'CUR_2',
+}
+export const DeviceFunctionMap: {
+  [T in ScheduleProductType]: (body: DeviceFunction[T]) => any;
+} = {
+  [ScheduleProductType.CUR_2]: ({ code, value }) => {
+    return [
+      {
+        code,
+        value,
+      },
+    ];
+  },
+};
+
+type DeviceFunction = {
+  [ScheduleProductType.CUR_2]:
+    | ControlCur2Command
+    | ControlCur2PercentCommand
+    | ControlCur2AccurateCalibrationCommand
+    | ControlCur2TDirectionConCommand
+    | ControlCur2QuickCalibrationCommand;
+};

src/schedule/services/schedule.service.ts

@@ -1,6 +1,6 @@
-import { Injectable, HttpException, HttpStatus } from '@nestjs/common';
+import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
-import { TuyaContext } from '@tuya/tuya-connector-nodejs';
 import { ConfigService } from '@nestjs/config';
+import { TuyaContext } from '@tuya/tuya-connector-nodejs';
 import {
   AddScheduleDto,
   EnableScheduleDto,
@@ -11,14 +11,14 @@ import {
   getDeviceScheduleInterface,
 } from '../interfaces/get.schedule.interface';
 
-import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
-import { DeviceRepository } from '@app/common/modules/device/repositories';
 import { ProductType } from '@app/common/constants/product-type.enum';
+import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
 import { convertTimestampToDubaiTime } from '@app/common/helper/convertTimestampToDubaiTime';
 import {
   getEnabledDays,
   getScheduleStatus,
 } from '@app/common/helper/getScheduleStatus';
+import { DeviceRepository } from '@app/common/modules/device/repositories';
 
 @Injectable()
 export class ScheduleService {
@@ -49,22 +49,11 @@ export class ScheduleService {
       }
 
       // Corrected condition for supported device types
-      if (
+      this.ensureProductTypeSupportedForSchedule(
-        deviceDetails.productDevice.prodType !== ProductType.THREE_G &&
+        ProductType[deviceDetails.productDevice.prodType],
-        deviceDetails.productDevice.prodType !== ProductType.ONE_G &&
+      );
-        deviceDetails.productDevice.prodType !== ProductType.TWO_G &&
+
-        deviceDetails.productDevice.prodType !== ProductType.WH &&
+      return this.enableScheduleDeviceInTuya(
-        deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
-        deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
-        deviceDetails.productDevice.prodType !== ProductType.GD
-      ) {
-        throw new HttpException(
-          'This device is not supported for schedule',
-          HttpStatus.BAD_REQUEST,
-        );
-      }
-      return await this.enableScheduleDeviceInTuya(
         deviceDetails.deviceTuyaUuid,
         enableScheduleDto,
       );
@@ -75,29 +64,6 @@ export class ScheduleService {
       );
     }
   }
-  async enableScheduleDeviceInTuya(
-    deviceId: string,
-    enableScheduleDto: EnableScheduleDto,
-  ): Promise<addScheduleDeviceInterface> {
-    try {
-      const path = `/v2.0/cloud/timer/device/${deviceId}/state`;
-      const response = await this.tuya.request({
-        method: 'PUT',
-        path,
-        body: {
-          enable: enableScheduleDto.enable,
-          timer_id: enableScheduleDto.scheduleId,
-        },
-      });
-
-      return response as addScheduleDeviceInterface;
-    } catch (error) {
-      throw new HttpException(
-        'Error while updating schedule from Tuya',
-        HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
   async deleteDeviceSchedule(deviceUuid: string, scheduleId: string) {
     try {
       const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
@@ -107,21 +73,10 @@ export class ScheduleService {
       }
 
       // Corrected condition for supported device types
-      if (
+      this.ensureProductTypeSupportedForSchedule(
-        deviceDetails.productDevice.prodType !== ProductType.THREE_G &&
+        ProductType[deviceDetails.productDevice.prodType],
-        deviceDetails.productDevice.prodType !== ProductType.ONE_G &&
+      );
-        deviceDetails.productDevice.prodType !== ProductType.TWO_G &&
+
-        deviceDetails.productDevice.prodType !== ProductType.WH &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
-        deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
-        deviceDetails.productDevice.prodType !== ProductType.GD
-      ) {
-        throw new HttpException(
-          'This device is not supported for schedule',
-          HttpStatus.BAD_REQUEST,
-        );
-      }
       return await this.deleteScheduleDeviceInTuya(
         deviceDetails.deviceTuyaUuid,
         scheduleId,
@@ -133,25 +88,6 @@ export class ScheduleService {
       );
     }
   }
-  async deleteScheduleDeviceInTuya(
-    deviceId: string,
-    scheduleId: string,
-  ): Promise<addScheduleDeviceInterface> {
-    try {
-      const path = `/v2.0/cloud/timer/device/${deviceId}/batch?timer_ids=${scheduleId}`;
-      const response = await this.tuya.request({
-        method: 'DELETE',
-        path,
-      });
-
-      return response as addScheduleDeviceInterface;
-    } catch (error) {
-      throw new HttpException(
-        'Error while deleting schedule from Tuya',
-        HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
   async addDeviceSchedule(deviceUuid: string, addScheduleDto: AddScheduleDto) {
     try {
       const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
@@ -160,22 +96,10 @@ export class ScheduleService {
         throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
       }
 
-      // Corrected condition for supported device types
+      this.ensureProductTypeSupportedForSchedule(
-      if (
+        ProductType[deviceDetails.productDevice.prodType],
-        deviceDetails.productDevice.prodType !== ProductType.THREE_G &&
+      );
-        deviceDetails.productDevice.prodType !== ProductType.ONE_G &&
+
-        deviceDetails.productDevice.prodType !== ProductType.TWO_G &&
-        deviceDetails.productDevice.prodType !== ProductType.WH &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
-        deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
-        deviceDetails.productDevice.prodType !== ProductType.GD
-      ) {
-        throw new HttpException(
-          'This device is not supported for schedule',
-          HttpStatus.BAD_REQUEST,
-        );
-      }
       await this.addScheduleDeviceInTuya(
         deviceDetails.deviceTuyaUuid,
         addScheduleDto,
@@ -187,40 +111,6 @@ export class ScheduleService {
       );
     }
   }
-  async addScheduleDeviceInTuya(
-    deviceId: string,
-    addScheduleDto: AddScheduleDto,
-  ): Promise<addScheduleDeviceInterface> {
-    try {
-      const convertedTime = convertTimestampToDubaiTime(addScheduleDto.time);
-      const loops = getScheduleStatus(addScheduleDto.days);
-
-      const path = `/v2.0/cloud/timer/device/${deviceId}`;
-      const response = await this.tuya.request({
-        method: 'POST',
-        path,
-        body: {
-          time: convertedTime.time,
-          timezone_id: 'Asia/Dubai',
-          loops: `${loops}`,
-          functions: [
-            {
-              code: addScheduleDto.function.code,
-              value: addScheduleDto.function.value,
-            },
-          ],
-          category: `category_${addScheduleDto.category}`,
-        },
-      });
-
-      return response as addScheduleDeviceInterface;
-    } catch (error) {
-      throw new HttpException(
-        'Error adding schedule from Tuya',
-        HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
   async getDeviceScheduleByCategory(deviceUuid: string, category: string) {
     try {
       const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
@@ -229,21 +119,10 @@ export class ScheduleService {
         throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
       }
       // Corrected condition for supported device types
-      if (
+      this.ensureProductTypeSupportedForSchedule(
-        deviceDetails.productDevice.prodType !== ProductType.THREE_G &&
+        ProductType[deviceDetails.productDevice.prodType],
-        deviceDetails.productDevice.prodType !== ProductType.ONE_G &&
+      );
-        deviceDetails.productDevice.prodType !== ProductType.TWO_G &&
+
-        deviceDetails.productDevice.prodType !== ProductType.WH &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
-        deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
-        deviceDetails.productDevice.prodType !== ProductType.GD
-      ) {
-        throw new HttpException(
-          'This device is not supported for schedule',
-          HttpStatus.BAD_REQUEST,
-        );
-      }
       const schedules = await this.getScheduleDeviceInTuya(
         deviceDetails.deviceTuyaUuid,
         category,
@@ -270,7 +149,82 @@ export class ScheduleService {
       );
     }
   }
-  async getScheduleDeviceInTuya(
+  async updateDeviceSchedule(
+    deviceUuid: string,
+    updateScheduleDto: UpdateScheduleDto,
+  ) {
+    try {
+      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+
+      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
+        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
+      }
+
+      // Corrected condition for supported device types
+      this.ensureProductTypeSupportedForSchedule(
+        ProductType[deviceDetails.productDevice.prodType],
+      );
+
+      await this.updateScheduleDeviceInTuya(
+        deviceDetails.deviceTuyaUuid,
+        updateScheduleDto,
+      );
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Error While Updating Schedule',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  private getDeviceByDeviceUuid(
+    deviceUuid: string,
+    withProductDevice: boolean = true,
+  ) {
+    return this.deviceRepository.findOne({
+      where: {
+        uuid: deviceUuid,
+        isActive: true,
+      },
+      ...(withProductDevice && { relations: ['productDevice'] }),
+    });
+  }
+
+  private async addScheduleDeviceInTuya(
+    deviceId: string,
+    addScheduleDto: AddScheduleDto,
+  ): Promise<addScheduleDeviceInterface> {
+    try {
+      const convertedTime = convertTimestampToDubaiTime(addScheduleDto.time);
+      const loops = getScheduleStatus(addScheduleDto.days);
+
+      const path = `/v2.0/cloud/timer/device/${deviceId}`;
+      const response = await this.tuya.request({
+        method: 'POST',
+        path,
+        body: {
+          time: convertedTime.time,
+          timezone_id: 'Asia/Dubai',
+          loops: `${loops}`,
+          functions: [
+            {
+              ...addScheduleDto.function,
+            },
+          ],
+          category: `category_${addScheduleDto.category}`,
+        },
+      });
+
+      return response as addScheduleDeviceInterface;
+    } catch (error) {
+      throw new HttpException(
+        'Error adding schedule from Tuya',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  private async getScheduleDeviceInTuya(
     deviceId: string,
     category: string,
   ): Promise<getDeviceScheduleInterface> {
@@ -291,57 +245,8 @@ export class ScheduleService {
       );
     }
   }
-  async getDeviceByDeviceUuid(
-    deviceUuid: string,
-    withProductDevice: boolean = true,
-  ) {
-    return await this.deviceRepository.findOne({
-      where: {
-        uuid: deviceUuid,
-        isActive: true,
-      },
-      ...(withProductDevice && { relations: ['productDevice'] }),
-    });
-  }
-  async updateDeviceSchedule(
-    deviceUuid: string,
-    updateScheduleDto: UpdateScheduleDto,
-  ) {
-    try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
 
-      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
+  private async updateScheduleDeviceInTuya(
-        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
-      }
-
-      // Corrected condition for supported device types
-      if (
-        deviceDetails.productDevice.prodType !== ProductType.THREE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_G &&
-        deviceDetails.productDevice.prodType !== ProductType.WH &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
-        deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
-        deviceDetails.productDevice.prodType !== ProductType.GD
-      ) {
-        throw new HttpException(
-          'This device is not supported for schedule',
-          HttpStatus.BAD_REQUEST,
-        );
-      }
-      await this.updateScheduleDeviceInTuya(
-        deviceDetails.deviceTuyaUuid,
-        updateScheduleDto,
-      );
-    } catch (error) {
-      throw new HttpException(
-        error.message || 'Error While Updating Schedule',
-        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
-  async updateScheduleDeviceInTuya(
     deviceId: string,
     updateScheduleDto: UpdateScheduleDto,
   ): Promise<addScheduleDeviceInterface> {
@@ -376,4 +281,69 @@ export class ScheduleService {
       );
     }
   }
+
+  private async enableScheduleDeviceInTuya(
+    deviceId: string,
+    enableScheduleDto: EnableScheduleDto,
+  ): Promise<addScheduleDeviceInterface> {
+    try {
+      const path = `/v2.0/cloud/timer/device/${deviceId}/state`;
+      const response = await this.tuya.request({
+        method: 'PUT',
+        path,
+        body: {
+          enable: enableScheduleDto.enable,
+          timer_id: enableScheduleDto.scheduleId,
+        },
+      });
+
+      return response as addScheduleDeviceInterface;
+    } catch (error) {
+      throw new HttpException(
+        'Error while updating schedule from Tuya',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  private async deleteScheduleDeviceInTuya(
+    deviceId: string,
+    scheduleId: string,
+  ): Promise<addScheduleDeviceInterface> {
+    try {
+      const path = `/v2.0/cloud/timer/device/${deviceId}/batch?timer_ids=${scheduleId}`;
+      const response = await this.tuya.request({
+        method: 'DELETE',
+        path,
+      });
+
+      return response as addScheduleDeviceInterface;
+    } catch (error) {
+      throw new HttpException(
+        'Error while deleting schedule from Tuya',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  private ensureProductTypeSupportedForSchedule(deviceType: ProductType): void {
+    if (
+      ![
+        ProductType.THREE_G,
+        ProductType.ONE_G,
+        ProductType.TWO_G,
+        ProductType.WH,
+        ProductType.ONE_1TG,
+        ProductType.TWO_2TG,
+        ProductType.THREE_3TG,
+        ProductType.GD,
+        ProductType.CUR_2,
+      ].includes(deviceType)
+    ) {
+      throw new HttpException(
+        'This device is not supported for schedule',
+        HttpStatus.BAD_REQUEST,
+      );
+    }
+  }
 }

src/space/services/space.service.ts

@@ -333,7 +333,12 @@ export class SpaceService {
         .andWhere('space.disabled = :disabled', { disabled: false });
 
       const space = await queryBuilder.getOne();
-
+      if (!space) {
+        throw new HttpException(
+          `Space with ID ${spaceUuid} not found`,
+          HttpStatus.NOT_FOUND,
+        );
+      }
       return new SuccessResponseDto({
         message: `Space with ID ${spaceUuid} successfully fetched`,
         data: space,
@@ -343,7 +348,7 @@ export class SpaceService {
         throw error; // If it's an HttpException, rethrow it
       } else {
         throw new HttpException(
-          'An error occurred while deleting the community',
+          'An error occurred while fetching the space',
           HttpStatus.INTERNAL_SERVER_ERROR,
         );
       }