add booking points to user table (#461)

* chore: remove unused imports and dead code for space link

* chore: remove unused imports and dead code

* chore: remove unused imports and dead code of tag service

.github/pull_request_template.md

@@ -0,0 +1,17 @@
+<!--
+  Thanks for contributing!
+
+  Provide a description of your changes below and a general summary in the title.
+-->
+
+## Jira Ticket
+
+[SP-0000](https://syncrow.atlassian.net/browse/SP-0000)
+
+## Description
+
+<!--- Describe your changes in detail -->
+
+## How to Test
+
+<!--- Describe the created APIs / Logic -->

.github/workflows/main_syncrow(staging).yml

@@ -1,4 +1,7 @@
-name: Backend deployment to Azure App Service
+# Docs for the Azure Web Apps Deploy action: https://github.com/Azure/webapps-deploy
+# More GitHub Actions for Azure: https://github.com/Azure/actions
+
+name: Build and deploy container app to Azure Web App - syncrow(staging)
 
 on:
   push:
@@ -6,50 +9,43 @@ on:
       - main
   workflow_dispatch:
 
-env:
-  AZURE_WEB_APP_NAME: 'syncrow'
-  AZURE_WEB_APP_SLOT_NAME: 'staging'
-  ACR_REGISTRY: 'syncrow.azurecr.io'
-  IMAGE_NAME: 'backend'
-  IMAGE_TAG: 'latest'
-
 jobs:
-  build_and_deploy:
+  build:
-    runs-on: ubuntu-latest
+    runs-on: 'ubuntu-latest'
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
 
-      - name: Set up Node.js
+      - name: Set up Docker Buildx
-        uses: actions/setup-node@v3
+        uses: docker/setup-buildx-action@v2
+
+      - name: Log in to registry
+        uses: docker/login-action@v2
         with:
-          node-version: '20'
+          registry: https://syncrow.azurecr.io/
+          username: ${{ secrets.AzureAppService_ContainerUsername_47395803300340b49931ea82f6d80be3 }}
+          password: ${{ secrets.AzureAppService_ContainerPassword_e7b0ff54f54d44cba04a970a22384848 }}
 
-      - name: Install dependencies and build project
+      - name: Build and push container image to registry
-        run: |
+        uses: docker/build-push-action@v3
-          npm install
-          npm run build
-
-      - name: Log in to Azure
-        uses: azure/login@v1
         with:
-          creds: ${{ secrets.AZURE_CREDENTIALS }}
+          push: true
+          tags: syncrow.azurecr.io/${{ secrets.AzureAppService_ContainerUsername_47395803300340b49931ea82f6d80be3 }}/syncrow/backend:${{ github.sha }}
+          file: ./Dockerfile
 
-      - name: Log in to Azure Container Registry
+  deploy:
-        run: az acr login --name ${{ env.ACR_REGISTRY }}
+    runs-on: ubuntu-latest
+    needs: build
+    environment:
+      name: 'staging'
+      url: ${{ steps.deploy-to-webapp.outputs.webapp-url }}
 
-      - name: List build output
+    steps:
-        run: ls -R dist/
+      - name: Deploy to Azure Web App
-
+        id: deploy-to-webapp
-      - name: Build and push Docker image
+        uses: azure/webapps-deploy@v2
-        run: |
+        with:
-          docker build . -t ${{ env.ACR_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.IMAGE_TAG }}
+          app-name: 'syncrow'
-          docker push ${{ env.ACR_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.IMAGE_TAG }}
+          slot-name: 'staging'
-
+          publish-profile: ${{ secrets.AzureAppService_PublishProfile_44f7766441ec4796b74789e9761ef589 }}
-      - name: Set Web App with Docker container
+          images: 'syncrow.azurecr.io/${{ secrets.AzureAppService_ContainerUsername_47395803300340b49931ea82f6d80be3 }}/syncrow/backend:${{ github.sha }}'
-        run: |
-          az webapp config container set \
-          --name ${{ env.AZURE_WEB_APP_NAME }} \
-          --resource-group backend \
-          --docker-custom-image-name ${{ env.ACR_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.IMAGE_TAG }} \
-          --docker-registry-server-url https://${{ env.ACR_REGISTRY }}

.github/workflows/main_syncrow(stg).yml

@@ -0,0 +1,73 @@
+# Docs for the Azure Web Apps Deploy action: https://github.com/Azure/webapps-deploy
+# More GitHub Actions for Azure: https://github.com/Azure/actions
+
+name: Build and deploy Node.js app to Azure Web App - syncrow
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read #This is required for actions/checkout
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js version
+        uses: actions/setup-node@v3
+        with:
+          node-version: '20.x'
+
+      - name: npm install, build, and test
+        run: |
+          npm install
+          npm run build --if-present
+          npm run test --if-present
+
+      - name: Zip artifact for deployment
+        run: zip release.zip ./* -r
+
+      - name: Upload artifact for deployment job
+        uses: actions/upload-artifact@v4
+        with:
+          name: node-app
+          path: release.zip
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: build
+    environment:
+      name: 'stg'
+      url: ${{ steps.deploy-to-webapp.outputs.webapp-url }}
+    permissions:
+      id-token: write #This is required for requesting the JWT
+      contents: read #This is required for actions/checkout
+
+    steps:
+      - name: Download artifact from build job
+        uses: actions/download-artifact@v4
+        with:
+          name: node-app
+
+      - name: Unzip artifact for deployment
+        run: unzip release.zip
+
+      - name: Login to Azure
+        uses: azure/login@v2
+        with:
+          client-id: ${{ secrets.AZUREAPPSERVICE_CLIENTID_515C8E782CFF431AB20448C85CA0FE58 }}
+          tenant-id: ${{ secrets.AZUREAPPSERVICE_TENANTID_2AEFE5534424490387C08FAE41573CC2 }}
+          subscription-id: ${{ secrets.AZUREAPPSERVICE_SUBSCRIPTIONID_00623C33023749FEA5F6BC36884F9C8A }}
+
+      - name: 'Deploy to Azure Web App'
+        id: deploy-to-webapp
+        uses: azure/webapps-deploy@v3
+        with:
+          app-name: 'syncrow'
+          slot-name: 'stg'
+          package: .

.gitignore

@@ -4,7 +4,7 @@
 /build
 
 #github 
-/.github
+/.github/workflows
 
 # Logs
 logs

libs/common/src/auth/services/auth.service.ts

@@ -1,5 +1,6 @@
 import { PlatformType } from '@app/common/constants/platform-type.enum';
 import { RoleType } from '@app/common/constants/role.type.enum';
+import { UserEntity } from '@app/common/modules/user/entities';
 import {
   BadRequestException,
   Injectable,
@@ -32,7 +33,7 @@ export class AuthService {
     pass: string,
     regionUuid?: string,
     platform?: PlatformType,
-  ): Promise<any> {
+  ): Promise<Omit<UserEntity, 'password'>> {
     const user = await this.userRepository.findOne({
       where: {
         email,
@@ -70,8 +71,9 @@ export class AuthService {
     }
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { password, ...result } = user;
+    // const { password, ...result } = user;
-    return result;
+    delete user.password;
+    return user;
   }
 
   async createSession(data): Promise<UserSessionEntity> {
@@ -114,6 +116,7 @@ export class AuthService {
       hasAcceptedWebAgreement: user.hasAcceptedWebAgreement,
       hasAcceptedAppAgreement: user.hasAcceptedAppAgreement,
       project: user?.project,
+      bookingPoints: user?.bookingPoints,
     };
     if (payload.googleCode) {
       const profile = await this.getProfile(payload.googleCode);

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

@@ -69,7 +69,28 @@ export class ControllerRoute {
         'Retrieve the list of all regions registered in Syncrow.';
     };
   };
+  static BOOKABLE_SPACES = class {
+    public static readonly ROUTE = 'bookable-spaces';
+    static ACTIONS = class {
+      public static readonly ADD_BOOKABLE_SPACES_SUMMARY =
+        'Add new bookable spaces';
 
+      public static readonly ADD_BOOKABLE_SPACES_DESCRIPTION =
+        'This endpoint allows you to add new bookable spaces by providing the required details.';
+
+      public static readonly GET_ALL_BOOKABLE_SPACES_SUMMARY =
+        'Get all bookable spaces';
+
+      public static readonly GET_ALL_BOOKABLE_SPACES_DESCRIPTION =
+        'This endpoint retrieves all bookable spaces.';
+
+      public static readonly UPDATE_BOOKABLE_SPACES_SUMMARY =
+        'Update existing bookable spaces';
+
+      public static readonly UPDATE_BOOKABLE_SPACES_DESCRIPTION =
+        'This endpoint allows you to update existing bookable spaces by providing the required details.';
+    };
+  };
   static COMMUNITY = class {
     public static readonly ROUTE = '/projects/:projectUuid/communities';
     static ACTIONS = class {
@@ -199,6 +220,11 @@ export class ControllerRoute {
       public static readonly UPDATE_SPACE_DESCRIPTION =
         'Updates a space by its UUID and community ID. You can update the name, parent space, and other properties. If a parent space is provided and not already a parent, its `isParent` flag will be set to true.';
 
+      public static readonly UPDATE_CHILDREN_SPACES_ORDER_OF_A_SPACE_SUMMARY =
+        'Update the order of child spaces under a specific parent space';
+      public static readonly UPDATE_CHILDREN_SPACES_ORDER_OF_A_SPACE_DESCRIPTION =
+        'Updates the order of child spaces under a specific parent space. You can provide a new order for the child spaces.';
+
       public static readonly GET_HEIRARCHY_SUMMARY = 'Get space hierarchy';
       public static readonly GET_HEIRARCHY_DESCRIPTION =
         'This endpoint retrieves the hierarchical structure of spaces under a given space ID. It returns all the child spaces nested within the specified space, organized by their parent-child relationships. ';
@@ -397,6 +423,11 @@ export class ControllerRoute {
       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.';
+
+      public static readonly DELETE_USER_PROFILE_SUMMARY =
+        'Delete user profile by UUID';
+      public static readonly DELETE_USER_PROFILE_DESCRIPTION =
+        'This endpoint deletes a user profile identified by their UUID. Accessible only by users with the Super Admin role.';
       public static readonly UPDATE_USER_WEB_AGREEMENT_SUMMARY =
         'Update user web agreement by user UUID';
       public static readonly UPDATE_USER_WEB_AGREEMENT_DESCRIPTION =
@@ -501,7 +532,6 @@ export class ControllerRoute {
   };
   static PowerClamp = class {
     public static readonly ROUTE = 'power-clamp';
-
     static ACTIONS = class {
       public static readonly GET_ENERGY_SUMMARY =
         'Get power clamp historical data';
@@ -628,6 +658,11 @@ export class ControllerRoute {
         'Delete scenes by device uuid and switch name';
       public static readonly DELETE_SCENES_BY_SWITCH_NAME_DESCRIPTION =
         'This endpoint deletes all scenes associated with a specific switch device.';
+
+      public static readonly POPULATE_TUYA_CONST_UUID_SUMMARY =
+        'Populate Tuya const UUID';
+      public static readonly POPULATE_TUYA_CONST_UUID_DESCRIPTION =
+        'This endpoint populates the Tuya const UUID for all devices.';
     };
   };
   static DEVICE_COMMISSION = class {

libs/common/src/database/database.module.ts

@@ -58,6 +58,7 @@ import {
   UserSpaceEntity,
 } from '../modules/user/entities';
 import { VisitorPasswordEntity } from '../modules/visitor-password/entities';
+import { BookableSpaceEntity } from '../modules/booking/entities';
 @Module({
   imports: [
     TypeOrmModule.forRootAsync({
@@ -117,6 +118,7 @@ import { VisitorPasswordEntity } from '../modules/visitor-password/entities';
             PresenceSensorDailySpaceEntity,
             AqiSpaceDailyPollutantStatsEntity,
             SpaceDailyOccupancyDurationEntity,
+            BookableSpaceEntity,
           ],
           namingStrategy: new SnakeNamingStrategy(),
           synchronize: Boolean(JSON.parse(configService.get('DB_SYNC'))),

libs/common/src/firebase/devices-status/dtos/add.devices-status.dto.ts

@@ -13,6 +13,7 @@ class StatusDto {
 
   @IsNotEmpty()
   value: any;
+  t?: string | number | Date;
 }
 
 export class AddDeviceStatusDto {

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

@@ -22,6 +22,8 @@ import { DeviceStatusLogRepository } from '@app/common/modules/device-status-log
 export class DeviceStatusFirebaseService {
   private tuya: TuyaContext;
   private firebaseDb: Database;
+  private readonly isDevEnv: boolean;
+
   constructor(
     private readonly configService: ConfigService,
     private readonly deviceRepository: DeviceRepository,
@@ -38,6 +40,8 @@ export class DeviceStatusFirebaseService {
 
     // Initialize firebaseDb using firebaseDataBase function
     this.firebaseDb = firebaseDataBase(this.configService);
+    this.isDevEnv =
+      this.configService.get<string>('NODE_ENV') === 'development';
   }
   async addDeviceStatusByDeviceUuid(
     deviceTuyaUuid: string,
@@ -52,7 +56,7 @@ export class DeviceStatusFirebaseService {
           const deviceStatusSaved = await this.createDeviceStatusFirebase({
             deviceUuid: device.uuid,
             deviceTuyaUuid: deviceTuyaUuid,
-            status: deviceStatus.status,
+            status: deviceStatus?.status,
             productUuid: deviceStatus.productUuid,
             productType: deviceStatus.productType,
           });
@@ -191,7 +195,7 @@ export class DeviceStatusFirebaseService {
       return {
         productUuid: deviceDetails.productDevice.uuid,
         productType: deviceDetails.productDevice.prodType,
-        status: deviceStatus.result[0].status,
+        status: deviceStatus.result[0]?.status,
       };
     } catch (error) {
       throw new HttpException(
@@ -256,18 +260,18 @@ export class DeviceStatusFirebaseService {
       if (!existingData.productType) {
         existingData.productType = addDeviceStatusDto.productType;
       }
-      if (!existingData.status) {
+      if (!existingData?.status) {
         existingData.status = [];
       }
 
       // Create a map to track existing status codes
       const statusMap = new Map(
-        existingData.status.map((item) => [item.code, item.value]),
+        existingData?.status.map((item) => [item.code, item.value]),
       );
 
       // Update or add status codes
 
-      for (const statusItem of addDeviceStatusDto.status) {
+      for (const statusItem of addDeviceStatusDto?.status) {
         statusMap.set(statusItem.code, statusItem.value);
       }
 

libs/common/src/helper/timeToMinutes.ts

@@ -0,0 +1,5 @@
+// Convert time string (HH:mm) to minutes
+export function timeToMinutes(time: string): number {
+  const [hours, minutes] = time.split(':').map(Number);
+  return hours * 60 + minutes;
+}

libs/common/src/integrations/tuya/services/tuya.service.ts

@@ -49,12 +49,12 @@ export class TuyaService {
       path,
     });
 
-    if (!response.success) {
+    // if (!response.success) {
-      throw new HttpException(
+    //   throw new HttpException(
-        `Error fetching device details: ${response.msg}`,
+    //     `Error fetching device details: ${response.msg}`,
-        HttpStatus.BAD_REQUEST,
+    //     HttpStatus.BAD_REQUEST,
-      );
+    //   );
-    }
+    // }
 
     return response.result;
   }

libs/common/src/logger/services/winston.logger.ts

@@ -1,32 +1,18 @@
 import { utilities as nestWinstonModuleUtilities } from 'nest-winston';
 import * as winston from 'winston';
-const environment = process.env.NODE_ENV || 'local';
 
 export const winstonLoggerOptions: winston.LoggerOptions = {
   level:
-    environment === 'local'
+    process.env.AZURE_POSTGRESQL_DATABASE === 'development' ? 'debug' : 'error',
-      ? 'debug'
-      : environment === 'development'
-        ? 'warn'
-        : 'error',
   transports: [
     new winston.transports.Console({
-      level:
-        environment === 'local'
-          ? 'debug'
-          : environment === 'development'
-            ? 'warn'
-            : 'error',
       format: winston.format.combine(
         winston.format.timestamp(),
         nestWinstonModuleUtilities.format.nestLike('MyApp', {
-          prettyPrint: environment === 'local',
+          prettyPrint: true,
         }),
       ),
     }),
-    // Only create file logs if NOT local
-    ...(environment !== 'local'
-      ? [
     new winston.transports.File({
       filename: 'logs/error.log',
       level: 'error',
@@ -34,10 +20,7 @@ export const winstonLoggerOptions: winston.LoggerOptions = {
     }),
     new winston.transports.File({
       filename: 'logs/combined.log',
-            level: 'info',
       format: winston.format.json(),
     }),
-        ]
-      : []),
   ],
 };

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

@@ -8,14 +8,14 @@ import {
   Unique,
 } from 'typeorm';
 
-import { AbstractEntity } from '../../abstract/entities/abstract.entity';
-import { RoleTypeEntity } from '../../role-type/entities';
-import { UserStatusEnum } from '@app/common/constants/user-status.enum';
-import { UserEntity } from '../../user/entities';
 import { RoleType } from '@app/common/constants/role.type.enum';
-import { InviteUserDto, InviteUserSpaceDto } from '../dtos';
+import { UserStatusEnum } from '@app/common/constants/user-status.enum';
+import { AbstractEntity } from '../../abstract/entities/abstract.entity';
 import { ProjectEntity } from '../../project/entities';
+import { RoleTypeEntity } from '../../role-type/entities';
 import { SpaceEntity } from '../../space/entities/space.entity';
+import { UserEntity } from '../../user/entities';
+import { InviteUserDto, InviteUserSpaceDto } from '../dtos';
 
 @Entity({ name: 'invite-user' })
 @Unique(['email', 'project'])
@@ -82,7 +82,10 @@ export class InviteUserEntity extends AbstractEntity<InviteUserDto> {
     onDelete: 'CASCADE',
   })
   public roleType: RoleTypeEntity;
-  @OneToOne(() => UserEntity, (user) => user.inviteUser, { nullable: true })
+  @OneToOne(() => UserEntity, (user) => user.inviteUser, {
+    nullable: true,
+    onDelete: 'CASCADE',
+  })
   @JoinColumn({ name: 'user_uuid' })
   user: UserEntity;
   @OneToMany(
@@ -112,7 +115,9 @@ export class InviteUserSpaceEntity extends AbstractEntity<InviteUserSpaceDto> {
   })
   public uuid: string;
 
-  @ManyToOne(() => InviteUserEntity, (inviteUser) => inviteUser.spaces)
+  @ManyToOne(() => InviteUserEntity, (inviteUser) => inviteUser.spaces, {
+    onDelete: 'CASCADE',
+  })
   @JoinColumn({ name: 'invite_user_uuid' })
   public inviteUser: InviteUserEntity;
 

libs/common/src/modules/booking/booking.repository.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { BookableSpaceEntity } from './entities/bookable-space.entity';
+
+@Module({
+  providers: [],
+  exports: [],
+  controllers: [],
+  imports: [TypeOrmModule.forFeature([BookableSpaceEntity])],
+})
+export class BookableRepositoryModule {}

libs/common/src/modules/booking/entities/bookable-space.entity.ts

@@ -0,0 +1,51 @@
+import { DaysEnum } from '@app/common/constants/days.enum';
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  OneToOne,
+  UpdateDateColumn,
+} from 'typeorm';
+import { AbstractEntity } from '../../abstract/entities/abstract.entity';
+import { SpaceEntity } from '../../space/entities/space.entity';
+
+@Entity('bookable-space')
+export class BookableSpaceEntity extends AbstractEntity {
+  @Column({
+    type: 'uuid',
+    default: () => 'gen_random_uuid()',
+    nullable: false,
+  })
+  public uuid: string;
+
+  @OneToOne(() => SpaceEntity, (space) => space.bookableConfig)
+  @JoinColumn({ name: 'space_uuid' })
+  space: SpaceEntity;
+
+  @Column({
+    type: 'enum',
+    enum: DaysEnum,
+    array: true,
+    nullable: false,
+  })
+  daysAvailable: DaysEnum[];
+
+  @Column({ type: 'time' })
+  startTime: string;
+
+  @Column({ type: 'time' })
+  endTime: string;
+
+  @Column({ type: Boolean, default: true })
+  active: boolean;
+
+  @Column({ type: 'int', default: null })
+  points?: number;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

libs/common/src/modules/booking/entities/index.ts

@@ -0,0 +1 @@
+export * from './bookable-space.entity';

libs/common/src/modules/booking/repositories/booking.repository.ts

@@ -0,0 +1,10 @@
+import { DataSource, Repository } from 'typeorm';
+import { Injectable } from '@nestjs/common';
+import { BookableSpaceEntity } from '../entities/bookable-space.entity';
+
+@Injectable()
+export class BookableSpaceEntityRepository extends Repository<BookableSpaceEntity> {
+  constructor(private dataSource: DataSource) {
+    super(BookableSpaceEntity, dataSource.createEntityManager());
+  }
+}

libs/common/src/modules/booking/repositories/index.ts

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

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

@@ -1,24 +1,24 @@
 import {
   Column,
   Entity,
+  Index,
+  JoinColumn,
   ManyToOne,
   OneToMany,
   Unique,
-  Index,
-  JoinColumn,
 } from 'typeorm';
 import { AbstractEntity } from '../../abstract/entities/abstract.entity';
-import { DeviceDto, DeviceUserPermissionDto } from '../dtos/device.dto';
-import { ProductEntity } from '../../product/entities';
-import { UserEntity } from '../../user/entities';
-import { DeviceNotificationDto } from '../dtos';
 import { PermissionTypeEntity } from '../../permission/entities';
+import { PowerClampHourlyEntity } from '../../power-clamp/entities/power-clamp.entity';
+import { PresenceSensorDailyDeviceEntity } from '../../presence-sensor/entities';
+import { ProductEntity } from '../../product/entities';
 import { SceneDeviceEntity } from '../../scene-device/entities';
 import { SpaceEntity } from '../../space/entities/space.entity';
 import { SubspaceEntity } from '../../space/entities/subspace/subspace.entity';
 import { NewTagEntity } from '../../tag';
-import { PowerClampHourlyEntity } from '../../power-clamp/entities/power-clamp.entity';
+import { UserEntity } from '../../user/entities';
-import { PresenceSensorDailyDeviceEntity } from '../../presence-sensor/entities';
+import { DeviceNotificationDto } from '../dtos';
+import { DeviceDto, DeviceUserPermissionDto } from '../dtos/device.dto';
 
 @Entity({ name: 'device' })
 @Unique(['deviceTuyaUuid'])
@@ -28,6 +28,11 @@ export class DeviceEntity extends AbstractEntity<DeviceDto> {
   })
   deviceTuyaUuid: string;
 
+  @Column({
+    nullable: true,
+  })
+  deviceTuyaConstUuid: string;
+
   @Column({
     nullable: true,
     default: true,
@@ -111,6 +116,7 @@ export class DeviceNotificationEntity extends AbstractEntity<DeviceNotificationD
 
   @ManyToOne(() => UserEntity, (user) => user.userPermission, {
     nullable: false,
+    onDelete: 'CASCADE',
   })
   user: UserEntity;
 
@@ -149,6 +155,7 @@ export class DeviceUserPermissionEntity extends AbstractEntity<DeviceUserPermiss
 
   @ManyToOne(() => UserEntity, (user) => user.userPermission, {
     nullable: false,
+    onDelete: 'CASCADE',
   })
   user: UserEntity;
   constructor(partial: Partial<DeviceUserPermissionEntity>) {

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

@@ -1,3 +0,0 @@
-import { AbstractEntity } from '../../abstract/entities/abstract.entity';
-
-export class SpaceLinkEntity extends AbstractEntity {}

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

@@ -1,6 +1,14 @@
-import { Column, Entity, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+import {
+  Column,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+} from 'typeorm';
 import { AbstractEntity } from '../../abstract/entities/abstract.entity';
 import { AqiSpaceDailyPollutantStatsEntity } from '../../aqi/entities';
+import { BookableSpaceEntity } from '../../booking/entities';
 import { CommunityEntity } from '../../community/entities';
 import { DeviceEntity } from '../../device/entities';
 import { InviteUserSpaceEntity } from '../../Invite-user/entities';
@@ -56,6 +64,12 @@ export class SpaceEntity extends AbstractEntity<SpaceDto> {
   })
   public disabled: boolean;
 
+  @Column({
+    nullable: true,
+    type: Number,
+  })
+  public order?: number;
+
   @OneToMany(() => SubspaceEntity, (subspace) => subspace.space, {
     nullable: true,
   })
@@ -115,6 +129,9 @@ export class SpaceEntity extends AbstractEntity<SpaceDto> {
   )
   occupancyDaily: SpaceDailyOccupancyDurationEntity[];
 
+  @OneToOne(() => BookableSpaceEntity, (bookable) => bookable.space)
+  bookableConfig: BookableSpaceEntity;
+
   constructor(partial: Partial<SpaceEntity>) {
     super();
     Object.assign(this, partial);

libs/common/src/modules/space/repositories/space.repository.ts

@@ -11,9 +11,6 @@ export class SpaceRepository extends Repository<SpaceEntity> {
   }
 }
 
-@Injectable()
-export class SpaceLinkRepository {}
-
 @Injectable()
 export class InviteSpaceRepository extends Repository<InviteSpaceEntity> {
   constructor(private dataSource: DataSource) {

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

@@ -1,3 +1,4 @@
+import { defaultProfilePicture } from '@app/common/constants/default.profile.picture';
 import {
   Column,
   DeleteDateColumn,
@@ -8,27 +9,26 @@ import {
   OneToOne,
   Unique,
 } from 'typeorm';
+import { OtpType } from '../../../../src/constants/otp-type.enum';
+import { AbstractEntity } from '../../abstract/entities/abstract.entity';
+import { ClientEntity } from '../../client/entities';
+import {
+  DeviceNotificationEntity,
+  DeviceUserPermissionEntity,
+} from '../../device/entities';
+import { InviteUserEntity } from '../../Invite-user/entities';
+import { ProjectEntity } from '../../project/entities';
+import { RegionEntity } from '../../region/entities';
+import { RoleTypeEntity } from '../../role-type/entities';
+import { SpaceEntity } from '../../space/entities/space.entity';
+import { TimeZoneEntity } from '../../timezone/entities';
+import { VisitorPasswordEntity } from '../../visitor-password/entities';
 import {
   UserDto,
   UserNotificationDto,
   UserOtpDto,
   UserSpaceDto,
 } from '../dtos';
-import { AbstractEntity } from '../../abstract/entities/abstract.entity';
-import {
-  DeviceNotificationEntity,
-  DeviceUserPermissionEntity,
-} from '../../device/entities';
-import { defaultProfilePicture } from '@app/common/constants/default.profile.picture';
-import { RegionEntity } from '../../region/entities';
-import { TimeZoneEntity } from '../../timezone/entities';
-import { OtpType } from '../../../../src/constants/otp-type.enum';
-import { RoleTypeEntity } from '../../role-type/entities';
-import { VisitorPasswordEntity } from '../../visitor-password/entities';
-import { InviteUserEntity } from '../../Invite-user/entities';
-import { ProjectEntity } from '../../project/entities';
-import { SpaceEntity } from '../../space/entities/space.entity';
-import { ClientEntity } from '../../client/entities';
 
 @Entity({ name: 'user' })
 export class UserEntity extends AbstractEntity<UserDto> {
@@ -82,6 +82,12 @@ export class UserEntity extends AbstractEntity<UserDto> {
   })
   public isActive: boolean;
 
+  @Column({
+    nullable: true,
+    type: Number,
+  })
+  public bookingPoints?: number;
+
   @Column({ default: false })
   hasAcceptedWebAgreement: boolean;
 
@@ -94,7 +100,9 @@ export class UserEntity extends AbstractEntity<UserDto> {
   @Column({ type: 'timestamp', nullable: true })
   appAgreementAcceptedAt: Date;
 
-  @OneToMany(() => UserSpaceEntity, (userSpace) => userSpace.user)
+  @OneToMany(() => UserSpaceEntity, (userSpace) => userSpace.user, {
+    onDelete: 'CASCADE',
+  })
   userSpaces: UserSpaceEntity[];
 
   @OneToMany(
@@ -158,6 +166,7 @@ export class UserEntity extends AbstractEntity<UserDto> {
 export class UserNotificationEntity extends AbstractEntity<UserNotificationDto> {
   @ManyToOne(() => UserEntity, (user) => user.roleType, {
     nullable: false,
+    onDelete: 'CASCADE',
   })
   user: UserEntity;
   @Column({
@@ -219,7 +228,10 @@ export class UserSpaceEntity extends AbstractEntity<UserSpaceDto> {
   })
   public uuid: string;
 
-  @ManyToOne(() => UserEntity, (user) => user.userSpaces, { nullable: false })
+  @ManyToOne(() => UserEntity, (user) => user.userSpaces, {
+    nullable: false,
+    onDelete: 'CASCADE',
+  })
   user: UserEntity;
 
   @ManyToOne(() => SpaceEntity, (space) => space.userSpaces, {

libs/common/src/modules/visitor-password/entities/visitor-password.entity.ts

@@ -1,7 +1,7 @@
-import { Column, Entity, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
-import { VisitorPasswordDto } from '../dtos';
 import { AbstractEntity } from '../../abstract/entities/abstract.entity';
 import { UserEntity } from '../../user/entities/user.entity';
+import { VisitorPasswordDto } from '../dtos';
 
 @Entity({ name: 'visitor-password' })
 @Index('IDX_PASSWORD_TUYA_UUID', ['passwordTuyaUuid'])
@@ -14,6 +14,7 @@ export class VisitorPasswordEntity extends AbstractEntity<VisitorPasswordDto> {
 
   @ManyToOne(() => UserEntity, (user) => user.visitorPasswords, {
     nullable: false,
+    onDelete: 'CASCADE',
   })
   @JoinColumn({ name: 'authorizer_uuid' })
   public user: UserEntity;

package.json

@@ -56,7 +56,7 @@
     "onesignal-node": "^3.4.0",
     "passport-jwt": "^4.0.1",
     "pg": "^8.11.3",
-    "reflect-metadata": "^0.2.0",
+    "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1",
     "typeorm": "^0.3.20",
     "winston": "^3.17.0",
@@ -89,5 +89,9 @@
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.1.3"
+  },
+  "engines": {
+    "node": "20.x",
+    "npm": "10.x"
   }
 }

src/app.module.ts

@@ -44,6 +44,7 @@ import { OccupancyModule } from './occupancy/occupancy.module';
 import { WeatherModule } from './weather/weather.module';
 import { ScheduleModule as NestScheduleModule } from '@nestjs/schedule';
 import { SchedulerModule } from './scheduler/scheduler.module';
+import { BookingModule } from './booking';
 @Module({
   imports: [
     ConfigModule.forRoot({
@@ -98,6 +99,7 @@ import { SchedulerModule } from './scheduler/scheduler.module';
     AqiModule,
     SchedulerModule,
     NestScheduleModule.forRoot(),
+    BookingModule,
   ],
   providers: [
     {

src/auth/services/user-auth.service.ts

@@ -1,25 +1,25 @@
-import { UserRepository } from '../../../libs/common/src/modules/user/repositories';
+import { RoleType } from '@app/common/constants/role.type.enum';
+import { differenceInSeconds } from '@app/common/helper/differenceInSeconds';
 import {
   BadRequestException,
   ForbiddenException,
   Injectable,
 } from '@nestjs/common';
-import { UserSignUpDto } from '../dtos/user-auth.dto';
-import { HelperHashService } from '../../../libs/common/src/helper/services';
-import { UserLoginDto } from '../dtos/user-login.dto';
-import { AuthService } from '../../../libs/common/src/auth/services/auth.service';
-import { UserSessionRepository } from '../../../libs/common/src/modules/session/repositories/session.repository';
-import { UserOtpRepository } from '../../../libs/common/src/modules/user/repositories/user.repository';
-import { ForgetPasswordDto, UserOtpDto, VerifyOtpDto } from '../dtos';
-import { EmailService } from '../../../libs/common/src/util/email.service';
-import { OtpType } from '../../../libs/common/src/constants/otp-type.enum';
-import { UserEntity } from '../../../libs/common/src/modules/user/entities/user.entity';
-import * as argon2 from 'argon2';
-import { differenceInSeconds } from '@app/common/helper/differenceInSeconds';
-import { LessThan, MoreThan } from 'typeorm';
 import { ConfigService } from '@nestjs/config';
+import * as argon2 from 'argon2';
 import { RoleService } from 'src/role/services';
-import { RoleType } from '@app/common/constants/role.type.enum';
+import { LessThan, MoreThan } from 'typeorm';
+import { AuthService } from '../../../libs/common/src/auth/services/auth.service';
+import { OtpType } from '../../../libs/common/src/constants/otp-type.enum';
+import { HelperHashService } from '../../../libs/common/src/helper/services';
+import { UserSessionRepository } from '../../../libs/common/src/modules/session/repositories/session.repository';
+import { UserEntity } from '../../../libs/common/src/modules/user/entities/user.entity';
+import { UserRepository } from '../../../libs/common/src/modules/user/repositories';
+import { UserOtpRepository } from '../../../libs/common/src/modules/user/repositories/user.repository';
+import { EmailService } from '../../../libs/common/src/util/email.service';
+import { ForgetPasswordDto, UserOtpDto, VerifyOtpDto } from '../dtos';
+import { UserSignUpDto } from '../dtos/user-auth.dto';
+import { UserLoginDto } from '../dtos/user-login.dto';
 
 @Injectable()
 export class UserAuthService {
@@ -108,7 +108,7 @@ export class UserAuthService {
 
   async userLogin(data: UserLoginDto) {
     try {
-      let user;
+      let user: Omit<UserEntity, 'password'>;
       if (data.googleCode) {
         const googleUserData = await this.authService.login({
           googleCode: data.googleCode,
@@ -145,7 +145,7 @@ export class UserAuthService {
       }
       const session = await Promise.all([
         await this.sessionRepository.update(
-          { userId: user.id },
+          { userId: user?.['id'] },
           {
             isLoggedOut: true,
           },
@@ -166,6 +166,7 @@ export class UserAuthService {
         hasAcceptedAppAgreement: user.hasAcceptedAppAgreement,
         project: user.project,
         sessionId: session[1].uuid,
+        bookingPoints: user.bookingPoints,
       });
       return res;
     } catch (error) {
@@ -347,6 +348,7 @@ export class UserAuthService {
       userId: user.uuid,
       uuid: user.uuid,
       type,
+      bookingPoints: user.bookingPoints,
       sessionId,
     });
     await this.authService.updateRefreshToken(user.uuid, tokens.refreshToken);

src/booking/booking.module.ts

@@ -0,0 +1,17 @@
+import { Global, Module } from '@nestjs/common';
+import { BookableSpaceController } from './controllers';
+import { BookableSpaceService } from './services';
+import { BookableSpaceEntityRepository } from '@app/common/modules/booking/repositories';
+import { SpaceRepository } from '@app/common/modules/space';
+
+@Global()
+@Module({
+  controllers: [BookableSpaceController],
+  providers: [
+    BookableSpaceService,
+    BookableSpaceEntityRepository,
+    SpaceRepository,
+  ],
+  exports: [BookableSpaceService],
+})
+export class BookingModule {}

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

@@ -0,0 +1,106 @@
+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,
+  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 { CreateBookableSpaceDto } from '../dtos';
+import { BookableSpaceRequestDto } from '../dtos/bookable-space-request.dto';
+import { BookableSpaceResponseDto } from '../dtos/bookable-space-response.dto';
+import { UpdateBookableSpaceDto } from '../dtos/update-bookable-space.dto';
+import { BookableSpaceService } from '../services';
+
+@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') 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/index.ts

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

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/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/index.ts

@@ -0,0 +1 @@
+export * from './create-bookable-space.dto';

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,198 @@
+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';
+import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
+import { SpaceRepository } from '@app/common/modules/space/repositories/space.repository';
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { In } from 'typeorm';
+import { CreateBookableSpaceDto } from '../dtos';
+import { BookableSpaceRequestDto } from '../dtos/bookable-space-request.dto';
+import { UpdateBookableSpaceDto } from '../dtos/update-bookable-space.dto';
+
+@Injectable()
+export class BookableSpaceService {
+  constructor(
+    private readonly bookableSpaceEntityRepository: BookableSpaceEntityRepository,
+    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('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,
+    };
+  }
+
+  /**
+   * todo: if updating availability, send to the ones who have access to this space
+   * todo: if updating other fields, just send emails to all users who's bookings might be affected
+   */
+  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,
+      );
+    }
+    Object.assign(space.bookableConfig, dto);
+    return this.bookableSpaceEntityRepository.save(space.bookableConfig);
+  }
+
+  /**
+   * 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/index.ts

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

src/commission-device/services/commission-device.service.ts

@@ -3,6 +3,7 @@ import * as fs from 'fs';
 
 import { ProjectParam } from '@app/common/dto/project-param.dto';
 import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
+import { DeviceStatusFirebaseService } from '@app/common/firebase/devices-status/services/devices-status.service';
 import { TuyaService } from '@app/common/integrations/tuya/services/tuya.service';
 import { CommunityRepository } from '@app/common/modules/community/repositories';
 import { DeviceRepository } from '@app/common/modules/device/repositories';
@@ -20,6 +21,7 @@ export class DeviceCommissionService {
   constructor(
     private readonly tuyaService: TuyaService,
     private readonly deviceService: DeviceService,
+    private readonly deviceStatusFirebaseService: DeviceStatusFirebaseService,
     private readonly communityRepository: CommunityRepository,
     private readonly spaceRepository: SpaceRepository,
     private readonly subspaceRepository: SubspaceRepository,
@@ -209,6 +211,10 @@ export class DeviceCommissionService {
         rawDeviceId,
         tuyaSpaceId,
       );
+
+      await this.deviceStatusFirebaseService.addDeviceStatusByDeviceUuid(
+        rawDeviceId,
+      );
       successCount.value++;
       console.log(
         `Device ${rawDeviceId} successfully processed and transferred to Tuya space ${tuyaSpaceId}`,

src/community/community.module.ts

@@ -5,7 +5,6 @@ import { ConfigModule } from '@nestjs/config';
 import { SpaceRepositoryModule } from '@app/common/modules/space/space.repository.module';
 import {
   InviteSpaceRepository,
-  SpaceLinkRepository,
   SpaceProductAllocationRepository,
   SpaceRepository,
 } from '@app/common/modules/space/repositories';
@@ -16,14 +15,12 @@ import { CommunityRepository } from '@app/common/modules/community/repositories'
 import { TuyaService } from '@app/common/integrations/tuya/services/tuya.service';
 import { ProjectRepository } from '@app/common/modules/project/repositiories';
 import {
-  SpaceLinkService,
   SpaceService,
   SubspaceDeviceService,
   SubSpaceService,
   ValidationService,
 } from 'src/space/services';
 import { TagService as NewTagService } from 'src/tags/services';
-import { TagService } from 'src/space/services/tag';
 import {
   SpaceModelService,
   SubSpaceModelService,
@@ -81,16 +78,13 @@ import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/r
     SpaceService,
     InviteSpaceRepository,
     // Todo: find out why this is needed
-    SpaceLinkService,
     SubSpaceService,
     ValidationService,
     NewTagService,
     SpaceModelService,
     SpaceProductAllocationService,
-    SpaceLinkRepository,
     SubspaceRepository,
     // Todo: find out why this is needed
-    TagService,
     SubspaceDeviceService,
     SubspaceProductAllocationService,
     SpaceModelRepository,

src/community/services/community.service.ts

@@ -120,6 +120,7 @@ export class CommunityService {
         .leftJoin('c.spaces', 's', 's.disabled = false')
         .where('c.project = :projectUuid', { projectUuid })
         .andWhere(`c.name != '${ORPHAN_COMMUNITY_NAME}-${project.name}'`)
+        .orderBy('c.createdAt', 'DESC')
         .distinct(true);
       if (pageable.search) {
         qb.andWhere(
@@ -209,7 +210,7 @@ export class CommunityService {
       if (search) {
         qb.andWhere(
           `c.name ILIKE :search ${includeSpaces ? 'OR space.space_name ILIKE :search' : ''}`,
-          { search },
+          { search: `%${search}%` },
         );
       }
 

src/device/controllers/device.controller.ts

@@ -1,39 +1,41 @@
-import { DeviceService } from '../services/device.service';
+import { ControllerRoute } from '@app/common/constants/controller-route';
+import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
+import { RoleType } from '@app/common/constants/role.type.enum';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
 import {
   Body,
   Controller,
-  Get,
-  Post,
-  Query,
-  Param,
-  UseGuards,
-  Put,
   Delete,
+  Get,
+  Param,
+  Post,
+  Put,
+  Query,
   Req,
+  UnauthorizedException,
+  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 { CheckRoomGuard } from 'src/guards/room.guard';
+import { CheckFourAndSixSceneDeviceTypeGuard } from 'src/guards/scene.device.type.guard';
 import {
   AddDeviceDto,
   AddSceneToFourSceneDeviceDto,
   AssignDeviceToSpaceDto,
   UpdateDeviceDto,
 } from '../dtos/add.device.dto';
-import { GetDeviceLogsDto } from '../dtos/get.device.dto';
 import {
-  ControlDeviceDto,
   BatchControlDevicesDto,
   BatchStatusDevicesDto,
+  ControlDeviceDto,
   GetSceneFourSceneDeviceDto,
 } from '../dtos/control.device.dto';
-import { CheckRoomGuard } from 'src/guards/room.guard';
-import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
-import { CheckFourAndSixSceneDeviceTypeGuard } from 'src/guards/scene.device.type.guard';
-import { ControllerRoute } from '@app/common/constants/controller-route';
-import { BaseResponseDto } from '@app/common/dto/base.response.dto';
-import { DeviceSceneParamDto } from '../dtos/device.param.dto';
 import { DeleteSceneFromSceneDeviceDto } from '../dtos/delete.device.dto';
-import { PermissionsGuard } from 'src/guards/permissions.guard';
+import { DeviceSceneParamDto } from '../dtos/device.param.dto';
-import { Permissions } from 'src/decorators/permissions.decorator';
+import { GetDeviceLogsDto } from '../dtos/get.device.dto';
+import { DeviceService } from '../services/device.service';
 
 @ApiTags('Device Module')
 @Controller({
@@ -340,4 +342,22 @@ export class DeviceController {
       projectUuid,
     );
   }
+
+  @ApiBearerAuth()
+  @UseGuards(PermissionsGuard)
+  @Permissions('DEVICE_UPDATE')
+  @Post('/populate-tuya-const-uuids')
+  @ApiOperation({
+    summary: ControllerRoute.DEVICE.ACTIONS.POPULATE_TUYA_CONST_UUID_SUMMARY,
+    description:
+      ControllerRoute.DEVICE.ACTIONS.POPULATE_TUYA_CONST_UUID_DESCRIPTION,
+  })
+  async populateTuyaConstUuid(@Req() req: any): Promise<void> {
+    const userUuid = req['user']?.userUuid;
+    const userRole = req['user']?.role;
+    if (!userUuid || (userRole && userRole !== RoleType.SUPER_ADMIN)) {
+      throw new UnauthorizedException('Unauthorized to perform this action');
+    }
+    return this.deviceService.addTuyaConstUuidToDevices();
+  }
 }

src/device/dtos/add.device.dto.ts

@@ -18,6 +18,14 @@ export class AddDeviceDto {
   @IsNotEmpty()
   public spaceUuid: string;
 
+  @ApiProperty({
+    description: 'tagUuid',
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  public tagUuid: string;
+
   @ApiProperty({
     description: 'deviceName',
     required: true,

src/device/dtos/get.device.dto.ts

@@ -1,7 +1,7 @@
 import { DeviceTypeEnum } from '@app/common/constants/device-type.enum';
 import { ApiProperty } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
 import {
-  IsArray,
   IsEnum,
   IsNotEmpty,
   IsOptional,
@@ -74,13 +74,34 @@ export class GetDevicesFilterDto {
   @IsEnum(DeviceTypeEnum)
   @IsOptional()
   public deviceType: DeviceTypeEnum;
+
   @ApiProperty({
     description: 'List of Space IDs to filter devices',
     required: false,
     example: ['60d21b4667d0d8992e610c85', '60d21b4967d0d8992e610c86'],
   })
   @IsOptional()
-  @IsArray()
+  @Transform(({ value }) => {
+    if (!Array.isArray(value)) {
+      return [value];
+    }
+    return value;
+  })
   @IsUUID('4', { each: true })
   public spaces?: string[];
+
+  @ApiProperty({
+    description: 'List of Community IDs to filter devices',
+    required: false,
+    example: ['60d21b4667d0d8992e610c85', '60d21b4967d0d8992e610c86'],
+  })
+  @Transform(({ value }) => {
+    if (!Array.isArray(value)) {
+      return [value];
+    }
+    return value;
+  })
+  @IsOptional()
+  @IsUUID('4', { each: true })
+  public communities?: string[];
 }

src/invite-user/invite-user.module.ts

@@ -38,7 +38,6 @@ import {
 } from '@app/common/modules/scene/repositories';
 import {
   InviteSpaceRepository,
-  SpaceLinkRepository,
   SpaceProductAllocationRepository,
   SpaceRepository,
 } from '@app/common/modules/space';
@@ -121,7 +120,6 @@ import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/r
     NewTagService,
     SpaceModelService,
     SpaceProductAllocationService,
-    SpaceLinkRepository,
     SubspaceRepository,
     SubspaceDeviceService,
     SubspaceProductAllocationService,

src/invite-user/services/invite-user.service.ts

@@ -111,6 +111,7 @@ export class InviteUserService {
       });
 
       const invitedUser = await queryRunner.manager.save(inviteUser);
+      const invitedRoleType = await this.getRoleTypeByUuid(roleUuid);
 
       // Link user to spaces
       const spacePromises = validSpaces.map(async (space) => {
@@ -128,7 +129,7 @@ export class InviteUserService {
       await this.emailService.sendEmailWithInvitationTemplate(email, {
         name: firstName,
         invitationCode,
-        role: roleType,
+        role: invitedRoleType.replace(/_/g, ' '),
         spacesList: spaceNames,
       });
 

src/power-clamp/controllers/power-clamp.controller.ts

@@ -1,25 +1,24 @@
+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 { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
 import {
-  ApiTags,
   ApiBearerAuth,
   ApiOperation,
   ApiParam,
   ApiQuery,
+  ApiTags,
 } 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 { PowerClampService } from '../services/power-clamp.service';
 import {
   GetPowerClampBySpaceDto,
   GetPowerClampDto,
 } from '../dto/get-power-clamp.dto';
-import { BaseResponseDto } from '@app/common/dto/base.response.dto';
 import {
   PowerClampParamsDto,
   ResourceParamsDto,
 } from '../dto/power-clamp-params.dto';
-
+import { PowerClampService } from '../services/power-clamp.service';
 @ApiTags('Power Clamp Module')
 @Controller({
   version: EnableDisableStatusEnum.ENABLED,
@@ -27,7 +26,6 @@ import {
 })
 export class PowerClampController {
   constructor(private readonly powerClampService: PowerClampService) {}
-
   @ApiBearerAuth()
   @UseGuards(JwtAuthGuard)
   @Get(':powerClampUuid/historical')

src/power-clamp/power-clamp.module.ts

@@ -22,7 +22,6 @@ import {
 } from '@app/common/modules/scene/repositories';
 import {
   InviteSpaceRepository,
-  SpaceLinkRepository,
   SpaceProductAllocationRepository,
   SpaceRepository,
 } from '@app/common/modules/space';
@@ -96,7 +95,6 @@ import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/r
     SpaceModelService,
     SpaceProductAllocationService,
     SqlLoaderService,
-    SpaceLinkRepository,
     SubspaceRepository,
     SubspaceDeviceService,
     SubspaceProductAllocationService,

src/power-clamp/services/power-clamp.service.ts

@@ -23,10 +23,10 @@ import { SpaceDeviceService } from 'src/space/services';
 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 { filterByMonth, toMMYYYY } from '@app/common/helper/date-format';
 import { ProductType } from '@app/common/constants/product-type.enum';
 import { CommunityService } from 'src/community/services';
 import { BaseResponseDto } from '@app/common/dto/base.response.dto';
+import { filterByMonth, toMMYYYY } from '@app/common/helper/date-format';
 
 @Injectable()
 export class PowerClampService {

src/project/project.module.ts

@@ -23,7 +23,6 @@ import {
 } from '@app/common/modules/scene/repositories';
 import {
   InviteSpaceRepository,
-  SpaceLinkRepository,
   SpaceProductAllocationRepository,
   SpaceRepository,
 } from '@app/common/modules/space';
@@ -94,7 +93,6 @@ const CommandHandlers = [CreateOrphanSpaceHandler];
     SpaceModelService,
     DeviceService,
     SpaceProductAllocationService,
-    SpaceLinkRepository,
     SubspaceRepository,
     SubspaceDeviceService,
     SubspaceProductAllocationService,

src/schedule/services/schedule.service.ts

@@ -96,6 +96,26 @@ export class ScheduleService {
         throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
       }
 
+      if (
+        deviceDetails.productDevice.prodType == ProductType.CUR_2 &&
+        addScheduleDto.category != 'Timer'
+      ) {
+        throw new HttpException(
+          'Invalid category for CUR_2 devices',
+          HttpStatus.BAD_REQUEST,
+        );
+      }
+
+      if (
+        deviceDetails.productDevice.prodType == ProductType.CUR_2 &&
+        addScheduleDto.category != 'Timer'
+      ) {
+        throw new HttpException(
+          'Invalid category for CUR_2 devices',
+          HttpStatus.BAD_REQUEST,
+        );
+      }
+
       this.ensureProductTypeSupportedForSchedule(
         deviceDetails.productDevice.prodType as ProductType,
       );
@@ -103,6 +123,7 @@ export class ScheduleService {
       await this.addScheduleDeviceInTuya(
         deviceDetails.deviceTuyaUuid,
         addScheduleDto,
+        deviceDetails.productDevice.prodType as ProductType,
       );
     } catch (error) {
       throw new HttpException(
@@ -125,10 +146,14 @@ export class ScheduleService {
       const schedules = await this.getScheduleDeviceInTuya(
         deviceDetails.deviceTuyaUuid,
         category,
+        deviceDetails.productDevice.prodType as ProductType,
       );
       const result = schedules.result.map((schedule: any) => {
         return {
-          category: schedule.category.replace('category_', ''),
+          category:
+            deviceDetails.productDevice.prodType == ProductType.CUR_2
+              ? schedule.category
+              : schedule.category.replace('category_', ''),
           enable: schedule.enable,
           function: {
             code: schedule.functions[0].code,
@@ -159,6 +184,26 @@ export class ScheduleService {
         throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
       }
 
+      if (
+        deviceDetails.productDevice.prodType == ProductType.CUR_2 &&
+        updateScheduleDto.category != 'Timer'
+      ) {
+        throw new HttpException(
+          'Invalid category for CUR_2 devices',
+          HttpStatus.BAD_REQUEST,
+        );
+      }
+
+      if (
+        deviceDetails.productDevice.prodType == ProductType.CUR_2 &&
+        updateScheduleDto.category != 'Timer'
+      ) {
+        throw new HttpException(
+          'Invalid category for CUR_2 devices',
+          HttpStatus.BAD_REQUEST,
+        );
+      }
+
       // Corrected condition for supported device types
       this.ensureProductTypeSupportedForSchedule(
         deviceDetails.productDevice.prodType as ProductType,
@@ -167,6 +212,7 @@ export class ScheduleService {
       await this.updateScheduleDeviceInTuya(
         deviceDetails.deviceTuyaUuid,
         updateScheduleDto,
+        deviceDetails.productDevice.prodType as ProductType,
       );
     } catch (error) {
       throw new HttpException(
@@ -192,6 +238,7 @@ export class ScheduleService {
   private async addScheduleDeviceInTuya(
     deviceId: string,
     addScheduleDto: AddScheduleDto,
+    deviceType: ProductType,
   ): Promise<addScheduleDeviceInterface> {
     try {
       const convertedTime = convertTimestampToDubaiTime(addScheduleDto.time);
@@ -210,7 +257,10 @@ export class ScheduleService {
               ...addScheduleDto.function,
             },
           ],
-          category: `category_${addScheduleDto.category}`,
+          category:
+            deviceType == ProductType.CUR_2
+              ? addScheduleDto.category
+              : `category_${addScheduleDto.category}`,
         },
       });
 
@@ -226,9 +276,12 @@ export class ScheduleService {
   private async getScheduleDeviceInTuya(
     deviceId: string,
     category: string,
+    deviceType: ProductType,
   ): Promise<getDeviceScheduleInterface> {
     try {
-      const path = `/v2.0/cloud/timer/device/${deviceId}?category=category_${category}`;
+      const categoryToSent =
+        deviceType == ProductType.CUR_2 ? category : `category_${category}`;
+      const path = `/v2.0/cloud/timer/device/${deviceId}?category=${categoryToSent}`;
       const response = await this.tuya.request({
         method: 'GET',
         path,
@@ -248,6 +301,7 @@ export class ScheduleService {
   private async updateScheduleDeviceInTuya(
     deviceId: string,
     updateScheduleDto: UpdateScheduleDto,
+    deviceType: ProductType,
   ): Promise<addScheduleDeviceInterface> {
     try {
       const convertedTime = convertTimestampToDubaiTime(updateScheduleDto.time);
@@ -268,7 +322,10 @@ export class ScheduleService {
               value: updateScheduleDto.function.value,
             },
           ],
-          category: `category_${updateScheduleDto.category}`,
+          category:
+            deviceType == ProductType.CUR_2
+              ? updateScheduleDto.category
+              : `category_${updateScheduleDto.category}`,
         },
       });
 

src/space-model/space-model.module.ts

@@ -22,7 +22,6 @@ import {
 } from '@app/common/modules/scene/repositories';
 import {
   InviteSpaceRepository,
-  SpaceLinkRepository,
   SpaceProductAllocationRepository,
   SpaceRepository,
 } from '@app/common/modules/space';
@@ -93,7 +92,6 @@ const CommandHandlers = [
     DeviceRepository,
     TuyaService,
     CommunityRepository,
-    SpaceLinkRepository,
     InviteSpaceRepository,
     NewTagService,
     DeviceService,

src/space/controllers/space.controller.ts

@@ -1,6 +1,5 @@
-import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { SpaceService } from '../services';
 import { ControllerRoute } from '@app/common/constants/controller-route';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
 import {
   Body,
   Controller,
@@ -12,12 +11,14 @@ import {
   Query,
   UseGuards,
 } from '@nestjs/common';
-import { AddSpaceDto, CommunitySpaceParam, UpdateSpaceDto } from '../dtos';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { BaseResponseDto } from '@app/common/dto/base.response.dto';
-import { GetSpaceParam } from '../dtos/get.space.param';
-import { PermissionsGuard } from 'src/guards/permissions.guard';
 import { Permissions } from 'src/decorators/permissions.decorator';
+import { PermissionsGuard } from 'src/guards/permissions.guard';
+import { AddSpaceDto, CommunitySpaceParam, UpdateSpaceDto } from '../dtos';
 import { GetSpaceDto } from '../dtos/get.space.dto';
+import { GetSpaceParam } from '../dtos/get.space.param';
+import { OrderSpacesDto } from '../dtos/order.spaces.dto';
+import { SpaceService } from '../services';
 
 @ApiTags('Space Module')
 @Controller({
@@ -65,6 +66,26 @@ export class SpaceController {
     );
   }
 
+  @ApiBearerAuth()
+  @UseGuards(PermissionsGuard)
+  @Permissions('SPACE_UPDATE')
+  @ApiOperation({
+    summary:
+      ControllerRoute.SPACE.ACTIONS
+        .UPDATE_CHILDREN_SPACES_ORDER_OF_A_SPACE_SUMMARY,
+    description:
+      ControllerRoute.SPACE.ACTIONS
+        .UPDATE_CHILDREN_SPACES_ORDER_OF_A_SPACE_DESCRIPTION,
+  })
+  @Post(':parentSpaceUuid/spaces/order')
+  async updateSpacesOrder(
+    @Body() orderSpacesDto: OrderSpacesDto,
+    @Param() communitySpaceParam: CommunitySpaceParam,
+    @Param('parentSpaceUuid') parentSpaceUuid: string,
+  ) {
+    return this.spaceService.updateSpacesOrder(parentSpaceUuid, orderSpacesDto);
+  }
+
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
   @Permissions('SPACE_DELETE')

src/space/dtos/order.spaces.dto.ts

@@ -0,0 +1,13 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ArrayUnique, IsNotEmpty, IsUUID } from 'class-validator';
+
+export class OrderSpacesDto {
+  @ApiProperty({
+    description: 'List of children spaces associated with the space',
+    type: [String],
+  })
+  @IsNotEmpty()
+  @ArrayUnique()
+  @IsUUID('4', { each: true, message: 'Invalid space UUID provided' })
+  spacesUuids: string[];
+}

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

@@ -2,6 +2,7 @@ import { ORPHAN_SPACE_NAME } from '@app/common/constants/orphan-constant';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Type } from 'class-transformer';
 import {
+  ArrayUnique,
   IsArray,
   IsNumber,
   IsOptional,
@@ -49,6 +50,20 @@ export class UpdateSpaceDto {
     description: 'List of subspace modifications',
     type: [UpdateSubspaceDto],
   })
+  @ArrayUnique((subspace) => subspace.subspaceName, {
+    message(validationArguments) {
+      const subspaces = validationArguments.value;
+      const nameCounts = subspaces.reduce((acc, curr) => {
+        acc[curr.subspaceName] = (acc[curr.subspaceName] || 0) + 1;
+        return acc;
+      }, {});
+      // Find duplicates
+      const duplicates = Object.keys(nameCounts).filter(
+        (name) => nameCounts[name] > 1,
+      );
+      return `Duplicate subspace names found: ${duplicates.join(', ')}`;
+    },
+  })
   @IsOptional()
   @IsArray()
   @ValidateNested({ each: true })

src/space/services/index.ts

@@ -2,6 +2,5 @@ export * from './space.service';
 export * from './space-user.service';
 export * from './space-device.service';
 export * from './subspace';
-export * from './space-link';
 export * from './space-scene.service';
 export * from './space-validation.service';

src/space/services/space-link/index.ts

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

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

@@ -1,6 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-// todo: find out why we need to import this
-// in community module in order for the whole system to work
-@Injectable()
-export class SpaceLinkService {}

src/space/services/space.service.ts

@@ -33,6 +33,7 @@ import {
 } from '../dtos';
 import { CreateProductAllocationDto } from '../dtos/create-product-allocation.dto';
 import { GetSpaceDto } from '../dtos/get.space.dto';
+import { OrderSpacesDto } from '../dtos/order.spaces.dto';
 import { SpaceWithParentsDto } from '../dtos/space.parents.dto';
 import { SpaceProductAllocationService } from './space-product-allocation.service';
 import { ValidationService } from './space-validation.service';
@@ -355,6 +356,32 @@ export class SpaceService {
     }
   }
 
+  async updateSpacesOrder(
+    parentSpaceUuid: string,
+    { spacesUuids }: OrderSpacesDto,
+  ) {
+    try {
+      await this.spaceRepository.update(
+        { uuid: In(spacesUuids), parent: { uuid: parentSpaceUuid } },
+        {
+          order: () =>
+            'CASE ' +
+            spacesUuids
+              .map((s, index) => `WHEN uuid = '${s}' THEN ${index + 1}`)
+              .join(' ') +
+            ' END',
+        },
+      );
+      return true;
+    } catch (error) {
+      console.error('Error updating spaces order:', error);
+      throw new HttpException(
+        'An error occurred while updating spaces order',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
   async delete(params: GetSpaceParam): Promise<BaseResponseDto> {
     const queryRunner = this.dataSource.createQueryRunner();
     await queryRunner.connect();
@@ -426,7 +453,7 @@ export class SpaceService {
     }
   }
 
-  async disableSpace(space: SpaceEntity, orphanSpace: SpaceEntity) {
+  private async disableSpace(space: SpaceEntity, orphanSpace: SpaceEntity) {
     await this.commandBus.execute(
       new DisableSpaceCommand({ spaceUuid: space.uuid, orphanSpace }),
     );
@@ -709,10 +736,21 @@ export class SpaceService {
         rootSpaces.push(map.get(space.uuid)!); // Push only root spaces
       }
     });
-
+    rootSpaces.forEach(this.sortSpaceChildren.bind(this));
     return rootSpaces;
   }
 
+  private sortSpaceChildren(space: SpaceEntity) {
+    if (space.children && space.children.length > 0) {
+      space.children.sort((a, b) => {
+        const aOrder = a.order ?? Infinity;
+        const bOrder = b.order ?? Infinity;
+        return aOrder - bOrder;
+      });
+      space.children.forEach(this.sortSpaceChildren.bind(this)); // Recursively sort children of children
+    }
+  }
+
   private validateSpaceCreationCriteria({
     spaceModelUuid,
     productAllocations,

src/space/services/subspace/subspace-product-allocation.service.ts

@@ -23,7 +23,7 @@ export class SubspaceProductAllocationService {
     // spaceAllocationsToExclude?: SpaceProductAllocationEntity[],
   ): Promise<void> {
     try {
-      if (!allocationsData.length) return;
+      if (!allocationsData?.length) return;
 
       const allocations: SubspaceProductAllocationEntity[] = [];
 
@@ -112,7 +112,7 @@ export class SubspaceProductAllocationService {
         );
 
         // Create the product-tag mapping based on the processed tags
-        const productTagMapping = subspace.productAllocations.map(
+        const productTagMapping = subspace.productAllocations?.map(
           ({ tagUuid, tagName, productUuid }) => {
             const inputTag = tagUuid
               ? createdTagsByUUID.get(tagUuid)

src/space/services/subspace/subspace.service.ts

@@ -39,7 +39,7 @@ export class SubSpaceService {
     private readonly subspaceProductAllocationService: SubspaceProductAllocationService,
   ) {}
 
-  async createSubspaces(
+  private async createSubspaces(
     subspaceData: Array<{
       subspaceName: string;
       space: SpaceEntity;

src/space/services/tag/index.ts

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

src/space/services/tag/tag.service.ts

@@ -1,8 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-// todo: find out why we need to import this
-// in community module in order for the whole system to work
-@Injectable()
-export class TagService {
-  constructor() {}
-}

src/space/space.module.ts

@@ -37,7 +37,6 @@ import {
 } from '@app/common/modules/space-model';
 import {
   InviteSpaceRepository,
-  SpaceLinkRepository,
   SpaceProductAllocationRepository,
   SpaceRepository,
 } from '@app/common/modules/space/repositories';
@@ -116,7 +115,6 @@ export const CommandHandlers = [DisableSpaceHandler];
     SubspaceRepository,
     DeviceRepository,
     CommunityRepository,
-    SpaceLinkRepository,
     UserSpaceRepository,
     UserRepository,
     SpaceUserService,

src/users/controllers/user.controller.ts

@@ -1,3 +1,7 @@
+import { ControllerRoute } from '@app/common/constants/controller-route';
+import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
+import { RoleType } from '@app/common/constants/role.type.enum';
+import { BaseResponseDto } from '@app/common/dto/base.response.dto';
 import {
   Body,
   Controller,
@@ -7,10 +11,12 @@ import {
   Param,
   Patch,
   Put,
+  Req,
   UseGuards,
 } from '@nestjs/common';
-import { UserService } from '../services/user.service';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
+import { CheckProfilePictureGuard } from 'src/guards/profile.picture.guard';
+import { SuperAdminRoleGuard } from 'src/guards/super.admin.role.guard';
 import { JwtAuthGuard } from '../../../libs/common/src/guards/jwt.auth.guard';
 import {
   UpdateNameDto,
@@ -18,11 +24,7 @@ import {
   UpdateRegionDataDto,
   UpdateTimezoneDataDto,
 } from '../dtos';
-import { CheckProfilePictureGuard } from 'src/guards/profile.picture.guard';
+import { UserService } from '../services/user.service';
-import { SuperAdminRoleGuard } from 'src/guards/super.admin.role.guard';
-import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
-import { ControllerRoute } from '@app/common/constants/controller-route';
-import { BaseResponseDto } from '@app/common/dto/base.response.dto';
 
 @ApiTags('User Module')
 @Controller({
@@ -154,6 +156,32 @@ export class UserController {
     };
   }
 
+  @ApiBearerAuth()
+  @UseGuards(JwtAuthGuard)
+  @Delete('')
+  @ApiOperation({
+    summary: ControllerRoute.USER.ACTIONS.DELETE_USER_PROFILE_SUMMARY,
+    description: ControllerRoute.USER.ACTIONS.DELETE_USER_PROFILE_DESCRIPTION,
+  })
+  async deleteUserProfile(@Req() req: Request) {
+    const userUuid = req['user']?.userUuid;
+    const userRole = req['user']?.role;
+    if (!userUuid || (userRole && userRole == RoleType.SUPER_ADMIN)) {
+      throw {
+        statusCode: HttpStatus.UNAUTHORIZED,
+        message: 'Unauthorized',
+      };
+    }
+    await this.userService.deleteUserProfile(userUuid);
+    return {
+      statusCode: HttpStatus.OK,
+      data: {
+        userId: userUuid,
+      },
+      message: 'User deleted successfully',
+    };
+  }
+
   @ApiBearerAuth()
   @UseGuards(JwtAuthGuard)
   @Patch('agreements/web/:userUuid')

src/users/services/user.service.ts

@@ -1,21 +1,21 @@
-import {
+import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
-  UpdateNameDto,
+import { removeBase64Prefix } from '@app/common/helper/removeBase64Prefix';
-  UpdateProfilePictureDataDto,
+import { RegionRepository } from '@app/common/modules/region/repositories';
-  UpdateRegionDataDto,
+import { TimeZoneRepository } from '@app/common/modules/timezone/repositories';
-  UpdateTimezoneDataDto,
+import { UserEntity } from '@app/common/modules/user/entities';
-} from './../dtos/update.user.dto';
+import { UserRepository } from '@app/common/modules/user/repositories';
 import {
   BadRequestException,
   HttpException,
   HttpStatus,
   Injectable,
 } from '@nestjs/common';
-import { UserRepository } from '@app/common/modules/user/repositories';
+import {
-import { RegionRepository } from '@app/common/modules/region/repositories';
+  UpdateNameDto,
-import { TimeZoneRepository } from '@app/common/modules/timezone/repositories';
+  UpdateProfilePictureDataDto,
-import { removeBase64Prefix } from '@app/common/helper/removeBase64Prefix';
+  UpdateRegionDataDto,
-import { UserEntity } from '@app/common/modules/user/entities';
+  UpdateTimezoneDataDto,
-import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
+} from './../dtos/update.user.dto';
 
 @Injectable()
 export class UserService {
@@ -269,4 +269,12 @@ export class UserService {
     }
     return await this.userRepository.update({ uuid }, { isActive: false });
   }
+
+  async deleteUserProfile(uuid: string) {
+    const user = await this.findOneById(uuid);
+    if (!user) {
+      throw new BadRequestException('User not found');
+    }
+    return this.userRepository.delete({ uuid });
+  }
 }

src/vistor-password/services/visitor-password.service.ts

@@ -1,39 +1,39 @@
-import { VisitorPasswordRepository } from './../../../libs/common/src/modules/visitor-password/repositories/visitor-password.repository';
+import { ProductType } from '@app/common/constants/product-type.enum';
+import { DeviceRepository } from '@app/common/modules/device/repositories';
 import {
-  Injectable,
+  BadRequestException,
   HttpException,
   HttpStatus,
-  BadRequestException,
+  Injectable,
 } from '@nestjs/common';
-import { TuyaContext } from '@tuya/tuya-connector-nodejs';
 import { ConfigService } from '@nestjs/config';
+import { TuyaContext } from '@tuya/tuya-connector-nodejs';
 import {
   addDeviceObjectInterface,
   createTickInterface,
 } from '../interfaces/visitor-password.interface';
-import { DeviceRepository } from '@app/common/modules/device/repositories';
+import { VisitorPasswordRepository } from './../../../libs/common/src/modules/visitor-password/repositories/visitor-password.repository';
-import { ProductType } from '@app/common/constants/product-type.enum';
 
-import { AddDoorLockTemporaryPasswordDto } from '../dtos';
-import { EmailService } from '@app/common/util/email.service';
-import { PasswordEncryptionService } from 'src/door-lock/services/encryption.services';
-import { DoorLockService } from 'src/door-lock/services';
-import { DeviceService } from 'src/device/services';
-import { DeviceStatuses } from '@app/common/constants/device-status.enum';
 import {
   DaysEnum,
   EnableDisableStatusEnum,
 } from '@app/common/constants/days.enum';
-import { PasswordType } from '@app/common/constants/password-type.enum';
+import { DeviceStatuses } from '@app/common/constants/device-status.enum';
 import {
   CommonHourMinutes,
   CommonHours,
 } from '@app/common/constants/hours-minutes.enum';
-import { ProjectRepository } from '@app/common/modules/project/repositiories';
+import { ORPHAN_SPACE_NAME } from '@app/common/constants/orphan-constant';
+import { PasswordType } from '@app/common/constants/password-type.enum';
 import { VisitorPasswordEnum } from '@app/common/constants/visitor-password.enum';
 import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
+import { ProjectRepository } from '@app/common/modules/project/repositiories';
+import { EmailService } from '@app/common/util/email.service';
+import { DeviceService } from 'src/device/services';
+import { DoorLockService } from 'src/door-lock/services';
+import { PasswordEncryptionService } from 'src/door-lock/services/encryption.services';
 import { Not } from 'typeorm';
-import { ORPHAN_SPACE_NAME } from '@app/common/constants/orphan-constant';
+import { AddDoorLockTemporaryPasswordDto } from '../dtos';
 
 @Injectable()
 export class VisitorPasswordService {
@@ -57,6 +57,67 @@ export class VisitorPasswordService {
       secretKey,
     });
   }
+
+  async getPasswords(projectUuid: string) {
+    await this.validateProject(projectUuid);
+
+    const deviceIds = await this.deviceRepository.find({
+      where: {
+        productDevice: {
+          prodType: ProductType.DL,
+        },
+        spaceDevice: {
+          spaceName: Not(ORPHAN_SPACE_NAME),
+          community: {
+            project: {
+              uuid: projectUuid,
+            },
+          },
+        },
+        isActive: true,
+      },
+    });
+
+    const data = [];
+    deviceIds.forEach((deviceId) => {
+      data.push(
+        this.doorLockService
+          .getOnlineTemporaryPasswordsOneTime(deviceId.uuid, true, false)
+          .catch(() => {}),
+        this.doorLockService
+          .getOnlineTemporaryPasswordsOneTime(deviceId.uuid, true, true)
+          .catch(() => {}),
+        this.doorLockService
+          .getOnlineTemporaryPasswordsMultiple(deviceId.uuid, true, false)
+          .catch(() => {}),
+        this.doorLockService
+          .getOnlineTemporaryPasswordsMultiple(deviceId.uuid, true, true)
+          .catch(() => {}),
+        this.doorLockService
+          .getOfflineOneTimeTemporaryPasswords(deviceId.uuid, true, false)
+          .catch(() => {}),
+        this.doorLockService
+          .getOfflineOneTimeTemporaryPasswords(deviceId.uuid, true, true)
+          .catch(() => {}),
+        this.doorLockService
+          .getOfflineMultipleTimeTemporaryPasswords(deviceId.uuid, true, false)
+          .catch(() => {}),
+        this.doorLockService
+          .getOfflineMultipleTimeTemporaryPasswords(deviceId.uuid, true, true)
+          .catch(() => {}),
+      );
+    });
+    const result = (await Promise.all(data)).flat().filter((datum) => {
+      return datum != null;
+    });
+
+    return new SuccessResponseDto({
+      message: 'Successfully retrieved temporary passwords',
+      data: result,
+      statusCode: HttpStatus.OK,
+    });
+  }
+
   async handleTemporaryPassword(
     addDoorLockTemporaryPasswordDto: AddDoorLockTemporaryPasswordDto,
     userUuid: string,
@@ -105,7 +166,7 @@ export class VisitorPasswordService {
       statusCode: HttpStatus.CREATED,
     });
   }
-  async addOfflineMultipleTimeTemporaryPassword(
+  private async addOfflineMultipleTimeTemporaryPassword(
     addDoorLockOfflineMultipleDto: AddDoorLockTemporaryPasswordDto,
     userUuid: string,
     projectUuid: string,
@@ -169,6 +230,7 @@ export class VisitorPasswordService {
               success: true,
               result: createMultipleOfflinePass.result,
               deviceUuid,
+              deviceName: deviceDetails.name,
             };
           } catch (error) {
             return {
@@ -231,7 +293,7 @@ export class VisitorPasswordService {
     }
   }
 
-  async addOfflineOneTimeTemporaryPassword(
+  private async addOfflineOneTimeTemporaryPassword(
     addDoorLockOfflineOneTimeDto: AddDoorLockTemporaryPasswordDto,
     userUuid: string,
     projectUuid: string,
@@ -295,6 +357,7 @@ export class VisitorPasswordService {
               success: true,
               result: createOnceOfflinePass.result,
               deviceUuid,
+              deviceName: deviceDetails.name,
             };
           } catch (error) {
             return {
@@ -357,7 +420,7 @@ export class VisitorPasswordService {
     }
   }
 
-  async addOfflineTemporaryPasswordTuya(
+  private async addOfflineTemporaryPasswordTuya(
     doorLockUuid: string,
     type: string,
     addDoorLockOfflineMultipleDto: AddDoorLockTemporaryPasswordDto,
@@ -387,7 +450,7 @@ export class VisitorPasswordService {
       );
     }
   }
-  async addOnlineTemporaryPasswordMultipleTime(
+  private async addOnlineTemporaryPasswordMultipleTime(
     addDoorLockOnlineMultipleDto: AddDoorLockTemporaryPasswordDto,
     userUuid: string,
     projectUuid: string,
@@ -448,6 +511,7 @@ export class VisitorPasswordService {
               success: true,
               id: createPass.result.id,
               deviceUuid,
+              deviceName: passwordData.deviceName,
             };
           } catch (error) {
             return {
@@ -508,67 +572,8 @@ export class VisitorPasswordService {
       );
     }
   }
-  async getPasswords(projectUuid: string) {
-    await this.validateProject(projectUuid);
 
-    const deviceIds = await this.deviceRepository.find({
+  private async addOnlineTemporaryPasswordOneTime(
-      where: {
-        productDevice: {
-          prodType: ProductType.DL,
-        },
-        spaceDevice: {
-          spaceName: Not(ORPHAN_SPACE_NAME),
-          community: {
-            project: {
-              uuid: projectUuid,
-            },
-          },
-        },
-        isActive: true,
-      },
-    });
-
-    const data = [];
-    deviceIds.forEach((deviceId) => {
-      data.push(
-        this.doorLockService
-          .getOnlineTemporaryPasswordsOneTime(deviceId.uuid, true, false)
-          .catch(() => {}),
-        this.doorLockService
-          .getOnlineTemporaryPasswordsOneTime(deviceId.uuid, true, true)
-          .catch(() => {}),
-        this.doorLockService
-          .getOnlineTemporaryPasswordsMultiple(deviceId.uuid, true, false)
-          .catch(() => {}),
-        this.doorLockService
-          .getOnlineTemporaryPasswordsMultiple(deviceId.uuid, true, true)
-          .catch(() => {}),
-        this.doorLockService
-          .getOfflineOneTimeTemporaryPasswords(deviceId.uuid, true, false)
-          .catch(() => {}),
-        this.doorLockService
-          .getOfflineOneTimeTemporaryPasswords(deviceId.uuid, true, true)
-          .catch(() => {}),
-        this.doorLockService
-          .getOfflineMultipleTimeTemporaryPasswords(deviceId.uuid, true, false)
-          .catch(() => {}),
-        this.doorLockService
-          .getOfflineMultipleTimeTemporaryPasswords(deviceId.uuid, true, true)
-          .catch(() => {}),
-      );
-    });
-    const result = (await Promise.all(data)).flat().filter((datum) => {
-      return datum != null;
-    });
-
-    return new SuccessResponseDto({
-      message: 'Successfully retrieved temporary passwords',
-      data: result,
-      statusCode: HttpStatus.OK,
-    });
-  }
-
-  async addOnlineTemporaryPasswordOneTime(
     addDoorLockOnlineOneTimeDto: AddDoorLockTemporaryPasswordDto,
     userUuid: string,
     projectUuid: string,
@@ -627,6 +632,7 @@ export class VisitorPasswordService {
             return {
               success: true,
               id: createPass.result.id,
+              deviceName: passwordData.deviceName,
               deviceUuid,
             };
           } catch (error) {
@@ -688,7 +694,7 @@ export class VisitorPasswordService {
       );
     }
   }
-  async getTicketAndEncryptedPassword(
+  private async getTicketAndEncryptedPassword(
     doorLockUuid: string,
     passwordPlan: string,
     projectUuid: string,
@@ -725,6 +731,7 @@ export class VisitorPasswordService {
         ticketKey: ticketDetails.result.ticket_key,
         encryptedPassword: decrypted,
         deviceTuyaUuid: deviceDetails.deviceTuyaUuid,
+        deviceName: deviceDetails.name,
       };
     } catch (error) {
       throw new HttpException(
@@ -734,7 +741,7 @@ export class VisitorPasswordService {
     }
   }
 
-  async createDoorLockTicketTuya(
+  private async createDoorLockTicketTuya(
     deviceUuid: string,
   ): Promise<createTickInterface> {
     try {
@@ -753,7 +760,7 @@ export class VisitorPasswordService {
     }
   }
 
-  async addOnlineTemporaryPasswordMultipleTuya(
+  private async addOnlineTemporaryPasswordMultipleTuya(
     addDeviceObj: addDeviceObjectInterface,
     doorLockUuid: string,
   ): Promise<createTickInterface> {
@@ -795,7 +802,7 @@ export class VisitorPasswordService {
     }
   }
 
-  getWorkingDayValue(days) {
+  private getWorkingDayValue(days) {
     // Array representing the days of the week
     const weekDays = [
       DaysEnum.SAT,
@@ -827,36 +834,7 @@ export class VisitorPasswordService {
 
     return workingDayValue;
   }
-  getDaysFromWorkingDayValue(workingDayValue) {
+  private timeToMinutes(timeStr) {
-    // Array representing the days of the week
-    const weekDays = [
-      DaysEnum.SAT,
-      DaysEnum.FRI,
-      DaysEnum.THU,
-      DaysEnum.WED,
-      DaysEnum.TUE,
-      DaysEnum.MON,
-      DaysEnum.SUN,
-    ];
-
-    // Convert the integer to a binary string and pad with leading zeros to ensure 7 bits
-    const binaryString = workingDayValue
-      .toString(2)
-      .padStart(7, EnableDisableStatusEnum.DISABLED);
-
-    // Initialize an array to hold the days of the week
-    const days = [];
-
-    // Iterate through the binary string and weekDays array
-    for (let i = 0; i < binaryString.length; i++) {
-      if (binaryString[i] === EnableDisableStatusEnum.ENABLED) {
-        days.push(weekDays[i]);
-      }
-    }
-
-    return days;
-  }
-  timeToMinutes(timeStr) {
     try {
       // Special case for "24:00"
       if (timeStr === CommonHours.TWENTY_FOUR) {
@@ -883,38 +861,7 @@ export class VisitorPasswordService {
       throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
     }
   }
-  minutesToTime(totalMinutes) {
+  private async getDeviceByDeviceUuid(
-    try {
-      if (
-        typeof totalMinutes !== 'number' ||
-        totalMinutes < 0 ||
-        totalMinutes > CommonHourMinutes.TWENTY_FOUR
-      ) {
-        throw new Error('Invalid minutes value');
-      }
-
-      if (totalMinutes === CommonHourMinutes.TWENTY_FOUR) {
-        return CommonHours.TWENTY_FOUR;
-      }
-
-      const hours = Math.floor(totalMinutes / 60);
-      const minutes = totalMinutes % 60;
-
-      const formattedHours = String(hours).padStart(
-        2,
-        EnableDisableStatusEnum.DISABLED,
-      );
-      const formattedMinutes = String(minutes).padStart(
-        2,
-        EnableDisableStatusEnum.DISABLED,
-      );
-
-      return `${formattedHours}:${formattedMinutes}`;
-    } catch (error) {
-      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
-    }
-  }
-  async getDeviceByDeviceUuid(
     deviceUuid: string,
     withProductDevice: boolean = true,
     projectUuid: string,
@@ -939,7 +886,7 @@ export class VisitorPasswordService {
       throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
     }
   }
-  async addOnlineTemporaryPasswordOneTimeTuya(
+  private async addOnlineTemporaryPasswordOneTimeTuya(
     addDeviceObj: addDeviceObjectInterface,
     doorLockUuid: string,
   ): Promise<createTickInterface> {