test

src/automation/services/automation.service.ts

@@ -0,0 +1,304 @@
+import {
+  Injectable,
+  HttpException,
+  HttpStatus,
+  BadRequestException,
+} from '@nestjs/common';
+import { SpaceRepository } from '@app/common/modules/space/repositories';
+import { AddAutomationDto, UpdateSceneTapToRunDto } from '../dtos';
+import { GetUnitByUuidInterface } from 'src/unit/interface/unit.interface';
+import { ConfigService } from '@nestjs/config';
+import { TuyaContext } from '@tuya/tuya-connector-nodejs';
+import { convertKeysToSnakeCase } from '@app/common/helper/snakeCaseConverter';
+import { DeviceService } from 'src/device/services';
+import {
+  AddTapToRunSceneInterface,
+  DeleteTapToRunSceneInterface,
+  GetTapToRunSceneByUnitInterface,
+} from '../interface/automation.interface';
+import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
+
+@Injectable()
+export class AutomationService {
+  private tuya: TuyaContext;
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly spaceRepository: SpaceRepository,
+    private readonly deviceService: DeviceService,
+  ) {
+    const accessKey = this.configService.get<string>('auth-config.ACCESS_KEY');
+    const secretKey = this.configService.get<string>('auth-config.SECRET_KEY');
+    const tuyaEuUrl = this.configService.get<string>('tuya-config.TUYA_EU_URL');
+    this.tuya = new TuyaContext({
+      baseUrl: tuyaEuUrl,
+      accessKey,
+      secretKey,
+    });
+  }
+
+  async addAutomation(addAutomationDto: AddAutomationDto, spaceTuyaId = null) {
+    try {
+      let unitSpaceTuyaId;
+      if (!spaceTuyaId) {
+        const unitDetails = await this.getUnitByUuid(addAutomationDto.unitUuid);
+        unitSpaceTuyaId = unitDetails.spaceTuyaUuid;
+        if (!unitDetails) {
+          throw new BadRequestException('Invalid unit UUID');
+        }
+      } else {
+        unitSpaceTuyaId = spaceTuyaId;
+      }
+      const actions = addAutomationDto.actions.map((action) => {
+        return {
+          ...action,
+        };
+      });
+
+      const convertedData = convertKeysToSnakeCase(actions);
+      for (const action of convertedData) {
+        if (action.action_executor === 'device_issue') {
+          const device = await this.deviceService.getDeviceByDeviceUuid(
+            action.entity_id,
+            false,
+          );
+          if (device) {
+            action.entity_id = device.deviceTuyaUuid;
+          }
+        }
+      }
+      const path = `/v2.0/cloud/scene/rule`;
+      const response: AddTapToRunSceneInterface = await this.tuya.request({
+        method: 'POST',
+        path,
+        body: {
+          space_id: unitSpaceTuyaId,
+          name: addAutomationDto.sceneName,
+          type: 'scene',
+          decision_expr: addAutomationDto.decisionExpr,
+          actions: convertedData,
+        },
+      });
+      if (!response.success) {
+        throw new HttpException(response.msg, HttpStatus.BAD_REQUEST);
+      }
+      return {
+        id: response.result.id,
+      };
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException(
+          err.message || 'Scene not found',
+          err.status || HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+  async getUnitByUuid(unitUuid: string): Promise<GetUnitByUuidInterface> {
+    try {
+      const unit = await this.spaceRepository.findOne({
+        where: {
+          uuid: unitUuid,
+          spaceType: {
+            type: 'unit',
+          },
+        },
+        relations: ['spaceType'],
+      });
+      if (!unit || !unit.spaceType || unit.spaceType.type !== 'unit') {
+        throw new BadRequestException('Invalid unit UUID');
+      }
+      return {
+        uuid: unit.uuid,
+        createdAt: unit.createdAt,
+        updatedAt: unit.updatedAt,
+        name: unit.spaceName,
+        type: unit.spaceType.type,
+        spaceTuyaUuid: unit.spaceTuyaUuid,
+      };
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException('Unit not found', HttpStatus.NOT_FOUND);
+      }
+    }
+  }
+  async getTapToRunSceneByUnit(unitUuid: string) {
+    try {
+      const unit = await this.getUnitByUuid(unitUuid);
+      if (!unit.spaceTuyaUuid) {
+        throw new BadRequestException('Invalid unit UUID');
+      }
+
+      const path = `/v2.0/cloud/scene/rule?space_id=${unit.spaceTuyaUuid}&type=scene`;
+      const response: GetTapToRunSceneByUnitInterface = await this.tuya.request(
+        {
+          method: 'GET',
+          path,
+        },
+      );
+
+      if (!response.success) {
+        throw new HttpException(response.msg, HttpStatus.BAD_REQUEST);
+      }
+
+      return response.result.list.map((item) => {
+        return {
+          id: item.id,
+          name: item.name,
+          status: item.status,
+          type: 'tap_to_run',
+        };
+      });
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException(
+          err.message || 'Scene not found',
+          err.status || HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+  async deleteTapToRunScene(
+    unitUuid: string,
+    sceneId: string,
+    spaceTuyaId = null,
+  ) {
+    try {
+      let unitSpaceTuyaId;
+      if (!spaceTuyaId) {
+        const unitDetails = await this.getUnitByUuid(unitUuid);
+        unitSpaceTuyaId = unitDetails.spaceTuyaUuid;
+        if (!unitSpaceTuyaId) {
+          throw new BadRequestException('Invalid unit UUID');
+        }
+      } else {
+        unitSpaceTuyaId = spaceTuyaId;
+      }
+
+      const path = `/v2.0/cloud/scene/rule?ids=${sceneId}&space_id=${unitSpaceTuyaId}`;
+      const response: DeleteTapToRunSceneInterface = await this.tuya.request({
+        method: 'DELETE',
+        path,
+      });
+
+      if (!response.success) {
+        throw new HttpException('Scene not found', HttpStatus.NOT_FOUND);
+      }
+
+      return response;
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException(
+          err.message || 'Scene not found',
+          err.status || HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+  async triggerTapToRunScene(sceneId: string) {
+    try {
+      const path = `/v2.0/cloud/scene/rule/${sceneId}/actions/trigger`;
+      const response: DeleteTapToRunSceneInterface = await this.tuya.request({
+        method: 'POST',
+        path,
+      });
+      if (!response.success) {
+        throw new HttpException(response.msg, HttpStatus.BAD_REQUEST);
+      }
+      return response;
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException(
+          err.message || 'Scene not found',
+          err.status || HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+  async getTapToRunSceneDetails(sceneId: string, withSpaceId = false) {
+    try {
+      const path = `/v2.0/cloud/scene/rule/${sceneId}`;
+      const response = await this.tuya.request({
+        method: 'GET',
+        path,
+      });
+      if (!response.success) {
+        throw new HttpException(response.msg, HttpStatus.BAD_REQUEST);
+      }
+      const responseData = convertKeysToCamelCase(response.result);
+      const actions = responseData.actions.map((action) => {
+        return {
+          ...action,
+        };
+      });
+
+      for (const action of actions) {
+        if (action.actionExecutor === 'device_issue') {
+          const device = await this.deviceService.getDeviceByDeviceTuyaUuid(
+            action.entityId,
+          );
+
+          if (device) {
+            action.entityId = device.uuid;
+          }
+        }
+      }
+
+      return {
+        id: responseData.id,
+        name: responseData.name,
+        status: responseData.status,
+        type: 'tap_to_run',
+        actions: actions,
+        ...(withSpaceId && { spaceId: responseData.spaceId }),
+      };
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException('Scene not found', HttpStatus.NOT_FOUND);
+      }
+    }
+  }
+  async updateTapToRunScene(
+    updateSceneTapToRunDto: UpdateSceneTapToRunDto,
+    sceneId: string,
+  ) {
+    try {
+      const spaceTuyaId = await this.getTapToRunSceneDetails(sceneId, true);
+      if (!spaceTuyaId.spaceId) {
+        throw new HttpException("Scene doesn't exist", HttpStatus.NOT_FOUND);
+      }
+      const addSceneTapToRunDto: AddAutomationDto = {
+        ...updateSceneTapToRunDto,
+        unitUuid: null,
+      };
+      const newTapToRunScene = await this.addAutomation(
+        addSceneTapToRunDto,
+        spaceTuyaId.spaceId,
+      );
+      if (newTapToRunScene.id) {
+        await this.deleteTapToRunScene(null, sceneId, spaceTuyaId.spaceId);
+        return newTapToRunScene;
+      }
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException(
+          err.message || 'Scene not found',
+          err.status || HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+}