merged dev

src/app.module.ts

@@ -20,6 +20,9 @@ import { SceneModule } from './scene/scene.module';
 import { DoorLockModule } from './door-lock/door.lock.module';
 import { APP_INTERCEPTOR } from '@nestjs/core';
 import { LoggingInterceptor } from './interceptors/logging.interceptor';
+import { AutomationModule } from './automation/automation.module';
+import { RegionModule } from './region/region.module';
+import { TimeZoneModule } from './timezone/timezone.module';
 @Module({
   imports: [
     ConfigModule.forRoot({
@@ -41,8 +44,10 @@ import { LoggingInterceptor } from './interceptors/logging.interceptor';
     UserNotificationModule,
     SeederModule,
     SceneModule,
+    AutomationModule,
     DoorLockModule,
-    //
+    RegionModule,
+    TimeZoneModule,
   ],
   controllers: [AuthenticationController],
   providers: [

src/auth/controllers/authentication.controller.ts

@@ -9,7 +9,7 @@ import { ApiTags } from '@nestjs/swagger';
 @ApiTags('Tuya Auth')
 export class AuthenticationController {
   constructor(private readonly authenticationService: AuthenticationService) {}
-  @Post('auth')
+  @Post('auth2')
   async Authentication() {
     return await this.authenticationService.main();
   }

src/auth/dtos/user-auth.dto.ts

@@ -1,5 +1,6 @@
 import { ApiProperty } from '@nestjs/swagger';
 import { IsEmail, IsNotEmpty, IsString } from 'class-validator';
+import { IsPasswordStrong } from 'src/validators/password.validator';
 
 export class UserSignUpDto {
   @ApiProperty({
@@ -16,6 +17,10 @@ export class UserSignUpDto {
   })
   @IsString()
   @IsNotEmpty()
+  @IsPasswordStrong({
+    message:
+      'password must be at least 8 characters long and include at least one uppercase letter, one lowercase letter, one numeric digit, and one special character.',
+  })
   public password: string;
 
   @ApiProperty({

src/auth/dtos/user-password.dto.ts

@@ -1,14 +1,25 @@
 import { ApiProperty } from '@nestjs/swagger';
 import { IsEmail, IsNotEmpty, IsString } from 'class-validator';
+import { IsPasswordStrong } from 'src/validators/password.validator';
 
 export class ForgetPasswordDto {
-  @ApiProperty()
+  @ApiProperty({
+    description: 'email',
+    required: true,
+  })
   @IsEmail()
   @IsNotEmpty()
-  email: string;
+  public email: string;
 
-  @ApiProperty()
+  @ApiProperty({
+    description: 'password',
+    required: true,
+  })
   @IsString()
   @IsNotEmpty()
-  password: string;
+  @IsPasswordStrong({
+    message:
+      'password must be at least 8 characters long and include at least one uppercase letter, one lowercase letter, one numeric digit, and one special character.',
+  })
+  public password: string;
 }

src/automation/automation.module.ts

@@ -0,0 +1,23 @@
+import { Module } from '@nestjs/common';
+import { AutomationService } from './services/automation.service';
+import { AutomationController } from './controllers/automation.controller';
+import { ConfigModule } from '@nestjs/config';
+import { SpaceRepositoryModule } from '@app/common/modules/space/space.repository.module';
+import { SpaceRepository } from '@app/common/modules/space/repositories';
+import { DeviceService } from 'src/device/services';
+import { DeviceRepository } from '@app/common/modules/device/repositories';
+import { ProductRepository } from '@app/common/modules/product/repositories';
+
+@Module({
+  imports: [ConfigModule, SpaceRepositoryModule],
+  controllers: [AutomationController],
+  providers: [
+    AutomationService,
+    SpaceRepository,
+    DeviceService,
+    DeviceRepository,
+    ProductRepository,
+  ],
+  exports: [AutomationService],
+})
+export class AutomationModule {}

src/automation/controllers/automation.controller.ts

@@ -0,0 +1,150 @@
+import { AutomationService } from '../services/automation.service';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpException,
+  HttpStatus,
+  Param,
+  Post,
+  Put,
+  UseGuards,
+} from '@nestjs/common';
+import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
+import {
+  AddAutomationDto,
+  UpdateAutomationDto,
+  UpdateAutomationStatusDto,
+} from '../dtos/automation.dto';
+import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
+
+@ApiTags('Automation Module')
+@Controller({
+  version: '1',
+  path: 'automation',
+})
+export class AutomationController {
+  constructor(private readonly automationService: AutomationService) {}
+
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Post()
+  async addAutomation(@Body() addAutomationDto: AddAutomationDto) {
+    try {
+      const automation =
+        await this.automationService.addAutomation(addAutomationDto);
+      return {
+        statusCode: HttpStatus.CREATED,
+        success: true,
+        message: 'Automation added successfully',
+        data: automation,
+      };
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Get(':unitUuid')
+  async getAutomationByUnit(@Param('unitUuid') unitUuid: string) {
+    try {
+      const automation =
+        await this.automationService.getAutomationByUnit(unitUuid);
+      return automation;
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Get('details/:automationId')
+  async getAutomationDetails(@Param('automationId') automationId: string) {
+    try {
+      const automation =
+        await this.automationService.getAutomationDetails(automationId);
+      return automation;
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+      ``;
+    }
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Delete(':unitUuid/:automationId')
+  async deleteAutomation(
+    @Param('unitUuid') unitUuid: string,
+    @Param('automationId') automationId: string,
+  ) {
+    try {
+      await this.automationService.deleteAutomation(unitUuid, automationId);
+      return {
+        statusCode: HttpStatus.OK,
+        message: 'Automation Deleted Successfully',
+      };
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Put(':automationId')
+  async updateAutomation(
+    @Body() updateAutomationDto: UpdateAutomationDto,
+    @Param('automationId') automationId: string,
+  ) {
+    try {
+      const automation = await this.automationService.updateAutomation(
+        updateAutomationDto,
+        automationId,
+      );
+      return {
+        statusCode: HttpStatus.CREATED,
+        success: true,
+        message: 'Automation updated successfully',
+        data: automation,
+      };
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Put('status/:automationId')
+  async updateAutomationStatus(
+    @Body() updateAutomationStatusDto: UpdateAutomationStatusDto,
+    @Param('automationId') automationId: string,
+  ) {
+    try {
+      await this.automationService.updateAutomationStatus(
+        updateAutomationStatusDto,
+        automationId,
+      );
+      return {
+        statusCode: HttpStatus.CREATED,
+        success: true,
+        message: 'Automation status updated successfully',
+      };
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+}

src/automation/controllers/index.ts

@@ -0,0 +1 @@
+export * from './automation.controller';

src/automation/dtos/automation.dto.ts

@@ -0,0 +1,213 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsNotEmpty,
+  IsString,
+  IsArray,
+  ValidateNested,
+  IsOptional,
+  IsNumber,
+  IsBoolean,
+} from 'class-validator';
+import { Type } from 'class-transformer';
+
+class EffectiveTime {
+  @ApiProperty({ description: 'Start time', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public start: string;
+
+  @ApiProperty({ description: 'End time', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public end: string;
+
+  @ApiProperty({ description: 'Loops', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public loops: string;
+}
+
+class Expr {
+  @ApiProperty({ description: 'Status code', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public statusCode: string;
+
+  @ApiProperty({ description: 'Comparator', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public comparator: string;
+
+  @ApiProperty({ description: 'Status value', required: true })
+  @IsNotEmpty()
+  public statusValue: any;
+}
+
+class Condition {
+  @ApiProperty({ description: 'Condition code', required: true })
+  @IsNumber()
+  @IsNotEmpty()
+  public code: number;
+
+  @ApiProperty({ description: 'Entity ID', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public entityId: string;
+
+  @ApiProperty({ description: 'Entity type', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public entityType: string;
+
+  @ApiProperty({ description: 'Expression', required: true, type: Expr })
+  @ValidateNested()
+  @Type(() => Expr)
+  @IsNotEmpty()
+  public expr: Expr;
+}
+
+class ExecutorProperty {
+  @ApiProperty({
+    description: 'Function code (for device issue action)',
+    required: false,
+  })
+  @IsString()
+  @IsOptional()
+  public functionCode?: string;
+
+  @ApiProperty({
+    description: 'Function value (for device issue action)',
+    required: false,
+  })
+  @IsOptional()
+  public functionValue?: any;
+
+  @ApiProperty({
+    description: 'Delay in seconds (for delay action)',
+    required: false,
+  })
+  @IsNumber()
+  @IsOptional()
+  public delaySeconds?: number;
+}
+
+class Action {
+  @ApiProperty({ description: 'Entity ID', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public entityId: string;
+
+  @ApiProperty({ description: 'Action executor', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public actionExecutor: string;
+
+  @ApiProperty({
+    description: 'Executor property',
+    required: false,
+    type: ExecutorProperty,
+  })
+  @ValidateNested()
+  @Type(() => ExecutorProperty)
+  @IsOptional()
+  public executorProperty?: ExecutorProperty;
+}
+
+export class AddAutomationDto {
+  @ApiProperty({ description: 'Unit ID', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public unitUuid: string;
+
+  @ApiProperty({ description: 'Automation name', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public automationName: string;
+
+  @ApiProperty({ description: 'Decision expression', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public decisionExpr: string;
+
+  @ApiProperty({
+    description: 'Effective time',
+    required: true,
+    type: EffectiveTime,
+  })
+  @ValidateNested()
+  @Type(() => EffectiveTime)
+  @IsNotEmpty()
+  public effectiveTime: EffectiveTime;
+
+  @ApiProperty({ description: 'Conditions', required: true, type: [Condition] })
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => Condition)
+  @IsNotEmpty()
+  public conditions: Condition[];
+
+  @ApiProperty({ description: 'Actions', required: true, type: [Action] })
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => Action)
+  @IsNotEmpty()
+  public actions: Action[];
+
+  constructor(dto: Partial<AddAutomationDto>) {
+    Object.assign(this, dto);
+  }
+}
+
+export class UpdateAutomationDto {
+  @ApiProperty({ description: 'Automation name', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public automationName: string;
+
+  @ApiProperty({ description: 'Decision expression', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public decisionExpr: string;
+
+  @ApiProperty({
+    description: 'Effective time',
+    required: true,
+    type: EffectiveTime,
+  })
+  @ValidateNested()
+  @Type(() => EffectiveTime)
+  @IsNotEmpty()
+  public effectiveTime: EffectiveTime;
+
+  @ApiProperty({ description: 'Conditions', required: true, type: [Condition] })
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => Condition)
+  @IsNotEmpty()
+  public conditions: Condition[];
+
+  @ApiProperty({ description: 'Actions', required: true, type: [Action] })
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => Action)
+  @IsNotEmpty()
+  public actions: Action[];
+  constructor(dto: Partial<UpdateAutomationDto>) {
+    Object.assign(this, dto);
+  }
+}
+export class UpdateAutomationStatusDto {
+  @ApiProperty({ description: 'Unit uuid', required: true })
+  @IsString()
+  @IsNotEmpty()
+  public unitUuid: string;
+
+  @ApiProperty({ description: 'Is enable', required: true })
+  @IsBoolean()
+  @IsNotEmpty()
+  public isEnable: boolean;
+
+  constructor(dto: Partial<UpdateAutomationStatusDto>) {
+    Object.assign(this, dto);
+  }
+}

src/automation/dtos/index.ts

@@ -0,0 +1 @@
+export * from './automation.dto';

src/automation/interface/automation.interface.ts

@@ -0,0 +1,50 @@
+export interface AddAutomationInterface {
+  success: boolean;
+  msg?: string;
+  result: {
+    id: string;
+  };
+}
+export interface GetAutomationByUnitInterface {
+  success: boolean;
+  msg?: string;
+  result: {
+    list: Array<{
+      id: string;
+      name: string;
+      status: string;
+    }>;
+  };
+}
+export interface DeleteAutomationInterface {
+  success: boolean;
+  msg?: string;
+  result: boolean;
+}
+export interface Action {
+  actionExecutor: string;
+  entityId: string;
+  [key: string]: any; // Allow additional properties
+}
+
+export interface Condition {
+  entityType: string;
+  entityId: string;
+  [key: string]: any; // Allow additional properties
+}
+
+export interface AutomationResponseData {
+  id: string;
+  name: string;
+  status: string;
+  spaceId?: string;
+  runningMode?: string;
+  actions: Action[];
+  conditions: Condition[];
+  [key: string]: any; // Allow additional properties
+}
+export interface AutomationDetailsResult {
+  id: string;
+  name: string;
+  type: string;
+}

src/automation/services/automation.service.ts

@@ -0,0 +1,423 @@
+import {
+  Injectable,
+  HttpException,
+  HttpStatus,
+  BadRequestException,
+} from '@nestjs/common';
+import { SpaceRepository } from '@app/common/modules/space/repositories';
+import {
+  AddAutomationDto,
+  UpdateAutomationDto,
+  UpdateAutomationStatusDto,
+} 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 {
+  AddAutomationInterface,
+  AutomationDetailsResult,
+  AutomationResponseData,
+  DeleteAutomationInterface,
+  GetAutomationByUnitInterface,
+} 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) =>
+        convertKeysToSnakeCase(action),
+      );
+      const conditions = addAutomationDto.conditions.map((condition) =>
+        convertKeysToSnakeCase(condition),
+      );
+
+      for (const action of actions) {
+        if (action.action_executor === 'device_issue') {
+          const device = await this.deviceService.getDeviceByDeviceUuid(
+            action.entity_id,
+            false,
+          );
+          if (device) {
+            action.entity_id = device.deviceTuyaUuid;
+          }
+        }
+      }
+
+      for (const condition of conditions) {
+        if (condition.entity_type === 'device_report') {
+          const device = await this.deviceService.getDeviceByDeviceUuid(
+            condition.entity_id,
+            false,
+          );
+          if (device) {
+            condition.entity_id = device.deviceTuyaUuid;
+          }
+        }
+      }
+
+      const path = `/v2.0/cloud/scene/rule`;
+      const response: AddAutomationInterface = await this.tuya.request({
+        method: 'POST',
+        path,
+        body: {
+          space_id: unitSpaceTuyaId,
+          name: addAutomationDto.automationName,
+          effective_time: {
+            ...addAutomationDto.effectiveTime,
+            timezone_id: 'Asia/Dubai',
+          },
+          type: 'automation',
+          decision_expr: addAutomationDto.decisionExpr,
+          conditions: conditions,
+          actions: actions,
+        },
+      });
+      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 || 'Automation 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 getAutomationByUnit(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=automation`;
+      const response: GetAutomationByUnitInterface = 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: 'automation',
+        };
+      });
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException(
+          err.message || 'Automation not found',
+          err.status || HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+  async getTapToRunSceneDetailsTuya(
+    sceneId: string,
+  ): Promise<AutomationDetailsResult> {
+    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 camelCaseResponse = convertKeysToCamelCase(response);
+      const { id, name, type } = camelCaseResponse.result;
+
+      return {
+        id,
+        name,
+        type,
+      } as AutomationDetailsResult;
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException(
+          'Scene not found for Tuya',
+          HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+  async getAutomationDetails(automationId: string, withSpaceId = false) {
+    try {
+      const path = `/v2.0/cloud/scene/rule/${automationId}`;
+      const response = await this.tuya.request({
+        method: 'GET',
+        path,
+      });
+
+      if (!response.success) {
+        throw new HttpException(response.msg, HttpStatus.BAD_REQUEST);
+      }
+
+      const responseData: AutomationResponseData = convertKeysToCamelCase(
+        response.result,
+      );
+
+      const actions = responseData.actions.map((action) => ({
+        ...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;
+          }
+        } else if (
+          action.actionExecutor !== 'device_issue' &&
+          action.actionExecutor !== 'delay'
+        ) {
+          const sceneDetails = await this.getTapToRunSceneDetailsTuya(
+            action.entityId,
+          );
+
+          if (sceneDetails.id) {
+            action.name = sceneDetails.name;
+            action.type = sceneDetails.type;
+          }
+        }
+      }
+
+      const conditions = responseData.conditions.map((condition) => ({
+        ...condition,
+      }));
+
+      for (const condition of conditions) {
+        if (condition.entityType === 'device_report') {
+          const device = await this.deviceService.getDeviceByDeviceTuyaUuid(
+            condition.entityId,
+          );
+
+          if (device) {
+            condition.entityId = device.uuid;
+          }
+        }
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { timeZoneId, ...effectiveTimeWithoutTimeZoneId } =
+        responseData.effectiveTime || {};
+
+      return {
+        id: responseData.id,
+        name: responseData.name,
+        status: responseData.status,
+        type: 'automation',
+        ...(() => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          const { spaceId, runningMode, ...rest } = responseData;
+          return rest;
+        })(),
+        actions,
+        conditions,
+        effectiveTime: effectiveTimeWithoutTimeZoneId, // Use modified effectiveTime
+        ...(withSpaceId && { spaceId: responseData.spaceId }),
+      };
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException('Automation not found', HttpStatus.NOT_FOUND);
+      }
+    }
+  }
+
+  async deleteAutomation(
+    unitUuid: string,
+    automationId: 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=${automationId}&space_id=${unitSpaceTuyaId}`;
+      const response: DeleteAutomationInterface = await this.tuya.request({
+        method: 'DELETE',
+        path,
+      });
+
+      if (!response.success) {
+        throw new HttpException('Automation not found', HttpStatus.NOT_FOUND);
+      }
+
+      return response;
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException(
+          err.message || 'Automation not found',
+          err.status || HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+
+  async updateAutomation(
+    updateAutomationDto: UpdateAutomationDto,
+    automationId: string,
+  ) {
+    try {
+      const spaceTuyaId = await this.getAutomationDetails(automationId, true);
+      if (!spaceTuyaId.spaceId) {
+        throw new HttpException(
+          "Automation doesn't exist",
+          HttpStatus.NOT_FOUND,
+        );
+      }
+      const addAutomation = {
+        ...updateAutomationDto,
+        unitUuid: null,
+      };
+      const newAutomation = await this.addAutomation(
+        addAutomation,
+        spaceTuyaId.spaceId,
+      );
+      if (newAutomation.id) {
+        await this.deleteAutomation(null, automationId, spaceTuyaId.spaceId);
+        return newAutomation;
+      }
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException(
+          err.message || 'Automation not found',
+          err.status || HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+  async updateAutomationStatus(
+    updateAutomationStatusDto: UpdateAutomationStatusDto,
+    automationId: string,
+  ) {
+    try {
+      const unitDetails = await this.getUnitByUuid(
+        updateAutomationStatusDto.unitUuid,
+      );
+      if (!unitDetails.spaceTuyaUuid) {
+        throw new BadRequestException('Invalid unit UUID');
+      }
+
+      const path = `/v2.0/cloud/scene/rule/state?space_id=${unitDetails.spaceTuyaUuid}`;
+      const response: DeleteAutomationInterface = await this.tuya.request({
+        method: 'PUT',
+        path,
+        body: {
+          ids: automationId,
+          is_enable: updateAutomationStatusDto.isEnable,
+        },
+      });
+
+      if (!response.success) {
+        throw new HttpException('Automation not found', HttpStatus.NOT_FOUND);
+      }
+
+      return response;
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException(
+          err.message || 'Automation not found',
+          err.status || HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+}

src/automation/services/index.ts

@@ -0,0 +1 @@
+export * from './automation.service';

src/device/services/device.service.ts

@@ -197,8 +197,15 @@ export class DeviceService {
         where: {
           uuid: updateDeviceInRoomDto.deviceUuid,
         },
-        relations: ['spaceDevice'],
+        relations: ['spaceDevice', 'spaceDevice.parent'],
       });
+      if (device.spaceDevice.parent.spaceTuyaUuid) {
+        await this.transferDeviceInSpacesTuya(
+          device.deviceTuyaUuid,
+          device.spaceDevice.parent.spaceTuyaUuid,
+        );
+      }
+
       return {
         uuid: device.uuid,
         roomUuid: device.spaceDevice.uuid,
@@ -210,7 +217,26 @@ export class DeviceService {
       );
     }
   }
+  async transferDeviceInSpacesTuya(
+    deviceId: string,
+    spaceId: string,
+  ): Promise<controlDeviceInterface> {
+    try {
+      const path = `/v2.0/cloud/thing/${deviceId}/transfer`;
+      const response = await this.tuya.request({
+        method: 'POST',
+        path,
+        body: { space_id: spaceId },
+      });
 
+      return response as controlDeviceInterface;
+    } catch (error) {
+      throw new HttpException(
+        'Error transferring device in spaces from Tuya',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
   async controlDevice(controlDeviceDto: ControlDeviceDto, deviceUuid: string) {
     try {
       const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid, false);

src/door-lock/controllers/door.lock.controller.ts

@@ -9,11 +9,13 @@ import {
   Get,
   Delete,
   UseGuards,
+  Put,
 } from '@nestjs/common';
 import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
 import { AddDoorLockOnlineDto } from '../dtos/add.online-temp.dto';
-import { AddDoorLockOfflineTempDto } from '../dtos/add.offline-temp.dto';
+import { AddDoorLockOfflineTempMultipleTimeDto } from '../dtos/add.offline-temp.dto';
 import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
+import { UpdateDoorLockOfflineTempDto } from '../dtos/update.offline-temp.dto';
 
 @ApiTags('Door Lock Module')
 @Controller({
@@ -55,13 +57,11 @@ export class DoorLockController {
   @UseGuards(JwtAuthGuard)
   @Post('temporary-password/offline/one-time/:doorLockUuid')
   async addOfflineOneTimeTemporaryPassword(
-    @Body() addDoorLockOfflineTempDto: AddDoorLockOfflineTempDto,
     @Param('doorLockUuid') doorLockUuid: string,
   ) {
     try {
       const temporaryPassword =
         await this.doorLockService.addOfflineOneTimeTemporaryPassword(
-          addDoorLockOfflineTempDto,
           doorLockUuid,
         );
 
@@ -82,13 +82,14 @@ export class DoorLockController {
   @UseGuards(JwtAuthGuard)
   @Post('temporary-password/offline/multiple-time/:doorLockUuid')
   async addOfflineMultipleTimeTemporaryPassword(
-    @Body() addDoorLockOfflineTempDto: AddDoorLockOfflineTempDto,
+    @Body()
+    addDoorLockOfflineTempMultipleTimeDto: AddDoorLockOfflineTempMultipleTimeDto,
     @Param('doorLockUuid') doorLockUuid: string,
   ) {
     try {
       const temporaryPassword =
         await this.doorLockService.addOfflineMultipleTimeTemporaryPassword(
-          addDoorLockOfflineTempDto,
+          addDoorLockOfflineTempMultipleTimeDto,
           doorLockUuid,
         );
 
@@ -124,6 +125,29 @@ export class DoorLockController {
   }
   @ApiBearerAuth()
   @UseGuards(JwtAuthGuard)
+  @Delete('temporary-password/online/:doorLockUuid/:passwordId')
+  async deleteDoorLockPassword(
+    @Param('doorLockUuid') doorLockUuid: string,
+    @Param('passwordId') passwordId: string,
+  ) {
+    try {
+      await this.doorLockService.deleteDoorLockPassword(
+        doorLockUuid,
+        passwordId,
+      );
+      return {
+        statusCode: HttpStatus.OK,
+        message: 'Temporary Password deleted Successfully',
+      };
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
   @Get('temporary-password/offline/one-time/:doorLockUuid')
   async getOfflineOneTimeTemporaryPasswords(
     @Param('doorLockUuid') doorLockUuid: string,
@@ -156,21 +180,29 @@ export class DoorLockController {
       );
     }
   }
+
   @ApiBearerAuth()
   @UseGuards(JwtAuthGuard)
-  @Delete('temporary-password/:doorLockUuid/:passwordId')
-  async deleteDoorLockPassword(
+  @Put('temporary-password/:doorLockUuid/offline/:passwordId')
+  async updateOfflineTemporaryPassword(
+    @Body()
+    updateDoorLockOfflineTempDto: UpdateDoorLockOfflineTempDto,
     @Param('doorLockUuid') doorLockUuid: string,
     @Param('passwordId') passwordId: string,
   ) {
     try {
-      await this.doorLockService.deleteDoorLockPassword(
-        doorLockUuid,
-        passwordId,
-      );
+      const temporaryPassword =
+        await this.doorLockService.updateOfflineTemporaryPassword(
+          updateDoorLockOfflineTempDto,
+          doorLockUuid,
+          passwordId,
+        );
+
       return {
-        statusCode: HttpStatus.OK,
-        message: 'Temporary Password deleted Successfully',
+        statusCode: HttpStatus.CREATED,
+        success: true,
+        message: 'offline temporary password updated successfully',
+        data: temporaryPassword,
       };
     } catch (error) {
       throw new HttpException(

src/door-lock/dtos/add.offline-temp.dto.ts

@@ -1,23 +1,7 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { IsNotEmpty, IsString, Length } from 'class-validator';
-
-export class AddDoorLockOfflineTempDto {
-  @ApiProperty({
-    description: 'name',
-    required: true,
-  })
-  @IsString()
-  @IsNotEmpty()
-  public name: string;
-  @ApiProperty({
-    description: 'password',
-    required: true,
-  })
-  @IsString()
-  @IsNotEmpty()
-  @Length(7, 7)
-  public password: string;
+import { IsNotEmpty, IsString } from 'class-validator';
 
+export class AddDoorLockOfflineTempMultipleTimeDto {
   @ApiProperty({
     description: 'effectiveTime',
     required: true,

src/door-lock/dtos/update.offline-temp.dto.ts

@@ -0,0 +1,12 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class UpdateDoorLockOfflineTempDto {
+  @ApiProperty({
+    description: 'name',
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  public name: string;
+}

src/door-lock/interfaces/door.lock.interface.ts

@@ -55,3 +55,10 @@ export interface deleteTemporaryPasswordInterface {
   result: boolean;
   msg?: string;
 }
+export interface getPasswordOfflineInterface {
+  success: boolean;
+  result: {
+    records: [];
+  };
+  msg?: string;
+}

src/door-lock/services/door.lock.service.ts

@@ -7,13 +7,15 @@ import {
   createTickInterface,
   deleteTemporaryPasswordInterface,
   getPasswordInterface,
+  getPasswordOfflineInterface,
 } from '../interfaces/door.lock.interface';
 import { DeviceRepository } from '@app/common/modules/device/repositories';
 import { ProductType } from '@app/common/constants/product-type.enum';
 
 import { PasswordEncryptionService } from './encryption.services';
-import { AddDoorLockOfflineTempDto } from '../dtos/add.offline-temp.dto';
+import { AddDoorLockOfflineTempMultipleTimeDto } from '../dtos/add.offline-temp.dto';
 import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
+import { UpdateDoorLockOfflineTempDto } from '../dtos/update.offline-temp.dto';
 
 @Injectable()
 export class DoorLockService {
@@ -93,18 +95,13 @@ export class DoorLockService {
           HttpStatus.BAD_REQUEST,
         );
       }
-      const passwords = await this.getTemporaryPasswordsTuya(
+      const passwords = await this.getTemporaryOfflinePasswordsTuya(
         deviceDetails.deviceTuyaUuid,
+        'multiple',
       );
 
-      if (passwords.result.length > 0) {
-        const passwordFiltered = passwords.result.filter(
-          (item) =>
-            (!item.schedule_list || item.schedule_list.length === 0) &&
-            item.type === 0,
-        );
-
-        return convertKeysToCamelCase(passwordFiltered);
+      if (passwords.result.records.length > 0) {
+        return convertKeysToCamelCase(passwords.result.records);
       }
 
       return passwords;
@@ -128,18 +125,13 @@ export class DoorLockService {
           HttpStatus.BAD_REQUEST,
         );
       }
-      const passwords = await this.getTemporaryPasswordsTuya(
+      const passwords = await this.getTemporaryOfflinePasswordsTuya(
         deviceDetails.deviceTuyaUuid,
+        'once',
       );
 
-      if (passwords.result.length > 0) {
-        const passwordFiltered = passwords.result.filter(
-          (item) =>
-            (!item.schedule_list || item.schedule_list.length === 0) &&
-            item.type === 0, //temp solution
-        );
-
-        return convertKeysToCamelCase(passwordFiltered);
+      if (passwords.result.records.length > 0) {
+        return convertKeysToCamelCase(passwords.result.records);
       }
 
       return passwords;
@@ -162,13 +154,13 @@ export class DoorLockService {
           HttpStatus.BAD_REQUEST,
         );
       }
-      const passwords = await this.getTemporaryPasswordsTuya(
+      const passwords = await this.getOnlineTemporaryPasswordsTuya(
         deviceDetails.deviceTuyaUuid,
       );
 
       if (passwords.result.length > 0) {
         const passwordFiltered = passwords.result
-          .filter((item) => item.type === 0) //temp solution
+          .filter((item) => item.type === 0)
           .map((password: any) => {
             if (password.schedule_list?.length > 0) {
               password.schedule_list = password.schedule_list.map(
@@ -200,7 +192,7 @@ export class DoorLockService {
       );
     }
   }
-  async getTemporaryPasswordsTuya(
+  async getOnlineTemporaryPasswordsTuya(
     doorLockUuid: string,
   ): Promise<getPasswordInterface> {
     try {
@@ -219,25 +211,45 @@ export class DoorLockService {
       );
     }
   }
+  async getTemporaryOfflinePasswordsTuya(
+    doorLockUuid: string,
+    type: string,
+  ): Promise<getPasswordOfflineInterface> {
+    try {
+      const path = `/v1.0/devices/${doorLockUuid}/door-lock/offline-temp-password?pwd_type_codes=${type}&target_status=EFFECTIVE&page_no=1&page_size=100`;
+
+      const response = await this.tuya.request({
+        method: 'GET',
+        path,
+      });
+
+      return response as getPasswordOfflineInterface;
+    } catch (error) {
+      throw new HttpException(
+        'Error getting offline temporary passwords from Tuya',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
   async addOfflineMultipleTimeTemporaryPassword(
-    addDoorLockOfflineTempDto: AddDoorLockOfflineTempDto,
+    addDoorLockOfflineTempMultipleTimeDto: AddDoorLockOfflineTempMultipleTimeDto,
     doorLockUuid: string,
   ) {
     try {
-      const createOnlinePass = await this.addOnlineTemporaryPassword(
-        addDoorLockOfflineTempDto,
-        doorLockUuid,
-        'multiple',
-        false,
-      );
-      if (!createOnlinePass) {
+      const deviceDetails = await this.getDeviceByDeviceUuid(doorLockUuid);
+
+      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
         throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
+      } else if (deviceDetails.productDevice.prodType !== ProductType.DL) {
+        throw new HttpException(
+          'This is not a door lock device',
+          HttpStatus.BAD_REQUEST,
+        );
       }
       const createOnceOfflinePass = await this.addOfflineTemporaryPasswordTuya(
-        addDoorLockOfflineTempDto,
-        createOnlinePass.id,
-        createOnlinePass.deviceTuyaUuid,
+        deviceDetails.deviceTuyaUuid,
         'multiple',
+        addDoorLockOfflineTempMultipleTimeDto,
       );
       if (!createOnceOfflinePass.success) {
         throw new HttpException(
@@ -255,25 +267,22 @@ export class DoorLockService {
       );
     }
   }
-  async addOfflineOneTimeTemporaryPassword(
-    addDoorLockOfflineTempDto: AddDoorLockOfflineTempDto,
-    doorLockUuid: string,
-  ) {
+  async addOfflineOneTimeTemporaryPassword(doorLockUuid: string) {
     try {
-      const createOnlinePass = await this.addOnlineTemporaryPassword(
-        addDoorLockOfflineTempDto,
-        doorLockUuid,
-        'once',
-        false,
-      );
-      if (!createOnlinePass) {
+      const deviceDetails = await this.getDeviceByDeviceUuid(doorLockUuid);
+
+      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
         throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
+      } else if (deviceDetails.productDevice.prodType !== ProductType.DL) {
+        throw new HttpException(
+          'This is not a door lock device',
+          HttpStatus.BAD_REQUEST,
+        );
       }
       const createOnceOfflinePass = await this.addOfflineTemporaryPasswordTuya(
-        addDoorLockOfflineTempDto,
-        createOnlinePass.id,
-        createOnlinePass.deviceTuyaUuid,
+        deviceDetails.deviceTuyaUuid,
         'once',
+        null,
       );
       if (!createOnceOfflinePass.success) {
         throw new HttpException(
@@ -292,10 +301,9 @@ export class DoorLockService {
     }
   }
   async addOfflineTemporaryPasswordTuya(
-    addDoorLockDto: AddDoorLockOnlineInterface,
-    onlinePassId: number,
     doorLockUuid: string,
     type: string,
+    addDoorLockOfflineTempMultipleTimeDto: AddDoorLockOfflineTempMultipleTimeDto,
   ): Promise<createTickInterface> {
     try {
       const path = `/v1.1/devices/${doorLockUuid}/door-lock/offline-temp-password`;
@@ -304,14 +312,12 @@ export class DoorLockService {
         method: 'POST',
         path,
         body: {
-          name: addDoorLockDto.name,
           ...(type === 'multiple' && {
-            effective_time: addDoorLockDto.effectiveTime,
-            invalid_time: addDoorLockDto.invalidTime,
+            effective_time: addDoorLockOfflineTempMultipleTimeDto.effectiveTime,
+            invalid_time: addDoorLockOfflineTempMultipleTimeDto.invalidTime,
           }),
 
           type,
-          password_id: onlinePassId,
         },
       });
 
@@ -326,8 +332,6 @@ export class DoorLockService {
   async addOnlineTemporaryPassword(
     addDoorLockDto: AddDoorLockOnlineInterface,
     doorLockUuid: string,
-    type: string = 'once',
-    isOnline: boolean = true,
   ) {
     try {
       const passwordData = await this.getTicketAndEncryptedPassword(
@@ -348,8 +352,6 @@ export class DoorLockService {
       const createPass = await this.addOnlineTemporaryPasswordTuya(
         addDeviceObj,
         passwordData.deviceTuyaUuid,
-        type,
-        addDeviceObj.scheduleList ? isOnline : false,
       );
 
       if (!createPass.success) {
@@ -429,13 +431,11 @@ export class DoorLockService {
   async addOnlineTemporaryPasswordTuya(
     addDeviceObj: addDeviceObjectInterface,
     doorLockUuid: string,
-    type: string,
-    isOnline: boolean = true,
   ): Promise<createTickInterface> {
     try {
       const path = `/v1.0/devices/${doorLockUuid}/door-lock/temp-password`;
       let scheduleList;
-      if (isOnline) {
+      if (addDeviceObj.scheduleList.length > 0) {
         scheduleList = addDeviceObj.scheduleList.map((schedule) => ({
           effective_time: this.timeToMinutes(schedule.effectiveTime),
           invalid_time: this.timeToMinutes(schedule.invalidTime),
@@ -453,11 +453,11 @@ export class DoorLockService {
           invalid_time: addDeviceObj.invalidTime,
           password_type: 'ticket',
           ticket_id: addDeviceObj.ticketId,
-          ...(isOnline && {
+          ...(addDeviceObj.scheduleList.length > 0 && {
             schedule_list: scheduleList,
           }),
 
-          type: '0', //temporary solution,
+          type: '0',
         },
       });
 
@@ -579,4 +579,64 @@ export class DoorLockService {
       throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
     }
   }
+
+  async updateOfflineTemporaryPassword(
+    updateDoorLockOfflineTempDto: UpdateDoorLockOfflineTempDto,
+    doorLockUuid: string,
+    passwordId: string,
+  ) {
+    try {
+      const deviceDetails = await this.getDeviceByDeviceUuid(doorLockUuid);
+
+      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
+        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
+      } else if (deviceDetails.productDevice.prodType !== ProductType.DL) {
+        throw new HttpException(
+          'This is not a door lock device',
+          HttpStatus.BAD_REQUEST,
+        );
+      }
+      const updateOfflinePass = await this.updateOfflineTemporaryPasswordTuya(
+        deviceDetails.deviceTuyaUuid,
+        updateDoorLockOfflineTempDto,
+        passwordId,
+      );
+      if (!updateOfflinePass.success) {
+        throw new HttpException(updateOfflinePass.msg, HttpStatus.BAD_REQUEST);
+      }
+      return {
+        result: updateOfflinePass.result,
+      };
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Error updating offline temporary password from Tuya',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  async updateOfflineTemporaryPasswordTuya(
+    doorLockUuid: string,
+    updateDoorLockOfflineTempDto: UpdateDoorLockOfflineTempDto,
+    passwordId: string,
+  ): Promise<createTickInterface> {
+    try {
+      const path = `/v1.0/cloud/lock/${doorLockUuid}/door-lock/offline-temp-password/${passwordId}`;
+
+      const response = await this.tuya.request({
+        method: 'PUT',
+        path,
+        body: {
+          password_name: updateDoorLockOfflineTempDto.name,
+        },
+      });
+
+      return response as createTickInterface;
+    } catch (error) {
+      throw new HttpException(
+        'Error updating offline temporary password from Tuya',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
 }

src/guards/profile.picture.guard.ts

@@ -0,0 +1,45 @@
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+import { BadRequestException } from '@nestjs/common';
+
+@Injectable()
+export class CheckProfilePictureGuard implements CanActivate {
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const req = context.switchToHttp().getRequest();
+
+    try {
+      if (req.body) {
+        const { profilePicture } = req.body;
+        if (profilePicture) {
+          const isBase64 = /^data:image\/[a-z]+;base64,/.test(profilePicture);
+          if (!isBase64) {
+            throw new BadRequestException(
+              'Profile picture must be in base64 format.',
+            );
+          }
+
+          // Get the size of the base64 string (in bytes)
+          const base64StringLength =
+            profilePicture.length - 'data:image/[a-z]+;base64,'.length;
+          const base64ImageSizeInBytes = base64StringLength * 0.75; // Base64 encoding expands data by 33%
+          const maxSizeInBytes = 1 * 1024 * 1024; // 1 MB
+
+          // Check if the size exceeds the limit
+          if (base64ImageSizeInBytes > maxSizeInBytes) {
+            throw new BadRequestException(
+              'Profile picture size exceeds the allowed limit.',
+            );
+          }
+        }
+        // Check if profilePicture is a base64 string
+      } else {
+        throw new BadRequestException('Invalid request parameters');
+      }
+
+      return true;
+    } catch (error) {
+      console.log('Profile picture guard error: ', error);
+
+      throw error;
+    }
+  }
+}

src/main.ts

@@ -4,6 +4,7 @@ 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';
 
 async function bootstrap() {
@@ -11,6 +12,10 @@ async function bootstrap() {
 
   app.enableCors();
 
+  // Set the body parser limit to 1 MB
+  app.use(json({ limit: '1mb' }));
+  app.use(urlencoded({ limit: '1mb', extended: true }));
+
   app.use(
     rateLimit({
       windowMs: 5 * 60 * 1000,
@@ -42,7 +47,8 @@ async function bootstrap() {
   } catch (error) {
     console.error('Seeding failed!', error);
   }
+
+  console.log('Starting auth at port ...', process.env.PORT || 4000);
   await app.listen(process.env.PORT || 4000);
 }
-console.log('Starting auth at port ...', process.env.PORT || 4000);
 bootstrap();

src/region/controllers/index.ts

@@ -0,0 +1 @@
+export * from './region.controller';

src/region/controllers/region.controller.ts

@@ -0,0 +1,33 @@
+import {
+  Controller,
+  Get,
+  HttpException,
+  HttpStatus,
+  UseGuards,
+} from '@nestjs/common';
+import { RegionService } from '../services/region.service';
+import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
+import { JwtAuthGuard } from '../../../libs/common/src/guards/jwt.auth.guard';
+
+@ApiTags('Region Module')
+@Controller({
+  version: '1',
+  path: 'region',
+})
+export class RegionController {
+  constructor(private readonly regionService: RegionService) {}
+
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Get()
+  async getAllRegions() {
+    try {
+      return await this.regionService.getAllRegions();
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+}

src/region/region.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { RegionService } from './services/region.service';
+import { RegionController } from './controllers/region.controller';
+import { ConfigModule } from '@nestjs/config';
+import { RegionRepository } from '@app/common/modules/region/repositories';
+
+@Module({
+  imports: [ConfigModule],
+  controllers: [RegionController],
+  providers: [RegionService, RegionRepository],
+  exports: [RegionService],
+})
+export class RegionModule {}

src/region/services/index.ts

@@ -0,0 +1 @@
+export * from './region.service';

src/region/services/region.service.ts

@@ -0,0 +1,25 @@
+import {
+  BadRequestException,
+  HttpException,
+  HttpStatus,
+  Injectable,
+} from '@nestjs/common';
+import { RegionRepository } from '@app/common/modules/region/repositories';
+
+@Injectable()
+export class RegionService {
+  constructor(private readonly regionRepository: RegionRepository) {}
+  async getAllRegions() {
+    try {
+      const regions = await this.regionRepository.find();
+
+      return regions;
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException('Regions found', HttpStatus.NOT_FOUND);
+      }
+    }
+  }
+}

src/scene/interface/scene.interface.ts

@@ -21,3 +21,8 @@ export interface DeleteTapToRunSceneInterface {
   msg?: string;
   result: boolean;
 }
+export interface SceneDetailsResult {
+  id: string;
+  name: string;
+  type: string;
+}

src/scene/services/scene.service.ts

@@ -15,6 +15,7 @@ import {
   AddTapToRunSceneInterface,
   DeleteTapToRunSceneInterface,
   GetTapToRunSceneByUnitInterface,
+  SceneDetailsResult,
 } from '../interface/scene.interface';
 import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
 
@@ -256,6 +257,18 @@ export class SceneService {
           if (device) {
             action.entityId = device.uuid;
           }
+        } else if (
+          action.actionExecutor !== 'device_issue' &&
+          action.actionExecutor !== 'delay'
+        ) {
+          const sceneDetails = await this.getTapToRunSceneDetailsTuya(
+            action.entityId,
+          );
+
+          if (sceneDetails.id) {
+            action.name = sceneDetails.name;
+            action.type = sceneDetails.type;
+          }
         }
       }
 
@@ -275,6 +288,38 @@ export class SceneService {
       }
     }
   }
+  async getTapToRunSceneDetailsTuya(
+    sceneId: string,
+  ): Promise<SceneDetailsResult> {
+    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 camelCaseResponse = convertKeysToCamelCase(response);
+      const { id, name, type } = camelCaseResponse.result;
+
+      return {
+        id,
+        name,
+        type,
+      } as SceneDetailsResult;
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException(
+          'Scene not found for Tuya',
+          HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
   async updateTapToRunScene(
     updateSceneTapToRunDto: UpdateSceneTapToRunDto,
     sceneId: string,

src/timezone/controllers/index.ts

@@ -0,0 +1 @@
+export * from './timezone.controller';

src/timezone/controllers/timezone.controller.ts

@@ -0,0 +1,33 @@
+import {
+  Controller,
+  Get,
+  HttpException,
+  HttpStatus,
+  UseGuards,
+} from '@nestjs/common';
+import { TimeZoneService } from '../services/timezone.service';
+import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
+import { JwtAuthGuard } from '../../../libs/common/src/guards/jwt.auth.guard';
+
+@ApiTags('TimeZone Module')
+@Controller({
+  version: '1',
+  path: 'timezone',
+})
+export class TimeZoneController {
+  constructor(private readonly timeZoneService: TimeZoneService) {}
+
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Get()
+  async getAllTimeZones() {
+    try {
+      return await this.timeZoneService.getAllTimeZones();
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+}

src/timezone/services/index.ts

@@ -0,0 +1 @@
+export * from './timezone.service';

src/timezone/services/timezone.service.ts

@@ -0,0 +1,25 @@
+import { TimeZoneRepository } from '@app/common/modules/timezone/repositories';
+import {
+  BadRequestException,
+  HttpException,
+  HttpStatus,
+  Injectable,
+} from '@nestjs/common';
+
+@Injectable()
+export class TimeZoneService {
+  constructor(private readonly timeZoneRepository: TimeZoneRepository) {}
+  async getAllTimeZones() {
+    try {
+      const timeZones = await this.timeZoneRepository.find();
+
+      return timeZones;
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException('TimeZones found', HttpStatus.NOT_FOUND);
+      }
+    }
+  }
+}

src/timezone/timezone.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TimeZoneService } from './services/timezone.service';
+import { TimeZoneController } from './controllers/timezone.controller';
+import { ConfigModule } from '@nestjs/config';
+import { TimeZoneRepository } from '@app/common/modules/timezone/repositories';
+
+@Module({
+  imports: [ConfigModule],
+  controllers: [TimeZoneController],
+  providers: [TimeZoneService, TimeZoneRepository],
+  exports: [TimeZoneService],
+})
+export class TimeZoneModule {}

src/users/controllers/user.controller.ts

@@ -1,8 +1,23 @@
-import { Controller, Get, Query, UseGuards } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Get,
+  HttpException,
+  HttpStatus,
+  Param,
+  Put,
+  UseGuards,
+} from '@nestjs/common';
 import { UserService } from '../services/user.service';
-import { UserListDto } from '../dtos/user.list.dto';
 import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
-import { AdminRoleGuard } from 'src/guards/admin.role.guard';
+import { JwtAuthGuard } from '../../../libs/common/src/guards/jwt.auth.guard';
+import {
+  UpdateNameDto,
+  UpdateProfilePictureDataDto,
+  UpdateRegionDataDto,
+  UpdateTimezoneDataDto,
+} from '../dtos';
+import { CheckProfilePictureGuard } from 'src/guards/profile.picture.guard';
 
 @ApiTags('User Module')
 @Controller({
@@ -13,13 +28,116 @@ export class UserController {
   constructor(private readonly userService: UserService) {}
 
   @ApiBearerAuth()
-  @UseGuards(AdminRoleGuard)
-  @Get('list')
-  async userList(@Query() userListDto: UserListDto) {
+  @UseGuards(JwtAuthGuard)
+  @Get(':userUuid')
+  async getUserDetailsByUserUuid(@Param('userUuid') userUuid: string) {
     try {
-      return await this.userService.userDetails(userListDto);
-    } catch (err) {
-      throw new Error(err);
+      return await this.userService.getUserDetailsByUserUuid(userUuid);
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard, CheckProfilePictureGuard)
+  @Put('/profile-picture/:userUuid')
+  async updateProfilePictureByUserUuid(
+    @Param('userUuid') userUuid: string,
+    @Body() updateProfilePictureDataDto: UpdateProfilePictureDataDto,
+  ) {
+    try {
+      const userData = await this.userService.updateProfilePictureByUserUuid(
+        userUuid,
+        updateProfilePictureDataDto,
+      );
+      return {
+        statusCode: HttpStatus.CREATED,
+        success: true,
+        message: 'profile picture updated successfully',
+        data: userData,
+      };
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Put('/region/:userUuid')
+  async updateRegionByUserUuid(
+    @Param('userUuid') userUuid: string,
+    @Body() updateRegionDataDto: UpdateRegionDataDto,
+  ) {
+    try {
+      const userData = await this.userService.updateRegionByUserUuid(
+        userUuid,
+        updateRegionDataDto,
+      );
+      return {
+        statusCode: HttpStatus.CREATED,
+        success: true,
+        message: 'region updated successfully',
+        data: userData,
+      };
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Put('/timezone/:userUuid')
+  async updateNameByUserUuid(
+    @Param('userUuid') userUuid: string,
+    @Body() updateTimezoneDataDto: UpdateTimezoneDataDto,
+  ) {
+    try {
+      const userData = await this.userService.updateTimezoneByUserUuid(
+        userUuid,
+        updateTimezoneDataDto,
+      );
+      return {
+        statusCode: HttpStatus.CREATED,
+        success: true,
+        message: 'timezone updated successfully',
+        data: userData,
+      };
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Put('/name/:userUuid')
+  async updateTimezoneByUserUuid(
+    @Param('userUuid') userUuid: string,
+    @Body() updateNameDto: UpdateNameDto,
+  ) {
+    try {
+      const userData = await this.userService.updateNameByUserUuid(
+        userUuid,
+        updateNameDto,
+      );
+      return {
+        statusCode: HttpStatus.CREATED,
+        success: true,
+        message: 'name updated successfully',
+        data: userData,
+      };
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Internal server error',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
     }
   }
 }

src/users/dtos/index.ts

@@ -1 +1 @@
-export * from './user.list.dto';
+export * from './update.user.dto';

src/users/dtos/update.user.dto.ts

@@ -0,0 +1,61 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class UpdateProfilePictureDataDto {
+  @ApiProperty({
+    description: 'profilePicture',
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  public profilePicture: string;
+
+  constructor(dto: Partial<UpdateProfilePictureDataDto>) {
+    Object.assign(this, dto);
+  }
+}
+export class UpdateRegionDataDto {
+  @ApiProperty({
+    description: 'regionUuid',
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  public regionUuid: string;
+
+  constructor(dto: Partial<UpdateProfilePictureDataDto>) {
+    Object.assign(this, dto);
+  }
+}
+export class UpdateTimezoneDataDto {
+  @ApiProperty({
+    description: 'timezoneUuid',
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  public timezoneUuid: string;
+
+  constructor(dto: Partial<UpdateProfilePictureDataDto>) {
+    Object.assign(this, dto);
+  }
+}
+export class UpdateNameDto {
+  @ApiProperty({
+    description: 'firstName',
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  public firstName: string;
+  @ApiProperty({
+    description: 'lastName',
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  public lastName: string;
+  constructor(dto: Partial<UpdateProfilePictureDataDto>) {
+    Object.assign(this, dto);
+  }
+}

src/users/dtos/user.list.dto.ts

@@ -1,32 +0,0 @@
-import {
-  IsNotEmpty,
-  IsNumberString,
-  IsOptional,
-  IsString,
-} from 'class-validator';
-
-export class UserListDto {
-  @IsString()
-  @IsOptional()
-  schema: string;
-
-  @IsNumberString()
-  @IsNotEmpty()
-  page_no: number;
-
-  @IsNumberString()
-  @IsNotEmpty()
-  page_size: number;
-
-  @IsString()
-  @IsOptional()
-  username: string;
-
-  @IsNumberString()
-  @IsOptional()
-  start_time: number;
-
-  @IsNumberString()
-  @IsOptional()
-  end_time: number;
-}

src/users/services/user.service.ts

@@ -1,28 +1,240 @@
-import { Injectable } from '@nestjs/common';
-import { TuyaContext } from '@tuya/tuya-connector-nodejs';
-import { UserListDto } from '../dtos/user.list.dto';
-import { ConfigService } from '@nestjs/config';
+import {
+  UpdateNameDto,
+  UpdateProfilePictureDataDto,
+  UpdateRegionDataDto,
+  UpdateTimezoneDataDto,
+} from './../dtos/update.user.dto';
+import {
+  BadRequestException,
+  HttpException,
+  HttpStatus,
+  Injectable,
+} from '@nestjs/common';
+import { UserRepository } from '@app/common/modules/user/repositories';
+import { RegionRepository } from '@app/common/modules/region/repositories';
+import { TimeZoneRepository } from '@app/common/modules/timezone/repositories';
+import { removeBase64Prefix } from '@app/common/helper/removeBase64Prefix';
 
 @Injectable()
 export class UserService {
-  private tuya: TuyaContext;
-  constructor(private readonly configService: ConfigService) {
-    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,
-    });
+  constructor(
+    private readonly userRepository: UserRepository,
+    private readonly regionRepository: RegionRepository,
+    private readonly timeZoneRepository: TimeZoneRepository,
+  ) {}
+  async getUserDetailsByUserUuid(userUuid: string) {
+    try {
+      const user = await this.userRepository.findOne({
+        where: {
+          uuid: userUuid,
+        },
+        relations: ['region', 'timezone'],
+      });
+      if (!user) {
+        throw new BadRequestException('Invalid room UUID');
+      }
+
+      // Use the utility function to remove the base64 prefix
+      const cleanedProfilePicture = removeBase64Prefix(user.profilePicture);
+
+      return {
+        uuid: user.uuid,
+        email: user.email,
+        firstName: user.firstName,
+        lastName: user.lastName,
+        profilePicture: cleanedProfilePicture,
+        region: user.region,
+        timeZone: user.timezone,
+      };
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException('User not found', HttpStatus.NOT_FOUND);
+      }
+    }
   }
-  async userDetails(userListDto: UserListDto) {
-    const path = `/v2.0/apps/${userListDto.schema}/users`;
-    const data = await this.tuya.request({
-      method: 'GET',
-      path,
-      query: userListDto,
-    });
-    return data;
+
+  async updateProfilePictureByUserUuid(
+    userUuid: string,
+    updateProfilePictureDataDto: UpdateProfilePictureDataDto,
+  ) {
+    try {
+      await this.userRepository.update(
+        { uuid: userUuid },
+        { ...updateProfilePictureDataDto },
+      );
+      const updatedUser = await this.getUserDetailsByUserUuid(userUuid);
+      // Use the utility function to remove the base64 prefix
+      const cleanedProfilePicture = removeBase64Prefix(
+        updatedUser.profilePicture,
+      );
+      return {
+        uuid: updatedUser.uuid,
+        firstName: updatedUser.firstName,
+        lastName: updatedUser.lastName,
+        profilePicture: cleanedProfilePicture,
+        region: updatedUser.region,
+        timeZoneUuid: updatedUser.timeZone,
+      };
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException('User not found', HttpStatus.NOT_FOUND);
+      }
+    }
+  }
+  async updateRegionByUserUuid(
+    userUuid: string,
+    updateRegionDataDto: UpdateRegionDataDto,
+  ) {
+    try {
+      const user = await this.getUserDetailsByUserUuid(userUuid);
+      if (!user) {
+        throw new HttpException('User not found', HttpStatus.NOT_FOUND);
+      }
+
+      // Ensure the region UUID is provided
+      if (!updateRegionDataDto.regionUuid) {
+        throw new BadRequestException('Region UUID is required');
+      }
+
+      // Ensure the region exists
+      const region = await this.regionRepository.findOne({
+        where: {
+          uuid: updateRegionDataDto.regionUuid,
+        },
+      });
+      if (!region) {
+        throw new BadRequestException('Invalid region UUID');
+      }
+
+      await this.userRepository.update(
+        { uuid: userUuid },
+        {
+          region: region,
+        },
+      );
+
+      const updatedUser = await this.getUserDetailsByUserUuid(userUuid);
+      if (!updatedUser.region) {
+        throw new BadRequestException('Region update failed');
+      }
+      // Use the utility function to remove the base64 prefix
+      const cleanedProfilePicture = removeBase64Prefix(
+        updatedUser.profilePicture,
+      );
+      return {
+        uuid: updatedUser.uuid,
+        firstName: updatedUser.firstName,
+        lastName: updatedUser.lastName,
+        profilePicture: cleanedProfilePicture,
+        region: updatedUser.region,
+        timeZoneUuid: updatedUser.timeZone,
+      };
+    } catch (err) {
+      throw new HttpException(
+        err.message || 'User not found',
+        HttpStatus.NOT_FOUND,
+      );
+    }
+  }
+  async updateTimezoneByUserUuid(
+    userUuid: string,
+    updateTimezoneDataDto: UpdateTimezoneDataDto,
+  ) {
+    try {
+      const user = await this.getUserDetailsByUserUuid(userUuid);
+      if (!user) {
+        throw new HttpException('User not found', HttpStatus.NOT_FOUND);
+      }
+
+      // Ensure the region UUID is provided
+      if (!updateTimezoneDataDto.timezoneUuid) {
+        throw new BadRequestException('Timezone UUID is required');
+      }
+
+      // Ensure the region exists
+      const timezone = await this.timeZoneRepository.findOne({
+        where: {
+          uuid: updateTimezoneDataDto.timezoneUuid,
+        },
+      });
+      if (!timezone) {
+        throw new BadRequestException('Invalid timezone UUID');
+      }
+
+      await this.userRepository.update(
+        { uuid: userUuid },
+        {
+          timezone: timezone,
+        },
+      );
+
+      const updatedUser = await this.getUserDetailsByUserUuid(userUuid);
+      if (!updatedUser.timeZone) {
+        throw new BadRequestException('Timezone update failed');
+      }
+      // Use the utility function to remove the base64 prefix
+      const cleanedProfilePicture = removeBase64Prefix(
+        updatedUser.profilePicture,
+      );
+      return {
+        uuid: updatedUser.uuid,
+        firstName: updatedUser.firstName,
+        lastName: updatedUser.lastName,
+        profilePicture: cleanedProfilePicture,
+        region: updatedUser.region,
+        timeZoneUuid: updatedUser.timeZone,
+      };
+    } catch (err) {
+      throw new HttpException(
+        err.message || 'User not found',
+        HttpStatus.NOT_FOUND,
+      );
+    }
+  }
+  async updateNameByUserUuid(userUuid: string, updateNameDto: UpdateNameDto) {
+    try {
+      const user = await this.getUserDetailsByUserUuid(userUuid);
+      if (!user) {
+        throw new HttpException('User not found', HttpStatus.NOT_FOUND);
+      }
+
+      if (!updateNameDto.firstName || !updateNameDto.lastName) {
+        throw new BadRequestException('First Name and Last Name is required');
+      }
+
+      await this.userRepository.update(
+        { uuid: userUuid },
+        {
+          firstName: updateNameDto.firstName,
+          lastName: updateNameDto.lastName,
+        },
+      );
+
+      const updatedUser = await this.getUserDetailsByUserUuid(userUuid);
+      if (!updatedUser.firstName || !updatedUser.lastName) {
+        throw new BadRequestException('First Name and Last Name update failed');
+      }
+      // Use the utility function to remove the base64 prefix
+      const cleanedProfilePicture = removeBase64Prefix(
+        updatedUser.profilePicture,
+      );
+      return {
+        uuid: updatedUser.uuid,
+        firstName: updatedUser.firstName,
+        lastName: updatedUser.lastName,
+        profilePicture: cleanedProfilePicture,
+        region: updatedUser.region,
+        timeZoneUuid: updatedUser.timeZone,
+      };
+    } catch (err) {
+      throw new HttpException(
+        err.message || 'User not found',
+        HttpStatus.NOT_FOUND,
+      );
+    }
   }
 }

src/users/user.module.ts

@@ -2,11 +2,19 @@ import { Module } from '@nestjs/common';
 import { UserService } from './services/user.service';
 import { UserController } from './controllers/user.controller';
 import { ConfigModule } from '@nestjs/config';
+import { UserRepository } from '@app/common/modules/user/repositories';
+import { RegionRepository } from '@app/common/modules/region/repositories';
+import { TimeZoneRepository } from '@app/common/modules/timezone/repositories';
 
 @Module({
   imports: [ConfigModule],
   controllers: [UserController],
-  providers: [UserService],
+  providers: [
+    UserService,
+    UserRepository,
+    RegionRepository,
+    TimeZoneRepository,
+  ],
   exports: [UserService],
 })
 export class UserModule {}

src/validators/password.validator.ts

@@ -0,0 +1,33 @@
+import {
+  registerDecorator,
+  ValidationOptions,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from 'class-validator';
+
+@ValidatorConstraint({ async: false })
+export class IsPasswordStrongConstraint
+  implements ValidatorConstraintInterface
+{
+  validate(password: string) {
+    const regex =
+      /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~])[A-Za-z\d!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~]{8,}$/;
+    return regex.test(password);
+  }
+
+  defaultMessage() {
+    return 'Password must be at least 8 characters long and include at least one uppercase letter, one lowercase letter, one numeric digit, and one special character from the set !"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~.';
+  }
+}
+
+export function IsPasswordStrong(validationOptions?: ValidationOptions) {
+  return function (object: Record<string, any>, propertyName: string) {
+    registerDecorator({
+      target: object.constructor,
+      propertyName: propertyName,
+      options: validationOptions,
+      constraints: [],
+      validator: IsPasswordStrongConstraint,
+    });
+  };
+}