Merge branch 'dev' into SP-1780-be-configure-the-curtain-module-device

* increase DB max connection to 50

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/database/database.module.ts

@@ -125,7 +125,7 @@ import { VisitorPasswordEntity } from '../modules/visitor-password/entities';
           logger: typeOrmLogger,
           extra: {
             charset: 'utf8mb4',
-            max: 20, // set pool max size
+            max: 50, // 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/util/email.service.ts

@@ -1,7 +1,7 @@
 import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
-import * as nodemailer from 'nodemailer';
 import axios from 'axios';
+import * as nodemailer from 'nodemailer';
 import {
   SEND_EMAIL_API_URL_DEV,
   SEND_EMAIL_API_URL_PROD,
@@ -83,12 +83,17 @@ export class EmailService {
       );
     }
   }
-  async sendEmailWithTemplate(
-    email: string,
-    name: string,
-    isEnable: boolean,
-    isDelete: boolean,
-  ): Promise<void> {
+  async sendEmailWithTemplate({
+    email,
+    name,
+    isEnable,
+    isDelete,
+  }: {
+    email: string;
+    name: string;
+    isEnable: boolean;
+    isDelete: boolean;
+  }): Promise<void> {
     const isProduction = process.env.NODE_ENV === 'production';
     const API_TOKEN = this.configService.get<string>(
       'email-config.MAILTRAP_API_TOKEN',

src/community/services/community.service.ts

@@ -190,24 +190,26 @@ export class CommunityService {
         .distinct(true);
 
       if (includeSpaces) {
-        qb.leftJoinAndSelect('c.spaces', 'space', 'space.disabled = false')
+        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')
-          .andWhere('space.spaceName != :orphanSpaceName', {
-            orphanSpaceName: ORPHAN_SPACE_NAME,
-          })
-          .andWhere('space.disabled = :disabled', { disabled: false });
+          );
+        // .leftJoinAndSelect('space.spaceModel', 'spaceModel')
       }
 
       if (search) {
         qb.andWhere(
-          `c.name ILIKE '%${search}%' ${includeSpaces ? "OR space.space_name ILIKE '%" + search + "%'" : ''}`,
+          `c.name ILIKE :search ${includeSpaces ? 'OR space.space_name ILIKE :search' : ''}`,
+          { search },
         );
       }
 
@@ -215,12 +217,21 @@ export class CommunityService {
 
       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,

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/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/services/invite-user.service.ts

@@ -1,36 +1,42 @@
-import {
-  Injectable,
-  HttpException,
-  HttpStatus,
-  BadRequestException,
-} from '@nestjs/common';
-import { AddUserInvitationDto } from '../dtos';
-import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+import { RoleType } from '@app/common/constants/role.type.enum';
 import { UserStatusEnum } from '@app/common/constants/user-status.enum';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
 import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
 import { generateRandomString } from '@app/common/helper/randomString';
-import { EntityManager, In, IsNull, Not, QueryRunner } from 'typeorm';
-import { DataSource } from 'typeorm';
-import { UserEntity } from '@app/common/modules/user/entities';
-import { RoleType } from '@app/common/constants/role.type.enum';
+import { InviteUserEntity } from '@app/common/modules/Invite-user/entities';
 import {
   InviteUserRepository,
   InviteUserSpaceRepository,
 } from '@app/common/modules/Invite-user/repositiories';
-import { CheckEmailDto } from '../dtos/check-email.dto';
+import { RoleTypeRepository } from '@app/common/modules/role-type/repositories';
+import { SpaceRepository } from '@app/common/modules/space';
+import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
+import { UserEntity } from '@app/common/modules/user/entities';
 import { UserRepository } from '@app/common/modules/user/repositories';
 import { EmailService } from '@app/common/util/email.service';
-import { SpaceRepository } from '@app/common/modules/space';
-import { ActivateCodeDto } from '../dtos/active-code.dto';
-import { UserSpaceService } from 'src/users/services';
+import {
+  BadRequestException,
+  HttpException,
+  HttpStatus,
+  Injectable,
+} from '@nestjs/common';
 import { SpaceUserService } from 'src/space/services';
+import { UserSpaceService } from 'src/users/services';
+import {
+  DataSource,
+  EntityManager,
+  In,
+  IsNull,
+  Not,
+  QueryRunner,
+} from 'typeorm';
+import { AddUserInvitationDto } from '../dtos';
+import { ActivateCodeDto } from '../dtos/active-code.dto';
+import { CheckEmailDto } from '../dtos/check-email.dto';
 import {
   DisableUserInvitationDto,
   UpdateUserInvitationDto,
 } from '../dtos/update.invite-user.dto';
-import { RoleTypeRepository } from '@app/common/modules/role-type/repositories';
-import { InviteUserEntity } from '@app/common/modules/Invite-user/entities';
-import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
 
 @Injectable()
 export class InviteUserService {
@@ -658,12 +664,12 @@ export class InviteUserService {
           HttpStatus.BAD_REQUEST,
         );
       }
-      await this.emailService.sendEmailWithTemplate(
-        userData.email,
-        userData.firstName,
-        disable,
-        false,
-      );
+      await this.emailService.sendEmailWithTemplate({
+        email: userData.email,
+        name: userData.firstName,
+        isEnable: !disable,
+        isDelete: false,
+      });
       await queryRunner.commitTransaction();
 
       return new SuccessResponseDto({
@@ -797,12 +803,12 @@ export class InviteUserService {
           { isActive: false },
         );
       }
-      await this.emailService.sendEmailWithTemplate(
-        userData.email,
-        userData.firstName,
-        false,
-        true,
-      );
+      await this.emailService.sendEmailWithTemplate({
+        email: userData.email,
+        name: userData.firstName,
+        isEnable: false,
+        isDelete: true,
+      });
       await queryRunner.commitTransaction();
 
       return new SuccessResponseDto({

src/main.ts

@@ -1,15 +1,14 @@
+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 { AppModule } from './app.module';
+import { json, urlencoded } from 'body-parser';
 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 { 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);
@@ -30,6 +29,13 @@ async function bootstrap() {
     }),
   );
 
+  app.use((req, res, next) => {
+    console.log('Real IP:', req.ip);
+    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 { TuyaContext } from '@tuya/tuya-connector-nodejs';
+import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
 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 (
-        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,
-        );
-      }
-      return await this.enableScheduleDeviceInTuya(
+      this.ensureProductTypeSupportedForSchedule(
+        ProductType[deviceDetails.productDevice.prodType],
+      );
+
+      return 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 (
-        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,
-        );
-      }
+      this.ensureProductTypeSupportedForSchedule(
+        ProductType[deviceDetails.productDevice.prodType],
+      );
+
       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
-      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,
-        );
-      }
+      this.ensureProductTypeSupportedForSchedule(
+        ProductType[deviceDetails.productDevice.prodType],
+      );
+
       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 (
-        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,
-        );
-      }
+      this.ensureProductTypeSupportedForSchedule(
+        ProductType[deviceDetails.productDevice.prodType],
+      );
+
       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) {
-        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(
+  private 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

@@ -681,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