add update booking settings API

SP-1883, SP-1884: Task/add spaces and communities filters to automations and scenes

.github/workflows/pr-description.yml

@@ -1,4 +1,4 @@
-name: 🤖 AI PR Description Generator (with Template)
+name: 🤖 AI PR Description Commenter (100% Safe with jq)
 
 on:
   pull_request:
@@ -12,8 +12,10 @@ jobs:
       - name: Checkout Repo
         uses: actions/checkout@v4
 
-      - name: Install GitHub CLI
-        uses: cli/cli-action@v2
+      - name: Install GitHub CLI and jq
+        run: |
+          sudo apt-get update
+          sudo apt-get install gh jq -y
 
       - name: Fetch PR Commits
         id: fetch_commits
@@ -23,23 +25,31 @@ jobs:
           echo "$COMMITS" >> $GITHUB_ENV
           echo "EOF" >> $GITHUB_ENV
         env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
 
-      - name: Generate PR Description with OpenAI
-        id: generate_description
+      - name: Generate PR Description with OpenAI (Safe JSON with jq)
         run: |
+          REQUEST_BODY=$(jq -n \
+            --arg model "gpt-4o" \
+            --arg content "Given the following commit messages:\n\n${commits}\n\nGenerate a clear and professional pull request description." \
+            '{
+              model: $model,
+              messages: [{ role: "user", content: $content }]
+            }'
+          )
+
           RESPONSE=$(curl -s https://api.openai.com/v1/chat/completions \
             -H "Authorization: Bearer $OPENAI_API_KEY" \
             -H "Content-Type: application/json" \
-            -d '{
-              "model": "gpt-4o",
-              "messages": [{
-                "role": "user",
-                "content": "Given the following commit messages:\n\n'"${commits}"'\n\nFill the following pull request template. Only fill the \"## Description\" section:\n\n<!--\n  Thanks for contributing!\n\n  Provide a description of your changes below and a general summary in the title.\n-->\n\n## Jira Ticket\n\n[SP-0000](https://syncrow.atlassian.net/browse/SP-0000)\n\n## Description\n\n<!--- Describe your changes in detail -->\n\n## How to Test\n\n<!--- Describe the created APIs / Logic -->"
-              }]
-            }')
+            -d "$REQUEST_BODY")
 
           DESCRIPTION=$(echo "$RESPONSE" | jq -r '.choices[0].message.content')
+
+          echo "---------- OpenAI Raw Response ----------"
+          echo "$RESPONSE"
+          echo "---------- Extracted Description ----------"
+          echo "$DESCRIPTION"
+
           echo "description<<EOF" >> $GITHUB_ENV
           echo "$DESCRIPTION" >> $GITHUB_ENV
           echo "EOF" >> $GITHUB_ENV
@@ -47,8 +57,8 @@ jobs:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
           commits: ${{ env.commits }}
 
-      - name: Update PR Body with AI Description
+      - name: Post AI Generated Description as Comment
         run: |
-          gh pr edit ${{ github.event.pull_request.number }} --body "${{ env.description }}"
+          gh pr comment ${{ github.event.pull_request.number }} --body "${{ env.description }}"
         env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}

libs/common/src/constants/controller-route.ts

@@ -188,6 +188,11 @@ export class ControllerRoute {
   static SCENE = class {
     public static readonly ROUTE = 'scene';
     static ACTIONS = class {
+      public static readonly GET_TAP_TO_RUN_SCENES_SUMMARY =
+        'Get Tap-to-Run Scenes by spaces';
+      public static readonly GET_TAP_TO_RUN_SCENES_DESCRIPTION =
+        'Gets Tap-to-Run scenes by spaces';
+
       public static readonly CREATE_TAP_TO_RUN_SCENE_SUMMARY =
         'Create a Tap-to-Run Scene';
       public static readonly CREATE_TAP_TO_RUN_SCENE_DESCRIPTION =
@@ -223,6 +228,10 @@ export class ControllerRoute {
       public static readonly CREATE_SPACE_DESCRIPTION =
         'This endpoint allows you to create a space in a specified community. Optionally, you can specify a parent space to nest the new space under it.';
 
+      public static readonly DUPLICATE_SPACE_SUMMARY = 'Duplicate a space';
+      public static readonly DUPLICATE_SPACE_DESCRIPTION =
+        'This endpoint allows you to create a copy of an existing space in a specified community.';
+
       public static readonly LIST_SPACE_SUMMARY = 'List spaces in community';
       public static readonly LIST_SPACE_DESCRIPTION =
         'List spaces in specified community by community id';
@@ -439,6 +448,11 @@ export class ControllerRoute {
       public static readonly UPDATE_NAME_DESCRIPTION =
         'This endpoint updates the name for a user identified by their UUID.';
 
+      public static readonly UPDATE_BOOKING_SETTINGS_SUMMARY =
+        'Update booking settings by user UUID';
+      public static readonly UPDATE_BOOKING_SETTINGS_DESCRIPTION =
+        'This endpoint updates the booking settings for a user identified by their UUID.';
+
       public static readonly DELETE_USER_SUMMARY = 'Delete user by UUID';
       public static readonly DELETE_USER_DESCRIPTION =
         'This endpoint deletes a user identified by their UUID. Accessible only by users with the Super Admin role.';
@@ -768,6 +782,10 @@ export class ControllerRoute {
       public static readonly ADD_AUTOMATION_DESCRIPTION =
         'This endpoint creates a new automation based on the provided details.';
 
+      public static readonly GET_AUTOMATION_SUMMARY = 'Get all automations';
+      public static readonly GET_AUTOMATION_DESCRIPTION =
+        'This endpoint retrieves automations data';
+
       public static readonly GET_AUTOMATION_DETAILS_SUMMARY =
         'Get automation details';
       public static readonly GET_AUTOMATION_DETAILS_DESCRIPTION =

libs/common/src/firebase/devices-status/services/devices-status.service.ts

@@ -1,15 +1,13 @@
+import { DeviceStatusLogRepository } from '@app/common/modules/device-status-log/repositories';
+import { DeviceRepository } from '@app/common/modules/device/repositories';
 import {
   HttpException,
   HttpStatus,
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
-import { AddDeviceStatusDto } from '../dtos/add.devices-status.dto';
-import { DeviceRepository } from '@app/common/modules/device/repositories';
-import { GetDeviceDetailsFunctionsStatusInterface } from 'src/device/interfaces/get.device.interface';
-import { TuyaContext } from '@tuya/tuya-connector-nodejs';
 import { ConfigService } from '@nestjs/config';
-import { firebaseDataBase } from '../../firebase.config';
+import { TuyaContext } from '@tuya/tuya-connector-nodejs';
 import {
   Database,
   DataSnapshot,
@@ -17,7 +15,9 @@ import {
   ref,
   runTransaction,
 } from 'firebase/database';
-import { DeviceStatusLogRepository } from '@app/common/modules/device-status-log/repositories';
+import { GetDeviceDetailsFunctionsStatusInterface } from 'src/device/interfaces/get.device.interface';
+import { firebaseDataBase } from '../../firebase.config';
+import { AddDeviceStatusDto } from '../dtos/add.devices-status.dto';
 @Injectable()
 export class DeviceStatusFirebaseService {
   private tuya: TuyaContext;
@@ -79,64 +79,77 @@ export class DeviceStatusFirebaseService {
       device: any;
     }[],
   ): Promise<void> {
-    const allLogs = [];
-
     console.log(`🔁 Preparing logs from batch of ${batch.length} items...`);
 
+    const allLogs = [];
+
     for (const item of batch) {
       const device = item.device;
+
       if (!device?.uuid) {
         console.log(`⛔ Skipped unknown device: ${item.deviceTuyaUuid}`);
         continue;
       }
 
-      const logs = item.log.properties.map((property) =>
+      // Determine properties based on environment
+      const properties =
+        this.isDevEnv && Array.isArray(item.log?.properties)
+          ? item.log.properties
+          : Array.isArray(item.status)
+            ? item.status
+            : null;
+
+      if (!properties) {
+        console.log(
+          `⛔ Skipped invalid status/properties for device: ${item.deviceTuyaUuid}`,
+        );
+        continue;
+      }
+
+      const logs = properties.map((property) =>
         this.deviceStatusLogRepository.create({
           deviceId: device.uuid,
           deviceTuyaId: item.deviceTuyaUuid,
-          productId: item.log.productId,
+          productId: device.productDevice?.uuid,
           log: item.log,
           code: property.code,
           value: property.value,
-          eventId: item.log.dataId,
-          eventTime: new Date(property.time).toISOString(),
+          eventId: item.log?.dataId,
+          eventTime: new Date(
+            this.isDevEnv ? property.time : property.t,
+          ).toISOString(),
         }),
       );
+
       allLogs.push(...logs);
     }
 
     console.log(`📝 Total logs to insert: ${allLogs.length}`);
 
-    const insertLogsPromise = (async () => {
-      const chunkSize = 300;
-      let insertedCount = 0;
+    const chunkSize = 300;
+    let insertedCount = 0;
 
-      for (let i = 0; i < allLogs.length; i += chunkSize) {
-        const chunk = allLogs.slice(i, i + chunkSize);
-        try {
-          const result = await this.deviceStatusLogRepository
-            .createQueryBuilder()
-            .insert()
-            .into('device-status-log') // or use DeviceStatusLogEntity
-            .values(chunk)
-            .orIgnore() // skip duplicates
-            .execute();
+    for (let i = 0; i < allLogs.length; i += chunkSize) {
+      const chunk = allLogs.slice(i, i + chunkSize);
+      try {
+        const result = await this.deviceStatusLogRepository
+          .createQueryBuilder()
+          .insert()
+          .into('device-status-log')
+          .values(chunk)
+          .orIgnore()
+          .execute();
 
-          insertedCount += result.identifiers.length;
-          console.log(
-            `✅ Inserted ${result.identifiers.length} / ${chunk.length} logs (chunk)`,
-          );
-        } catch (error) {
-          console.error('❌ Insert error (skipped chunk):', error.message);
-        }
+        insertedCount += result.identifiers.length;
+        console.log(
+          `✅ Inserted ${result.identifiers.length} / ${chunk.length} logs (chunk)`,
+        );
+      } catch (error) {
+        console.error('❌ Insert error (skipped chunk):', error.message);
       }
+    }
 
-      console.log(
-        `✅ Total logs inserted: ${insertedCount} / ${allLogs.length}`,
-      );
-    })();
-
-    await insertLogsPromise;
+    console.log(`✅ Total logs inserted: ${insertedCount} / ${allLogs.length}`);
   }
 
   async addDeviceStatusToFirebase(

libs/common/src/helper/services/tuya.web.socket.service.ts

@@ -1,9 +1,9 @@
-import { Injectable, OnModuleInit } from '@nestjs/common';
-import TuyaWebsocket from '../../config/tuya-web-socket-config';
-import { ConfigService } from '@nestjs/config';
 import { DeviceStatusFirebaseService } from '@app/common/firebase/devices-status/services/devices-status.service';
-import { SosHandlerService } from './sos.handler.service';
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
 import * as NodeCache from 'node-cache';
+import TuyaWebsocket from '../../config/tuya-web-socket-config';
+import { SosHandlerService } from './sos.handler.service';
 
 @Injectable()
 export class TuyaWebSocketService implements OnModuleInit {
@@ -74,7 +74,12 @@ export class TuyaWebSocketService implements OnModuleInit {
     this.client.message(async (ws: WebSocket, message: any) => {
       try {
         const { devId, status, logData } = this.extractMessageData(message);
-        if (!Array.isArray(logData?.properties)) {
+        // console.log(
+        //   `📬 Received message for device: ${devId}, status:`,
+        //   status,
+        //   logData,
+        // );
+        if (!Array.isArray(status)) {
           this.client.ackMessage(message.messageId);
           return;
         }
@@ -162,6 +167,8 @@ export class TuyaWebSocketService implements OnModuleInit {
     status: any;
     logData: any;
   } {
+    // console.log('Received message:', message);
+
     const payloadData = message.payload.data;
 
     if (this.isDevEnv) {

libs/common/src/modules/space/entities/space-product-allocation.entity.ts

@@ -22,6 +22,11 @@ export class SpaceProductAllocationEntity extends AbstractEntity<SpaceProductAll
   })
   public space: SpaceEntity;
 
+  @Column({
+    name: 'space_uuid',
+  })
+  public spaceUuid: string;
+
   @ManyToOne(() => SpaceModelProductAllocationEntity, {
     nullable: true,
     onDelete: 'SET NULL',
@@ -31,9 +36,19 @@ export class SpaceProductAllocationEntity extends AbstractEntity<SpaceProductAll
   @ManyToOne(() => ProductEntity, { nullable: false, onDelete: 'CASCADE' })
   public product: ProductEntity;
 
+  @Column({
+    name: 'product_uuid',
+  })
+  public productUuid: string;
+
   @ManyToOne(() => NewTagEntity, { nullable: true, onDelete: 'CASCADE' })
   public tag: NewTagEntity;
 
+  @Column({
+    name: 'tag_uuid',
+  })
+  public tagUuid: string;
+
   constructor(partial: Partial<SpaceProductAllocationEntity>) {
     super();
     Object.assign(this, partial);

libs/common/src/modules/space/entities/space.entity.ts

@@ -9,6 +9,7 @@ import {
 import { AbstractEntity } from '../../abstract/entities/abstract.entity';
 import { AqiSpaceDailyPollutantStatsEntity } from '../../aqi/entities';
 import { BookableSpaceEntity } from '../../booking/entities/bookable-space.entity';
+import { BookingEntity } from '../../booking/entities/booking.entity';
 import { CommunityEntity } from '../../community/entities';
 import { DeviceEntity } from '../../device/entities';
 import { InviteUserSpaceEntity } from '../../Invite-user/entities';
@@ -20,7 +21,6 @@ import { UserSpaceEntity } from '../../user/entities';
 import { SpaceDto } from '../dtos';
 import { SpaceProductAllocationEntity } from './space-product-allocation.entity';
 import { SubspaceEntity } from './subspace/subspace.entity';
-import { BookingEntity } from '../../booking/entities/booking.entity';
 
 @Entity({ name: 'space' })
 export class SpaceEntity extends AbstractEntity<SpaceDto> {
@@ -47,12 +47,26 @@ export class SpaceEntity extends AbstractEntity<SpaceDto> {
   @JoinColumn({ name: 'community_id' })
   community: CommunityEntity;
 
-  @ManyToOne(() => SpaceEntity, (space) => space.children, { nullable: true })
+  @Column({
+    name: 'community_id',
+  })
+  communityId: string;
+
+  @ManyToOne(() => SpaceEntity, (space) => space.children, {
+    nullable: true,
+  })
   parent: SpaceEntity;
 
+  @Column({
+    name: 'parent_uuid',
+    nullable: true,
+  })
+  public parentUuid: string;
+
   @OneToMany(() => SpaceEntity, (space) => space.parent, {
     nullable: false,
     onDelete: 'CASCADE',
+    cascade: true,
   })
   children: SpaceEntity[];
 
@@ -73,16 +87,10 @@ export class SpaceEntity extends AbstractEntity<SpaceDto> {
 
   @OneToMany(() => SubspaceEntity, (subspace) => subspace.space, {
     nullable: true,
+    cascade: true,
   })
   subspaces?: SubspaceEntity[];
 
-  // Position columns
-  @Column({ type: 'float', nullable: false, default: 0 })
-  public x: number; // X coordinate for position
-
-  @Column({ type: 'float', nullable: false, default: 0 })
-  public y: number; // Y coordinate for position
-
   @OneToMany(
     () => DeviceEntity,
     (devicesSpaceEntity) => devicesSpaceEntity.spaceDevice,

libs/common/src/modules/space/entities/subspace/subspace-product-allocation.entity.ts

@@ -22,6 +22,11 @@ export class SubspaceProductAllocationEntity extends AbstractEntity<SubspaceProd
   })
   public subspace: SubspaceEntity;
 
+  @Column({
+    name: 'subspace_uuid',
+  })
+  public subspaceUuid: string;
+
   @ManyToOne(() => SubspaceModelProductAllocationEntity, {
     nullable: true,
     onDelete: 'SET NULL',
@@ -31,9 +36,19 @@ export class SubspaceProductAllocationEntity extends AbstractEntity<SubspaceProd
   @ManyToOne(() => ProductEntity, { nullable: false, onDelete: 'CASCADE' })
   public product: ProductEntity;
 
+  @Column({
+    name: 'product_uuid',
+  })
+  public productUuid: string;
+
   @ManyToOne(() => NewTagEntity, { nullable: true, onDelete: 'CASCADE' })
   public tag: NewTagEntity;
 
+  @Column({
+    name: 'tag_uuid',
+  })
+  public tagUuid: string;
+
   constructor(partial: Partial<SubspaceProductAllocationEntity>) {
     super();
     Object.assign(this, partial);

libs/common/src/modules/space/entities/subspace/subspace.entity.ts

@@ -26,6 +26,11 @@ export class SubspaceEntity extends AbstractEntity<SubspaceDto> {
   @JoinColumn({ name: 'space_uuid' })
   space: SpaceEntity;
 
+  @Column({
+    name: 'space_uuid',
+  })
+  public spaceUuid: string;
+
   @Column({
     nullable: false,
     default: false,

libs/common/src/modules/user/entities/user.entity.ts

@@ -11,6 +11,7 @@ import {
 } from 'typeorm';
 import { OtpType } from '../../../../src/constants/otp-type.enum';
 import { AbstractEntity } from '../../abstract/entities/abstract.entity';
+import { BookingEntity } from '../../booking/entities/booking.entity';
 import { ClientEntity } from '../../client/entities';
 import {
   DeviceNotificationEntity,
@@ -29,7 +30,6 @@ import {
   UserOtpDto,
   UserSpaceDto,
 } from '../dtos';
-import { BookingEntity } from '../../booking/entities/booking.entity';
 
 @Entity({ name: 'user' })
 export class UserEntity extends AbstractEntity<UserDto> {
@@ -101,6 +101,9 @@ export class UserEntity extends AbstractEntity<UserDto> {
   @Column({ type: 'timestamp', nullable: true })
   appAgreementAcceptedAt: Date;
 
+  @Column({ type: Boolean, default: false })
+  bookingEnabled: boolean;
+
   @OneToMany(() => UserSpaceEntity, (userSpace) => userSpace.user, {
     onDelete: 'CASCADE',
   })

package-lock.json

@@ -48,6 +48,7 @@
         "reflect-metadata": "^0.2.2",
         "rxjs": "^7.8.1",
         "typeorm": "^0.3.20",
+        "uuid": "^11.1.0",
         "winston": "^3.17.0",
         "ws": "^8.17.0"
       },
@@ -2365,6 +2366,18 @@
         "rxjs": "^7.2.0"
       }
     },
+    "node_modules/@nestjs/cqrs/node_modules/uuid": {
+      "version": "11.0.2",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.0.2.tgz",
+      "integrity": "sha512-14FfcOJmqdjbBPdDjFQyk/SdT4NySW4eM0zcG+HqbHP5jzuH56xO3J1DGhgs/cEMCfwYi3HQI1gnTO62iaG+tQ==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "bin": {
+        "uuid": "dist/esm/bin/uuid"
+      }
+    },
     "node_modules/@nestjs/jwt": {
       "version": "10.2.0",
       "resolved": "https://registry.npmjs.org/@nestjs/jwt/-/jwt-10.2.0.tgz",
@@ -12749,18 +12762,6 @@
         "url": "https://dotenvx.com"
       }
     },
-    "node_modules/typeorm/node_modules/uuid": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz",
-      "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==",
-      "funding": [
-        "https://github.com/sponsors/broofa",
-        "https://github.com/sponsors/ctavan"
-      ],
-      "bin": {
-        "uuid": "dist/esm/bin/uuid"
-      }
-    },
     "node_modules/typescript": {
       "version": "5.8.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
@@ -12896,9 +12897,9 @@
       }
     },
     "node_modules/uuid": {
-      "version": "11.0.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.0.2.tgz",
-      "integrity": "sha512-14FfcOJmqdjbBPdDjFQyk/SdT4NySW4eM0zcG+HqbHP5jzuH56xO3J1DGhgs/cEMCfwYi3HQI1gnTO62iaG+tQ==",
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz",
+      "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==",
       "funding": [
         "https://github.com/sponsors/broofa",
         "https://github.com/sponsors/ctavan"

package.json

@@ -60,6 +60,7 @@
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1",
     "typeorm": "^0.3.20",
+    "uuid": "^11.1.0",
     "winston": "^3.17.0",
     "ws": "^8.17.0"
   },

src/aqi/aqi.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service';
+import { AqiService } from './services';
+import { AqiController } from './controllers';
+@Module({
+  imports: [ConfigModule],
+  controllers: [AqiController],
+  providers: [AqiService, SqlLoaderService],
+})
+export class AqiModule {}

src/aqi/controllers/aqi.controller.ts

@@ -0,0 +1,64 @@
+import { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
+import {
+  ApiTags,
+  ApiBearerAuth,
+  ApiOperation,
+  ApiParam,
+} from '@nestjs/swagger';
+import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
+import { ControllerRoute } from '@app/common/constants/controller-route';
+import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
+import { AqiService } from '../services/aqi.service';
+import {
+  GetAqiDailyBySpaceDto,
+  GetAqiPollutantBySpaceDto,
+} from '../dto/get-aqi.dto';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+import { SpaceParamsDto } from '../dto/aqi-params.dto';
+
+@ApiTags('AQI Module')
+@Controller({
+  version: EnableDisableStatusEnum.ENABLED,
+  path: ControllerRoute.AQI.ROUTE,
+})
+export class AqiController {
+  constructor(private readonly aqiService: AqiService) {}
+
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Get('range/space/:spaceUuid')
+  @ApiOperation({
+    summary: ControllerRoute.AQI.ACTIONS.GET_AQI_RANGE_DATA_SUMMARY,
+    description: ControllerRoute.AQI.ACTIONS.GET_AQI_RANGE_DATA_DESCRIPTION,
+  })
+  @ApiParam({
+    name: 'spaceUuid',
+    description: 'UUID of the Space',
+    required: true,
+  })
+  async getAQIRangeDataBySpace(
+    @Param() params: SpaceParamsDto,
+    @Query() query: GetAqiDailyBySpaceDto,
+  ): Promise<BaseResponseDto> {
+    return await this.aqiService.getAQIRangeDataBySpace(params, query);
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Get('distribution/space/:spaceUuid')
+  @ApiOperation({
+    summary: ControllerRoute.AQI.ACTIONS.GET_AQI_DISTRIBUTION_DATA_SUMMARY,
+    description:
+      ControllerRoute.AQI.ACTIONS.GET_AQI_DISTRIBUTION_DATA_DESCRIPTION,
+  })
+  @ApiParam({
+    name: 'spaceUuid',
+    description: 'UUID of the Space',
+    required: true,
+  })
+  async getAQIDistributionDataBySpace(
+    @Param() params: SpaceParamsDto,
+    @Query() query: GetAqiPollutantBySpaceDto,
+  ): Promise<BaseResponseDto> {
+    return await this.aqiService.getAQIDistributionDataBySpace(params, query);
+  }
+}

src/aqi/controllers/index.ts

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

src/aqi/dto/aqi-params.dto.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsUUID } from 'class-validator';
+
+export class SpaceParamsDto {
+  @IsUUID('4', { message: 'Invalid UUID format' })
+  @IsNotEmpty()
+  spaceUuid: string;
+}

src/aqi/dto/get-aqi.dto.ts

@@ -0,0 +1,37 @@
+import { PollutantType } from '@app/common/constants/pollutants.enum';
+import { ApiProperty } from '@nestjs/swagger';
+import { Matches, IsNotEmpty, IsString } from 'class-validator';
+
+export class GetAqiDailyBySpaceDto {
+  @ApiProperty({
+    description: 'Month and year in format YYYY-MM',
+    example: '2025-03',
+    required: true,
+  })
+  @Matches(/^\d{4}-(0[1-9]|1[0-2])$/, {
+    message: 'monthDate must be in YYYY-MM format',
+  })
+  @IsNotEmpty()
+  monthDate: string;
+}
+export class GetAqiPollutantBySpaceDto {
+  @ApiProperty({
+    description: 'Pollutant Type',
+    enum: PollutantType,
+    example: PollutantType.AQI,
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  public pollutantType: string;
+  @ApiProperty({
+    description: 'Month and year in format YYYY-MM',
+    example: '2025-03',
+    required: true,
+  })
+  @Matches(/^\d{4}-(0[1-9]|1[0-2])$/, {
+    message: 'monthDate must be in YYYY-MM format',
+  })
+  @IsNotEmpty()
+  monthDate: string;
+}

src/aqi/services/aqi.service.ts

@@ -0,0 +1,138 @@
+import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
+import {
+  GetAqiDailyBySpaceDto,
+  GetAqiPollutantBySpaceDto,
+} from '../dto/get-aqi.dto';
+import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
+import { SpaceParamsDto } from '../dto/aqi-params.dto';
+import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service';
+import { DataSource } from 'typeorm';
+import { SQL_PROCEDURES_PATH } from '@app/common/constants/sql-query-path';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
+import { PollutantType } from '@app/common/constants/pollutants.enum';
+
+@Injectable()
+export class AqiService {
+  constructor(
+    private readonly sqlLoader: SqlLoaderService,
+    private readonly dataSource: DataSource,
+  ) {}
+  async getAQIDistributionDataBySpace(
+    params: SpaceParamsDto,
+    query: GetAqiPollutantBySpaceDto,
+  ): Promise<BaseResponseDto> {
+    const { monthDate, pollutantType } = query;
+    const { spaceUuid } = params;
+
+    try {
+      const data = await this.executeProcedure(
+        'fact_daily_space_aqi',
+        'proceduce_select_daily_space_aqi',
+        [spaceUuid, monthDate],
+      );
+
+      const categories = [
+        'good',
+        'moderate',
+        'unhealthy_sensitive',
+        'unhealthy',
+        'very_unhealthy',
+        'hazardous',
+      ];
+
+      const transformedData = data.map((item) => {
+        const date = new Date(item.event_date).toLocaleDateString('en-CA'); // YYYY-MM-DD
+
+        const categoryData = categories.map((category) => {
+          const key = `${category}_${pollutantType.toLowerCase()}_percentage`;
+          return {
+            type: category,
+            percentage: item[key] ?? 0,
+          };
+        });
+
+        return { date, data: categoryData };
+      });
+
+      const response = this.buildResponse(
+        `AQI distribution data fetched successfully for ${spaceUuid} space and pollutant ${pollutantType}`,
+        transformedData,
+      );
+      return response;
+    } catch (error) {
+      console.error('Failed to fetch AQI distribution data', {
+        error,
+        spaceUuid,
+      });
+      throw new HttpException(
+        error.response?.message || 'Failed to fetch AQI distribution data',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  async getAQIRangeDataBySpace(
+    params: SpaceParamsDto,
+    query: GetAqiDailyBySpaceDto,
+  ): Promise<BaseResponseDto> {
+    const { monthDate } = query;
+    const { spaceUuid } = params;
+
+    try {
+      const data = await this.executeProcedure(
+        'fact_daily_space_aqi',
+        'proceduce_select_daily_space_aqi',
+        [spaceUuid, monthDate],
+      );
+
+      // Define pollutants dynamically
+      const pollutants = Object.values(PollutantType);
+
+      const transformedData = data.map((item) => {
+        const date = new Date(item.event_date).toLocaleDateString('en-CA'); // YYYY-MM-DD
+        const dailyData = pollutants.map((type) => ({
+          type,
+          min: item[`daily_min_${type}`],
+          max: item[`daily_max_${type}`],
+          average: item[`daily_avg_${type}`],
+        }));
+        return { date, data: dailyData };
+      });
+
+      const response = this.buildResponse(
+        `AQI data fetched successfully for ${spaceUuid} space`,
+        transformedData,
+      );
+      return convertKeysToCamelCase(response);
+    } catch (error) {
+      console.error('Failed to fetch AQI data', {
+        error,
+        spaceUuid,
+      });
+      throw new HttpException(
+        error.response?.message || 'Failed to fetch AQI data',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  private buildResponse(message: string, data: any[]) {
+    return new SuccessResponseDto({
+      message,
+      data,
+      statusCode: HttpStatus.OK,
+    });
+  }
+  private async executeProcedure(
+    procedureFolderName: string,
+    procedureFileName: string,
+    params: (string | number | null)[],
+  ): Promise<any[]> {
+    const query = this.loadQuery(procedureFolderName, procedureFileName);
+    return await this.dataSource.query(query, params);
+  }
+  private loadQuery(folderName: string, fileName: string): string {
+    return this.sqlLoader.loadQuery(folderName, fileName, SQL_PROCEDURES_PATH);
+  }
+}

src/aqi/services/index.ts

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

src/automation/controllers/automation.controller.ts

@@ -1,4 +1,7 @@
-import { AutomationService } from '../services/automation.service';
+import { ControllerRoute } from '@app/common/constants/controller-route';
+import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
+import { ProjectParam } from '@app/common/dto/project-param.dto';
+import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
 import {
   Body,
   Controller,
@@ -9,20 +12,20 @@ import {
   Patch,
   Post,
   Put,
+  Query,
   UseGuards,
 } from '@nestjs/common';
-import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { Permissions } from 'src/decorators/permissions.decorator';
+import { PermissionsGuard } from 'src/guards/permissions.guard';
+import { AutomationParamDto } from '../dtos';
 import {
   AddAutomationDto,
   UpdateAutomationDto,
   UpdateAutomationStatusDto,
 } from '../dtos/automation.dto';
-import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
-import { AutomationParamDto } from '../dtos';
-import { ControllerRoute } from '@app/common/constants/controller-route';
-import { PermissionsGuard } from 'src/guards/permissions.guard';
-import { Permissions } from 'src/decorators/permissions.decorator';
-import { ProjectParam } from '@app/common/dto/project-param.dto';
+import { GetAutomationBySpacesDto } from '../dtos/get-automation-by-spaces.dto';
+import { AutomationService } from '../services/automation.service';
 
 @ApiTags('Automation Module')
 @Controller({
@@ -56,6 +59,28 @@ export class AutomationController {
     };
   }
 
+  @ApiBearerAuth()
+  @UseGuards(PermissionsGuard)
+  @Permissions('AUTOMATION_VIEW')
+  @Get('')
+  @ApiOperation({
+    summary: ControllerRoute.AUTOMATION.ACTIONS.GET_AUTOMATION_SUMMARY,
+    description: ControllerRoute.AUTOMATION.ACTIONS.GET_AUTOMATION_DESCRIPTION,
+  })
+  async getAutomationBySpaces(
+    @Param() param: ProjectParam,
+    @Query() spaces: GetAutomationBySpacesDto,
+  ) {
+    const automation = await this.automationService.getAutomationBySpaces(
+      spaces,
+      param.projectUuid,
+    );
+    return new SuccessResponseDto({
+      message: 'Automation retrieved Successfully',
+      data: automation,
+    });
+  }
+
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
   @Permissions('AUTOMATION_VIEW')

src/automation/dtos/get-automation-by-spaces.dto.ts

@@ -0,0 +1,20 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import { IsOptional, IsUUID } from 'class-validator';
+
+export class GetAutomationBySpacesDto {
+  @ApiProperty({
+    description: 'List of Space IDs to filter automation',
+    required: false,
+    example: ['60d21b4667d0d8992e610c85', '60d21b4967d0d8992e610c86'],
+  })
+  @IsOptional()
+  @Transform(({ value }) => {
+    if (!Array.isArray(value)) {
+      return [value];
+    }
+    return value;
+  })
+  @IsUUID('4', { each: true })
+  public spaces?: string[];
+}

src/automation/services/automation.service.ts

@@ -1,28 +1,3 @@
-import {
-  Injectable,
-  HttpException,
-  HttpStatus,
-  BadRequestException,
-} from '@nestjs/common';
-import { SpaceRepository } from '@app/common/modules/space/repositories';
-import {
-  AddAutomationDto,
-  AutomationParamDto,
-  UpdateAutomationDto,
-  UpdateAutomationStatusDto,
-} from '../dtos';
-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 {
-  Action,
-  AddAutomationParams,
-  AutomationDetailsResult,
-  AutomationResponseData,
-  Condition,
-} from '../interface/automation.interface';
-import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
 import {
   ActionExecutorEnum,
   ActionTypeEnum,
@@ -30,18 +5,45 @@ import {
   AUTOMATION_TYPE,
   EntityTypeEnum,
 } from '@app/common/constants/automation.enum';
-import { TuyaService } from '@app/common/integrations/tuya/services/tuya.service';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+import { GetSpaceParam } from '@app/common/dto/get.space.param';
+import { ProjectParam } from '@app/common/dto/project-param.dto';
+import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
+import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
+import { convertKeysToSnakeCase } from '@app/common/helper/snakeCaseConverter';
 import { ConvertedAction } from '@app/common/integrations/tuya/interfaces';
+import { TuyaService } from '@app/common/integrations/tuya/services/tuya.service';
+import { AutomationEntity } from '@app/common/modules/automation/entities';
+import { AutomationRepository } from '@app/common/modules/automation/repositories';
+import { ProjectRepository } from '@app/common/modules/project/repositiories';
 import { SceneDeviceRepository } from '@app/common/modules/scene-device/repositories';
 import { SceneRepository } from '@app/common/modules/scene/repositories';
-import { AutomationRepository } from '@app/common/modules/automation/repositories';
-import { BaseResponseDto } from '@app/common/dto/base.response.dto';
-import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
-import { AutomationEntity } from '@app/common/modules/automation/entities';
+import { SpaceRepository } from '@app/common/modules/space/repositories';
+import {
+  BadRequestException,
+  HttpException,
+  HttpStatus,
+  Injectable,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { TuyaContext } from '@tuya/tuya-connector-nodejs';
+import { DeviceService } from 'src/device/services';
 import { DeleteTapToRunSceneInterface } from 'src/scene/interface/scene.interface';
-import { ProjectParam } from '@app/common/dto/project-param.dto';
-import { ProjectRepository } from '@app/common/modules/project/repositiories';
-import { GetSpaceParam } from '@app/common/dto/get.space.param';
+import { In } from 'typeorm';
+import {
+  AddAutomationDto,
+  AutomationParamDto,
+  UpdateAutomationDto,
+  UpdateAutomationStatusDto,
+} from '../dtos';
+import { GetAutomationBySpacesDto } from '../dtos/get-automation-by-spaces.dto';
+import {
+  Action,
+  AddAutomationParams,
+  AutomationDetailsResult,
+  AutomationResponseData,
+  Condition,
+} from '../interface/automation.interface';
 
 @Injectable()
 export class AutomationService {
@@ -112,128 +114,25 @@ export class AutomationService {
           );
     }
   }
-  async createAutomationExternalService(
-    params: AddAutomationParams,
+  async getAutomationBySpace({ projectUuid, spaceUuid }: GetSpaceParam) {
+    return this.getAutomationBySpaces({ spaces: [spaceUuid] }, projectUuid);
+  }
+
+  async getAutomationBySpaces(
+    { spaces }: GetAutomationBySpacesDto,
     projectUuid: string,
   ) {
     try {
-      const formattedActions = await this.prepareActions(
-        params.actions,
-        projectUuid,
-      );
-      const formattedCondition = await this.prepareConditions(
-        params.conditions,
-        projectUuid,
-      );
-
-      const response = await this.tuyaService.createAutomation(
-        params.spaceTuyaId,
-        params.automationName,
-        params.effectiveTime,
-        params.decisionExpr,
-        formattedCondition,
-        formattedActions,
-      );
-
-      if (!response.result?.id) {
-        throw new HttpException(
-          'Failed to create automation in Tuya',
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-
-      return response;
-    } catch (err) {
-      if (err instanceof HttpException) {
-        throw err;
-      } else if (err.message?.includes('tuya')) {
-        throw new HttpException(
-          'API error: Failed to create automation',
-          HttpStatus.BAD_GATEWAY,
-        );
-      } else {
-        throw new HttpException(
-          `An Internal error has been occured ${err}`,
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-    }
-  }
-  async add(params: AddAutomationParams, projectUuid: string) {
-    try {
-      const response = await this.createAutomationExternalService(
-        params,
-        projectUuid,
-      );
-
-      const automation = await this.automationRepository.save({
-        automationTuyaUuid: response.result.id,
-        space: { uuid: params.spaceUuid },
-      });
-
-      return automation;
-    } catch (err) {
-      if (err instanceof HttpException) {
-        throw err;
-      } else if (err.message?.includes('tuya')) {
-        throw new HttpException(
-          'API error: Failed to create automation',
-          HttpStatus.BAD_GATEWAY,
-        );
-      } else {
-        throw new HttpException(
-          'Database error: Failed to save automation',
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-    }
-  }
-
-  async getSpaceByUuid(spaceUuid: string, projectUuid: string) {
-    try {
-      const space = await this.spaceRepository.findOne({
-        where: {
-          uuid: spaceUuid,
-          community: {
-            project: {
-              uuid: projectUuid,
-            },
-          },
-        },
-        relations: ['community'],
-      });
-      if (!space) {
-        throw new BadRequestException(`Invalid space UUID ${spaceUuid}`);
-      }
-      return {
-        uuid: space.uuid,
-        createdAt: space.createdAt,
-        updatedAt: space.updatedAt,
-        name: space.spaceName,
-        spaceTuyaUuid: space.community.externalId,
-      };
-    } catch (err) {
-      if (err instanceof BadRequestException) {
-        throw err; // Re-throw BadRequestException
-      } else {
-        throw new HttpException('Space not found', HttpStatus.NOT_FOUND);
-      }
-    }
-  }
-
-  async getAutomationBySpace(param: GetSpaceParam) {
-    try {
-      await this.validateProject(param.projectUuid);
+      await this.validateProject(projectUuid);
 
       // Fetch automation data from the repository
       const automationData = await this.automationRepository.find({
         where: {
           space: {
-            uuid: param.spaceUuid,
+            uuid: In(spaces ?? []),
             community: {
-              uuid: param.communityUuid,
               project: {
-                uuid: param.projectUuid,
+                uuid: projectUuid,
               },
             },
           },
@@ -290,46 +189,277 @@ export class AutomationService {
     }
   }
 
-  async findAutomationBySpace(spaceUuid: string, projectUuid: string) {
+  async getAutomationDetails(param: AutomationParamDto) {
+    await this.validateProject(param.projectUuid);
+
     try {
-      await this.getSpaceByUuid(spaceUuid, projectUuid);
-
-      const automationData = await this.automationRepository.find({
-        where: {
-          space: { uuid: spaceUuid },
-          disabled: false,
-        },
-        relations: ['space'],
-      });
-
-      const automations = await Promise.all(
-        automationData.map(async (automation) => {
-          // eslint-disable-next-line @typescript-eslint/no-unused-vars
-          const { actions, ...automationDetails } =
-            await this.getAutomation(automation);
-
-          return automationDetails;
-        }),
+      const automation = await this.findAutomationByUuid(
+        param.automationUuid,
+        param.projectUuid,
       );
 
-      return automations;
-    } catch (err) {
+      const automationDetails = await this.getAutomation(automation);
+
+      return automationDetails;
+    } catch (error) {
       console.error(
-        `Error fetching Tap-to-Run scenes for space UUID ${spaceUuid}:`,
-        err.message,
+        `Error fetching automation details for automationUuid ${param.automationUuid}:`,
+        error,
       );
 
-      if (err instanceof HttpException) {
-        throw err;
+      if (error instanceof HttpException) {
+        throw error;
       } else {
         throw new HttpException(
-          'An error occurred while retrieving scenes',
+          'An error occurred while retrieving automation details',
           HttpStatus.INTERNAL_SERVER_ERROR,
         );
       }
     }
   }
-  async getTapToRunSceneDetailsTuya(
+  async updateAutomation(
+    updateAutomationDto: UpdateAutomationDto,
+    param: AutomationParamDto,
+  ) {
+    await this.validateProject(param.projectUuid);
+
+    try {
+      const automation = await this.findAutomationByUuid(
+        param.automationUuid,
+        param.projectUuid,
+      );
+      const space = await this.getSpaceByUuid(
+        automation.space.uuid,
+        param.projectUuid,
+      );
+
+      const updateTuyaAutomationResponse =
+        await this.updateAutomationExternalService(
+          space.spaceTuyaUuid,
+          automation.automationTuyaUuid,
+          updateAutomationDto,
+          param.projectUuid,
+        );
+
+      if (!updateTuyaAutomationResponse.success) {
+        throw new HttpException(
+          `Failed to update a external automation`,
+          HttpStatus.BAD_GATEWAY,
+        );
+      }
+      const updatedScene = await this.automationRepository.update(
+        { uuid: param.automationUuid },
+        {
+          space: { uuid: automation.space.uuid },
+        },
+      );
+      return new SuccessResponseDto({
+        data: updatedScene,
+        message: `Automation with ID ${param.automationUuid} updated successfully`,
+      });
+    } 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,
+    param: AutomationParamDto,
+  ) {
+    const { isEnable, spaceUuid } = updateAutomationStatusDto;
+    await this.validateProject(param.projectUuid);
+
+    try {
+      const automation = await this.findAutomationByUuid(
+        param.automationUuid,
+        param.projectUuid,
+      );
+      const space = await this.getSpaceByUuid(spaceUuid, param.projectUuid);
+      if (!space.spaceTuyaUuid) {
+        throw new HttpException(
+          `Invalid space UUID ${spaceUuid}`,
+          HttpStatus.NOT_FOUND,
+        );
+      }
+
+      const response = await this.tuyaService.updateAutomationState(
+        space.spaceTuyaUuid,
+        automation.automationTuyaUuid,
+        isEnable,
+      );
+
+      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 deleteAutomation(param: AutomationParamDto) {
+    const { automationUuid } = param;
+    await this.validateProject(param.projectUuid);
+
+    try {
+      const automationData = await this.findAutomationByUuid(
+        automationUuid,
+        param.projectUuid,
+      );
+      const space = await this.getSpaceByUuid(
+        automationData.space.uuid,
+        param.projectUuid,
+      );
+      await this.delete(automationData.automationTuyaUuid, space.spaceTuyaUuid);
+      const existingSceneDevice = await this.sceneDeviceRepository.findOne({
+        where: { automationTuyaUuid: automationData.automationTuyaUuid },
+      });
+
+      if (existingSceneDevice) {
+        await this.sceneDeviceRepository.delete({
+          automationTuyaUuid: automationData.automationTuyaUuid,
+        });
+      }
+      await this.automationRepository.update(
+        {
+          uuid: automationUuid,
+        },
+        { disabled: true },
+      );
+      return new SuccessResponseDto({
+        message: `Automation with ID ${automationUuid} deleted successfully`,
+      });
+    } catch (err) {
+      if (err instanceof HttpException) {
+        throw err;
+      } else {
+        throw new HttpException(
+          err.message || `Automation not found for id ${param.automationUuid}`,
+          err.status || HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+
+  private async createAutomationExternalService(
+    params: AddAutomationParams,
+    projectUuid: string,
+  ) {
+    try {
+      const formattedActions = await this.prepareActions(
+        params.actions,
+        projectUuid,
+      );
+      const formattedCondition = await this.prepareConditions(
+        params.conditions,
+        projectUuid,
+      );
+
+      const response = await this.tuyaService.createAutomation(
+        params.spaceTuyaId,
+        params.automationName,
+        params.effectiveTime,
+        params.decisionExpr,
+        formattedCondition,
+        formattedActions,
+      );
+
+      if (!response.result?.id) {
+        throw new HttpException(
+          'Failed to create automation in Tuya',
+          HttpStatus.INTERNAL_SERVER_ERROR,
+        );
+      }
+
+      return response;
+    } catch (err) {
+      if (err instanceof HttpException) {
+        throw err;
+      } else if (err.message?.includes('tuya')) {
+        throw new HttpException(
+          'API error: Failed to create automation',
+          HttpStatus.BAD_GATEWAY,
+        );
+      } else {
+        throw new HttpException(
+          `An Internal error has been occured ${err}`,
+          HttpStatus.INTERNAL_SERVER_ERROR,
+        );
+      }
+    }
+  }
+  private async add(params: AddAutomationParams, projectUuid: string) {
+    try {
+      const response = await this.createAutomationExternalService(
+        params,
+        projectUuid,
+      );
+
+      const automation = await this.automationRepository.save({
+        automationTuyaUuid: response.result.id,
+        space: { uuid: params.spaceUuid },
+      });
+
+      return automation;
+    } catch (err) {
+      if (err instanceof HttpException) {
+        throw err;
+      } else if (err.message?.includes('tuya')) {
+        throw new HttpException(
+          'API error: Failed to create automation',
+          HttpStatus.BAD_GATEWAY,
+        );
+      } else {
+        throw new HttpException(
+          'Database error: Failed to save automation',
+          HttpStatus.INTERNAL_SERVER_ERROR,
+        );
+      }
+    }
+  }
+
+  private async getSpaceByUuid(spaceUuid: string, projectUuid: string) {
+    try {
+      const space = await this.spaceRepository.findOne({
+        where: {
+          uuid: spaceUuid,
+          community: {
+            project: {
+              uuid: projectUuid,
+            },
+          },
+        },
+        relations: ['community'],
+      });
+      if (!space) {
+        throw new BadRequestException(`Invalid space UUID ${spaceUuid}`);
+      }
+      return {
+        uuid: space.uuid,
+        createdAt: space.createdAt,
+        updatedAt: space.updatedAt,
+        name: space.spaceName,
+        spaceTuyaUuid: space.community.externalId,
+      };
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err; // Re-throw BadRequestException
+      } else {
+        throw new HttpException('Space not found', HttpStatus.NOT_FOUND);
+      }
+    }
+  }
+
+  private async getTapToRunSceneDetailsTuya(
     sceneUuid: string,
   ): Promise<AutomationDetailsResult> {
     try {
@@ -361,35 +491,8 @@ export class AutomationService {
       }
     }
   }
-  async getAutomationDetails(param: AutomationParamDto) {
-    await this.validateProject(param.projectUuid);
 
-    try {
-      const automation = await this.findAutomation(
-        param.automationUuid,
-        param.projectUuid,
-      );
-
-      const automationDetails = await this.getAutomation(automation);
-
-      return automationDetails;
-    } catch (error) {
-      console.error(
-        `Error fetching automation details for automationUuid ${param.automationUuid}:`,
-        error,
-      );
-
-      if (error instanceof HttpException) {
-        throw error;
-      } else {
-        throw new HttpException(
-          'An error occurred while retrieving automation details',
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-    }
-  }
-  async getAutomation(automation: AutomationEntity) {
+  private async getAutomation(automation: AutomationEntity) {
     try {
       const response = await this.tuyaService.getSceneRule(
         automation.automationTuyaUuid,
@@ -496,13 +599,13 @@ export class AutomationService {
       }
     }
   }
-  async findAutomation(
-    sceneUuid: string,
+  private async findAutomationByUuid(
+    uuid: string,
     projectUuid: string,
   ): Promise<AutomationEntity> {
     const automation = await this.automationRepository.findOne({
       where: {
-        uuid: sceneUuid,
+        uuid: uuid,
         space: { community: { project: { uuid: projectUuid } } },
       },
       relations: ['space'],
@@ -510,57 +613,14 @@ export class AutomationService {
 
     if (!automation) {
       throw new HttpException(
-        `Invalid automation with id ${sceneUuid}`,
+        `Invalid automation with id ${uuid}`,
         HttpStatus.NOT_FOUND,
       );
     }
     return automation;
   }
 
-  async deleteAutomation(param: AutomationParamDto) {
-    const { automationUuid } = param;
-    await this.validateProject(param.projectUuid);
-
-    try {
-      const automationData = await this.findAutomation(
-        automationUuid,
-        param.projectUuid,
-      );
-      const space = await this.getSpaceByUuid(
-        automationData.space.uuid,
-        param.projectUuid,
-      );
-      await this.delete(automationData.automationTuyaUuid, space.spaceTuyaUuid);
-      const existingSceneDevice = await this.sceneDeviceRepository.findOne({
-        where: { automationTuyaUuid: automationData.automationTuyaUuid },
-      });
-
-      if (existingSceneDevice) {
-        await this.sceneDeviceRepository.delete({
-          automationTuyaUuid: automationData.automationTuyaUuid,
-        });
-      }
-      await this.automationRepository.update(
-        {
-          uuid: automationUuid,
-        },
-        { disabled: true },
-      );
-      return new SuccessResponseDto({
-        message: `Automation with ID ${automationUuid} deleted successfully`,
-      });
-    } catch (err) {
-      if (err instanceof HttpException) {
-        throw err;
-      } else {
-        throw new HttpException(
-          err.message || `Automation not found for id ${param.automationUuid}`,
-          err.status || HttpStatus.NOT_FOUND,
-        );
-      }
-    }
-  }
-  async delete(tuyaAutomationId: string, tuyaSpaceId: string) {
+  private async delete(tuyaAutomationId: string, tuyaSpaceId: string) {
     try {
       const response = (await this.tuyaService.deleteSceneRule(
         tuyaAutomationId,
@@ -578,7 +638,7 @@ export class AutomationService {
       }
     }
   }
-  async updateAutomationExternalService(
+  private async updateAutomationExternalService(
     spaceTuyaUuid: string,
     automationUuid: string,
     updateAutomationDto: UpdateAutomationDto,
@@ -626,95 +686,6 @@ export class AutomationService {
       }
     }
   }
-  async updateAutomation(
-    updateAutomationDto: UpdateAutomationDto,
-    param: AutomationParamDto,
-  ) {
-    await this.validateProject(param.projectUuid);
-
-    try {
-      const automation = await this.findAutomation(
-        param.automationUuid,
-        param.projectUuid,
-      );
-      const space = await this.getSpaceByUuid(
-        automation.space.uuid,
-        param.projectUuid,
-      );
-
-      const updateTuyaAutomationResponse =
-        await this.updateAutomationExternalService(
-          space.spaceTuyaUuid,
-          automation.automationTuyaUuid,
-          updateAutomationDto,
-          param.projectUuid,
-        );
-
-      if (!updateTuyaAutomationResponse.success) {
-        throw new HttpException(
-          `Failed to update a external automation`,
-          HttpStatus.BAD_GATEWAY,
-        );
-      }
-      const updatedScene = await this.automationRepository.update(
-        { uuid: param.automationUuid },
-        {
-          space: { uuid: automation.space.uuid },
-        },
-      );
-      return new SuccessResponseDto({
-        data: updatedScene,
-        message: `Automation with ID ${param.automationUuid} updated successfully`,
-      });
-    } 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,
-    param: AutomationParamDto,
-  ) {
-    const { isEnable, spaceUuid } = updateAutomationStatusDto;
-    await this.validateProject(param.projectUuid);
-
-    try {
-      const automation = await this.findAutomation(
-        param.automationUuid,
-        param.projectUuid,
-      );
-      const space = await this.getSpaceByUuid(spaceUuid, param.projectUuid);
-      if (!space.spaceTuyaUuid) {
-        throw new HttpException(
-          `Invalid space UUID ${spaceUuid}`,
-          HttpStatus.NOT_FOUND,
-        );
-      }
-
-      const response = await this.tuyaService.updateAutomationState(
-        space.spaceTuyaUuid,
-        automation.automationTuyaUuid,
-        isEnable,
-      );
-
-      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,
-        );
-      }
-    }
-  }
 
   private async prepareActions(
     actions: Action[],
@@ -753,7 +724,7 @@ export class AutomationService {
           action.action_executor === ActionExecutorEnum.RULE_ENABLE
         ) {
           if (action.action_type === ActionTypeEnum.AUTOMATION) {
-            const automation = await this.findAutomation(
+            const automation = await this.findAutomationByUuid(
               action.entity_id,
               projectUuid,
             );

src/booking/booking.module.ts

@@ -0,0 +1,29 @@
+import { BookingRepositoryModule } from '@app/common/modules/booking/booking.repository.module';
+import { BookableSpaceEntityRepository } from '@app/common/modules/booking/repositories/bookable-space.repository';
+import { BookingEntityRepository } from '@app/common/modules/booking/repositories/booking.repository';
+import { SpaceRepository } from '@app/common/modules/space';
+import { UserRepository } from '@app/common/modules/user/repositories';
+import { EmailService } from '@app/common/util/email/email.service';
+import { Global, Module } from '@nestjs/common';
+import { BookableSpaceController } from './controllers/bookable-space.controller';
+import { BookingController } from './controllers/booking.controller';
+import { BookableSpaceService } from './services/bookable-space.service';
+import { BookingService } from './services/booking.service';
+
+@Global()
+@Module({
+  imports: [BookingRepositoryModule],
+  controllers: [BookableSpaceController, BookingController],
+  providers: [
+    BookableSpaceService,
+    BookingService,
+    EmailService,
+    BookableSpaceEntityRepository,
+    BookingEntityRepository,
+
+    SpaceRepository,
+    UserRepository,
+  ],
+  exports: [BookableSpaceService, BookingService],
+})
+export class BookingModule {}

src/booking/controllers/bookable-space.controller.ts

@@ -0,0 +1,107 @@
+import { ControllerRoute } from '@app/common/constants/controller-route';
+import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Post,
+  Put,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { PageResponse } from '@app/common/dto/pagination.response.dto';
+import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
+import { plainToInstance } from 'class-transformer';
+import { BookableSpaceRequestDto } from '../dtos/bookable-space-request.dto';
+import { BookableSpaceResponseDto } from '../dtos/bookable-space-response.dto';
+import { CreateBookableSpaceDto } from '../dtos/create-bookable-space.dto';
+import { UpdateBookableSpaceDto } from '../dtos/update-bookable-space.dto';
+import { BookableSpaceService } from '../services/bookable-space.service';
+
+@ApiTags('Booking Module')
+@Controller({
+  version: EnableDisableStatusEnum.ENABLED,
+  path: ControllerRoute.BOOKABLE_SPACES.ROUTE,
+})
+export class BookableSpaceController {
+  constructor(private readonly bookableSpaceService: BookableSpaceService) {}
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Post()
+  @ApiOperation({
+    summary:
+      ControllerRoute.BOOKABLE_SPACES.ACTIONS.ADD_BOOKABLE_SPACES_SUMMARY,
+    description:
+      ControllerRoute.BOOKABLE_SPACES.ACTIONS.ADD_BOOKABLE_SPACES_DESCRIPTION,
+  })
+  async create(@Body() dto: CreateBookableSpaceDto): Promise<BaseResponseDto> {
+    const result = await this.bookableSpaceService.create(dto);
+    return new SuccessResponseDto({
+      data: result,
+      message: 'Successfully created bookable spaces',
+    });
+  }
+
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Get()
+  @ApiOperation({
+    summary:
+      ControllerRoute.BOOKABLE_SPACES.ACTIONS.GET_ALL_BOOKABLE_SPACES_SUMMARY,
+    description:
+      ControllerRoute.BOOKABLE_SPACES.ACTIONS
+        .GET_ALL_BOOKABLE_SPACES_DESCRIPTION,
+  })
+  async findAll(
+    @Query() query: BookableSpaceRequestDto,
+    @Req() req: Request,
+  ): Promise<PageResponse<BookableSpaceResponseDto>> {
+    const project = req['user']?.project?.uuid;
+    if (!project) {
+      throw new Error('Project UUID is required in the request');
+    }
+    const { data, pagination } = await this.bookableSpaceService.findAll(
+      query,
+      project,
+    );
+    return new PageResponse<BookableSpaceResponseDto>(
+      {
+        data: data.map((space) =>
+          plainToInstance(BookableSpaceResponseDto, space, {
+            excludeExtraneousValues: true,
+          }),
+        ),
+        message: 'Successfully fetched all bookable spaces',
+      },
+      pagination,
+    );
+  }
+
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Put(':spaceUuid')
+  @ApiOperation({
+    summary:
+      ControllerRoute.BOOKABLE_SPACES.ACTIONS.UPDATE_BOOKABLE_SPACES_SUMMARY,
+    description:
+      ControllerRoute.BOOKABLE_SPACES.ACTIONS
+        .UPDATE_BOOKABLE_SPACES_DESCRIPTION,
+  })
+  async update(
+    @Param('spaceUuid', ParseUUIDPipe) spaceUuid: string,
+    @Body() dto: UpdateBookableSpaceDto,
+  ): Promise<BaseResponseDto> {
+    const result = await this.bookableSpaceService.update(spaceUuid, dto);
+    return new SuccessResponseDto({
+      data: result,
+      message: 'Successfully updated bookable spaces',
+    });
+  }
+}

src/booking/controllers/booking.controller.ts

@@ -0,0 +1,107 @@
+import { ControllerRoute } from '@app/common/constants/controller-route';
+import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
+import {
+  Body,
+  Controller,
+  Get,
+  Post,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
+import { plainToInstance } from 'class-transformer';
+import { AdminRoleGuard } from 'src/guards/admin.role.guard';
+import { BookingRequestDto } from '../dtos/booking-request.dto';
+import { BookingResponseDto } from '../dtos/booking-response.dto';
+import { CreateBookingDto } from '../dtos/create-booking.dto';
+import { MyBookingRequestDto } from '../dtos/my-booking-request.dto';
+import { BookingService } from '../services/booking.service';
+
+@ApiTags('Booking Module')
+@Controller({
+  version: EnableDisableStatusEnum.ENABLED,
+  path: ControllerRoute.BOOKING.ROUTE,
+})
+export class BookingController {
+  constructor(private readonly bookingService: BookingService) {}
+
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Post()
+  @ApiOperation({
+    summary: ControllerRoute.BOOKING.ACTIONS.ADD_BOOKING_SUMMARY,
+    description: ControllerRoute.BOOKING.ACTIONS.ADD_BOOKING_DESCRIPTION,
+  })
+  async create(
+    @Body() dto: CreateBookingDto,
+    @Req() req: Request,
+  ): Promise<BaseResponseDto> {
+    const userUuid = req['user']?.uuid;
+    if (!userUuid) {
+      throw new Error('User UUID is required in the request');
+    }
+    const result = await this.bookingService.create(userUuid, dto);
+    return new SuccessResponseDto({
+      data: result,
+      message: 'Successfully created booking',
+    });
+  }
+
+  @ApiBearerAuth()
+  @UseGuards(AdminRoleGuard)
+  @Get()
+  @ApiOperation({
+    summary: ControllerRoute.BOOKING.ACTIONS.GET_ALL_BOOKINGS_SUMMARY,
+    description: ControllerRoute.BOOKING.ACTIONS.GET_ALL_BOOKINGS_DESCRIPTION,
+  })
+  async findAll(
+    @Query() query: BookingRequestDto,
+    @Req() req: Request,
+  ): Promise<BaseResponseDto> {
+    const project = req['user']?.project?.uuid;
+    if (!project) {
+      throw new Error('Project UUID is required in the request');
+    }
+    const result = await this.bookingService.findAll(query, project);
+    return new SuccessResponseDto({
+      data: plainToInstance(BookingResponseDto, result, {
+        excludeExtraneousValues: true,
+      }),
+      message: 'Successfully fetched all bookings',
+    });
+  }
+
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Get('my-bookings')
+  @ApiOperation({
+    summary: ControllerRoute.BOOKING.ACTIONS.GET_MY_BOOKINGS_SUMMARY,
+    description: ControllerRoute.BOOKING.ACTIONS.GET_MY_BOOKINGS_DESCRIPTION,
+  })
+  async findMyBookings(
+    @Query() query: MyBookingRequestDto,
+    @Req() req: Request,
+  ): Promise<BaseResponseDto> {
+    const userUuid = req['user']?.uuid;
+    const project = req['user']?.project?.uuid;
+    if (!project) {
+      throw new Error('Project UUID is required in the request');
+    }
+    const result = await this.bookingService.findMyBookings(
+      query,
+      userUuid,
+      project,
+    );
+    return new SuccessResponseDto({
+      data: plainToInstance(BookingResponseDto, result, {
+        excludeExtraneousValues: true,
+      }),
+      message: 'Successfully fetched all bookings',
+    });
+  }
+}

src/booking/dtos/bookable-space-request.dto.ts

@@ -0,0 +1,31 @@
+import { BooleanValues } from '@app/common/constants/boolean-values.enum';
+import { PaginationRequestWithSearchGetListDto } from '@app/common/dto/pagination-with-search.request.dto';
+import { ApiProperty, OmitType } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import { IsBoolean, IsNotEmpty, IsOptional } from 'class-validator';
+
+export class BookableSpaceRequestDto extends OmitType(
+  PaginationRequestWithSearchGetListDto,
+  ['includeSpaces'],
+) {
+  @ApiProperty({
+    type: Boolean,
+    required: false,
+  })
+  @IsBoolean()
+  @IsOptional()
+  @Transform(({ obj }) => {
+    return obj.active === BooleanValues.TRUE;
+  })
+  active?: boolean;
+
+  @ApiProperty({
+    type: Boolean,
+  })
+  @IsBoolean()
+  @IsNotEmpty()
+  @Transform(({ obj }) => {
+    return obj.configured === BooleanValues.TRUE;
+  })
+  configured: boolean;
+}

src/booking/dtos/bookable-space-response.dto.ts

@@ -0,0 +1,59 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose, Type } from 'class-transformer';
+export class BookableSpaceConfigResponseDto {
+  @ApiProperty()
+  @Expose()
+  uuid: string;
+
+  @ApiProperty({
+    type: [String],
+  })
+  @Expose()
+  daysAvailable: string[];
+
+  @ApiProperty()
+  @Expose()
+  startTime: string;
+
+  @ApiProperty()
+  @Expose()
+  endTime: string;
+
+  @ApiProperty({
+    type: Boolean,
+  })
+  @Expose()
+  active: boolean;
+
+  @ApiProperty({
+    type: Number,
+    nullable: true,
+  })
+  @Expose()
+  points?: number;
+}
+
+export class BookableSpaceResponseDto {
+  @ApiProperty()
+  @Expose()
+  uuid: string;
+
+  @ApiProperty()
+  @Expose()
+  spaceUuid: string;
+
+  @ApiProperty()
+  @Expose()
+  spaceName: string;
+
+  @ApiProperty()
+  @Expose()
+  virtualLocation: string;
+
+  @ApiProperty({
+    type: BookableSpaceConfigResponseDto,
+  })
+  @Expose()
+  @Type(() => BookableSpaceConfigResponseDto)
+  bookableConfig: BookableSpaceConfigResponseDto;
+}

src/booking/dtos/booking-request.dto.ts

@@ -0,0 +1,23 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsOptional, IsUUID, Matches } from 'class-validator';
+
+export class BookingRequestDto {
+  @ApiProperty({
+    description: 'Month in MM-YYYY format',
+    example: '07-2025',
+  })
+  @IsNotEmpty()
+  @Matches(/^(0[1-9]|1[0-2])\-\d{4}$/, {
+    message: 'Date must be in MM/YYYY format',
+  })
+  month: string;
+
+  @ApiProperty({
+    description: 'Space UUID',
+    example: '550e8400-e29b-41d4-a716-446655440000',
+    required: false,
+  })
+  @IsOptional()
+  @IsUUID('4')
+  space?: string;
+}

src/booking/dtos/booking-response.dto.ts

@@ -0,0 +1,88 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose, Transform, Type } from 'class-transformer';
+
+export class BookingUserResponseDto {
+  @ApiProperty()
+  @Expose()
+  uuid: string;
+
+  @ApiProperty()
+  @Expose()
+  firstName: string;
+
+  @ApiProperty()
+  @Expose()
+  lastName: string;
+
+  @ApiProperty({
+    type: String,
+    nullable: true,
+  })
+  @Expose()
+  email: string;
+
+  @ApiProperty({
+    type: String,
+    nullable: true,
+  })
+  @Expose()
+  @Transform(({ obj }) => obj.inviteUser?.companyName || null)
+  companyName: string;
+
+  @ApiProperty({
+    type: String,
+    nullable: true,
+  })
+  @Expose()
+  phoneNumber: string;
+}
+
+export class BookingSpaceResponseDto {
+  @ApiProperty()
+  @Expose()
+  uuid: string;
+
+  @ApiProperty()
+  @Expose()
+  spaceName: string;
+}
+
+export class BookingResponseDto {
+  @ApiProperty()
+  @Expose()
+  uuid: string;
+
+  @ApiProperty({
+    type: Date,
+  })
+  @Expose()
+  date: Date;
+
+  @ApiProperty()
+  @Expose()
+  startTime: string;
+
+  @ApiProperty()
+  @Expose()
+  endTime: string;
+
+  @ApiProperty({
+    type: Number,
+  })
+  @Expose()
+  cost: number;
+
+  @ApiProperty({
+    type: BookingUserResponseDto,
+  })
+  @Type(() => BookingUserResponseDto)
+  @Expose()
+  user: BookingUserResponseDto;
+
+  @ApiProperty({
+    type: BookingSpaceResponseDto,
+  })
+  @Type(() => BookingSpaceResponseDto)
+  @Expose()
+  space: BookingSpaceResponseDto;
+}

src/booking/dtos/create-bookable-space.dto.ts

@@ -0,0 +1,63 @@
+import { DaysEnum } from '@app/common/constants/days.enum';
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  ArrayMinSize,
+  IsArray,
+  IsEnum,
+  IsInt,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+  Matches,
+  Max,
+  Min,
+} from 'class-validator';
+
+export class CreateBookableSpaceDto {
+  @ApiProperty({
+    type: 'string',
+    isArray: true,
+    example: [
+      '3fa85f64-5717-4562-b3fc-2c963f66afa6',
+      '4fa85f64-5717-4562-b3fc-2c963f66afa7',
+    ],
+  })
+  @IsArray()
+  @ArrayMinSize(1, { message: 'At least one space must be selected' })
+  @IsUUID('all', { each: true, message: 'Invalid space UUID provided' })
+  spaceUuids: string[];
+
+  @ApiProperty({
+    enum: DaysEnum,
+    isArray: true,
+    example: [DaysEnum.MON, DaysEnum.WED, DaysEnum.FRI],
+  })
+  @IsArray()
+  @ArrayMinSize(1, { message: 'At least one day must be selected' })
+  @IsEnum(DaysEnum, { each: true, message: 'Invalid day provided' })
+  daysAvailable: DaysEnum[];
+
+  @ApiProperty({ example: '09:00' })
+  @IsString()
+  @IsNotEmpty({ message: 'Start time cannot be empty' })
+  @Matches(/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/, {
+    message: 'Start time must be in HH:mm format (24-hour)',
+  })
+  startTime: string;
+
+  @ApiProperty({ example: '17:00' })
+  @IsString()
+  @IsNotEmpty({ message: 'End time cannot be empty' })
+  @Matches(/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/, {
+    message: 'End time must be in HH:mm format (24-hour)',
+  })
+  endTime: string;
+
+  @ApiProperty({ example: 10, required: false })
+  @IsOptional()
+  @IsInt()
+  @Min(0, { message: 'Points cannot be negative' })
+  @Max(1000, { message: 'Points cannot exceed 1000' })
+  points?: number;
+}

src/booking/dtos/create-booking.dto.ts

@@ -0,0 +1,43 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsDate,
+  IsNotEmpty,
+  IsString,
+  IsUUID,
+  Matches,
+  MinDate,
+} from 'class-validator';
+
+export class CreateBookingDto {
+  @ApiProperty({
+    type: 'string',
+    example: '4fa85f64-5717-4562-b3fc-2c963f66afa7',
+  })
+  @IsNotEmpty()
+  @IsUUID('4', { message: 'Invalid space UUID provided' })
+  spaceUuid: string;
+
+  @ApiProperty({
+    type: Date,
+  })
+  @IsNotEmpty()
+  @IsDate()
+  @MinDate(new Date())
+  date: Date;
+
+  @ApiProperty({ example: '09:00' })
+  @IsString()
+  @IsNotEmpty({ message: 'Start time cannot be empty' })
+  @Matches(/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/, {
+    message: 'Start time must be in HH:mm format (24-hour)',
+  })
+  startTime: string;
+
+  @ApiProperty({ example: '17:00' })
+  @IsString()
+  @IsNotEmpty({ message: 'End time cannot be empty' })
+  @Matches(/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/, {
+    message: 'End time must be in HH:mm format (24-hour)',
+  })
+  endTime: string;
+}

src/booking/dtos/my-booking-request.dto.ts

@@ -0,0 +1,14 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsIn, IsOptional } from 'class-validator';
+
+export class MyBookingRequestDto {
+  @ApiProperty({
+    description: 'Filter bookings by time period',
+    example: 'past',
+    enum: ['past', 'future'],
+    required: false,
+  })
+  @IsOptional()
+  @IsIn(['past', 'future'])
+  when?: 'past' | 'future';
+}

src/booking/dtos/update-bookable-space.dto.ts

@@ -0,0 +1,12 @@
+import { ApiProperty, OmitType, PartialType } from '@nestjs/swagger';
+import { IsBoolean, IsOptional } from 'class-validator';
+import { CreateBookableSpaceDto } from './create-bookable-space.dto';
+
+export class UpdateBookableSpaceDto extends PartialType(
+  OmitType(CreateBookableSpaceDto, ['spaceUuids']),
+) {
+  @ApiProperty({ type: Boolean })
+  @IsOptional()
+  @IsBoolean()
+  active?: boolean;
+}

src/booking/index.ts

@@ -0,0 +1 @@
+export * from './booking.module';

src/booking/services/bookable-space.service.ts

@@ -0,0 +1,371 @@
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+import { PageResponseDto } from '@app/common/dto/pagination.response.dto';
+import { timeToMinutes } from '@app/common/helper/timeToMinutes';
+import { TypeORMCustomModel } from '@app/common/models/typeOrmCustom.model';
+import { BookableSpaceEntityRepository } from '@app/common/modules/booking/repositories/bookable-space.repository';
+import { BookingEntityRepository } from '@app/common/modules/booking/repositories/booking.repository';
+import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
+import { SpaceRepository } from '@app/common/modules/space/repositories/space.repository';
+import { EmailService } from '@app/common/util/email/email.service';
+import { to12HourFormat } from '@app/common/util/time-to-12-hours-convetion';
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { format } from 'date-fns';
+import { Brackets, In } from 'typeorm';
+import { BookableSpaceRequestDto } from '../dtos/bookable-space-request.dto';
+import { CreateBookableSpaceDto } from '../dtos/create-bookable-space.dto';
+import { UpdateBookableSpaceDto } from '../dtos/update-bookable-space.dto';
+
+@Injectable()
+export class BookableSpaceService {
+  constructor(
+    private readonly emailService: EmailService,
+    private readonly bookableSpaceEntityRepository: BookableSpaceEntityRepository,
+    private readonly bookingEntityRepository: BookingEntityRepository,
+    private readonly spaceRepository: SpaceRepository,
+  ) {}
+
+  async create(dto: CreateBookableSpaceDto) {
+    // Validate time slots first
+    this.validateTimeSlot(dto.startTime, dto.endTime);
+
+    // fetch spaces exist
+    const spaces = await this.getSpacesOrFindMissing(dto.spaceUuids);
+
+    // Validate no duplicate bookable configurations
+    await this.validateNoDuplicateBookableConfigs(dto.spaceUuids);
+
+    // Create and save bookable spaces
+    return this.createBookableSpaces(spaces, dto);
+  }
+
+  async findAll(
+    { active, page, size, configured, search }: BookableSpaceRequestDto,
+    project: string,
+  ): Promise<{
+    data: BaseResponseDto['data'];
+    pagination: PageResponseDto;
+  }> {
+    let qb = this.spaceRepository
+      .createQueryBuilder('space')
+      .leftJoinAndSelect('space.parent', 'parentSpace')
+      .leftJoinAndSelect('space.community', 'community')
+      .where('space.disabled = :disabled', { disabled: false })
+      .andWhere('community.project = :project', { project });
+
+    if (search) {
+      qb = qb.andWhere(
+        '(space.spaceName ILIKE :search OR community.name ILIKE :search OR parentSpace.spaceName ILIKE :search)',
+        { search: `%${search}%` },
+      );
+    }
+    if (configured) {
+      qb = qb
+        .leftJoinAndSelect('space.bookableConfig', 'bookableConfig')
+        .andWhere('bookableConfig.uuid IS NOT NULL');
+      if (active !== undefined) {
+        qb = qb.andWhere('bookableConfig.active = :active', { active });
+      }
+    } else {
+      qb = qb
+        .leftJoinAndSelect('space.bookableConfig', 'bookableConfig')
+        .andWhere('bookableConfig.uuid IS NULL');
+    }
+    const customModel = TypeORMCustomModel(this.spaceRepository);
+
+    const { baseResponseDto, paginationResponseDto } =
+      await customModel.findAll({ page, size, modelName: 'space' }, qb);
+    return {
+      data: baseResponseDto.data.map((space) => {
+        return {
+          ...space,
+          virtualLocation: `${space.community?.name} - ${space.parent ? space.parent?.spaceName + ' - ' : ''}${space.spaceName}`,
+        };
+      }),
+      pagination: paginationResponseDto,
+    };
+  }
+
+  /**
+   * Update bookable space configuration
+   */
+  async update(spaceUuid: string, dto: UpdateBookableSpaceDto) {
+    // fetch spaces exist
+    const space = (await this.getSpacesOrFindMissing([spaceUuid]))[0];
+
+    if (!space.bookableConfig) {
+      throw new NotFoundException(
+        `Bookable configuration not found for space: ${spaceUuid}`,
+      );
+    }
+    if (dto.startTime || dto.endTime) {
+      // Validate time slots first
+      this.validateTimeSlot(
+        dto.startTime || space.bookableConfig.startTime,
+        dto.endTime || space.bookableConfig.endTime,
+      );
+      if (
+        dto.startTime != space.bookableConfig.startTime ||
+        dto.endTime != space.bookableConfig.endTime ||
+        dto.daysAvailable != space.bookableConfig.daysAvailable
+      ) {
+        this.handleTimingUpdate(
+          {
+            daysAvailable:
+              dto.daysAvailable || space.bookableConfig.daysAvailable,
+            startTime: dto.startTime || space.bookableConfig.startTime,
+            endTime: dto.endTime || space.bookableConfig.endTime,
+          },
+          space,
+        );
+      }
+    }
+
+    if (
+      dto.active !== undefined &&
+      dto.active !== space.bookableConfig.active
+    ) {
+      this.handleAvailabilityUpdate(dto.active, space);
+    }
+
+    Object.assign(space.bookableConfig, dto);
+    return this.bookableSpaceEntityRepository.save(space.bookableConfig);
+  }
+
+  private async handleTimingUpdate(
+    dto: UpdateBookableSpaceDto,
+    space: SpaceEntity,
+  ): Promise<void> {
+    const affectedUsers = await this.getAffectedBookings(space.uuid);
+    if (!affectedUsers.length) return;
+
+    const groupedParams = this.groupBookingsByUser(affectedUsers);
+
+    return this.emailService.sendUpdateBookingTimingEmailWithTemplate(
+      groupedParams,
+      {
+        space_name: space.spaceName,
+        start_time: to12HourFormat(dto.startTime),
+        end_time: to12HourFormat(dto.endTime),
+        days: dto.daysAvailable.join(', '),
+      },
+    );
+  }
+
+  private async getAffectedBookings(spaceUuid: string) {
+    const today = new Date();
+    const nowTime = format(today, 'HH:mm');
+
+    const bookingWithDayCte = this.bookingEntityRepository
+      .createQueryBuilder('b')
+      .select('b.*')
+      .addSelect(
+        `
+        CASE EXTRACT(DOW FROM b.date)
+          WHEN 0 THEN 'Sun'
+          WHEN 1 THEN 'Mon'
+          WHEN 2 THEN 'Tue'
+          WHEN 3 THEN 'Wed'
+          WHEN 4 THEN 'Thu'
+          WHEN 5 THEN 'Fri'
+          WHEN 6 THEN 'Sat'
+        END::"bookable-space_days_available_enum"
+      `,
+        'booking_day',
+      )
+      .where(
+        `(DATE(b.date) > :today OR (DATE(b.date) = :today AND b.startTime >= :nowTime))`,
+        { today, nowTime },
+      )
+      .andWhere('b.space_uuid = :spaceUuid', { spaceUuid });
+
+    const query = this.bookableSpaceEntityRepository
+      .createQueryBuilder('bs')
+      .distinct(true)
+      .addCommonTableExpression(bookingWithDayCte, 'booking_with_day')
+      .select('u.first_name', 'name')
+      .addSelect('u.email', 'email')
+      .addSelect('DATE(bwd.date)', 'date')
+      .addSelect('bwd.start_time', 'start_time')
+      .addSelect('bwd.end_time', 'end_time')
+      .from('booking_with_day', 'bwd')
+      .innerJoin('user', 'u', 'u.uuid = bwd.user_uuid')
+      .where('bs.space_uuid = :spaceUuid', { spaceUuid })
+      .andWhere(
+        new Brackets((qb) => {
+          qb.where('NOT (bwd.booking_day = ANY(bs.days_available))')
+            .orWhere('bwd.start_time < bs.start_time')
+            .orWhere('bwd.end_time > bs.end_time');
+        }),
+      );
+
+    return query.getRawMany<{
+      name: string;
+      email: string;
+      date: string;
+      start_time: string;
+      end_time: string;
+    }>();
+  }
+
+  private groupBookingsByUser(
+    bookings: {
+      name: string;
+      email: string;
+      date: string;
+      start_time: string;
+      end_time: string;
+    }[],
+  ): {
+    name: string;
+    email: string;
+    bookings: { date: string; start_time: string; end_time: string }[];
+  }[] {
+    const grouped: Record<
+      string,
+      {
+        name: string;
+        email: string;
+        bookings: { date: string; start_time: string; end_time: string }[];
+      }
+    > = {};
+
+    for (const { name, email, date, start_time, end_time } of bookings) {
+      const formattedDate = format(new Date(date), 'yyyy-MM-dd');
+      const formattedStartTime = to12HourFormat(start_time);
+      const formattedEndTime = to12HourFormat(end_time);
+
+      if (!grouped[email]) {
+        grouped[email] = {
+          name,
+          email,
+          bookings: [],
+        };
+      }
+
+      grouped[email].bookings.push({
+        date: formattedDate,
+        start_time: formattedStartTime,
+        end_time: formattedEndTime,
+      });
+    }
+
+    return Object.values(grouped);
+  }
+
+  private async handleAvailabilityUpdate(
+    active: boolean,
+    space: SpaceEntity,
+  ): Promise<void> {
+    space = await this.spaceRepository.findOne({
+      where: { uuid: space.uuid },
+      relations: ['userSpaces', 'userSpaces.user'],
+    });
+    const emails = space.userSpaces.map((userSpace) => ({
+      email: userSpace.user.email,
+      name: userSpace.user.firstName,
+    }));
+    if (!emails.length) return Promise.resolve();
+
+    return this.emailService.sendUpdateBookingAvailabilityEmailWithTemplate(
+      emails,
+      {
+        availability: active ? 'Available' : 'Unavailable',
+        space_name: space.spaceName,
+        isAvailable: active,
+      },
+    );
+  }
+
+  /**
+   * Fetch spaces by UUIDs and throw an error if any are missing
+   */
+  private async getSpacesOrFindMissing(
+    spaceUuids: string[],
+  ): Promise<SpaceEntity[]> {
+    const spaces = await this.spaceRepository.find({
+      where: { uuid: In(spaceUuids) },
+      relations: ['bookableConfig'],
+    });
+
+    if (spaces.length !== spaceUuids.length) {
+      const foundUuids = spaces.map((s) => s.uuid);
+      const missingUuids = spaceUuids.filter(
+        (uuid) => !foundUuids.includes(uuid),
+      );
+      throw new NotFoundException(
+        `Spaces not found: ${missingUuids.join(', ')}`,
+      );
+    }
+
+    return spaces;
+  }
+
+  /**
+   * Validate there are no existing bookable configurations for these spaces
+   */
+  private async validateNoDuplicateBookableConfigs(
+    spaceUuids: string[],
+  ): Promise<void> {
+    const existingBookables = await this.bookableSpaceEntityRepository.find({
+      where: { space: { uuid: In(spaceUuids) } },
+      relations: ['space'],
+    });
+
+    if (existingBookables.length > 0) {
+      const existingUuids = [
+        ...new Set(existingBookables.map((b) => b.space.uuid)),
+      ];
+      throw new ConflictException(
+        `Bookable configuration already exists for spaces: ${existingUuids.join(', ')}`,
+      );
+    }
+  }
+
+  /**
+   * Ensure the slot start time is before the end time
+   */
+  private validateTimeSlot(startTime: string, endTime: string): void {
+    const start = timeToMinutes(startTime);
+    const end = timeToMinutes(endTime);
+
+    if (start >= end) {
+      throw new BadRequestException(
+        `End time must be after start time for slot: ${startTime}-${endTime}`,
+      );
+    }
+  }
+
+  /**
+   * Create bookable space entries after all validations pass
+   */
+  private async createBookableSpaces(
+    spaces: SpaceEntity[],
+    dto: CreateBookableSpaceDto,
+  ) {
+    try {
+      const entries = spaces.map((space) =>
+        this.bookableSpaceEntityRepository.create({
+          space,
+          daysAvailable: dto.daysAvailable,
+          startTime: dto.startTime,
+          endTime: dto.endTime,
+          points: dto.points,
+        }),
+      );
+
+      return this.bookableSpaceEntityRepository.save(entries);
+    } catch (error) {
+      if (error.code === '23505') {
+        throw new ConflictException(
+          'Duplicate bookable space configuration detected',
+        );
+      }
+      throw error;
+    }
+  }
+}

src/booking/services/booking.service.ts

@@ -0,0 +1,218 @@
+import { DaysEnum } from '@app/common/constants/days.enum';
+import { timeToMinutes } from '@app/common/helper/timeToMinutes';
+import { BookingEntityRepository } from '@app/common/modules/booking/repositories/booking.repository';
+import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
+import { SpaceRepository } from '@app/common/modules/space/repositories/space.repository';
+import { UserRepository } from '@app/common/modules/user/repositories/user.repository';
+import {
+  BadRequestException,
+  ConflictException,
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { format } from 'date-fns';
+import { Between } from 'typeorm/find-options/operator/Between';
+import { BookingRequestDto } from '../dtos/booking-request.dto';
+import { CreateBookingDto } from '../dtos/create-booking.dto';
+import { MyBookingRequestDto } from '../dtos/my-booking-request.dto';
+
+@Injectable()
+export class BookingService {
+  constructor(
+    private readonly bookingEntityRepository: BookingEntityRepository,
+    private readonly spaceRepository: SpaceRepository,
+    private readonly userRepository: UserRepository,
+  ) {}
+
+  async create(userUuid: string, dto: CreateBookingDto) {
+    console.log(userUuid);
+    const user = await this.userRepository.findOne({
+      where: { uuid: userUuid },
+      relations: ['userSpaces', 'userSpaces.space'],
+    });
+    console.log(user.userSpaces);
+    if (!user.userSpaces.some(({ space }) => space.uuid === dto.spaceUuid)) {
+      throw new ForbiddenException(
+        `User does not have permission to book this space: ${dto.spaceUuid}`,
+      );
+    }
+    // Validate time slots first
+    this.validateTimeSlot(dto.startTime, dto.endTime);
+
+    // fetch spaces exist
+    const space = await this.getSpaceConfigurationAndBookings(dto.spaceUuid);
+
+    // Validate booking availability
+    this.validateBookingAvailability(space, dto);
+
+    // Create and save booking
+    return this.createBookings(space, userUuid, dto);
+  }
+
+  async findAll({ month, space }: BookingRequestDto, project: string) {
+    const [monthNumber, year] = month.split('-').map(Number);
+    const fromDate = new Date(year, monthNumber - 1, 1);
+    const toDate = new Date(year, monthNumber, 0, 23, 59, 59);
+    return this.bookingEntityRepository.find({
+      where: {
+        space: {
+          community: { project: { uuid: project } },
+          uuid: space ? space : undefined,
+        },
+        date: Between(fromDate, toDate),
+      },
+      relations: ['space', 'user', 'user.inviteUser'],
+      order: { date: 'DESC' },
+    });
+  }
+
+  async findMyBookings(
+    { when }: MyBookingRequestDto,
+    userUuid: string,
+    project: string,
+  ) {
+    const now = new Date();
+    const nowTime = format(now, 'HH:mm');
+
+    const query = this.bookingEntityRepository
+      .createQueryBuilder('booking')
+      .leftJoinAndSelect('booking.space', 'space')
+      .innerJoin(
+        'space.community',
+        'community',
+        'community.project = :project',
+        { project },
+      )
+      .leftJoinAndSelect('booking.user', 'user')
+      .where('user.uuid = :userUuid', { userUuid });
+
+    if (when === 'past') {
+      query.andWhere(
+        `(DATE(booking.date) < :today OR (DATE(booking.date) = :today AND booking.startTime < :nowTime))`,
+        { today: now, nowTime },
+      );
+    } else if (when === 'future') {
+      query.andWhere(
+        `(DATE(booking.date) > :today OR (DATE(booking.date) = :today AND booking.startTime >= :nowTime))`,
+        { today: now, nowTime },
+      );
+    }
+
+    query.orderBy({
+      'DATE(booking.date)': 'DESC',
+      'booking.startTime': 'DESC',
+    });
+
+    return query.getMany();
+  }
+
+  /**
+   * Fetch space by UUID and throw an error if not found or if not configured for booking
+   */
+  private async getSpaceConfigurationAndBookings(
+    spaceUuid: string,
+  ): Promise<SpaceEntity> {
+    const space = await this.spaceRepository.findOne({
+      where: { uuid: spaceUuid },
+      relations: ['bookableConfig', 'bookings'],
+    });
+
+    if (!space) {
+      throw new NotFoundException(`Space not found: ${spaceUuid}`);
+    }
+    if (!space.bookableConfig) {
+      throw new NotFoundException(
+        `This space is not configured for booking: ${spaceUuid}`,
+      );
+    }
+
+    return space;
+  }
+
+  /**
+   * Ensure the slot start time is before the end time
+   */
+  private validateTimeSlot(startTime: string, endTime: string): void {
+    const start = timeToMinutes(startTime);
+    const end = timeToMinutes(endTime);
+
+    if (start >= end) {
+      throw new BadRequestException(
+        `End time must be after start time for slot: ${startTime}-${endTime}`,
+      );
+    }
+  }
+
+  /**
+   * check if the space is available for booking on the requested day
+   * and if the requested time slot is within the available hours
+   */
+  private validateBookingAvailability(
+    space: SpaceEntity,
+    dto: CreateBookingDto,
+  ): void {
+    // Check if the space is available for booking on the requested day
+    const availableDays = space.bookableConfig?.daysAvailable || [];
+    const requestedDay = new Date(dto.date).toLocaleDateString('en-US', {
+      weekday: 'short',
+    }) as DaysEnum;
+
+    if (!availableDays.includes(requestedDay)) {
+      const dayFullName = new Date(dto.date).toLocaleDateString('en-US', {
+        weekday: 'long',
+      });
+      throw new BadRequestException(
+        `Space is not available for booking on ${dayFullName}s`,
+      );
+    }
+
+    const dtoStartTimeInMinutes = timeToMinutes(dto.startTime);
+    const dtoEndTimeInMinutes = timeToMinutes(dto.endTime);
+
+    if (
+      dtoStartTimeInMinutes < timeToMinutes(space.bookableConfig.startTime) ||
+      dtoEndTimeInMinutes > timeToMinutes(space.bookableConfig.endTime)
+    ) {
+      throw new BadRequestException(
+        `Booking time must be within the available hours for space: ${space.spaceName}`,
+      );
+    }
+
+    const previousBookings = space.bookings.filter(
+      (booking) =>
+        timeToMinutes(booking.startTime) < dtoEndTimeInMinutes &&
+        timeToMinutes(booking.endTime) > dtoStartTimeInMinutes &&
+        format(new Date(booking.date), 'yyyy-MM-dd') ===
+          format(new Date(dto.date), 'yyyy-MM-dd'),
+    );
+
+    if (previousBookings.length > 0) {
+      // tell the user what time is unavailable
+      const unavailableTimes = previousBookings.map((booking) => {
+        return `${booking.startTime}-${booking.endTime}`;
+      });
+      throw new ConflictException(
+        `Space is already booked during this times: ${unavailableTimes.join(', ')}`,
+      );
+    }
+  }
+  /**
+   * Create bookable space entries after all validations pass
+   */
+  private async createBookings(
+    space: SpaceEntity,
+    user: string,
+    { spaceUuid, date, ...dto }: CreateBookingDto,
+  ) {
+    const entry = this.bookingEntityRepository.create({
+      space: { uuid: spaceUuid },
+      user: { uuid: user },
+      ...dto,
+      date: new Date(date),
+      cost: space.bookableConfig?.points || null,
+    });
+
+    return this.bookingEntityRepository.save(entry);
+  }
+}

src/community/services/community.service.ts

@@ -25,7 +25,7 @@ import {
   NotFoundException,
 } from '@nestjs/common';
 import { SpaceService } from 'src/space/services';
-import { QueryRunner, SelectQueryBuilder } from 'typeorm';
+import { Brackets, QueryRunner, SelectQueryBuilder } from 'typeorm';
 import { AddCommunityDto, GetCommunityParams, ProjectParam } from '../dtos';
 import { UpdateCommunityNameDto } from '../dtos/update.community.dto';
 
@@ -184,18 +184,46 @@ export class CommunityService {
 
       let qb: undefined | SelectQueryBuilder<CommunityEntity> = undefined;
 
+      const matchingCommunityIdsQb = this.communityRepository
+        .createQueryBuilder('c')
+        .select('c.uuid')
+        .where('c.project = :projectUuid', { projectUuid })
+        .andWhere('c.name != :orphanCommunityName', {
+          orphanCommunityName: `${ORPHAN_COMMUNITY_NAME}-${project.name}`,
+        })
+        .distinct(true);
+      if (includeSpaces) {
+        matchingCommunityIdsQb.leftJoin('c.spaces', 'space');
+      }
+
+      if (search) {
+        matchingCommunityIdsQb
+          .andWhere(
+            new Brackets((qb) => {
+              qb.where('c.name ILIKE :search');
+              if (includeSpaces) qb.orWhere('space.spaceName ILIKE :search');
+            }),
+          )
+          .setParameter('search', `%${search}%`);
+      }
+
       qb = this.communityRepository
         .createQueryBuilder('c')
         .where('c.project = :projectUuid', { projectUuid })
-        .andWhere(`c.name != '${ORPHAN_COMMUNITY_NAME}-${project.name}'`)
-        .distinct(true);
-
+        .andWhere('c.name != :orphanCommunityName', {
+          orphanCommunityName: `${ORPHAN_COMMUNITY_NAME}-${project.name}`,
+        })
+        .andWhere(`c.uuid IN (${matchingCommunityIdsQb.getQuery()})`)
+        .setParameters(matchingCommunityIdsQb.getParameters());
       if (includeSpaces) {
         qb.leftJoinAndSelect(
           'c.spaces',
           'space',
           'space.disabled = :disabled AND space.spaceName != :orphanSpaceName',
-          { disabled: false, orphanSpaceName: ORPHAN_SPACE_NAME },
+          {
+            disabled: false,
+            orphanSpaceName: ORPHAN_SPACE_NAME,
+          },
         )
           .leftJoinAndSelect('space.parent', 'parent')
           .leftJoinAndSelect(
@@ -204,16 +232,7 @@ export class CommunityService {
             'children.disabled = :disabled',
             { disabled: false },
           );
-        // .leftJoinAndSelect('space.spaceModel', 'spaceModel')
       }
-
-      if (search) {
-        qb.andWhere(
-          `c.name ILIKE :search ${includeSpaces ? 'OR space.space_name ILIKE :search' : ''}`,
-          { search: `%${search}%` },
-        );
-      }
-
       const customModel = TypeORMCustomModel(this.communityRepository);
 
       const { baseResponseDto, paginationResponseDto } =

src/occupancy/controllers/index.ts

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

src/occupancy/controllers/occupancy.controller.ts

@@ -0,0 +1,71 @@
+import { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
+import {
+  ApiTags,
+  ApiBearerAuth,
+  ApiOperation,
+  ApiParam,
+} from '@nestjs/swagger';
+import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
+import { ControllerRoute } from '@app/common/constants/controller-route';
+import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
+import { OccupancyService } from '../services/occupancy.service';
+import {
+  GetOccupancyDurationBySpaceDto,
+  GetOccupancyHeatMapBySpaceDto,
+} from '../dto/get-occupancy.dto';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+import { SpaceParamsDto } from '../dto/occupancy-params.dto';
+
+@ApiTags('Occupancy Module')
+@Controller({
+  version: EnableDisableStatusEnum.ENABLED,
+  path: ControllerRoute.Occupancy.ROUTE,
+})
+export class OccupancyController {
+  constructor(private readonly occupancyService: OccupancyService) {}
+
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Get('heat-map/space/:spaceUuid')
+  @ApiOperation({
+    summary: ControllerRoute.Occupancy.ACTIONS.GET_OCCUPANCY_HEAT_MAP_SUMMARY,
+    description:
+      ControllerRoute.Occupancy.ACTIONS.GET_OCCUPANCY_HEAT_MAP_DESCRIPTION,
+  })
+  @ApiParam({
+    name: 'spaceUuid',
+    description: 'UUID of the Space',
+    required: true,
+  })
+  async getOccupancyHeatMapDataBySpace(
+    @Param() params: SpaceParamsDto,
+    @Query() query: GetOccupancyHeatMapBySpaceDto,
+  ): Promise<BaseResponseDto> {
+    return await this.occupancyService.getOccupancyHeatMapDataBySpace(
+      params,
+      query,
+    );
+  }
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Get('duration/space/:spaceUuid')
+  @ApiOperation({
+    summary: ControllerRoute.Occupancy.ACTIONS.GET_OCCUPANCY_HEAT_MAP_SUMMARY,
+    description:
+      ControllerRoute.Occupancy.ACTIONS.GET_OCCUPANCY_HEAT_MAP_DESCRIPTION,
+  })
+  @ApiParam({
+    name: 'spaceUuid',
+    description: 'UUID of the Space',
+    required: true,
+  })
+  async getOccupancyDurationDataBySpace(
+    @Param() params: SpaceParamsDto,
+    @Query() query: GetOccupancyDurationBySpaceDto,
+  ): Promise<BaseResponseDto> {
+    return await this.occupancyService.getOccupancyDurationDataBySpace(
+      params,
+      query,
+    );
+  }
+}

src/occupancy/dto/get-occupancy.dto.ts

@@ -0,0 +1,27 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Matches, IsNotEmpty } from 'class-validator';
+
+export class GetOccupancyHeatMapBySpaceDto {
+  @ApiPropertyOptional({
+    description: 'Input year in YYYY format to filter the data',
+    example: '2025',
+    required: false,
+  })
+  @IsNotEmpty()
+  @Matches(/^\d{4}$/, {
+    message: 'Year must be in YYYY format',
+  })
+  year: string;
+}
+export class GetOccupancyDurationBySpaceDto {
+  @ApiPropertyOptional({
+    description: 'Month and year in format YYYY-MM',
+    example: '2025-03',
+    required: true,
+  })
+  @Matches(/^\d{4}-(0[1-9]|1[0-2])$/, {
+    message: 'monthDate must be in YYYY-MM format',
+  })
+  @IsNotEmpty()
+  monthDate: string;
+}

src/occupancy/dto/occupancy-params.dto.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsUUID } from 'class-validator';
+
+export class SpaceParamsDto {
+  @IsUUID('4', { message: 'Invalid UUID format' })
+  @IsNotEmpty()
+  spaceUuid: string;
+}

src/occupancy/occupancy.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { OccupancyController } from './controllers';
+import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service';
+import { OccupancyService } from './services';
+@Module({
+  imports: [ConfigModule],
+  controllers: [OccupancyController],
+  providers: [OccupancyService, SqlLoaderService],
+})
+export class OccupancyModule {}

src/occupancy/services/index.ts

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

src/occupancy/services/occupancy.service.ts

@@ -0,0 +1,103 @@
+import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
+import {
+  GetOccupancyDurationBySpaceDto,
+  GetOccupancyHeatMapBySpaceDto,
+} from '../dto/get-occupancy.dto';
+import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
+import { SpaceParamsDto } from '../dto/occupancy-params.dto';
+import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service';
+import { DataSource } from 'typeorm';
+import { SQL_PROCEDURES_PATH } from '@app/common/constants/sql-query-path';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+
+@Injectable()
+export class OccupancyService {
+  constructor(
+    private readonly sqlLoader: SqlLoaderService,
+    private readonly dataSource: DataSource,
+  ) {}
+
+  async getOccupancyDurationDataBySpace(
+    params: SpaceParamsDto,
+    query: GetOccupancyDurationBySpaceDto,
+  ): Promise<BaseResponseDto> {
+    const { monthDate } = query;
+    const { spaceUuid } = params;
+
+    try {
+      const data = await this.executeProcedure(
+        'fact_daily_space_occupancy_duration',
+        'procedure_select_daily_space_occupancy_duration',
+        [spaceUuid, monthDate],
+      );
+      const formattedData = data.map((item) => ({
+        ...item,
+        event_date: new Date(item.event_date).toLocaleDateString('en-CA'), // YYYY-MM-DD
+      }));
+      return this.buildResponse(
+        `Occupancy duration data fetched successfully for ${spaceUuid} space`,
+        formattedData,
+      );
+    } catch (error) {
+      console.error('Failed to fetch occupancy duration data', {
+        error,
+        spaceUuid,
+      });
+      throw new HttpException(
+        error.response?.message || 'Failed to fetch occupancy duration data',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  async getOccupancyHeatMapDataBySpace(
+    params: SpaceParamsDto,
+    query: GetOccupancyHeatMapBySpaceDto,
+  ): Promise<BaseResponseDto> {
+    const { year } = query;
+    const { spaceUuid } = params;
+
+    try {
+      const data = await this.executeProcedure(
+        'fact_space_occupancy_count',
+        'proceduce_select_fact_space_occupancy',
+        [spaceUuid, year],
+      );
+      const formattedData = data.map((item) => ({
+        ...item,
+        event_date: new Date(item.event_date).toLocaleDateString('en-CA'), // YYYY-MM-DD
+      }));
+      return this.buildResponse(
+        `Occupancy heat map data fetched successfully for ${spaceUuid} space`,
+        formattedData,
+      );
+    } catch (error) {
+      console.error('Failed to fetch occupancy heat map data', {
+        error,
+        spaceUuid,
+      });
+      throw new HttpException(
+        error.response?.message || 'Failed to fetch occupancy heat map data',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  private buildResponse(message: string, data: any[]) {
+    return new SuccessResponseDto({
+      message,
+      data,
+      statusCode: HttpStatus.OK,
+    });
+  }
+  private async executeProcedure(
+    procedureFolderName: string,
+    procedureFileName: string,
+    params: (string | number | null)[],
+  ): Promise<any[]> {
+    const query = this.loadQuery(procedureFolderName, procedureFileName);
+    return await this.dataSource.query(query, params);
+  }
+  private loadQuery(folderName: string, fileName: string): string {
+    return this.sqlLoader.loadQuery(folderName, fileName, SQL_PROCEDURES_PATH);
+  }
+}

src/scene/controllers/scene.controller.ts

@@ -1,4 +1,7 @@
-import { SceneService } from '../services/scene.service';
+import { ControllerRoute } from '@app/common/constants/controller-route';
+import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
 import {
   Body,
   Controller,
@@ -8,21 +11,21 @@ import {
   Param,
   Post,
   Put,
+  Query,
   Req,
   UseGuards,
 } from '@nestjs/common';
-import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { Permissions } from 'src/decorators/permissions.decorator';
+import { PermissionsGuard } from 'src/guards/permissions.guard';
+import { SceneParamDto } from '../dtos';
 import {
   AddSceneIconDto,
   AddSceneTapToRunDto,
+  GetSceneDto,
   UpdateSceneTapToRunDto,
 } from '../dtos/scene.dto';
-import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
-import { SceneParamDto } from '../dtos';
-import { BaseResponseDto } from '@app/common/dto/base.response.dto';
-import { ControllerRoute } from '@app/common/constants/controller-route';
-import { PermissionsGuard } from 'src/guards/permissions.guard';
-import { Permissions } from 'src/decorators/permissions.decorator';
+import { SceneService } from '../services/scene.service';
 
 @ApiTags('Scene Module')
 @Controller({
@@ -52,6 +55,27 @@ export class SceneController {
     );
   }
 
+  @ApiBearerAuth()
+  @UseGuards(PermissionsGuard)
+  @Permissions('SCENES_VIEW')
+  @Get('tap-to-run')
+  @ApiOperation({
+    summary: ControllerRoute.SCENE.ACTIONS.GET_TAP_TO_RUN_SCENES_SUMMARY,
+    description:
+      ControllerRoute.SCENE.ACTIONS.GET_TAP_TO_RUN_SCENES_DESCRIPTION,
+  })
+  async getTapToRunSceneBySpaces(
+    @Query() dto: GetSceneDto,
+    @Req() req: any,
+  ): Promise<BaseResponseDto> {
+    const projectUuid = req.user.project.uuid;
+    const data = await this.sceneService.findScenesBySpaces(dto, projectUuid);
+    return new SuccessResponseDto({
+      message: 'Scenes Retrieved Successfully',
+      data,
+    });
+  }
+
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
   @Permissions('SCENES_DELETE')

src/scene/dtos/scene.dto.ts

@@ -1,15 +1,16 @@
-import { ApiProperty } from '@nestjs/swagger';
-import {
-  IsNotEmpty,
-  IsString,
-  IsArray,
-  ValidateNested,
-  IsOptional,
-  IsNumber,
-  IsBoolean,
-} from 'class-validator';
-import { Transform, Type } from 'class-transformer';
 import { BooleanValues } from '@app/common/constants/boolean-values.enum';
+import { ApiProperty } from '@nestjs/swagger';
+import { Transform, Type } from 'class-transformer';
+import {
+  IsArray,
+  IsBoolean,
+  IsNotEmpty,
+  IsNumber,
+  IsOptional,
+  IsString,
+  IsUUID,
+  ValidateNested,
+} from 'class-validator';
 
 class ExecutorProperty {
   @ApiProperty({
@@ -187,4 +188,19 @@ export class GetSceneDto {
     return value.obj.showInHomePage === BooleanValues.TRUE;
   })
   public showInHomePage: boolean = false;
+
+  @ApiProperty({
+    description: 'List of Space IDs to filter automation',
+    required: false,
+    example: ['60d21b4667d0d8992e610c85', '60d21b4967d0d8992e610c86'],
+  })
+  @IsOptional()
+  @Transform(({ value }) => {
+    if (!Array.isArray(value)) {
+      return [value];
+    }
+    return value;
+  })
+  @IsUUID('4', { each: true })
+  public spaces?: string[];
 }

src/scene/services/scene.service.ts

@@ -1,12 +1,36 @@
 import {
-  Injectable,
-  HttpException,
-  HttpStatus,
+  ActionExecutorEnum,
+  ActionTypeEnum,
+} from '@app/common/constants/automation.enum';
+import { SceneIconType } from '@app/common/constants/secne-icon-type.enum';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
+import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
+import { convertKeysToSnakeCase } from '@app/common/helper/snakeCaseConverter';
+import { ConvertedAction } from '@app/common/integrations/tuya/interfaces';
+import { TuyaService } from '@app/common/integrations/tuya/services/tuya.service';
+import { AutomationRepository } from '@app/common/modules/automation/repositories';
+import { SceneDeviceRepository } from '@app/common/modules/scene-device/repositories';
+import {
+  SceneEntity,
+  SceneIconEntity,
+} from '@app/common/modules/scene/entities';
+import {
+  SceneIconRepository,
+  SceneRepository,
+} from '@app/common/modules/scene/repositories';
+import { SpaceRepository } from '@app/common/modules/space/repositories';
+import {
   BadRequestException,
   forwardRef,
+  HttpException,
+  HttpStatus,
   Inject,
+  Injectable,
 } from '@nestjs/common';
-import { SpaceRepository } from '@app/common/modules/space/repositories';
+import { HttpStatusCode } from 'axios';
+import { DeviceService } from 'src/device/services';
+import { In } from 'typeorm';
 import {
   Action,
   AddSceneIconDto,
@@ -15,35 +39,12 @@ import {
   SceneParamDto,
   UpdateSceneTapToRunDto,
 } from '../dtos';
-import { convertKeysToSnakeCase } from '@app/common/helper/snakeCaseConverter';
 import {
   AddTapToRunSceneInterface,
   DeleteTapToRunSceneInterface,
   SceneDetails,
   SceneDetailsResult,
 } from '../interface/scene.interface';
-import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
-import {
-  ActionExecutorEnum,
-  ActionTypeEnum,
-} from '@app/common/constants/automation.enum';
-import {
-  SceneIconRepository,
-  SceneRepository,
-} from '@app/common/modules/scene/repositories';
-import { SceneIconType } from '@app/common/constants/secne-icon-type.enum';
-import {
-  SceneEntity,
-  SceneIconEntity,
-} from '@app/common/modules/scene/entities';
-import { TuyaService } from '@app/common/integrations/tuya/services/tuya.service';
-import { BaseResponseDto } from '@app/common/dto/base.response.dto';
-import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
-import { HttpStatusCode } from 'axios';
-import { ConvertedAction } from '@app/common/integrations/tuya/interfaces';
-import { DeviceService } from 'src/device/services';
-import { SceneDeviceRepository } from '@app/common/modules/scene-device/repositories';
-import { AutomationRepository } from '@app/common/modules/automation/repositories';
 
 @Injectable()
 export class SceneService {
@@ -92,158 +93,48 @@ export class SceneService {
     }
   }
 
-  async create(
-    spaceTuyaUuid: string,
-    addSceneTapToRunDto: AddSceneTapToRunDto,
-    projectUuid: string,
-  ): Promise<SceneEntity> {
-    const { iconUuid, showInHomePage, spaceUuid } = addSceneTapToRunDto;
-
-    try {
-      const [defaultSceneIcon] = await Promise.all([
-        this.getDefaultSceneIcon(),
-      ]);
-      if (!defaultSceneIcon) {
-        throw new HttpException(
-          'Default scene icon not found',
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-
-      const response = await this.createSceneExternalService(
-        spaceTuyaUuid,
-        addSceneTapToRunDto,
-        projectUuid,
-      );
-
-      const scene = await this.sceneRepository.save({
-        sceneTuyaUuid: response.result.id,
-        sceneIcon: { uuid: iconUuid || defaultSceneIcon.uuid },
-        showInHomePage,
-        space: { uuid: spaceUuid },
-      });
-
-      return scene;
-    } catch (err) {
-      if (err instanceof HttpException) {
-        throw err;
-      } else if (err.message?.includes('tuya')) {
-        throw new HttpException(
-          'API error: Failed to create scene',
-          HttpStatus.BAD_GATEWAY,
-        );
-      } else {
-        throw new HttpException(
-          'Database error: Failed to save scene',
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-    }
-  }
-  async updateSceneExternalService(
-    spaceTuyaUuid: string,
-    sceneTuyaUuid: string,
-    updateSceneTapToRunDto: UpdateSceneTapToRunDto,
-    projectUuid: string,
-  ) {
-    const { sceneName, decisionExpr, actions } = updateSceneTapToRunDto;
-    try {
-      const formattedActions = await this.prepareActions(actions, projectUuid);
-
-      const response = (await this.tuyaService.updateTapToRunScene(
-        sceneTuyaUuid,
-        spaceTuyaUuid,
-        sceneName,
-        formattedActions,
-        decisionExpr,
-      )) as AddTapToRunSceneInterface;
-
-      if (!response.success) {
-        throw new HttpException(
-          'Failed to update scene in Tuya',
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-
-      return response;
-    } catch (err) {
-      if (err instanceof HttpException) {
-        throw err;
-      } else if (err.message?.includes('tuya')) {
-        throw new HttpException(
-          'API error: Failed to update scene',
-          HttpStatus.BAD_GATEWAY,
-        );
-      } else {
-        throw new HttpException(
-          `An Internal error has been occured ${err}`,
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-    }
-  }
-
-  async createSceneExternalService(
-    spaceTuyaUuid: string,
-    addSceneTapToRunDto: AddSceneTapToRunDto,
-    projectUuid: string,
-  ) {
-    const { sceneName, decisionExpr, actions } = addSceneTapToRunDto;
-    try {
-      const formattedActions = await this.prepareActions(actions, projectUuid);
-
-      const response = (await this.tuyaService.addTapToRunScene(
-        spaceTuyaUuid,
-        sceneName,
-        formattedActions,
-        decisionExpr,
-      )) as AddTapToRunSceneInterface;
-
-      if (!response.result?.id) {
-        throw new HttpException(
-          'Failed to create scene in Tuya',
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-
-      return response;
-    } catch (err) {
-      if (err instanceof HttpException) {
-        throw err;
-      } else if (err.message?.includes('tuya')) {
-        throw new HttpException(
-          'API error: Failed to create scene',
-          HttpStatus.BAD_GATEWAY,
-        );
-      } else {
-        throw new HttpException(
-          `An Internal error has been occured ${err}`,
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-    }
-  }
-
-  async findScenesBySpace(spaceUuid: string, filter: GetSceneDto) {
+  async findScenesBySpace(spaceUuid: string, { showInHomePage }: GetSceneDto) {
     try {
       await this.getSpaceByUuid(spaceUuid);
-      const showInHomePage = filter?.showInHomePage;
+      return this.findScenesBySpaces({ showInHomePage, spaces: [spaceUuid] });
+    } catch (error) {
+      console.error(
+        `Error fetching Tap-to-Run scenes for space UUID ${spaceUuid}:`,
+        error.message,
+      );
 
+      throw error instanceof HttpException
+        ? error
+        : new HttpException(
+            'An error occurred while retrieving scenes',
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+    }
+  }
+
+  async findScenesBySpaces(
+    { showInHomePage, spaces }: GetSceneDto,
+    projectUuid?: string,
+  ) {
+    try {
       const scenesData = await this.sceneRepository.find({
         where: {
-          space: { uuid: spaceUuid },
+          space: {
+            uuid: In(spaces ?? []),
+            community: projectUuid ? { project: { uuid: projectUuid } } : null,
+          },
           disabled: false,
           ...(showInHomePage ? { showInHomePage } : {}),
         },
         relations: ['sceneIcon', 'space', 'space.community'],
       });
 
-      const safeFetch = async (scene: any) => {
+      const safeFetch = async (scene: SceneEntity) => {
         try {
           // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const { actions, ...sceneDetails } = await this.getScene(
             scene,
-            spaceUuid,
+            scene.space.uuid,
           );
           return sceneDetails;
         } catch (error) {
@@ -259,7 +150,7 @@ export class SceneService {
       return scenes.filter(Boolean); // Remove null values
     } catch (error) {
       console.error(
-        `Error fetching Tap-to-Run scenes for space UUID ${spaceUuid}:`,
+        `Error fetching Tap-to-Run scenes for specified spaces:`,
         error.message,
       );
 
@@ -291,45 +182,6 @@ export class SceneService {
     }
   }
 
-  async fetchSceneDetailsFromTuya(
-    sceneId: string,
-  ): Promise<SceneDetailsResult> {
-    try {
-      const response = await this.tuyaService.getSceneRule(sceneId);
-      const camelCaseResponse = convertKeysToCamelCase(response);
-      const {
-        id,
-        name,
-        type,
-        status,
-        actions: tuyaActions = [],
-      } = camelCaseResponse.result;
-
-      const actions = tuyaActions.map((action) => ({ ...action }));
-
-      return {
-        id,
-        name,
-        type,
-        status,
-        actions,
-      } as SceneDetailsResult;
-    } catch (err) {
-      console.error(
-        `Error fetching scene details for scene ID ${sceneId}:`,
-        err,
-      );
-      if (err instanceof HttpException) {
-        throw err;
-      } else {
-        throw new HttpException(
-          'An error occurred while fetching scene details from Tuya',
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-    }
-  }
-
   async updateTapToRunScene(
     updateSceneTapToRunDto: UpdateSceneTapToRunDto,
     sceneUuid: string,
@@ -386,6 +238,38 @@ export class SceneService {
     }
   }
 
+  async deleteScene(params: SceneParamDto): Promise<BaseResponseDto> {
+    const { sceneUuid } = params;
+    try {
+      const scene = await this.findScene(sceneUuid);
+      const space = await this.getSpaceByUuid(scene.space.uuid);
+
+      await this.delete(scene.sceneTuyaUuid, space.spaceTuyaUuid);
+      await this.sceneDeviceRepository.update(
+        { uuid: sceneUuid },
+        { disabled: true },
+      );
+      await this.sceneRepository.update(
+        {
+          uuid: sceneUuid,
+        },
+        { disabled: true },
+      );
+      return new SuccessResponseDto({
+        message: `Scene with ID ${sceneUuid} deleted successfully`,
+      });
+    } catch (err) {
+      if (err instanceof HttpException) {
+        throw err;
+      } else {
+        throw new HttpException(
+          err.message || `Scene not found for id ${params.sceneUuid}`,
+          err.status || HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+
   async addSceneIcon(addSceneIconDto: AddSceneIconDto) {
     try {
       const icon = await this.sceneIconRepository.save({
@@ -454,7 +338,237 @@ export class SceneService {
     }
   }
 
-  async getScene(scene: SceneEntity, spaceUuid: string): Promise<SceneDetails> {
+  async findScene(sceneUuid: string): Promise<SceneEntity> {
+    const scene = await this.sceneRepository.findOne({
+      where: { uuid: sceneUuid },
+      relations: ['sceneIcon', 'space', 'space.community'],
+    });
+
+    if (!scene) {
+      throw new HttpException(
+        `Invalid scene with id ${sceneUuid}`,
+        HttpStatus.NOT_FOUND,
+      );
+    }
+    return scene;
+  }
+
+  async getSpaceByUuid(spaceUuid: string) {
+    try {
+      const space = await this.spaceRepository.findOne({
+        where: {
+          uuid: spaceUuid,
+        },
+        relations: ['community'],
+      });
+
+      if (!space) {
+        throw new HttpException(
+          `Invalid space UUID ${spaceUuid}`,
+          HttpStatusCode.BadRequest,
+        );
+      }
+
+      if (!space.community.externalId) {
+        throw new HttpException(
+          `Space doesn't have any association with tuya${spaceUuid}`,
+          HttpStatusCode.BadRequest,
+        );
+      }
+      return {
+        uuid: space.uuid,
+        createdAt: space.createdAt,
+        updatedAt: space.updatedAt,
+        name: space.spaceName,
+        spaceTuyaUuid: space.community.externalId,
+      };
+    } catch (err) {
+      if (err instanceof BadRequestException) {
+        throw err;
+      } else {
+        throw new HttpException(
+          `Space with id ${spaceUuid} not found`,
+          HttpStatus.NOT_FOUND,
+        );
+      }
+    }
+  }
+
+  private async create(
+    spaceTuyaUuid: string,
+    addSceneTapToRunDto: AddSceneTapToRunDto,
+    projectUuid: string,
+  ): Promise<SceneEntity> {
+    const { iconUuid, showInHomePage, spaceUuid } = addSceneTapToRunDto;
+
+    try {
+      const [defaultSceneIcon] = await Promise.all([
+        this.getDefaultSceneIcon(),
+      ]);
+      if (!defaultSceneIcon) {
+        throw new HttpException(
+          'Default scene icon not found',
+          HttpStatus.INTERNAL_SERVER_ERROR,
+        );
+      }
+
+      const response = await this.createSceneExternalService(
+        spaceTuyaUuid,
+        addSceneTapToRunDto,
+        projectUuid,
+      );
+
+      const scene = await this.sceneRepository.save({
+        sceneTuyaUuid: response.result.id,
+        sceneIcon: { uuid: iconUuid || defaultSceneIcon.uuid },
+        showInHomePage,
+        space: { uuid: spaceUuid },
+      });
+
+      return scene;
+    } catch (err) {
+      if (err instanceof HttpException) {
+        throw err;
+      } else if (err.message?.includes('tuya')) {
+        throw new HttpException(
+          'API error: Failed to create scene',
+          HttpStatus.BAD_GATEWAY,
+        );
+      } else {
+        throw new HttpException(
+          'Database error: Failed to save scene',
+          HttpStatus.INTERNAL_SERVER_ERROR,
+        );
+      }
+    }
+  }
+  private async updateSceneExternalService(
+    spaceTuyaUuid: string,
+    sceneTuyaUuid: string,
+    updateSceneTapToRunDto: UpdateSceneTapToRunDto,
+    projectUuid: string,
+  ) {
+    const { sceneName, decisionExpr, actions } = updateSceneTapToRunDto;
+    try {
+      const formattedActions = await this.prepareActions(actions, projectUuid);
+
+      const response = (await this.tuyaService.updateTapToRunScene(
+        sceneTuyaUuid,
+        spaceTuyaUuid,
+        sceneName,
+        formattedActions,
+        decisionExpr,
+      )) as AddTapToRunSceneInterface;
+
+      if (!response.success) {
+        throw new HttpException(
+          'Failed to update scene in Tuya',
+          HttpStatus.INTERNAL_SERVER_ERROR,
+        );
+      }
+
+      return response;
+    } catch (err) {
+      if (err instanceof HttpException) {
+        throw err;
+      } else if (err.message?.includes('tuya')) {
+        throw new HttpException(
+          'API error: Failed to update scene',
+          HttpStatus.BAD_GATEWAY,
+        );
+      } else {
+        throw new HttpException(
+          `An Internal error has been occured ${err}`,
+          HttpStatus.INTERNAL_SERVER_ERROR,
+        );
+      }
+    }
+  }
+
+  private async createSceneExternalService(
+    spaceTuyaUuid: string,
+    addSceneTapToRunDto: AddSceneTapToRunDto,
+    projectUuid: string,
+  ) {
+    const { sceneName, decisionExpr, actions } = addSceneTapToRunDto;
+    try {
+      const formattedActions = await this.prepareActions(actions, projectUuid);
+
+      const response = (await this.tuyaService.addTapToRunScene(
+        spaceTuyaUuid,
+        sceneName,
+        formattedActions,
+        decisionExpr,
+      )) as AddTapToRunSceneInterface;
+
+      if (!response.result?.id) {
+        throw new HttpException(
+          'Failed to create scene in Tuya',
+          HttpStatus.INTERNAL_SERVER_ERROR,
+        );
+      }
+
+      return response;
+    } catch (err) {
+      if (err instanceof HttpException) {
+        throw err;
+      } else if (err.message?.includes('tuya')) {
+        throw new HttpException(
+          'API error: Failed to create scene',
+          HttpStatus.BAD_GATEWAY,
+        );
+      } else {
+        throw new HttpException(
+          `An Internal error has been occured ${err}`,
+          HttpStatus.INTERNAL_SERVER_ERROR,
+        );
+      }
+    }
+  }
+
+  private async fetchSceneDetailsFromTuya(
+    sceneId: string,
+  ): Promise<SceneDetailsResult> {
+    try {
+      const response = await this.tuyaService.getSceneRule(sceneId);
+      const camelCaseResponse = convertKeysToCamelCase(response);
+      const {
+        id,
+        name,
+        type,
+        status,
+        actions: tuyaActions = [],
+      } = camelCaseResponse.result;
+
+      const actions = tuyaActions.map((action) => ({ ...action }));
+
+      return {
+        id,
+        name,
+        type,
+        status,
+        actions,
+      } as SceneDetailsResult;
+    } catch (err) {
+      console.error(
+        `Error fetching scene details for scene ID ${sceneId}:`,
+        err,
+      );
+      if (err instanceof HttpException) {
+        throw err;
+      } else {
+        throw new HttpException(
+          'An error occurred while fetching scene details from Tuya',
+          HttpStatus.INTERNAL_SERVER_ERROR,
+        );
+      }
+    }
+  }
+
+  private async getScene(
+    scene: SceneEntity,
+    spaceUuid: string,
+  ): Promise<SceneDetails> {
     try {
       const { actions, name, status } = await this.fetchSceneDetailsFromTuya(
         scene.sceneTuyaUuid,
@@ -519,54 +633,7 @@ export class SceneService {
     }
   }
 
-  async deleteScene(params: SceneParamDto): Promise<BaseResponseDto> {
-    const { sceneUuid } = params;
-    try {
-      const scene = await this.findScene(sceneUuid);
-      const space = await this.getSpaceByUuid(scene.space.uuid);
-
-      await this.delete(scene.sceneTuyaUuid, space.spaceTuyaUuid);
-      await this.sceneDeviceRepository.update(
-        { uuid: sceneUuid },
-        { disabled: true },
-      );
-      await this.sceneRepository.update(
-        {
-          uuid: sceneUuid,
-        },
-        { disabled: true },
-      );
-      return new SuccessResponseDto({
-        message: `Scene with ID ${sceneUuid} deleted successfully`,
-      });
-    } catch (err) {
-      if (err instanceof HttpException) {
-        throw err;
-      } else {
-        throw new HttpException(
-          err.message || `Scene not found for id ${params.sceneUuid}`,
-          err.status || HttpStatus.NOT_FOUND,
-        );
-      }
-    }
-  }
-
-  async findScene(sceneUuid: string): Promise<SceneEntity> {
-    const scene = await this.sceneRepository.findOne({
-      where: { uuid: sceneUuid },
-      relations: ['sceneIcon', 'space', 'space.community'],
-    });
-
-    if (!scene) {
-      throw new HttpException(
-        `Invalid scene with id ${sceneUuid}`,
-        HttpStatus.NOT_FOUND,
-      );
-    }
-    return scene;
-  }
-
-  async delete(tuyaSceneId: string, tuyaSpaceId: string) {
+  private async delete(tuyaSceneId: string, tuyaSpaceId: string) {
     try {
       const response = (await this.tuyaService.deleteSceneRule(
         tuyaSceneId,
@@ -626,45 +693,4 @@ export class SceneService {
     });
     return defaultIcon;
   }
-
-  async getSpaceByUuid(spaceUuid: string) {
-    try {
-      const space = await this.spaceRepository.findOne({
-        where: {
-          uuid: spaceUuid,
-        },
-        relations: ['community'],
-      });
-
-      if (!space) {
-        throw new HttpException(
-          `Invalid space UUID ${spaceUuid}`,
-          HttpStatusCode.BadRequest,
-        );
-      }
-
-      if (!space.community.externalId) {
-        throw new HttpException(
-          `Space doesn't have any association with tuya${spaceUuid}`,
-          HttpStatusCode.BadRequest,
-        );
-      }
-      return {
-        uuid: space.uuid,
-        createdAt: space.createdAt,
-        updatedAt: space.updatedAt,
-        name: space.spaceName,
-        spaceTuyaUuid: space.community.externalId,
-      };
-    } catch (err) {
-      if (err instanceof BadRequestException) {
-        throw err;
-      } else {
-        throw new HttpException(
-          `Space with id ${spaceUuid} not found`,
-          HttpStatus.NOT_FOUND,
-        );
-      }
-    }
-  }
 }

src/space/controllers/space.controller.ts

@@ -17,6 +17,7 @@ import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { Permissions } from 'src/decorators/permissions.decorator';
 import { PermissionsGuard } from 'src/guards/permissions.guard';
 import { AddSpaceDto, CommunitySpaceParam, UpdateSpaceDto } from '../dtos';
+import { DuplicateSpaceDto } from '../dtos/duplicate-space.dto';
 import { GetSpaceDto } from '../dtos/get.space.dto';
 import { GetSpaceParam } from '../dtos/get.space.param';
 import { OrderSpacesDto } from '../dtos/order.spaces.dto';
@@ -48,6 +49,26 @@ export class SpaceController {
     );
   }
 
+  @ApiBearerAuth()
+  @UseGuards(PermissionsGuard)
+  @Permissions('SPACE_ADD')
+  @ApiOperation({
+    summary: ControllerRoute.SPACE.ACTIONS.DUPLICATE_SPACE_SUMMARY,
+    description: ControllerRoute.SPACE.ACTIONS.DUPLICATE_SPACE_DESCRIPTION,
+  })
+  @Post(':spaceUuid/duplicate')
+  async duplicateSpace(
+    @Param('spaceUuid', ParseUUIDPipe) spaceUuid: string,
+    @Body() dto: DuplicateSpaceDto,
+    @Param() communitySpaceParam: CommunitySpaceParam,
+  ): Promise<BaseResponseDto> {
+    return await this.spaceService.duplicateSpace(
+      spaceUuid,
+      communitySpaceParam,
+      dto,
+    );
+  }
+
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
   @Permissions('SPACE_VIEW')

src/space/dtos/add.space.dto.ts

@@ -6,7 +6,6 @@ import {
   IsArray,
   IsMongoId,
   IsNotEmpty,
-  IsNumber,
   IsOptional,
   IsString,
   IsUUID,
@@ -48,14 +47,6 @@ export class AddSpaceDto {
   @IsOptional()
   public icon?: string;
 
-  @ApiProperty({ description: 'X position on canvas', example: 120 })
-  @IsNumber()
-  x: number;
-
-  @ApiProperty({ description: 'Y position on canvas', example: 200 })
-  @IsNumber()
-  y: number;
-
   @ApiProperty({
     description: 'UUID of the Space Model',
     example: 'd290f1ee-6c54-4b01-90e6-d701748f0851',

src/space/dtos/duplicate-space.dto.ts

@@ -0,0 +1,18 @@
+import { ORPHAN_SPACE_NAME } from '@app/common/constants/orphan-constant';
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsString, NotEquals } from 'class-validator';
+
+export class DuplicateSpaceDto {
+  @ApiProperty({
+    description: 'Name of the space (e.g., Floor 1, Unit 101)',
+    example: 'Unit 101',
+  })
+  @IsString()
+  @IsNotEmpty()
+  @NotEquals(ORPHAN_SPACE_NAME, {
+    message() {
+      return `Space name cannot be "${ORPHAN_SPACE_NAME}". Please choose a different name.`;
+    },
+  })
+  spaceName: string;
+}

src/space/dtos/update.space.dto.ts

@@ -4,7 +4,6 @@ import { Type } from 'class-transformer';
 import {
   ArrayUnique,
   IsArray,
-  IsNumber,
   IsOptional,
   IsString,
   NotEquals,
@@ -36,16 +35,6 @@ export class UpdateSpaceDto {
   @IsOptional()
   public icon?: string;
 
-  @ApiProperty({ description: 'X position on canvas', example: 120 })
-  @IsNumber()
-  @IsOptional()
-  x?: number;
-
-  @ApiProperty({ description: 'Y position on canvas', example: 200 })
-  @IsNumber()
-  @IsOptional()
-  y?: number;
-
   @ApiPropertyOptional({
     description: 'List of subspace modifications',
     type: [UpdateSubspaceDto],

src/space/services/space-validation.service.ts

@@ -133,7 +133,7 @@ export class ValidationService {
         'subspaces.productAllocations',
         'subspaces.productAllocations.product',
         'subspaces.devices',
-        'spaceModel',
+        // 'spaceModel',
       ],
     });
 

src/space/services/space.service.ts

@@ -8,6 +8,7 @@ import { generateRandomString } from '@app/common/helper/randomString';
 import { removeCircularReferences } from '@app/common/helper/removeCircularReferences';
 import { SpaceProductAllocationEntity } from '@app/common/modules/space/entities/space-product-allocation.entity';
 import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
+import { SubspaceProductAllocationEntity } from '@app/common/modules/space/entities/subspace/subspace-product-allocation.entity';
 import { SubspaceEntity } from '@app/common/modules/space/entities/subspace/subspace.entity';
 import {
   InviteSpaceRepository,
@@ -24,6 +25,7 @@ import { DeviceService } from 'src/device/services';
 import { SpaceModelService } from 'src/space-model/services';
 import { TagService } from 'src/tags/services/tags.service';
 import { DataSource, In, Not, QueryRunner } from 'typeorm';
+import { v4 as uuidV4 } from 'uuid';
 import { DisableSpaceCommand } from '../commands';
 import {
   AddSpaceDto,
@@ -32,6 +34,7 @@ import {
   UpdateSpaceDto,
 } from '../dtos';
 import { CreateProductAllocationDto } from '../dtos/create-product-allocation.dto';
+import { DuplicateSpaceDto } from '../dtos/duplicate-space.dto';
 import { GetSpaceDto } from '../dtos/get.space.dto';
 import { OrderSpacesDto } from '../dtos/order.spaces.dto';
 import { SpaceWithParentsDto } from '../dtos/space.parents.dto';
@@ -93,6 +96,9 @@ export class SpaceService {
       parentUuid && !isRecursiveCall
         ? await this.validationService.validateSpace(parentUuid)
         : null;
+    if (parent) {
+      await this.validateNamingConflict(addSpaceDto.spaceName, parent);
+    }
 
     const spaceModel = spaceModelUuid
       ? await this.validationService.validateSpaceModel(spaceModelUuid)
@@ -102,8 +108,6 @@ export class SpaceService {
         // todo: find a better way to handle this instead of naming every key
         spaceName: addSpaceDto.spaceName,
         icon: addSpaceDto.icon,
-        x: addSpaceDto.x,
-        y: addSpaceDto.y,
         spaceModel,
         parent: isRecursiveCall
           ? recursiveCallParentEntity
@@ -181,6 +185,154 @@ export class SpaceService {
       !isRecursiveCall ? await queryRunner.release() : null;
     }
   }
+
+  async duplicateSpace(
+    spaceUuid: string,
+    { communityUuid, projectUuid }: CommunitySpaceParam,
+    dto: DuplicateSpaceDto,
+    queryRunner?: QueryRunner,
+  ): Promise<BaseResponseDto> {
+    if (!queryRunner) {
+      queryRunner = this.dataSource.createQueryRunner();
+      await queryRunner.connect();
+      await queryRunner.startTransaction();
+    }
+
+    try {
+      await this.validationService.validateCommunityAndProject(
+        communityUuid,
+        projectUuid,
+        queryRunner,
+      );
+      await this.handleSpaceDuplication(spaceUuid, dto.spaceName, queryRunner);
+
+      await queryRunner.commitTransaction();
+      const { data } = await this.getSpacesHierarchyForCommunity(
+        {
+          projectUuid,
+          communityUuid,
+        },
+        { onlyWithDevices: false },
+      );
+      return new SuccessResponseDto({
+        message: `Space with ID ${spaceUuid} successfully duplicated`,
+        data,
+      });
+    } catch (error) {
+      await queryRunner.rollbackTransaction();
+      console.log((error as Error).stack);
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    } finally {
+      await queryRunner.release();
+    }
+  }
+  private async handleSpaceDuplication(
+    spaceUuid: string,
+    newSpaceName: string | null,
+    queryRunner: QueryRunner,
+    parent?: SpaceEntity,
+  ) {
+    const space = await this.spaceRepository.findOne({
+      where: { uuid: spaceUuid },
+      relations: [
+        'children',
+        'productAllocations',
+        'subspaces',
+        'subspaces.productAllocations',
+      ],
+    });
+    const clonedSpace = structuredClone(space);
+    const newSpace = queryRunner.manager.create(SpaceEntity, {
+      ...clonedSpace,
+      spaceName: newSpaceName || clonedSpace.spaceName,
+      parent,
+      children: undefined,
+      subspaces: undefined,
+      productAllocations: undefined,
+      uuid: uuidV4(),
+    });
+
+    if (clonedSpace.productAllocations?.length) {
+      newSpace.productAllocations = this.copySpaceAllocations(
+        newSpace,
+        clonedSpace.productAllocations,
+        queryRunner,
+      );
+    }
+    if (clonedSpace.subspaces?.length) {
+      newSpace.subspaces = this.copySpaceSubspaces(
+        newSpace,
+        clonedSpace.subspaces,
+        queryRunner,
+      );
+    }
+    const savedSpace = await queryRunner.manager.save(newSpace);
+
+    if (clonedSpace.children?.length) {
+      for (const child of clonedSpace.children) {
+        if (child.disabled) continue;
+        await this.handleSpaceDuplication(
+          child.uuid,
+          child.spaceName,
+          queryRunner,
+          savedSpace,
+        );
+      }
+    }
+    return savedSpace;
+  }
+  private copySpaceSubspaces(
+    newSpace: SpaceEntity,
+    subspaces: SubspaceEntity[],
+    queryRunner: QueryRunner,
+  ) {
+    const newSubspaces = [];
+    for (const sub of subspaces) {
+      if (sub.disabled) continue;
+      const clonedSub = structuredClone(sub);
+      delete clonedSub.uuid;
+      const newSubspace = queryRunner.manager.create(SubspaceEntity, {
+        ...clonedSub,
+        space: newSpace,
+        productAllocations: [],
+        uuid: uuidV4(),
+      });
+      if (sub.productAllocations?.length) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for (const { uuid, ...allocation } of sub.productAllocations) {
+          newSubspace.productAllocations.push(
+            queryRunner.manager.create(SubspaceProductAllocationEntity, {
+              ...allocation,
+              subspace: newSubspace,
+              uuid: uuidV4(),
+            }),
+          );
+        }
+      }
+
+      newSubspaces.push(newSubspace);
+    }
+    return newSubspaces;
+  }
+  private copySpaceAllocations(
+    newSpace: SpaceEntity,
+    allocations: SpaceProductAllocationEntity[],
+    queryRunner: QueryRunner,
+  ) {
+    const newAllocations = [];
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (const { uuid, ...allocation } of allocations) {
+      newAllocations.push(
+        queryRunner.manager.create(SpaceProductAllocationEntity, {
+          ...allocation,
+          space: newSpace,
+          uuid: uuidV4(),
+        }),
+      );
+    }
+    return newAllocations;
+  }
+
   private checkDuplicateTags(allocations: CreateProductAllocationDto[]) {
     const tagUuidSet = new Set<string>();
     const tagNameProductSet = new Set<string>();
@@ -505,6 +657,8 @@ export class SpaceService {
           spaceUuid,
         );
 
+      await this.validateNamingConflict(updateSpaceDto.spaceName, space, true);
+
       if (space.spaceModel && !updateSpaceDto.spaceModelUuid) {
         await queryRunner.manager.update(SpaceEntity, space.uuid, {
           spaceModel: null,
@@ -655,13 +809,11 @@ export class SpaceService {
     updateSpaceDto: UpdateSpaceDto,
     queryRunner: QueryRunner,
   ): Promise<void> {
-    const { spaceName, x, y, icon } = updateSpaceDto;
+    const { spaceName, icon } = updateSpaceDto;
 
     const updateFields: Partial<SpaceEntity> = {};
 
     if (spaceName) updateFields.spaceName = spaceName;
-    if (x !== undefined) updateFields.x = x;
-    if (y !== undefined) updateFields.y = y;
     if (icon) updateFields.icon = icon;
 
     if (Object.keys(updateFields).length > 0) {
@@ -828,4 +980,34 @@ export class SpaceService {
       queryRunner,
     );
   }
+
+  async validateNamingConflict(
+    newSpaceName: string,
+    parent: SpaceEntity,
+    isUpdate: boolean = false,
+  ): Promise<void> {
+    if (!isUpdate && parent.spaceName === newSpaceName) {
+      throw new HttpException(
+        `Space can't be created with the same name as its parent space`,
+        HttpStatus.BAD_REQUEST,
+      );
+    }
+    if (parent.children?.some((child) => child.spaceName === newSpaceName)) {
+      throw new HttpException(
+        `Space name cannot be the same as one of its siblings/children`,
+        HttpStatus.BAD_REQUEST,
+      );
+    }
+    if (isUpdate) {
+      const sibling = await this.spaceRepository.exists({
+        where: { spaceName: newSpaceName, parent: { uuid: parent.uuid } },
+      });
+      if (sibling) {
+        throw new HttpException(
+          `Space name cannot be the same as one of its siblings/children`,
+          HttpStatus.BAD_REQUEST,
+        );
+      }
+    }
+  }
 }

src/users/controllers/user.controller.ts

@@ -25,6 +25,7 @@ import {
   UpdateTimezoneDataDto,
 } from '../dtos';
 import { UserService } from '../services/user.service';
+import { UpdateBookingSettingsDto } from '../dtos/update-user-booking-settings.dto';
 
 @ApiTags('User Module')
 @Controller({
@@ -138,6 +139,30 @@ export class UserController {
     };
   }
 
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Put('/booking-settings/:userUuid')
+  @ApiOperation({
+    summary: ControllerRoute.USER.ACTIONS.UPDATE_BOOKING_SETTINGS_SUMMARY,
+    description:
+      ControllerRoute.USER.ACTIONS.UPDATE_BOOKING_SETTINGS_DESCRIPTION,
+  })
+  async updateBookingSettingsByUserUuid(
+    @Param('userUuid') userUuid: string,
+    @Body() dto: UpdateBookingSettingsDto,
+  ) {
+    const userData = await this.userService.updateBookingSettingsByUserUuid(
+      userUuid,
+      dto,
+    );
+    return {
+      statusCode: HttpStatus.CREATED,
+      success: true,
+      message: 'Booking settings updated successfully',
+      data: userData,
+    };
+  }
+
   @ApiBearerAuth()
   @UseGuards(SuperAdminRoleGuard)
   @Delete('/:userUuid')

src/users/dtos/update-user-booking-settings.dto.ts

@@ -0,0 +1,29 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsBoolean, IsInt, IsOptional, IsPositive, Min } from 'class-validator';
+
+export class UpdateBookingSettingsDto {
+  @ApiProperty({
+    description: 'bookingEnable',
+    required: false,
+  })
+  @IsBoolean()
+  @IsOptional()
+  bookingEnable?: boolean;
+
+  @ApiProperty({
+    description: 'increase user booking balance by top up amount',
+    required: false,
+  })
+  @IsPositive()
+  @IsOptional()
+  topUp?: number;
+
+  @ApiProperty({
+    description: 'replace user booking balance by required amount',
+    required: false,
+  })
+  @IsInt()
+  @Min(0)
+  @IsOptional()
+  balance?: number;
+}

src/users/services/user.service.ts

@@ -10,6 +10,7 @@ import {
   HttpStatus,
   Injectable,
 } from '@nestjs/common';
+import { UpdateBookingSettingsDto } from '../dtos/update-user-booking-settings.dto';
 import {
   UpdateNameDto,
   UpdateProfilePictureDataDto,
@@ -33,7 +34,7 @@ export class UserService {
         relations: ['region', 'timezone', 'roleType', 'project'],
       });
       if (!user) {
-        throw new BadRequestException('Invalid room UUID');
+        throw new BadRequestException('Invalid user UUID');
       }
 
       // Use the utility function to remove the base64 prefix
@@ -53,6 +54,8 @@ export class UserService {
         appAgreementAcceptedAt: user?.appAgreementAcceptedAt,
         role: user?.roleType,
         project: user?.project,
+        bookingPoints: user?.bookingPoints ?? 0,
+        bookingEnabled: user?.bookingEnabled ?? false,
       };
     } catch (err) {
       if (err instanceof BadRequestException) {
@@ -245,6 +248,48 @@ export class UserService {
       );
     }
   }
+
+  async updateBookingSettingsByUserUuid(
+    userUuid: string,
+    { balance, bookingEnable, topUp }: UpdateBookingSettingsDto,
+  ) {
+    try {
+      let user = await this.getUserDetailsByUserUuid(userUuid);
+      if (!user) {
+        throw new HttpException('User not found', HttpStatus.NOT_FOUND);
+      }
+
+      if (balance && topUp) {
+        throw new BadRequestException(
+          'Please provide either balance or topUp, not both',
+        );
+      }
+
+      if (topUp) {
+        user.bookingPoints += topUp;
+      }
+      if (balance) {
+        user.bookingPoints = balance;
+      }
+      if (bookingEnable !== undefined) {
+        user.bookingEnabled = bookingEnable;
+      }
+
+      user = await this.userRepository.save(user);
+
+      return {
+        uuid: user.uuid,
+        bookingEnabled: user.bookingEnabled,
+        bookingPoints: user.bookingPoints,
+      };
+    } catch (err) {
+      throw new HttpException(
+        err.message || 'User not found',
+        HttpStatus.NOT_FOUND,
+      );
+    }
+  }
+
   async acceptWebAgreement(userUuid: string) {
     await this.userRepository.update(
       { uuid: userUuid },