add deviceName to handle password API

feat: enhance device status handling with caching and batch processin…

.eslintrc.js

@@ -21,6 +21,7 @@ module.exports = {
     '@typescript-eslint/explicit-function-return-type': 'off',
     '@typescript-eslint/explicit-module-boundary-types': 'off',
     '@typescript-eslint/no-explicit-any': 'off',
+    "@typescript-eslint/no-unused-vars": 'warn',
   },
   settings: {
     'import/resolver': {

.github/workflows/main_syncrow(staging).yml

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

@@ -1,73 +0,0 @@
-# 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: .

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

@@ -397,11 +397,6 @@ 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 =
@@ -506,6 +501,7 @@ 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';

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

@@ -25,6 +25,7 @@ import {
   InviteUserEntity,
   InviteUserSpaceEntity,
 } from '../modules/Invite-user/entities';
+import { SpaceDailyOccupancyDurationEntity } from '../modules/occupancy/entities';
 import {
   PowerClampDailyEntity,
   PowerClampHourlyEntity,
@@ -46,7 +47,6 @@ import {
   SubspaceModelProductAllocationEntity,
 } from '../modules/space-model/entities';
 import { InviteSpaceEntity } from '../modules/space/entities/invite-space.entity';
-import { SpaceLinkEntity } from '../modules/space/entities/space-link.entity';
 import { SpaceProductAllocationEntity } from '../modules/space/entities/space-product-allocation.entity';
 import { SpaceEntity } from '../modules/space/entities/space.entity';
 import { SubspaceProductAllocationEntity } from '../modules/space/entities/subspace/subspace-product-allocation.entity';
@@ -58,7 +58,6 @@ import {
   UserSpaceEntity,
 } from '../modules/user/entities';
 import { VisitorPasswordEntity } from '../modules/visitor-password/entities';
-import { SpaceDailyOccupancyDurationEntity } from '../modules/occupancy/entities';
 @Module({
   imports: [
     TypeOrmModule.forRootAsync({
@@ -87,7 +86,6 @@ import { SpaceDailyOccupancyDurationEntity } from '../modules/occupancy/entities
             PermissionTypeEntity,
             CommunityEntity,
             SpaceEntity,
-            SpaceLinkEntity,
             SubspaceEntity,
             UserSpaceEntity,
             DeviceUserPermissionEntity,
@@ -127,8 +125,8 @@ import { SpaceDailyOccupancyDurationEntity } from '../modules/occupancy/entities
           logger: typeOrmLogger,
           extra: {
             charset: 'utf8mb4',
-            max: 20, // set pool max size
-            idleTimeoutMillis: 5000, // close idle clients after 5 second
+            max: 100, // set pool max size
+            idleTimeoutMillis: 3000, // close idle clients after 5 second
             connectionTimeoutMillis: 12_000, // return an error after 11 second if connection could not be established
             maxUses: 7500, // close (and replace) a connection after it has been used 7500 times (see below for discussion)
           },

libs/common/src/dto/pagination.request.dto.ts

@@ -1,10 +1,9 @@
-import { IsBoolean, IsDate, IsOptional } from 'class-validator';
-import { IsPageRequestParam } from '../validators/is-page-request-param.validator';
 import { ApiProperty } from '@nestjs/swagger';
-import { IsSizeRequestParam } from '../validators/is-size-request-param.validator';
 import { Transform } from 'class-transformer';
-import { parseToDate } from '../util/parseToDate';
+import { IsBoolean, IsOptional } from 'class-validator';
 import { BooleanValues } from '../constants/boolean-values.enum';
+import { IsPageRequestParam } from '../validators/is-page-request-param.validator';
+import { IsSizeRequestParam } from '../validators/is-size-request-param.validator';
 
 export class PaginationRequestGetListDto {
   @ApiProperty({
@@ -19,6 +18,7 @@ export class PaginationRequestGetListDto {
     return value.obj.includeSpaces === BooleanValues.TRUE;
   })
   public includeSpaces?: boolean = false;
+
   @IsOptional()
   @IsPageRequestParam({
     message: 'Page must be bigger than 0',
@@ -40,40 +40,4 @@ export class PaginationRequestGetListDto {
     description: 'Size request',
   })
   size?: number;
-
-  @IsOptional()
-  @ApiProperty({
-    name: 'name',
-    required: false,
-    description: 'Name to be filtered',
-  })
-  name?: string;
-
-  @ApiProperty({
-    name: 'from',
-    required: false,
-    type: Number,
-    description: `Start time in UNIX timestamp format to filter`,
-    example: 1674172800000,
-  })
-  @IsOptional()
-  @Transform(({ value }) => parseToDate(value))
-  @IsDate({
-    message: `From must be in UNIX timestamp format in order to parse to Date instance`,
-  })
-  from?: Date;
-
-  @ApiProperty({
-    name: 'to',
-    required: false,
-    type: Number,
-    description: `End time in UNIX timestamp format to filter`,
-    example: 1674259200000,
-  })
-  @IsOptional()
-  @Transform(({ value }) => parseToDate(value))
-  @IsDate({
-    message: `To must be in UNIX timestamp format in order to parse to Date instance`,
-  })
-  to?: Date;
 }

libs/common/src/firebase/devices-status/devices-status.module.ts

@@ -3,28 +3,12 @@ import { DeviceStatusFirebaseController } from './controllers/devices-status.con
 import { DeviceStatusFirebaseService } from './services/devices-status.service';
 import { DeviceRepository } from '@app/common/modules/device/repositories';
 import { DeviceStatusLogRepository } from '@app/common/modules/device-status-log/repositories/device-status.repository';
-import { PowerClampService } from '@app/common/helper/services/power.clamp.service';
-import {
-  PowerClampHourlyRepository,
-  PowerClampDailyRepository,
-  PowerClampMonthlyRepository,
-} from '@app/common/modules/power-clamp/repositories';
-import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service';
-import { OccupancyService } from '@app/common/helper/services/occupancy.service';
-import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
 
 @Module({
   providers: [
     DeviceStatusFirebaseService,
     DeviceRepository,
     DeviceStatusLogRepository,
-    PowerClampService,
-    PowerClampHourlyRepository,
-    PowerClampDailyRepository,
-    PowerClampMonthlyRepository,
-    SqlLoaderService,
-    OccupancyService,
-    AqiDataService,
   ],
   controllers: [DeviceStatusFirebaseController],
   exports: [DeviceStatusFirebaseService, DeviceStatusLogRepository],

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

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

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

@@ -18,24 +18,13 @@ import {
   runTransaction,
 } from 'firebase/database';
 import { DeviceStatusLogRepository } from '@app/common/modules/device-status-log/repositories';
-import { ProductType } from '@app/common/constants/product-type.enum';
-import { PowerClampService } from '@app/common/helper/services/power.clamp.service';
-import { PowerClampEnergyEnum } from '@app/common/constants/power.clamp.enargy.enum';
-import { PresenceSensorEnum } from '@app/common/constants/presence.sensor.enum';
-import { OccupancyService } from '@app/common/helper/services/occupancy.service';
-import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
 @Injectable()
 export class DeviceStatusFirebaseService {
   private tuya: TuyaContext;
   private firebaseDb: Database;
-  private readonly isDevEnv: boolean;
-
   constructor(
     private readonly configService: ConfigService,
     private readonly deviceRepository: DeviceRepository,
-    private readonly powerClampService: PowerClampService,
-    private readonly occupancyService: OccupancyService,
-    private readonly aqiDataService: AqiDataService,
     private deviceStatusLogRepository: DeviceStatusLogRepository,
   ) {
     const accessKey = this.configService.get<string>('auth-config.ACCESS_KEY');
@@ -49,8 +38,6 @@ 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,
@@ -65,7 +52,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,
           });
@@ -80,25 +67,94 @@ export class DeviceStatusFirebaseService {
       );
     }
   }
+  async addBatchDeviceStatusToOurDb(
+    batch: {
+      deviceTuyaUuid: string;
+      status: any;
+      log: any;
+      device: any;
+    }[],
+  ): Promise<void> {
+    const allLogs = [];
+
+    console.log(`🔁 Preparing logs from batch of ${batch.length} items...`);
+
+    for (const item of batch) {
+      const device = item.device;
+      if (!device?.uuid) {
+        console.log(`⛔ Skipped unknown device: ${item.deviceTuyaUuid}`);
+        continue;
+      }
+
+      const logs = item.log.properties.map((property) =>
+        this.deviceStatusLogRepository.create({
+          deviceId: device.uuid,
+          deviceTuyaId: item.deviceTuyaUuid,
+          productId: item.log.productId,
+          log: item.log,
+          code: property.code,
+          value: property.value,
+          eventId: item.log.dataId,
+          eventTime: new Date(property.time).toISOString(),
+        }),
+      );
+      allLogs.push(...logs);
+    }
+
+    console.log(`📝 Total logs to insert: ${allLogs.length}`);
+
+    const insertLogsPromise = (async () => {
+      const chunkSize = 300;
+      let insertedCount = 0;
+
+      for (let i = 0; i < allLogs.length; i += chunkSize) {
+        const chunk = allLogs.slice(i, i + chunkSize);
+        try {
+          const result = await this.deviceStatusLogRepository
+            .createQueryBuilder()
+            .insert()
+            .into('device-status-log') // or use DeviceStatusLogEntity
+            .values(chunk)
+            .orIgnore() // skip duplicates
+            .execute();
+
+          insertedCount += result.identifiers.length;
+          console.log(
+            `✅ Inserted ${result.identifiers.length} / ${chunk.length} logs (chunk)`,
+          );
+        } catch (error) {
+          console.error('❌ Insert error (skipped chunk):', error.message);
+        }
+      }
+
+      console.log(
+        `✅ Total logs inserted: ${insertedCount} / ${allLogs.length}`,
+      );
+    })();
+
+    await insertLogsPromise;
+  }
+
   async addDeviceStatusToFirebase(
-    addDeviceStatusDto: AddDeviceStatusDto,
+    addDeviceStatusDto: AddDeviceStatusDto & { device?: any },
   ): Promise<AddDeviceStatusDto | null> {
     try {
-      const device = await this.getDeviceByDeviceTuyaUuid(
-        addDeviceStatusDto.deviceTuyaUuid,
-      );
-
+      let device = addDeviceStatusDto.device;
+      if (!device) {
+        device = await this.getDeviceByDeviceTuyaUuid(
+          addDeviceStatusDto.deviceTuyaUuid,
+        );
+      }
       if (device?.uuid) {
         return await this.createDeviceStatusFirebase({
           deviceUuid: device.uuid,
           ...addDeviceStatusDto,
-          productType: device.productDevice.prodType,
+          productType: device.productDevice?.prodType,
         });
       }
       // Return null if device not found or no UUID
       return null;
     } catch (error) {
-      // Handle the error silently, perhaps log it internally or ignore it
       return null;
     }
   }
@@ -112,6 +168,15 @@ export class DeviceStatusFirebaseService {
       relations: ['productDevice'],
     });
   }
+  async getAllDevices() {
+    return await this.deviceRepository.find({
+      where: {
+        isActive: true,
+      },
+      relations: ['productDevice'],
+    });
+  }
+
   async getDevicesInstructionStatus(deviceUuid: string) {
     try {
       const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
@@ -126,7 +191,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(
@@ -191,18 +256,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);
       }
 
@@ -215,126 +280,6 @@ export class DeviceStatusFirebaseService {
       return existingData;
     });
 
-    if (this.isDevEnv) {
-      // Save logs to your repository
-      const newLogs = addDeviceStatusDto.log.properties.map((property) => {
-        return this.deviceStatusLogRepository.create({
-          deviceId: addDeviceStatusDto.deviceUuid,
-          deviceTuyaId: addDeviceStatusDto.deviceTuyaUuid,
-          productId: addDeviceStatusDto.log.productId,
-          log: addDeviceStatusDto.log,
-          code: property.code,
-          value: property.value,
-          eventId: addDeviceStatusDto.log.dataId,
-          eventTime: new Date(property.time).toISOString(),
-        });
-      });
-      await this.deviceStatusLogRepository.save(newLogs);
-
-      if (addDeviceStatusDto.productType === ProductType.PC) {
-        const energyCodes = new Set([
-          PowerClampEnergyEnum.ENERGY_CONSUMED,
-          PowerClampEnergyEnum.ENERGY_CONSUMED_A,
-          PowerClampEnergyEnum.ENERGY_CONSUMED_B,
-          PowerClampEnergyEnum.ENERGY_CONSUMED_C,
-        ]);
-
-        const energyStatus = addDeviceStatusDto?.log?.properties?.find(
-          (status) => energyCodes.has(status.code),
-        );
-
-        if (energyStatus) {
-          await this.powerClampService.updateEnergyConsumedHistoricalData(
-            addDeviceStatusDto.deviceUuid,
-          );
-        }
-      }
-
-      if (
-        addDeviceStatusDto.productType === ProductType.CPS ||
-        addDeviceStatusDto.productType === ProductType.WPS
-      ) {
-        const occupancyCodes = new Set([PresenceSensorEnum.PRESENCE_STATE]);
-
-        const occupancyStatus = addDeviceStatusDto?.log?.properties?.find(
-          (status) => occupancyCodes.has(status.code),
-        );
-
-        if (occupancyStatus) {
-          await this.occupancyService.updateOccupancySensorHistoricalData(
-            addDeviceStatusDto.deviceUuid,
-          );
-          await this.occupancyService.updateOccupancySensorHistoricalDurationData(
-            addDeviceStatusDto.deviceUuid,
-          );
-        }
-      }
-      if (addDeviceStatusDto.productType === ProductType.AQI) {
-        await this.aqiDataService.updateAQISensorHistoricalData(
-          addDeviceStatusDto.deviceUuid,
-        );
-      }
-    } else {
-      // Save logs to your repository
-      const newLogs = addDeviceStatusDto?.status.map((property) => {
-        return this.deviceStatusLogRepository.create({
-          deviceId: addDeviceStatusDto.deviceUuid,
-          deviceTuyaId: addDeviceStatusDto.deviceTuyaUuid,
-          productId: addDeviceStatusDto.log.productKey,
-          log: addDeviceStatusDto.log,
-          code: property.code,
-          value: property.value,
-          eventId: addDeviceStatusDto.log.dataId,
-          eventTime: new Date(property.t).toISOString(),
-        });
-      });
-      await this.deviceStatusLogRepository.save(newLogs);
-
-      if (addDeviceStatusDto.productType === ProductType.PC) {
-        const energyCodes = new Set([
-          PowerClampEnergyEnum.ENERGY_CONSUMED,
-          PowerClampEnergyEnum.ENERGY_CONSUMED_A,
-          PowerClampEnergyEnum.ENERGY_CONSUMED_B,
-          PowerClampEnergyEnum.ENERGY_CONSUMED_C,
-        ]);
-
-        const energyStatus = addDeviceStatusDto?.status?.find((status) => {
-          return energyCodes.has(status.code as PowerClampEnergyEnum);
-        });
-
-        if (energyStatus) {
-          await this.powerClampService.updateEnergyConsumedHistoricalData(
-            addDeviceStatusDto.deviceUuid,
-          );
-        }
-      }
-
-      if (
-        addDeviceStatusDto.productType === ProductType.CPS ||
-        addDeviceStatusDto.productType === ProductType.WPS
-      ) {
-        const occupancyCodes = new Set([PresenceSensorEnum.PRESENCE_STATE]);
-
-        const occupancyStatus = addDeviceStatusDto?.status?.find((status) => {
-          return occupancyCodes.has(status.code as PresenceSensorEnum);
-        });
-
-        if (occupancyStatus) {
-          await this.occupancyService.updateOccupancySensorHistoricalData(
-            addDeviceStatusDto.deviceUuid,
-          );
-          await this.occupancyService.updateOccupancySensorHistoricalDurationData(
-            addDeviceStatusDto.deviceUuid,
-          );
-        }
-      }
-
-      if (addDeviceStatusDto.productType === ProductType.AQI) {
-        await this.aqiDataService.updateAQISensorHistoricalData(
-          addDeviceStatusDto.deviceUuid,
-        );
-      }
-    }
     // Return the updated data
     const snapshot: DataSnapshot = await get(dataRef);
     return snapshot.val();

libs/common/src/helper/helper.module.ts

@@ -8,7 +8,10 @@ import { TuyaWebSocketService } from './services/tuya.web.socket.service';
 import { OneSignalService } from './services/onesignal.service';
 import { DeviceMessagesService } from './services/device.messages.service';
 import { DeviceRepositoryModule } from '../modules/device/device.repository.module';
-import { DeviceNotificationRepository } from '../modules/device/repositories';
+import {
+  DeviceNotificationRepository,
+  DeviceRepository,
+} from '../modules/device/repositories';
 import { DeviceStatusFirebaseModule } from '../firebase/devices-status/devices-status.module';
 import { CommunityPermissionService } from './services/community.permission.service';
 import { CommunityRepository } from '../modules/community/repositories';
@@ -27,6 +30,7 @@ import { SosHandlerService } from './services/sos.handler.service';
     DeviceNotificationRepository,
     CommunityRepository,
     SosHandlerService,
+    DeviceRepository,
   ],
   exports: [
     HelperHashService,

libs/common/src/helper/services/aqi.data.service.ts

@@ -1,44 +1,63 @@
-import { DeviceRepository } from '@app/common/modules/device/repositories';
 import { Injectable } from '@nestjs/common';
-import { SqlLoaderService } from './sql-loader.service';
 import { DataSource } from 'typeorm';
 import { SQL_PROCEDURES_PATH } from '@app/common/constants/sql-query-path';
+import { SqlLoaderService } from './sql-loader.service';
 
 @Injectable()
 export class AqiDataService {
   constructor(
     private readonly sqlLoader: SqlLoaderService,
     private readonly dataSource: DataSource,
-    private readonly deviceRepository: DeviceRepository,
   ) {}
-  async updateAQISensorHistoricalData(deviceUuid: string): Promise<void> {
-    try {
-      const now = new Date();
-      const dateStr = now.toLocaleDateString('en-CA'); // YYYY-MM-DD
-      const device = await this.deviceRepository.findOne({
-        where: { uuid: deviceUuid },
-        relations: ['spaceDevice'],
-      });
 
-      await this.executeProcedure(
-        'fact_daily_space_aqi',
-        'proceduce_update_daily_space_aqi',
-        [dateStr, device.spaceDevice?.uuid],
-      );
+  async updateAQISensorHistoricalData(): Promise<void> {
+    try {
+      const { dateStr } = this.getFormattedDates();
+
+      // Execute all procedures in parallel
+      await Promise.all([
+        this.executeProcedureWithRetry(
+          'proceduce_update_daily_space_aqi',
+          [dateStr],
+          'fact_daily_space_aqi',
+        ),
+      ]);
     } catch (err) {
-      console.error('Failed to insert or update aqi data:', err);
+      console.error('Failed to update AQI sensor historical data:', err);
       throw err;
     }
   }
-
-  private async executeProcedure(
-    procedureFolderName: string,
+  private getFormattedDates(): { dateStr: string } {
+    const now = new Date();
+    return {
+      dateStr: now.toLocaleDateString('en-CA'), // YYYY-MM-DD
+    };
+  }
+  private async executeProcedureWithRetry(
     procedureFileName: string,
     params: (string | number | null)[],
+    folderName: string,
+    retries = 3,
   ): Promise<void> {
-    const query = this.loadQuery(procedureFolderName, procedureFileName);
-    await this.dataSource.query(query, params);
-    console.log(`Procedure ${procedureFileName} executed successfully.`);
+    try {
+      const query = this.loadQuery(folderName, procedureFileName);
+      await this.dataSource.query(query, params);
+      console.log(`Procedure ${procedureFileName} executed successfully.`);
+    } catch (err) {
+      if (retries > 0) {
+        const delayMs = 1000 * (4 - retries); // Exponential backoff
+        console.warn(`Retrying ${procedureFileName} (${retries} retries left)`);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        return this.executeProcedureWithRetry(
+          procedureFileName,
+          params,
+          folderName,
+          retries - 1,
+        );
+      }
+      console.error(`Failed to execute ${procedureFileName}:`, err);
+      throw err;
+    }
   }
 
   private loadQuery(folderName: string, fileName: string): string {

libs/common/src/helper/services/occupancy.service.ts

@@ -1,65 +1,68 @@
-import { DeviceRepository } from '@app/common/modules/device/repositories';
 import { Injectable } from '@nestjs/common';
-import { SqlLoaderService } from './sql-loader.service';
 import { DataSource } from 'typeorm';
 import { SQL_PROCEDURES_PATH } from '@app/common/constants/sql-query-path';
+import { SqlLoaderService } from './sql-loader.service';
 
 @Injectable()
 export class OccupancyService {
   constructor(
     private readonly sqlLoader: SqlLoaderService,
     private readonly dataSource: DataSource,
-    private readonly deviceRepository: DeviceRepository,
   ) {}
-  async updateOccupancySensorHistoricalDurationData(
-    deviceUuid: string,
-  ): Promise<void> {
-    try {
-      const now = new Date();
-      const dateStr = now.toLocaleDateString('en-CA'); // YYYY-MM-DD
-      const device = await this.deviceRepository.findOne({
-        where: { uuid: deviceUuid },
-        relations: ['spaceDevice'],
-      });
 
-      await this.executeProcedure(
-        'fact_daily_space_occupancy_duration',
-        'procedure_update_daily_space_occupancy_duration',
-        [dateStr, device.spaceDevice?.uuid],
-      );
+  async updateOccupancyDataProcedures(): Promise<void> {
+    try {
+      const { dateStr } = this.getFormattedDates();
+
+      // Execute all procedures in parallel
+      await Promise.all([
+        this.executeProcedureWithRetry(
+          'procedure_update_fact_space_occupancy',
+          [dateStr],
+          'fact_space_occupancy_count',
+        ),
+        this.executeProcedureWithRetry(
+          'procedure_update_daily_space_occupancy_duration',
+          [dateStr],
+          'fact_daily_space_occupancy_duration',
+        ),
+      ]);
     } catch (err) {
-      console.error('Failed to insert or update occupancy duration data:', err);
+      console.error('Failed to update occupancy data:', err);
       throw err;
     }
   }
-  async updateOccupancySensorHistoricalData(deviceUuid: string): Promise<void> {
-    try {
-      const now = new Date();
-      const dateStr = now.toLocaleDateString('en-CA'); // YYYY-MM-DD
-      const device = await this.deviceRepository.findOne({
-        where: { uuid: deviceUuid },
-        relations: ['spaceDevice'],
-      });
-
-      await this.executeProcedure(
-        'fact_space_occupancy_count',
-        'procedure_update_fact_space_occupancy',
-        [dateStr, device.spaceDevice?.uuid],
-      );
-    } catch (err) {
-      console.error('Failed to insert or update occupancy data:', err);
-      throw err;
-    }
+  private getFormattedDates(): { dateStr: string } {
+    const now = new Date();
+    return {
+      dateStr: now.toLocaleDateString('en-CA'), // YYYY-MM-DD
+    };
   }
-
-  private async executeProcedure(
-    procedureFolderName: string,
+  private async executeProcedureWithRetry(
     procedureFileName: string,
     params: (string | number | null)[],
+    folderName: string,
+    retries = 3,
   ): Promise<void> {
-    const query = this.loadQuery(procedureFolderName, procedureFileName);
-    await this.dataSource.query(query, params);
-    console.log(`Procedure ${procedureFileName} executed successfully.`);
+    try {
+      const query = this.loadQuery(folderName, procedureFileName);
+      await this.dataSource.query(query, params);
+      console.log(`Procedure ${procedureFileName} executed successfully.`);
+    } catch (err) {
+      if (retries > 0) {
+        const delayMs = 1000 * (4 - retries); // Exponential backoff
+        console.warn(`Retrying ${procedureFileName} (${retries} retries left)`);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        return this.executeProcedureWithRetry(
+          procedureFileName,
+          params,
+          folderName,
+          retries - 1,
+        );
+      }
+      console.error(`Failed to execute ${procedureFileName}:`, err);
+      throw err;
+    }
   }
 
   private loadQuery(folderName: string, fileName: string): string {

libs/common/src/helper/services/power.clamp.service.ts

@@ -1,7 +1,7 @@
 import { Injectable } from '@nestjs/common';
-import { SqlLoaderService } from './sql-loader.service';
 import { DataSource } from 'typeorm';
 import { SQL_PROCEDURES_PATH } from '@app/common/constants/sql-query-path';
+import { SqlLoaderService } from './sql-loader.service';
 
 @Injectable()
 export class PowerClampService {
@@ -10,48 +10,72 @@ export class PowerClampService {
     private readonly dataSource: DataSource,
   ) {}
 
-  async updateEnergyConsumedHistoricalData(deviceUuid: string): Promise<void> {
+  async updateEnergyConsumedHistoricalData(): Promise<void> {
     try {
-      const now = new Date();
-      const dateStr = now.toLocaleDateString('en-CA'); // YYYY-MM-DD
-      const hour = now.getHours();
-      const monthYear = now
-        .toLocaleDateString('en-US', {
-          month: '2-digit',
-          year: 'numeric',
-        })
-        .replace('/', '-'); // MM-YYYY
+      const { dateStr, monthYear } = this.getFormattedDates();
 
-      await this.executeProcedure(
-        'fact_hourly_device_energy_consumed_procedure',
-        [deviceUuid, dateStr, hour],
-      );
-
-      await this.executeProcedure(
-        'fact_daily_device_energy_consumed_procedure',
-        [deviceUuid, dateStr],
-      );
-
-      await this.executeProcedure(
-        'fact_monthly_device_energy_consumed_procedure',
-        [deviceUuid, monthYear],
-      );
+      // Execute all procedures in parallel
+      await Promise.all([
+        this.executeProcedureWithRetry(
+          'fact_hourly_device_energy_consumed_procedure',
+          [dateStr],
+          'fact_device_energy_consumed',
+        ),
+        this.executeProcedureWithRetry(
+          'fact_daily_device_energy_consumed_procedure',
+          [dateStr],
+          'fact_device_energy_consumed',
+        ),
+        this.executeProcedureWithRetry(
+          'fact_monthly_device_energy_consumed_procedure',
+          [monthYear],
+          'fact_device_energy_consumed',
+        ),
+      ]);
     } catch (err) {
-      console.error('Failed to insert or update energy data:', err);
+      console.error('Failed to update energy consumption data:', err);
       throw err;
     }
   }
 
-  private async executeProcedure(
+  private getFormattedDates(): { dateStr: string; monthYear: string } {
+    const now = new Date();
+    return {
+      dateStr: now.toLocaleDateString('en-CA'), // YYYY-MM-DD
+      monthYear: now
+        .toLocaleDateString('en-US', {
+          month: '2-digit',
+          year: 'numeric',
+        })
+        .replace('/', '-'), // MM-YYYY
+    };
+  }
+
+  private async executeProcedureWithRetry(
     procedureFileName: string,
     params: (string | number | null)[],
+    folderName: string,
+    retries = 3,
   ): Promise<void> {
-    const query = this.loadQuery(
-      'fact_device_energy_consumed',
-      procedureFileName,
-    );
-    await this.dataSource.query(query, params);
-    console.log(`Procedure ${procedureFileName} executed successfully.`);
+    try {
+      const query = this.loadQuery(folderName, procedureFileName);
+      await this.dataSource.query(query, params);
+      console.log(`Procedure ${procedureFileName} executed successfully.`);
+    } catch (err) {
+      if (retries > 0) {
+        const delayMs = 1000 * (4 - retries); // Exponential backoff
+        console.warn(`Retrying ${procedureFileName} (${retries} retries left)`);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        return this.executeProcedureWithRetry(
+          procedureFileName,
+          params,
+          folderName,
+          retries - 1,
+        );
+      }
+      console.error(`Failed to execute ${procedureFileName}:`, err);
+      throw err;
+    }
   }
 
   private loadQuery(folderName: string, fileName: string): string {

libs/common/src/helper/services/sos.handler.service.ts

@@ -16,21 +16,46 @@ export class SosHandlerService {
     );
   }
 
-  async handleSosEvent(devId: string, logData: any): Promise<void> {
+  async handleSosEventFirebase(device: any, logData: any): Promise<void> {
+    const sosTrueStatus = [{ code: 'sos', value: true }];
+    const sosFalseStatus = [{ code: 'sos', value: false }];
+
     try {
+      // ✅ Send true status
       await this.deviceStatusFirebaseService.addDeviceStatusToFirebase({
-        deviceTuyaUuid: devId,
-        status: [{ code: 'sos', value: true }],
+        deviceTuyaUuid: device.deviceTuyaUuid,
+        status: sosTrueStatus,
         log: logData,
+        device,
       });
 
+      await this.deviceStatusFirebaseService.addBatchDeviceStatusToOurDb([
+        {
+          deviceTuyaUuid: device.deviceTuyaUuid,
+          status: sosTrueStatus,
+          log: logData,
+          device,
+        },
+      ]);
+
+      // ✅ Schedule false status
       setTimeout(async () => {
         try {
           await this.deviceStatusFirebaseService.addDeviceStatusToFirebase({
-            deviceTuyaUuid: devId,
-            status: [{ code: 'sos', value: false }],
+            deviceTuyaUuid: device.deviceTuyaUuid,
+            status: sosFalseStatus,
             log: logData,
+            device,
           });
+
+          await this.deviceStatusFirebaseService.addBatchDeviceStatusToOurDb([
+            {
+              deviceTuyaUuid: device.deviceTuyaUuid,
+              status: sosFalseStatus,
+              log: logData,
+              device,
+            },
+          ]);
         } catch (err) {
           this.logger.error('Failed to send SOS false value', err);
         }

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

@@ -1,13 +1,24 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, OnModuleInit } from '@nestjs/common';
 import TuyaWebsocket from '../../config/tuya-web-socket-config';
 import { ConfigService } from '@nestjs/config';
 import { DeviceStatusFirebaseService } from '@app/common/firebase/devices-status/services/devices-status.service';
 import { SosHandlerService } from './sos.handler.service';
+import * as NodeCache from 'node-cache';
 
 @Injectable()
-export class TuyaWebSocketService {
+export class TuyaWebSocketService implements OnModuleInit {
   private client: any;
   private readonly isDevEnv: boolean;
+  private readonly deviceCache = new NodeCache({ stdTTL: 7200 }); // TTL = 2 hour
+
+  private messageQueue: {
+    devId: string;
+    status: any;
+    logData: any;
+    device: any;
+  }[] = [];
+
+  private isProcessing = false;
 
   constructor(
     private readonly configService: ConfigService,
@@ -26,16 +37,36 @@ export class TuyaWebSocketService {
     });
 
     if (this.configService.get<string>('tuya-config.TRUN_ON_TUYA_SOCKET')) {
-      // Set up event handlers
       this.setupEventHandlers();
-
-      // Start receiving messages
       this.client.start();
     }
+
+    // Run the queue processor every 15 seconds
+    setInterval(() => this.processQueue(), 15000);
+
+    // Refresh the cache every 1 hour
+    setInterval(() => this.initializeDeviceCache(), 30 * 60 * 1000); // 30 minutes
+  }
+
+  async onModuleInit() {
+    await this.initializeDeviceCache();
+  }
+
+  private async initializeDeviceCache() {
+    try {
+      const allDevices = await this.deviceStatusFirebaseService.getAllDevices();
+      allDevices.forEach((device) => {
+        if (device.deviceTuyaUuid) {
+          this.deviceCache.set(device.deviceTuyaUuid, device);
+        }
+      });
+      console.log(`✅ Refreshed cache with ${allDevices.length} devices.`);
+    } catch (error) {
+      console.error('❌ Failed to initialize device cache:', error);
+    }
   }
 
   private setupEventHandlers() {
-    // Event handlers
     this.client.open(() => {
       console.log('open');
     });
@@ -43,23 +74,38 @@ export class TuyaWebSocketService {
     this.client.message(async (ws: WebSocket, message: any) => {
       try {
         const { devId, status, logData } = this.extractMessageData(message);
+        if (!Array.isArray(logData?.properties)) {
+          this.client.ackMessage(message.messageId);
+          return;
+        }
+
+        const device = this.deviceCache.get(devId);
+        if (!device) {
+          // console.log(⛔ Unknown device: ${devId}, message ignored.);
+          this.client.ackMessage(message.messageId);
+          return;
+        }
 
         if (this.sosHandlerService.isSosTriggered(status)) {
-          await this.sosHandlerService.handleSosEvent(devId, logData);
+          await this.sosHandlerService.handleSosEventFirebase(devId, logData);
         } else {
           await this.deviceStatusFirebaseService.addDeviceStatusToFirebase({
             deviceTuyaUuid: devId,
-            status: status,
+            status,
             log: logData,
+            device,
           });
         }
 
+        // Push to internal queue
+        this.messageQueue.push({ devId, status, logData, device });
+
+        // Acknowledge the message
         this.client.ackMessage(message.messageId);
       } catch (error) {
-        console.error('Error processing message:', error);
+        console.error('❌ Error receiving message:', error);
       }
     });
-
     this.client.reconnect(() => {
       console.log('reconnect');
     });
@@ -80,6 +126,37 @@ export class TuyaWebSocketService {
       console.error('WebSocket error:', error);
     });
   }
+  private async processQueue() {
+    if (this.isProcessing) {
+      console.log('⏳ Skipping: still processing previous batch');
+      return;
+    }
+
+    if (this.messageQueue.length === 0) return;
+
+    this.isProcessing = true;
+    const batch = [...this.messageQueue];
+    this.messageQueue = [];
+
+    console.log(`🔁 Processing batch of size: ${batch.length}`);
+
+    try {
+      await this.deviceStatusFirebaseService.addBatchDeviceStatusToOurDb(
+        batch.map((item) => ({
+          deviceTuyaUuid: item.devId,
+          status: item.status,
+          log: item.logData,
+          device: item.device,
+        })),
+      );
+    } catch (error) {
+      console.error('❌ Error processing batch:', error);
+      this.messageQueue.unshift(...batch); // retry
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+
   private extractMessageData(message: any): {
     devId: string;
     status: any;

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

@@ -1,26 +1,43 @@
 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:
-    process.env.AZURE_POSTGRESQL_DATABASE === 'development' ? 'debug' : 'error',
+    environment === 'local'
+      ? '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: true,
+          prettyPrint: environment === 'local',
         }),
       ),
     }),
-    new winston.transports.File({
-      filename: 'logs/error.log',
-      level: 'error',
-      format: winston.format.json(),
-    }),
-    new winston.transports.File({
-      filename: 'logs/combined.log',
-      format: winston.format.json(),
-    }),
+    // Only create file logs if NOT local
+    ...(environment !== 'local'
+      ? [
+          new winston.transports.File({
+            filename: 'logs/error.log',
+            level: 'error',
+            format: winston.format.json(),
+          }),
+          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 { RoleType } from '@app/common/constants/role.type.enum';
-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 { 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 { ProjectEntity } from '../../project/entities';
+import { SpaceEntity } from '../../space/entities/space.entity';
 
 @Entity({ name: 'invite-user' })
 @Unique(['email', 'project'])
@@ -82,10 +82,7 @@ export class InviteUserEntity extends AbstractEntity<InviteUserDto> {
     onDelete: 'CASCADE',
   })
   public roleType: RoleTypeEntity;
-  @OneToOne(() => UserEntity, (user) => user.inviteUser, {
-    nullable: true,
-    onDelete: 'CASCADE',
-  })
+  @OneToOne(() => UserEntity, (user) => user.inviteUser, { nullable: true })
   @JoinColumn({ name: 'user_uuid' })
   user: UserEntity;
   @OneToMany(
@@ -115,9 +112,7 @@ export class InviteUserSpaceEntity extends AbstractEntity<InviteUserSpaceDto> {
   })
   public uuid: string;
 
-  @ManyToOne(() => InviteUserEntity, (inviteUser) => inviteUser.spaces, {
-    onDelete: 'CASCADE',
-  })
+  @ManyToOne(() => InviteUserEntity, (inviteUser) => inviteUser.spaces)
   @JoinColumn({ name: 'invite_user_uuid' })
   public inviteUser: InviteUserEntity;
 

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 { PermissionTypeEntity } from '../../permission/entities';
-import { PowerClampHourlyEntity } from '../../power-clamp/entities/power-clamp.entity';
-import { PresenceSensorDailyDeviceEntity } from '../../presence-sensor/entities';
+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 { 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 { UserEntity } from '../../user/entities';
-import { DeviceNotificationDto } from '../dtos';
-import { DeviceDto, DeviceUserPermissionDto } from '../dtos/device.dto';
+import { PowerClampHourlyEntity } from '../../power-clamp/entities/power-clamp.entity';
+import { PresenceSensorDailyDeviceEntity } from '../../presence-sensor/entities';
 
 @Entity({ name: 'device' })
 @Unique(['deviceTuyaUuid'])
@@ -111,7 +111,6 @@ export class DeviceNotificationEntity extends AbstractEntity<DeviceNotificationD
 
   @ManyToOne(() => UserEntity, (user) => user.userPermission, {
     nullable: false,
-    onDelete: 'CASCADE',
   })
   user: UserEntity;
 
@@ -150,7 +149,6 @@ 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,32 +1,3 @@
-import { Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
 import { AbstractEntity } from '../../abstract/entities/abstract.entity';
-import { SpaceEntity } from './space.entity';
-import { Direction } from '@app/common/constants/direction.enum';
 
-@Entity({ name: 'space-link' })
-export class SpaceLinkEntity extends AbstractEntity {
-  @ManyToOne(() => SpaceEntity, { nullable: false, onDelete: 'CASCADE' })
-  @JoinColumn({ name: 'start_space_id' })
-  public startSpace: SpaceEntity;
-
-  @ManyToOne(() => SpaceEntity, { nullable: false, onDelete: 'CASCADE' })
-  @JoinColumn({ name: 'end_space_id' })
-  public endSpace: SpaceEntity;
-
-  @Column({
-    nullable: false,
-    default: false,
-  })
-  public disabled: boolean;
-
-  @Column({
-    nullable: false,
-    enum: Object.values(Direction),
-  })
-  direction: string;
-
-  constructor(partial: Partial<SpaceLinkEntity>) {
-    super();
-    Object.assign(this, partial);
-  }
-}
+export class SpaceLinkEntity extends AbstractEntity {}

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

@@ -1,18 +1,17 @@
 import { Column, Entity, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
-import { SpaceDto } from '../dtos';
 import { AbstractEntity } from '../../abstract/entities/abstract.entity';
-import { UserSpaceEntity } from '../../user/entities';
-import { DeviceEntity } from '../../device/entities';
+import { AqiSpaceDailyPollutantStatsEntity } from '../../aqi/entities';
 import { CommunityEntity } from '../../community/entities';
-import { SpaceLinkEntity } from './space-link.entity';
+import { DeviceEntity } from '../../device/entities';
+import { InviteUserSpaceEntity } from '../../Invite-user/entities';
+import { SpaceDailyOccupancyDurationEntity } from '../../occupancy/entities';
+import { PresenceSensorDailySpaceEntity } from '../../presence-sensor/entities';
 import { SceneEntity } from '../../scene/entities';
 import { SpaceModelEntity } from '../../space-model';
-import { InviteUserSpaceEntity } from '../../Invite-user/entities';
+import { UserSpaceEntity } from '../../user/entities';
+import { SpaceDto } from '../dtos';
 import { SpaceProductAllocationEntity } from './space-product-allocation.entity';
 import { SubspaceEntity } from './subspace/subspace.entity';
-import { PresenceSensorDailySpaceEntity } from '../../presence-sensor/entities';
-import { AqiSpaceDailyPollutantStatsEntity } from '../../aqi/entities';
-import { SpaceDailyOccupancyDurationEntity } from '../../occupancy/entities';
 
 @Entity({ name: 'space' })
 export class SpaceEntity extends AbstractEntity<SpaceDto> {
@@ -75,16 +74,6 @@ export class SpaceEntity extends AbstractEntity<SpaceDto> {
   )
   devices: DeviceEntity[];
 
-  @OneToMany(() => SpaceLinkEntity, (connection) => connection.startSpace, {
-    nullable: true,
-  })
-  public outgoingConnections: SpaceLinkEntity[];
-
-  @OneToMany(() => SpaceLinkEntity, (connection) => connection.endSpace, {
-    nullable: true,
-  })
-  public incomingConnections: SpaceLinkEntity[];
-
   @Column({
     nullable: true,
     type: 'text',

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

@@ -1,7 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { DataSource, Repository } from 'typeorm';
 import { InviteSpaceEntity } from '../entities/invite-space.entity';
-import { SpaceLinkEntity } from '../entities/space-link.entity';
 import { SpaceProductAllocationEntity } from '../entities/space-product-allocation.entity';
 import { SpaceEntity } from '../entities/space.entity';
 
@@ -13,11 +12,7 @@ export class SpaceRepository extends Repository<SpaceEntity> {
 }
 
 @Injectable()
-export class SpaceLinkRepository extends Repository<SpaceLinkEntity> {
-  constructor(private dataSource: DataSource) {
-    super(SpaceLinkEntity, dataSource.createEntityManager());
-  }
-}
+export class SpaceLinkRepository {}
 
 @Injectable()
 export class InviteSpaceRepository extends Repository<InviteSpaceEntity> {

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

@@ -1,4 +1,3 @@
-import { defaultProfilePicture } from '@app/common/constants/default.profile.picture';
 import {
   Column,
   DeleteDateColumn,
@@ -9,26 +8,27 @@ 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> {
@@ -94,9 +94,7 @@ export class UserEntity extends AbstractEntity<UserDto> {
   @Column({ type: 'timestamp', nullable: true })
   appAgreementAcceptedAt: Date;
 
-  @OneToMany(() => UserSpaceEntity, (userSpace) => userSpace.user, {
-    onDelete: 'CASCADE',
-  })
+  @OneToMany(() => UserSpaceEntity, (userSpace) => userSpace.user)
   userSpaces: UserSpaceEntity[];
 
   @OneToMany(
@@ -160,7 +158,6 @@ export class UserEntity extends AbstractEntity<UserDto> {
 export class UserNotificationEntity extends AbstractEntity<UserNotificationDto> {
   @ManyToOne(() => UserEntity, (user) => user.roleType, {
     nullable: false,
-    onDelete: 'CASCADE',
   })
   user: UserEntity;
   @Column({
@@ -222,10 +219,7 @@ export class UserSpaceEntity extends AbstractEntity<UserSpaceDto> {
   })
   public uuid: string;
 
-  @ManyToOne(() => UserEntity, (user) => user.userSpaces, {
-    nullable: false,
-    onDelete: 'CASCADE',
-  })
+  @ManyToOne(() => UserEntity, (user) => user.userSpaces, { nullable: false })
   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, Index, JoinColumn, ManyToOne } from 'typeorm';
+import { Column, Entity, ManyToOne, JoinColumn, Index } 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,7 +14,6 @@ export class VisitorPasswordEntity extends AbstractEntity<VisitorPasswordDto> {
 
   @ManyToOne(() => UserEntity, (user) => user.visitorPasswords, {
     nullable: false,
-    onDelete: 'CASCADE',
   })
   @JoinColumn({ name: 'authorizer_uuid' })
   public user: UserEntity;

libs/common/src/sql/procedures/fact_daily_space_aqi/proceduce_update_daily_space_aqi.sql

@@ -1,7 +1,6 @@
 WITH params AS (
 	SELECT 
-      TO_DATE(NULLIF($1, ''), 'YYYY-MM-DD') AS event_date,
-      $2::uuid AS space_id
+      TO_DATE(NULLIF($1, ''), 'YYYY-MM-DD') AS event_date
 ),
 
 -- Query Pipeline Starts Here
@@ -276,11 +275,12 @@ SELECT
   p.good_ch2o_percentage, p.moderate_ch2o_percentage, p.unhealthy_sensitive_ch2o_percentage, p.unhealthy_ch2o_percentage, p.very_unhealthy_ch2o_percentage, p.hazardous_ch2o_percentage,
   a.daily_avg_ch2o,a.daily_max_ch2o, a.daily_min_ch2o
 FROM daily_percentages p
-  LEFT JOIN daily_averages a 
-    ON p.space_id = a.space_id AND p.event_date = a.event_date
-  WHERE p.space_id = (SELECT space_id FROM params)
-    AND p.event_date = (SELECT event_date FROM params)
-  ORDER BY p.space_id, p.event_date)
+LEFT JOIN daily_averages a 
+  ON p.space_id = a.space_id 
+  AND p.event_date = a.event_date
+JOIN params  
+    ON params.event_date = a.event_date
+ORDER BY p.space_id, p.event_date)
 
 
 INSERT INTO public."space-daily-pollutant-stats" (

libs/common/src/sql/procedures/fact_daily_space_occupancy_duration/procedure_update_daily_space_occupancy_duration.sql

@@ -1,7 +1,6 @@
 WITH params AS (
 	SELECT 
-      TO_DATE(NULLIF($1, ''), 'YYYY-MM-DD') AS event_date,
-      $2::uuid AS space_id
+      TO_DATE(NULLIF($1, ''), 'YYYY-MM-DD') AS event_date
 ),
 
 presence_logs AS (
@@ -86,8 +85,7 @@ final_data AS (
     ROUND(LEAST(raw_occupied_seconds, 86400) / 86400.0 * 100, 2) AS occupancy_percentage
   FROM summed_intervals s
   JOIN params p 
-    ON p.space_id = s.space_id 
-   AND p.event_date = s.event_date
+    ON p.event_date = s.event_date
 )
 
 INSERT INTO public."space-daily-occupancy-duration" (

libs/common/src/sql/procedures/fact_device_energy_consumed/fact_daily_device_energy_consumed_procedure.sql

@@ -1,7 +1,6 @@
 WITH params AS (
     SELECT 
-        $1::uuid AS device_id,
-        $2::date AS target_date
+        $1::date AS target_date
 ),
 total_energy AS (
     SELECT 
@@ -14,8 +13,7 @@ total_energy AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumed'
-      AND log.device_id = params.device_id
-      AND log.event_time::date = params.target_date
+    AND log.event_time::date = params.target_date
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_A AS (
@@ -29,8 +27,7 @@ energy_phase_A AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedA'
-      AND log.device_id = params.device_id
-      AND log.event_time::date = params.target_date
+    AND log.event_time::date = params.target_date
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_B AS (
@@ -44,8 +41,7 @@ energy_phase_B AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedB'
-      AND log.device_id = params.device_id
-      AND log.event_time::date = params.target_date
+    AND log.event_time::date = params.target_date
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_C AS (
@@ -59,8 +55,7 @@ energy_phase_C AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedC'
-      AND log.device_id = params.device_id
-      AND log.event_time::date = params.target_date
+    AND log.event_time::date = params.target_date
     GROUP BY 1,2,3,4,5
 ),
 final_data AS (

libs/common/src/sql/procedures/fact_device_energy_consumed/fact_hourly_device_energy_consumed_procedure.sql

@@ -1,8 +1,6 @@
 WITH params AS (
     SELECT 
-        $1::uuid AS device_id,
-        $2::date AS target_date,
-        $3::text AS target_hour
+        $1::date AS target_date
 ),
 total_energy AS (
     SELECT 
@@ -15,9 +13,7 @@ total_energy AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumed'
-      AND log.device_id = params.device_id
       AND log.event_time::date = params.target_date
-      AND EXTRACT(HOUR FROM log.event_time)::text = params.target_hour
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_A AS (
@@ -31,9 +27,7 @@ energy_phase_A AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedA'
-      AND log.device_id = params.device_id
       AND log.event_time::date = params.target_date
-      AND EXTRACT(HOUR FROM log.event_time)::text = params.target_hour
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_B AS (
@@ -47,9 +41,7 @@ energy_phase_B AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedB'
-      AND log.device_id = params.device_id
       AND log.event_time::date = params.target_date
-      AND EXTRACT(HOUR FROM log.event_time)::text = params.target_hour
     GROUP BY 1,2,3,4,5
 ),
 energy_phase_C AS (
@@ -63,9 +55,7 @@ energy_phase_C AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedC'
-      AND log.device_id = params.device_id
       AND log.event_time::date = params.target_date
-      AND EXTRACT(HOUR FROM log.event_time)::text = params.target_hour
     GROUP BY 1,2,3,4,5
 ),
 final_data AS (

libs/common/src/sql/procedures/fact_device_energy_consumed/fact_monthly_device_energy_consumed_procedure.sql

@@ -1,7 +1,6 @@
 WITH params AS (
     SELECT 
-        $1::uuid AS device_id,
-        $2::text AS target_month  -- Format should match 'MM-YYYY'
+        $1::text AS target_month  -- Format should match 'MM-YYYY'
 ),
 total_energy AS (
     SELECT 
@@ -14,7 +13,6 @@ total_energy AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumed'
-      AND log.device_id = params.device_id
       AND TO_CHAR(log.event_time, 'MM-YYYY') = params.target_month
     GROUP BY 1,2,3,4,5
 ),
@@ -29,7 +27,6 @@ energy_phase_A AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedA'
-      AND log.device_id = params.device_id
       AND TO_CHAR(log.event_time, 'MM-YYYY') = params.target_month
     GROUP BY 1,2,3,4,5
 ),
@@ -44,7 +41,6 @@ energy_phase_B AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedB'
-      AND log.device_id = params.device_id
       AND TO_CHAR(log.event_time, 'MM-YYYY') = params.target_month
     GROUP BY 1,2,3,4,5
 ),
@@ -59,7 +55,6 @@ energy_phase_C AS (
         MAX(log.value)::integer AS max_value
     FROM "device-status-log" log, params
     WHERE log.code = 'EnergyConsumedC'
-      AND log.device_id = params.device_id
       AND TO_CHAR(log.event_time, 'MM-YYYY') = params.target_month
     GROUP BY 1,2,3,4,5
 ),

libs/common/src/sql/procedures/fact_space_occupancy_count/procedure_update_fact_space_occupancy.sql

@@ -1,7 +1,6 @@
 WITH params AS (
 	SELECT 
-      TO_DATE(NULLIF($1, ''), 'YYYY-MM-DD') AS event_date,
-      $2::uuid AS space_id
+      TO_DATE(NULLIF($1, ''), 'YYYY-MM-DD') AS event_date
 ),
 
 device_logs AS (
@@ -87,8 +86,7 @@ SELECT summary.space_id,
        count_total_presence_detected
 FROM summary
 JOIN params P ON true
-where summary.space_id = P.space_id
-and (P.event_date IS NULL or summary.event_date::date = P.event_date)
+where (P.event_date IS NULL or summary.event_date::date = P.event_date)
 ORDER BY space_id, event_date)
 
 

package-lock.json

@@ -18,6 +18,7 @@
         "@nestjs/jwt": "^10.2.0",
         "@nestjs/passport": "^10.0.3",
         "@nestjs/platform-express": "^10.0.0",
+        "@nestjs/schedule": "^6.0.0",
         "@nestjs/swagger": "^7.3.0",
         "@nestjs/terminus": "^11.0.0",
         "@nestjs/throttler": "^6.4.0",
@@ -38,6 +39,7 @@
         "ioredis": "^5.3.2",
         "morgan": "^1.10.0",
         "nest-winston": "^1.10.2",
+        "node-cache": "^5.1.2",
         "nodemailer": "^6.9.10",
         "onesignal-node": "^3.4.0",
         "passport-jwt": "^4.0.1",
@@ -2538,6 +2540,19 @@
         "@nestjs/core": "^10.0.0"
       }
     },
+    "node_modules/@nestjs/schedule": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@nestjs/schedule/-/schedule-6.0.0.tgz",
+      "integrity": "sha512-aQySMw6tw2nhitELXd3EiRacQRgzUKD9mFcUZVOJ7jPLqIBvXOyvRWLsK9SdurGA+jjziAlMef7iB5ZEFFoQpw==",
+      "license": "MIT",
+      "dependencies": {
+        "cron": "4.3.0"
+      },
+      "peerDependencies": {
+        "@nestjs/common": "^10.0.0 || ^11.0.0",
+        "@nestjs/core": "^10.0.0 || ^11.0.0"
+      }
+    },
     "node_modules/@nestjs/schematics": {
       "version": "10.2.3",
       "resolved": "https://registry.npmjs.org/@nestjs/schematics/-/schematics-10.2.3.tgz",
@@ -3215,6 +3230,12 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@types/luxon": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/@types/luxon/-/luxon-3.6.2.tgz",
+      "integrity": "sha512-R/BdP7OxEMc44l2Ex5lSXHoIXTB2JLNa3y2QISIbr58U/YcsffyQrYW//hZSdrfxrjRZj3GcUoxMPGdO8gSYuw==",
+      "license": "MIT"
+    },
     "node_modules/@types/methods": {
       "version": "1.1.4",
       "resolved": "https://registry.npmjs.org/@types/methods/-/methods-1.1.4.tgz",
@@ -5426,6 +5447,19 @@
       "devOptional": true,
       "license": "MIT"
     },
+    "node_modules/cron": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/cron/-/cron-4.3.0.tgz",
+      "integrity": "sha512-ciiYNLfSlF9MrDqnbMdRWFiA6oizSF7kA1osPP9lRzNu0Uu+AWog1UKy7SkckiDY2irrNjeO6qLyKnXC8oxmrw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/luxon": "~3.6.0",
+        "luxon": "~3.6.0"
+      },
+      "engines": {
+        "node": ">=18.x"
+      }
+    },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -9777,6 +9811,15 @@
         "yallist": "^3.0.2"
       }
     },
+    "node_modules/luxon": {
+      "version": "3.6.1",
+      "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.6.1.tgz",
+      "integrity": "sha512-tJLxrKJhO2ukZ5z0gyjY1zPh3Rh88Ej9P7jNrZiHMUXHae1yvI2imgOZtL1TO8TW6biMMKfTtAOoEJANgtWBMQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/magic-string": {
       "version": "0.30.8",
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.8.tgz",
@@ -10142,6 +10185,27 @@
         "node": "^18 || ^20 || >= 21"
       }
     },
+    "node_modules/node-cache": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/node-cache/-/node-cache-5.1.2.tgz",
+      "integrity": "sha512-t1QzWwnk4sjLWaQAS8CHgOJ+RAfmHpxFWmc36IWTiWHQfs0w5JDMBS1b1ZxQteo0vVVuWJvIUKHDkkeK7vIGCg==",
+      "license": "MIT",
+      "dependencies": {
+        "clone": "2.x"
+      },
+      "engines": {
+        "node": ">= 8.0.0"
+      }
+    },
+    "node_modules/node-cache/node_modules/clone": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz",
+      "integrity": "sha512-3Pe/CF1Nn94hyhIYpjtiLhdCoEoz0DqQ+988E9gmeEdQZlojxnOb74wctFyuwWQHzqyf9X7C7MG8juUpqBJT8w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/node-emoji": {
       "version": "1.11.0",
       "resolved": "https://registry.npmjs.org/node-emoji/-/node-emoji-1.11.0.tgz",

package.json

@@ -30,6 +30,7 @@
     "@nestjs/jwt": "^10.2.0",
     "@nestjs/passport": "^10.0.3",
     "@nestjs/platform-express": "^10.0.0",
+    "@nestjs/schedule": "^6.0.0",
     "@nestjs/swagger": "^7.3.0",
     "@nestjs/terminus": "^11.0.0",
     "@nestjs/throttler": "^6.4.0",
@@ -50,6 +51,7 @@
     "ioredis": "^5.3.2",
     "morgan": "^1.10.0",
     "nest-winston": "^1.10.2",
+    "node-cache": "^5.1.2",
     "nodemailer": "^6.9.10",
     "onesignal-node": "^3.4.0",
     "passport-jwt": "^4.0.1",
@@ -87,9 +89,5 @@
     "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

@@ -1,7 +1,7 @@
 import { SeederModule } from '@app/common/seed/seeder.module';
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
-import { APP_INTERCEPTOR } from '@nestjs/core';
+import { APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
 import { WinstonModule } from 'nest-winston';
 import { AuthenticationModule } from './auth/auth.module';
 import { AutomationModule } from './automation/automation.module';
@@ -35,18 +35,32 @@ import { UserNotificationModule } from './user-notification/user-notification.mo
 import { UserModule } from './users/user.module';
 import { VisitorPasswordModule } from './vistor-password/visitor-password.module';
 
+import { ThrottlerGuard } from '@nestjs/throttler';
+import { ThrottlerModule } from '@nestjs/throttler/dist/throttler.module';
+import { isArray } from 'class-validator';
 import { winstonLoggerOptions } from '../libs/common/src/logger/services/winston.logger';
 import { AqiModule } from './aqi/aqi.module';
 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';
 @Module({
   imports: [
     ConfigModule.forRoot({
       load: config,
     }),
-    /*   ThrottlerModule.forRoot({
-      throttlers: [{ ttl: 100000, limit: 30 }],
-    }), */
+    ThrottlerModule.forRoot({
+      throttlers: [{ ttl: 60000, limit: 100 }],
+      generateKey: (context) => {
+        const req = context.switchToHttp().getRequest();
+        console.log('Real IP:', req.headers['x-forwarded-for']);
+        return req.headers['x-forwarded-for']
+          ? isArray(req.headers['x-forwarded-for'])
+            ? req.headers['x-forwarded-for'][0].split(':')[0]
+            : req.headers['x-forwarded-for'].split(':')[0]
+          : req.ip;
+      },
+    }),
     WinstonModule.forRoot(winstonLoggerOptions),
     ClientModule,
     AuthenticationModule,
@@ -82,16 +96,18 @@ import { WeatherModule } from './weather/weather.module';
     OccupancyModule,
     WeatherModule,
     AqiModule,
+    SchedulerModule,
+    NestScheduleModule.forRoot(),
   ],
   providers: [
     {
       provide: APP_INTERCEPTOR,
       useClass: LoggingInterceptor,
     },
-    /*  {
+    {
       provide: APP_GUARD,
       useClass: ThrottlerGuard,
-    }, */
+    },
   ],
 })
 export class AppModule {}

src/commission-device/commission-device.module.ts

@@ -30,6 +30,8 @@ import { PowerClampService } from '@app/common/helper/services/power.clamp.servi
 import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service';
 import { OccupancyService } from '@app/common/helper/services/occupancy.service';
 import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
+import { PresenceSensorDailySpaceRepository } from '@app/common/modules/presence-sensor/repositories';
+import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/repositories';
 
 @Module({
   imports: [ConfigModule, SpaceRepositoryModule],
@@ -59,6 +61,8 @@ import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
     SqlLoaderService,
     OccupancyService,
     AqiDataService,
+    PresenceSensorDailySpaceRepository,
+    AqiSpaceDailyPollutantStatsRepository,
   ],
   exports: [],
 })

src/community/community.module.ts

@@ -64,6 +64,8 @@ import {
 import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service';
 import { OccupancyService } from '@app/common/helper/services/occupancy.service';
 import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
+import { PresenceSensorDailySpaceRepository } from '@app/common/modules/presence-sensor/repositories';
+import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/repositories';
 
 @Module({
   imports: [ConfigModule, SpaceRepositoryModule, UserRepositoryModule],
@@ -78,6 +80,7 @@ import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
     ProjectRepository,
     SpaceService,
     InviteSpaceRepository,
+    // Todo: find out why this is needed
     SpaceLinkService,
     SubSpaceService,
     ValidationService,
@@ -117,6 +120,8 @@ import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
     SqlLoaderService,
     OccupancyService,
     AqiDataService,
+    PresenceSensorDailySpaceRepository,
+    AqiSpaceDailyPollutantStatsRepository,
   ],
   exports: [CommunityService, SpacePermissionService],
 })

src/community/controllers/community.controller.ts

@@ -1,4 +1,3 @@
-import { CommunityService } from '../services/community.service';
 import {
   Body,
   Controller,
@@ -10,17 +9,18 @@ import {
   Query,
   UseGuards,
 } from '@nestjs/common';
-import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { AddCommunityDto } from '../dtos/add.community.dto';
 import { GetCommunityParams } from '../dtos/get.community.dto';
 import { UpdateCommunityNameDto } from '../dtos/update.community.dto';
+import { CommunityService } from '../services/community.service';
 // import { CheckUserCommunityGuard } from 'src/guards/user.community.guard';
 import { ControllerRoute } from '@app/common/constants/controller-route';
 import { BaseResponseDto } from '@app/common/dto/base.response.dto';
-import { ProjectParam } from '../dtos';
-import { PermissionsGuard } from 'src/guards/permissions.guard';
-import { Permissions } from 'src/decorators/permissions.decorator';
 import { PaginationRequestWithSearchGetListDto } from '@app/common/dto/pagination-with-search.request.dto';
+import { Permissions } from 'src/decorators/permissions.decorator';
+import { PermissionsGuard } from 'src/guards/permissions.guard';
+import { ProjectParam } from '../dtos';
 
 @ApiTags('Community Module')
 @Controller({
@@ -45,6 +45,21 @@ export class CommunityController {
     return await this.communityService.createCommunity(param, addCommunityDto);
   }
 
+  @ApiBearerAuth()
+  @UseGuards(PermissionsGuard)
+  @Permissions('COMMUNITY_VIEW')
+  @ApiOperation({
+    summary: ControllerRoute.COMMUNITY.ACTIONS.LIST_COMMUNITY_SUMMARY,
+    description: ControllerRoute.COMMUNITY.ACTIONS.LIST_COMMUNITY_DESCRIPTION,
+  })
+  @Get('v2')
+  async getCommunitiesV2(
+    @Param() param: ProjectParam,
+    @Query() query: PaginationRequestWithSearchGetListDto,
+  ): Promise<any> {
+    return this.communityService.getCommunitiesV2(param, query);
+  }
+
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
   @Permissions('COMMUNITY_VIEW')

src/community/services/community.service.ts

@@ -1,4 +1,7 @@
-import { ORPHAN_COMMUNITY_NAME } from '@app/common/constants/orphan-constant';
+import {
+  ORPHAN_COMMUNITY_NAME,
+  ORPHAN_SPACE_NAME,
+} from '@app/common/constants/orphan-constant';
 import { BaseResponseDto } from '@app/common/dto/base.response.dto';
 import { PageResponse } from '@app/common/dto/pagination.response.dto';
 import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
@@ -22,7 +25,7 @@ import {
   NotFoundException,
 } from '@nestjs/common';
 import { SpaceService } from 'src/space/services';
-import { SelectQueryBuilder } from 'typeorm';
+import { QueryRunner, SelectQueryBuilder } from 'typeorm';
 import { AddCommunityDto, GetCommunityParams, ProjectParam } from '../dtos';
 import { UpdateCommunityNameDto } from '../dtos/update.community.dto';
 
@@ -69,12 +72,18 @@ export class CommunityService {
     }
   }
 
-  async getCommunityById(params: GetCommunityParams): Promise<BaseResponseDto> {
+  async getCommunityById(
+    params: GetCommunityParams,
+    queryRunner?: QueryRunner,
+  ): Promise<BaseResponseDto> {
     const { communityUuid, projectUuid } = params;
 
     await this.validateProject(projectUuid);
 
-    const community = await this.communityRepository.findOneBy({
+    const communityRepository =
+      queryRunner?.manager.getRepository(CommunityEntity) ||
+      this.communityRepository;
+    const community = await communityRepository.findOneBy({
       uuid: communityUuid,
     });
 
@@ -111,7 +120,6 @@ 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(
@@ -162,6 +170,75 @@ export class CommunityService {
     }
   }
 
+  async getCommunitiesV2(
+    { projectUuid }: ProjectParam,
+    {
+      search,
+      includeSpaces,
+      ...pageable
+    }: Partial<ExtendedTypeORMCustomModelFindAllQuery>,
+  ) {
+    try {
+      const project = await this.validateProject(projectUuid);
+
+      let qb: undefined | SelectQueryBuilder<CommunityEntity> = undefined;
+
+      qb = this.communityRepository
+        .createQueryBuilder('c')
+        .where('c.project = :projectUuid', { projectUuid })
+        .andWhere(`c.name != '${ORPHAN_COMMUNITY_NAME}-${project.name}'`)
+        .distinct(true);
+
+      if (includeSpaces) {
+        qb.leftJoinAndSelect(
+          'c.spaces',
+          'space',
+          'space.disabled = :disabled AND space.spaceName != :orphanSpaceName',
+          { disabled: false, orphanSpaceName: ORPHAN_SPACE_NAME },
+        )
+          .leftJoinAndSelect('space.parent', 'parent')
+          .leftJoinAndSelect(
+            'space.children',
+            'children',
+            'children.disabled = :disabled',
+            { disabled: false },
+          );
+        // .leftJoinAndSelect('space.spaceModel', 'spaceModel')
+      }
+
+      if (search) {
+        qb.andWhere(
+          `c.name ILIKE :search ${includeSpaces ? 'OR space.space_name ILIKE :search' : ''}`,
+          { search },
+        );
+      }
+
+      const customModel = TypeORMCustomModel(this.communityRepository);
+
+      const { baseResponseDto, paginationResponseDto } =
+        await customModel.findAll({ ...pageable, modelName: 'community' }, qb);
+      if (includeSpaces) {
+        baseResponseDto.data = baseResponseDto.data.map((community) => ({
+          ...community,
+          spaces: this.spaceService.buildSpaceHierarchy(community.spaces || []),
+        }));
+      }
+      return new PageResponse<CommunityDto>(
+        baseResponseDto,
+        paginationResponseDto,
+      );
+    } catch (error) {
+      // Generic error handling
+      if (error instanceof HttpException) {
+        throw error;
+      }
+      throw new HttpException(
+        error.message || 'An error occurred while fetching communities.',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
   async updateCommunity(
     params: GetCommunityParams,
     updateCommunityDto: UpdateCommunityNameDto,

src/device/commands/cur2-commands.ts

@@ -0,0 +1,28 @@
+interface BaseCommand {
+  code: string;
+  value: any;
+}
+export interface ControlCur2Command extends BaseCommand {
+  code: 'control';
+  value: 'open' | 'close' | 'stop';
+}
+export interface ControlCur2PercentCommand extends BaseCommand {
+  code: 'percent_control';
+  value: 10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 | 100;
+}
+export interface ControlCur2AccurateCalibrationCommand extends BaseCommand {
+  code: 'accurate_calibration';
+  value: 'start' | 'end'; // Assuming this is a numeric value for calibration
+}
+export interface ControlCur2TDirectionConCommand extends BaseCommand {
+  code: 'control_t_direction_con';
+  value: 'forward' | 'back';
+}
+export interface ControlCur2QuickCalibrationCommand extends BaseCommand {
+  code: 'tr_timecon';
+  value: number; // between 10 and 120
+}
+export interface ControlCur2MotorModeCommand extends BaseCommand {
+  code: 'elec_machinery_mode';
+  value: 'strong_power' | 'dry_contact';
+}

src/device/controllers/device-project.controller.ts

@@ -1,11 +1,11 @@
-import { DeviceService } from '../services/device.service';
-import { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
-import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
-import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
 import { ControllerRoute } from '@app/common/constants/controller-route';
-import { PermissionsGuard } from 'src/guards/permissions.guard';
+import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
+import { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { Permissions } from 'src/decorators/permissions.decorator';
-import { GetDoorLockDevices, ProjectParam } from '../dtos';
+import { PermissionsGuard } from 'src/guards/permissions.guard';
+import { GetDevicesFilterDto, ProjectParam } from '../dtos';
+import { DeviceService } from '../services/device.service';
 
 @ApiTags('Device Module')
 @Controller({
@@ -25,7 +25,7 @@ export class DeviceProjectController {
   })
   async getAllDevices(
     @Param() param: ProjectParam,
-    @Query() query: GetDoorLockDevices,
+    @Query() query: GetDevicesFilterDto,
   ) {
     return await this.deviceService.getAllDevices(param, query);
   }

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

@@ -1,6 +1,7 @@
 import { DeviceTypeEnum } from '@app/common/constants/device-type.enum';
 import { ApiProperty } from '@nestjs/swagger';
 import {
+  IsArray,
   IsEnum,
   IsNotEmpty,
   IsOptional,
@@ -41,16 +42,7 @@ export class GetDeviceLogsDto {
   @IsOptional()
   public endTime: string;
 }
-export class GetDoorLockDevices {
-  @ApiProperty({
-    description: 'Device Type',
-    enum: DeviceTypeEnum,
-    required: false,
-  })
-  @IsEnum(DeviceTypeEnum)
-  @IsOptional()
-  public deviceType: DeviceTypeEnum;
-}
+
 export class GetDevicesBySpaceOrCommunityDto {
   @ApiProperty({
     description: 'Device Product Type',
@@ -72,3 +64,23 @@ export class GetDevicesBySpaceOrCommunityDto {
   @IsNotEmpty({ message: 'Either spaceUuid or communityUuid must be provided' })
   requireEither?: never; // This ensures at least one of them is provided
 }
+
+export class GetDevicesFilterDto {
+  @ApiProperty({
+    description: 'Device Type',
+    enum: DeviceTypeEnum,
+    required: false,
+  })
+  @IsEnum(DeviceTypeEnum)
+  @IsOptional()
+  public deviceType: DeviceTypeEnum;
+  @ApiProperty({
+    description: 'List of Space IDs to filter devices',
+    required: false,
+    example: ['60d21b4667d0d8992e610c85', '60d21b4967d0d8992e610c86'],
+  })
+  @IsOptional()
+  @IsArray()
+  @IsUUID('4', { each: true })
+  public spaces?: string[];
+}

src/device/services/device.service.ts

@@ -53,7 +53,7 @@ import { DeviceSceneParamDto } from '../dtos/device.param.dto';
 import {
   GetDeviceLogsDto,
   GetDevicesBySpaceOrCommunityDto,
-  GetDoorLockDevices,
+  GetDevicesFilterDto,
 } from '../dtos/get.device.dto';
 import {
   controlDeviceInterface,
@@ -955,19 +955,20 @@ export class DeviceService {
 
   async getAllDevices(
     param: ProjectParam,
-    query: GetDoorLockDevices,
+    { deviceType, spaces }: GetDevicesFilterDto,
   ): Promise<BaseResponseDto> {
     try {
       await this.validateProject(param.projectUuid);
-      if (query.deviceType === DeviceTypeEnum.DOOR_LOCK) {
-        return await this.getDoorLockDevices(param.projectUuid);
-      } else if (!query.deviceType) {
+      if (deviceType === DeviceTypeEnum.DOOR_LOCK) {
+        return await this.getDoorLockDevices(param.projectUuid, spaces);
+      } else if (!deviceType) {
         const devices = await this.deviceRepository.find({
           where: {
             isActive: true,
             spaceDevice: {
-              community: { project: { uuid: param.projectUuid } },
+              uuid: spaces && spaces.length ? In(spaces) : undefined,
               spaceName: Not(ORPHAN_SPACE_NAME),
+              community: { project: { uuid: param.projectUuid } },
             },
           },
           relations: [
@@ -1563,7 +1564,7 @@ export class DeviceService {
     }
   }
 
-  async getDoorLockDevices(projectUuid: string) {
+  async getDoorLockDevices(projectUuid: string, spaces?: string[]) {
     await this.validateProject(projectUuid);
 
     const devices = await this.deviceRepository.find({
@@ -1573,6 +1574,7 @@ export class DeviceService {
         },
         spaceDevice: {
           spaceName: Not(ORPHAN_SPACE_NAME),
+          uuid: spaces && spaces.length ? In(spaces) : undefined,
           community: {
             project: {
               uuid: projectUuid,

src/door-lock/door.lock.module.ts

@@ -30,6 +30,8 @@ import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service
 import { OccupancyService } from '@app/common/helper/services/occupancy.service';
 import { CommunityRepository } from '@app/common/modules/community/repositories';
 import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
+import { PresenceSensorDailySpaceRepository } from '@app/common/modules/presence-sensor/repositories';
+import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/repositories';
 @Module({
   imports: [ConfigModule, DeviceRepositoryModule],
   controllers: [DoorLockController],
@@ -58,6 +60,8 @@ import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
     OccupancyService,
     CommunityRepository,
     AqiDataService,
+    PresenceSensorDailySpaceRepository,
+    AqiSpaceDailyPollutantStatsRepository,
   ],
   exports: [DoorLockService],
 })

src/group/group.module.ts

@@ -28,6 +28,8 @@ import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service
 import { OccupancyService } from '@app/common/helper/services/occupancy.service';
 import { CommunityRepository } from '@app/common/modules/community/repositories';
 import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
+import { PresenceSensorDailySpaceRepository } from '@app/common/modules/presence-sensor/repositories';
+import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/repositories';
 @Module({
   imports: [ConfigModule, DeviceRepositoryModule],
   controllers: [GroupController],
@@ -55,6 +57,8 @@ import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
     OccupancyService,
     CommunityRepository,
     AqiDataService,
+    PresenceSensorDailySpaceRepository,
+    AqiSpaceDailyPollutantStatsRepository,
   ],
   exports: [GroupService],
 })

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

@@ -71,7 +71,6 @@ import {
 import { SpaceModelProductAllocationService } from 'src/space-model/services/space-model-product-allocation.service';
 import { SubspaceModelProductAllocationService } from 'src/space-model/services/subspace/subspace-model-product-allocation.service';
 import {
-  SpaceLinkService,
   SpaceService,
   SpaceUserService,
   SubspaceDeviceService,
@@ -83,6 +82,8 @@ import { SubspaceProductAllocationService } from 'src/space/services/subspace/su
 import { TagService as NewTagService } from 'src/tags/services';
 import { UserDevicePermissionService } from 'src/user-device-permission/services';
 import { UserService, UserSpaceService } from 'src/users/services';
+import { PresenceSensorDailySpaceRepository } from '@app/common/modules/presence-sensor/repositories';
+import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/repositories';
 
 @Module({
   imports: [ConfigModule, InviteUserRepositoryModule, CommunityModule],
@@ -115,7 +116,6 @@ import { UserService, UserSpaceService } from 'src/users/services';
     TimeZoneRepository,
     SpaceService,
     InviteSpaceRepository,
-    SpaceLinkService,
     SubSpaceService,
     ValidationService,
     NewTagService,
@@ -152,6 +152,8 @@ import { UserService, UserSpaceService } from 'src/users/services';
     SqlLoaderService,
     OccupancyService,
     AqiDataService,
+    PresenceSensorDailySpaceRepository,
+    AqiSpaceDailyPollutantStatsRepository,
   ],
   exports: [InviteUserService],
 })

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

@@ -111,7 +111,6 @@ 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) => {
@@ -129,7 +128,7 @@ export class InviteUserService {
       await this.emailService.sendEmailWithInvitationTemplate(email, {
         name: firstName,
         invitationCode,
-        role: invitedRoleType.replace(/_/g, ' '),
+        role: roleType,
         spacesList: spaceNames,
       });
 

src/main.ts

@@ -1,15 +1,13 @@
-import { NestFactory } from '@nestjs/core';
-import { AppModule } from './app.module';
-import rateLimit from 'express-rate-limit';
-import helmet from 'helmet';
-import { setupSwaggerAuthentication } from '../libs/common/src/util/user-auth.swagger.utils';
-import { ValidationPipe } from '@nestjs/common';
-import { json, urlencoded } from 'body-parser';
-import { SeederService } from '@app/common/seed/services/seeder.service';
-import { HttpExceptionFilter } from './common/filters/http-exception/http-exception.filter';
-import { Logger } from '@nestjs/common';
-import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
 import { RequestContextMiddleware } from '@app/common/middleware/request-context.middleware';
+import { SeederService } from '@app/common/seed/services/seeder.service';
+import { Logger, ValidationPipe } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+import { json, urlencoded } from 'body-parser';
+import helmet from 'helmet';
+import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
+import { setupSwaggerAuthentication } from '../libs/common/src/util/user-auth.swagger.utils';
+import { AppModule } from './app.module';
+import { HttpExceptionFilter } from './common/filters/http-exception/http-exception.filter';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
@@ -23,13 +21,6 @@ async function bootstrap() {
 
   app.use(new RequestContextMiddleware().use);
 
-  app.use(
-    rateLimit({
-      windowMs: 5 * 60 * 1000,
-      max: 500,
-    }),
-  );
-
   app.use(
     helmet({
       contentSecurityPolicy: false,

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

@@ -1,24 +1,25 @@
-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,
@@ -26,6 +27,7 @@ import { PowerClampService } from '../services/power-clamp.service';
 })
 export class PowerClampController {
   constructor(private readonly powerClampService: PowerClampService) {}
+
   @ApiBearerAuth()
   @UseGuards(JwtAuthGuard)
   @Get(':powerClampUuid/historical')

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

@@ -1,4 +1,5 @@
 import { DeviceStatusFirebaseService } from '@app/common/firebase/devices-status/services/devices-status.service';
+import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
 import { OccupancyService } from '@app/common/helper/services/occupancy.service';
 import { PowerClampService } from '@app/common/helper/services/power.clamp.service';
 import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service';
@@ -49,7 +50,6 @@ import { SpaceModelProductAllocationService } from 'src/space-model/services/spa
 import { SubspaceModelProductAllocationService } from 'src/space-model/services/subspace/subspace-model-product-allocation.service';
 import {
   SpaceDeviceService,
-  SpaceLinkService,
   SpaceService,
   SubspaceDeviceService,
   SubSpaceService,
@@ -60,7 +60,8 @@ import { SubspaceProductAllocationService } from 'src/space/services/subspace/su
 import { TagService } from 'src/tags/services';
 import { PowerClampController } from './controllers';
 import { PowerClampService as PowerClamp } from './services/power-clamp.service';
-import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
+import { PresenceSensorDailySpaceRepository } from '@app/common/modules/presence-sensor/repositories';
+import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/repositories';
 @Module({
   imports: [ConfigModule],
   controllers: [PowerClampController],
@@ -90,7 +91,6 @@ import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
     SceneRepository,
     AutomationRepository,
     InviteSpaceRepository,
-    SpaceLinkService,
     SubSpaceService,
     TagService,
     SpaceModelService,
@@ -111,6 +111,8 @@ import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
     SubspaceModelProductAllocationRepoitory,
     OccupancyService,
     AqiDataService,
+    PresenceSensorDailySpaceRepository,
+    AqiSpaceDailyPollutantStatsRepository,
   ],
   exports: [PowerClamp],
 })

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

@@ -54,7 +54,6 @@ import {
 import { SpaceModelProductAllocationService } from 'src/space-model/services/space-model-product-allocation.service';
 import { SubspaceModelProductAllocationService } from 'src/space-model/services/subspace/subspace-model-product-allocation.service';
 import {
-  SpaceLinkService,
   SpaceService,
   SubspaceDeviceService,
   SubSpaceService,
@@ -68,6 +67,8 @@ import { ProjectUserController } from './controllers/project-user.controller';
 import { CreateOrphanSpaceHandler } from './handler';
 import { ProjectService } from './services';
 import { ProjectUserService } from './services/project-user.service';
+import { PresenceSensorDailySpaceRepository } from '@app/common/modules/presence-sensor/repositories';
+import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/repositories';
 
 const CommandHandlers = [CreateOrphanSpaceHandler];
 
@@ -87,7 +88,6 @@ const CommandHandlers = [CreateOrphanSpaceHandler];
     UserRepository,
     SpaceService,
     InviteSpaceRepository,
-    SpaceLinkService,
     SubSpaceService,
     ValidationService,
     TagService,
@@ -126,6 +126,8 @@ const CommandHandlers = [CreateOrphanSpaceHandler];
     SqlLoaderService,
     OccupancyService,
     AqiDataService,
+    PresenceSensorDailySpaceRepository,
+    AqiSpaceDailyPollutantStatsRepository,
   ],
   exports: [ProjectService, CqrsModule],
 })

src/project/services/project.service.ts

@@ -24,6 +24,7 @@ import { SpaceService } from 'src/space/services';
 import { PassThrough } from 'stream';
 import { CreateOrphanSpaceCommand } from '../command/create-orphan-space-command';
 import { CreateProjectDto, GetProjectParam } from '../dto';
+import { QueryRunner } from 'typeorm';
 
 @Injectable()
 export class ProjectService {
@@ -212,8 +213,14 @@ export class ProjectService {
     }
   }
 
-  async findOne(uuid: string): Promise<ProjectEntity> {
-    const project = await this.projectRepository.findOne({ where: { uuid } });
+  async findOne(
+    uuid: string,
+    queryRunner?: QueryRunner,
+  ): Promise<ProjectEntity> {
+    const projectRepository = queryRunner
+      ? queryRunner.manager.getRepository(ProjectEntity)
+      : this.projectRepository;
+    const project = await projectRepository.findOne({ where: { uuid } });
     if (!project) {
       throw new HttpException(
         `Invalid project with uuid ${uuid}`,

src/schedule/constants/device-function-map.ts

@@ -0,0 +1,32 @@
+import {
+  ControlCur2AccurateCalibrationCommand,
+  ControlCur2Command,
+  ControlCur2PercentCommand,
+  ControlCur2QuickCalibrationCommand,
+  ControlCur2TDirectionConCommand,
+} from 'src/device/commands/cur2-commands';
+
+export enum ScheduleProductType {
+  CUR_2 = 'CUR_2',
+}
+export const DeviceFunctionMap: {
+  [T in ScheduleProductType]: (body: DeviceFunction[T]) => any;
+} = {
+  [ScheduleProductType.CUR_2]: ({ code, value }) => {
+    return [
+      {
+        code,
+        value,
+      },
+    ];
+  },
+};
+
+type DeviceFunction = {
+  [ScheduleProductType.CUR_2]:
+    | ControlCur2Command
+    | ControlCur2PercentCommand
+    | ControlCur2AccurateCalibrationCommand
+    | ControlCur2TDirectionConCommand
+    | ControlCur2QuickCalibrationCommand;
+};

src/schedule/services/schedule.service.ts

@@ -49,23 +49,11 @@ export class ScheduleService {
       }
 
       // Corrected condition for supported device types
-      if (
-        deviceDetails.productDevice.prodType !== ProductType.THREE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_G &&
-        deviceDetails.productDevice.prodType !== ProductType.WH &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
-        deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
-        deviceDetails.productDevice.prodType !== ProductType.GD &&
-        deviceDetails.productDevice.prodType !== ProductType.CUR_2
-      ) {
-        throw new HttpException(
-          'This device is not supported for schedule',
-          HttpStatus.BAD_REQUEST,
-        );
-      }
-      return await this.enableScheduleDeviceInTuya(
+      this.ensureProductTypeSupportedForSchedule(
+        deviceDetails.productDevice.prodType as ProductType,
+      );
+
+      return this.enableScheduleDeviceInTuya(
         deviceDetails.deviceTuyaUuid,
         enableScheduleDto,
       );
@@ -76,7 +64,224 @@ export class ScheduleService {
       );
     }
   }
-  async enableScheduleDeviceInTuya(
+  async deleteDeviceSchedule(deviceUuid: string, scheduleId: string) {
+    try {
+      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+
+      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
+        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
+      }
+
+      // Corrected condition for supported device types
+      this.ensureProductTypeSupportedForSchedule(
+        deviceDetails.productDevice.prodType as ProductType,
+      );
+
+      return await this.deleteScheduleDeviceInTuya(
+        deviceDetails.deviceTuyaUuid,
+        scheduleId,
+      );
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Error While Deleting Schedule',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  async addDeviceSchedule(deviceUuid: string, addScheduleDto: AddScheduleDto) {
+    try {
+      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+
+      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
+        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
+      }
+
+      this.ensureProductTypeSupportedForSchedule(
+        deviceDetails.productDevice.prodType as ProductType,
+      );
+
+      await this.addScheduleDeviceInTuya(
+        deviceDetails.deviceTuyaUuid,
+        addScheduleDto,
+      );
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Error While Adding Schedule',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  async getDeviceScheduleByCategory(deviceUuid: string, category: string) {
+    try {
+      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+
+      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
+        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
+      }
+      // Corrected condition for supported device types
+      this.ensureProductTypeSupportedForSchedule(
+        deviceDetails.productDevice.prodType as ProductType,
+      );
+      const schedules = await this.getScheduleDeviceInTuya(
+        deviceDetails.deviceTuyaUuid,
+        category,
+      );
+      const result = schedules.result.map((schedule: any) => {
+        return {
+          category: schedule.category.replace('category_', ''),
+          enable: schedule.enable,
+          function: {
+            code: schedule.functions[0].code,
+            value: schedule.functions[0].value,
+          },
+          time: schedule.time,
+          schedule_id: schedule.timer_id,
+          timezone_id: schedule.timezone_id,
+          days: getEnabledDays(schedule.loops),
+        };
+      });
+      return convertKeysToCamelCase(result);
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Error While Adding Schedule',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+  async updateDeviceSchedule(
+    deviceUuid: string,
+    updateScheduleDto: UpdateScheduleDto,
+  ) {
+    try {
+      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+
+      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
+        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
+      }
+
+      // Corrected condition for supported device types
+      this.ensureProductTypeSupportedForSchedule(
+        deviceDetails.productDevice.prodType as ProductType,
+      );
+
+      await this.updateScheduleDeviceInTuya(
+        deviceDetails.deviceTuyaUuid,
+        updateScheduleDto,
+      );
+    } catch (error) {
+      throw new HttpException(
+        error.message || 'Error While Updating Schedule',
+        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  private getDeviceByDeviceUuid(
+    deviceUuid: string,
+    withProductDevice: boolean = true,
+  ) {
+    return this.deviceRepository.findOne({
+      where: {
+        uuid: deviceUuid,
+        isActive: true,
+      },
+      ...(withProductDevice && { relations: ['productDevice'] }),
+    });
+  }
+
+  private async addScheduleDeviceInTuya(
+    deviceId: string,
+    addScheduleDto: AddScheduleDto,
+  ): Promise<addScheduleDeviceInterface> {
+    try {
+      const convertedTime = convertTimestampToDubaiTime(addScheduleDto.time);
+      const loops = getScheduleStatus(addScheduleDto.days);
+
+      const path = `/v2.0/cloud/timer/device/${deviceId}`;
+      const response = await this.tuya.request({
+        method: 'POST',
+        path,
+        body: {
+          time: convertedTime.time,
+          timezone_id: 'Asia/Dubai',
+          loops: `${loops}`,
+          functions: [
+            {
+              ...addScheduleDto.function,
+            },
+          ],
+          category: `category_${addScheduleDto.category}`,
+        },
+      });
+
+      return response as addScheduleDeviceInterface;
+    } catch (error) {
+      throw new HttpException(
+        'Error adding schedule from Tuya',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  private async getScheduleDeviceInTuya(
+    deviceId: string,
+    category: string,
+  ): Promise<getDeviceScheduleInterface> {
+    try {
+      const path = `/v2.0/cloud/timer/device/${deviceId}?category=category_${category}`;
+      const response = await this.tuya.request({
+        method: 'GET',
+        path,
+      });
+
+      return response as getDeviceScheduleInterface;
+    } catch (error) {
+      console.error('Error fetching device schedule from Tuya:', error);
+
+      throw new HttpException(
+        'Error fetching device schedule from Tuya',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  private async updateScheduleDeviceInTuya(
+    deviceId: string,
+    updateScheduleDto: UpdateScheduleDto,
+  ): Promise<addScheduleDeviceInterface> {
+    try {
+      const convertedTime = convertTimestampToDubaiTime(updateScheduleDto.time);
+      const loops = getScheduleStatus(updateScheduleDto.days);
+
+      const path = `/v2.0/cloud/timer/device/${deviceId}`;
+      const response = await this.tuya.request({
+        method: 'PUT',
+        path,
+        body: {
+          timer_id: updateScheduleDto.scheduleId,
+          time: convertedTime.time,
+          timezone_id: 'Asia/Dubai',
+          loops: `${loops}`,
+          functions: [
+            {
+              code: updateScheduleDto.function.code,
+              value: updateScheduleDto.function.value,
+            },
+          ],
+          category: `category_${updateScheduleDto.category}`,
+        },
+      });
+
+      return response as addScheduleDeviceInterface;
+    } catch (error) {
+      throw new HttpException(
+        'Error updating schedule from Tuya',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
+  private async enableScheduleDeviceInTuya(
     deviceId: string,
     enableScheduleDto: EnableScheduleDto,
   ): Promise<addScheduleDeviceInterface> {
@@ -99,43 +304,8 @@ export class ScheduleService {
       );
     }
   }
-  async deleteDeviceSchedule(deviceUuid: string, scheduleId: string) {
-    try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
 
-      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
-        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
-      }
-
-      // Corrected condition for supported device types
-      if (
-        deviceDetails.productDevice.prodType !== ProductType.THREE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_G &&
-        deviceDetails.productDevice.prodType !== ProductType.WH &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
-        deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
-        deviceDetails.productDevice.prodType !== ProductType.GD &&
-        deviceDetails.productDevice.prodType !== ProductType.CUR_2
-      ) {
-        throw new HttpException(
-          'This device is not supported for schedule',
-          HttpStatus.BAD_REQUEST,
-        );
-      }
-      return await this.deleteScheduleDeviceInTuya(
-        deviceDetails.deviceTuyaUuid,
-        scheduleId,
-      );
-    } catch (error) {
-      throw new HttpException(
-        error.message || 'Error While Deleting Schedule',
-        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
-  async deleteScheduleDeviceInTuya(
+  private async deleteScheduleDeviceInTuya(
     deviceId: string,
     scheduleId: string,
   ): Promise<addScheduleDeviceInterface> {
@@ -154,263 +324,24 @@ export class ScheduleService {
       );
     }
   }
-  async addDeviceSchedule(deviceUuid: string, addScheduleDto: AddScheduleDto) {
-    try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
 
-      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
-        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,
-        );
-      }
-
-      // Corrected condition for supported device types
-      if (
-        deviceDetails.productDevice.prodType !== ProductType.THREE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_G &&
-        deviceDetails.productDevice.prodType !== ProductType.WH &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
-        deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
-        deviceDetails.productDevice.prodType !== ProductType.GD &&
-        deviceDetails.productDevice.prodType !== ProductType.CUR_2
-      ) {
-        throw new HttpException(
-          'This device is not supported for schedule',
-          HttpStatus.BAD_REQUEST,
-        );
-      }
-      await this.addScheduleDeviceInTuya(
-        deviceDetails.deviceTuyaUuid,
-        addScheduleDto,
-        deviceDetails.productDevice.prodType as ProductType,
-      );
-    } catch (error) {
+  private ensureProductTypeSupportedForSchedule(deviceType: ProductType): void {
+    if (
+      ![
+        ProductType.THREE_G,
+        ProductType.ONE_G,
+        ProductType.TWO_G,
+        ProductType.WH,
+        ProductType.ONE_1TG,
+        ProductType.TWO_2TG,
+        ProductType.THREE_3TG,
+        ProductType.GD,
+        ProductType.CUR_2,
+      ].includes(deviceType)
+    ) {
       throw new HttpException(
-        error.message || 'Error While Adding Schedule',
-        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
-  async addScheduleDeviceInTuya(
-    deviceId: string,
-    addScheduleDto: AddScheduleDto,
-    deviceType: ProductType,
-  ): Promise<addScheduleDeviceInterface> {
-    try {
-      const convertedTime = convertTimestampToDubaiTime(addScheduleDto.time);
-      const loops = getScheduleStatus(addScheduleDto.days);
-
-      const path = `/v2.0/cloud/timer/device/${deviceId}`;
-      const response = await this.tuya.request({
-        method: 'POST',
-        path,
-        body: {
-          time: convertedTime.time,
-          timezone_id: 'Asia/Dubai',
-          loops: `${loops}`,
-          functions: [
-            {
-              code: addScheduleDto.function.code,
-              value: addScheduleDto.function.value,
-            },
-          ],
-          category:
-            deviceType == ProductType.CUR_2
-              ? addScheduleDto.category
-              : `category_${addScheduleDto.category}`,
-        },
-      });
-
-      return response as addScheduleDeviceInterface;
-    } catch (error) {
-      throw new HttpException(
-        'Error adding schedule from Tuya',
-        HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
-  async getDeviceScheduleByCategory(deviceUuid: string, category: string) {
-    try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
-
-      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
-        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
-      }
-      // Corrected condition for supported device types
-      if (
-        deviceDetails.productDevice.prodType !== ProductType.THREE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_G &&
-        deviceDetails.productDevice.prodType !== ProductType.WH &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
-        deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
-        deviceDetails.productDevice.prodType !== ProductType.GD &&
-        deviceDetails.productDevice.prodType !== ProductType.CUR_2
-      ) {
-        throw new HttpException(
-          'This device is not supported for schedule',
-          HttpStatus.BAD_REQUEST,
-        );
-      }
-      const schedules = await this.getScheduleDeviceInTuya(
-        deviceDetails.deviceTuyaUuid,
-        category,
-      );
-      const result = schedules.result.map((schedule: any) => {
-        return {
-          category:
-            deviceDetails.productDevice.prodType == ProductType.CUR_2
-              ? schedule.category
-              : schedule.category.replace('category_', ''),
-          enable: schedule.enable,
-          function: {
-            code: schedule.functions[0].code,
-            value: schedule.functions[0].value,
-          },
-          time: schedule.time,
-          schedule_id: schedule.timer_id,
-          timezone_id: schedule.timezone_id,
-          days: getEnabledDays(schedule.loops),
-        };
-      });
-      return convertKeysToCamelCase(result);
-    } catch (error) {
-      throw new HttpException(
-        error.message || 'Error While Adding Schedule',
-        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
-  async getScheduleDeviceInTuya(
-    deviceId: string,
-    category: string,
-  ): Promise<getDeviceScheduleInterface> {
-    try {
-      const path = `/v2.0/cloud/timer/device/${deviceId}?category=category_${category}`;
-      const response = await this.tuya.request({
-        method: 'GET',
-        path,
-      });
-
-      return response as getDeviceScheduleInterface;
-    } catch (error) {
-      console.error('Error fetching device schedule from Tuya:', error);
-
-      throw new HttpException(
-        'Error fetching device schedule from Tuya',
-        HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
-  async getDeviceByDeviceUuid(
-    deviceUuid: string,
-    withProductDevice: boolean = true,
-  ) {
-    return await this.deviceRepository.findOne({
-      where: {
-        uuid: deviceUuid,
-        isActive: true,
-      },
-      ...(withProductDevice && { relations: ['productDevice'] }),
-    });
-  }
-  async updateDeviceSchedule(
-    deviceUuid: string,
-    updateScheduleDto: UpdateScheduleDto,
-  ) {
-    try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
-
-      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
-        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
-      }
-
-      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
-      if (
-        deviceDetails.productDevice.prodType !== ProductType.THREE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_G &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_G &&
-        deviceDetails.productDevice.prodType !== ProductType.WH &&
-        deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
-        deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
-        deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
-        deviceDetails.productDevice.prodType !== ProductType.GD &&
-        deviceDetails.productDevice.prodType !== ProductType.CUR_2
-      ) {
-        throw new HttpException(
-          'This device is not supported for schedule',
-          HttpStatus.BAD_REQUEST,
-        );
-      }
-      await this.updateScheduleDeviceInTuya(
-        deviceDetails.deviceTuyaUuid,
-        updateScheduleDto,
-        deviceDetails.productDevice.prodType as ProductType,
-      );
-    } catch (error) {
-      throw new HttpException(
-        error.message || 'Error While Updating Schedule',
-        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
-  async updateScheduleDeviceInTuya(
-    deviceId: string,
-    updateScheduleDto: UpdateScheduleDto,
-    deviceType: ProductType,
-  ): Promise<addScheduleDeviceInterface> {
-    try {
-      const convertedTime = convertTimestampToDubaiTime(updateScheduleDto.time);
-      const loops = getScheduleStatus(updateScheduleDto.days);
-
-      const path = `/v2.0/cloud/timer/device/${deviceId}`;
-      const response = await this.tuya.request({
-        method: 'PUT',
-        path,
-        body: {
-          timer_id: updateScheduleDto.scheduleId,
-          time: convertedTime.time,
-          timezone_id: 'Asia/Dubai',
-          loops: `${loops}`,
-          functions: [
-            {
-              code: updateScheduleDto.function.code,
-              value: updateScheduleDto.function.value,
-            },
-          ],
-          category:
-            deviceType == ProductType.CUR_2
-              ? updateScheduleDto.category
-              : `category_${updateScheduleDto.category.replace('category_', '')}`,
-        },
-      });
-
-      return response as addScheduleDeviceInterface;
-    } catch (error) {
-      throw new HttpException(
-        'Error updating schedule from Tuya',
-        HttpStatus.INTERNAL_SERVER_ERROR,
+        'This device is not supported for schedule',
+        HttpStatus.BAD_REQUEST,
       );
     }
   }

src/scheduler/scheduler.module.ts

@@ -0,0 +1,25 @@
+import { DatabaseModule } from '@app/common/database/database.module';
+import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service';
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { SchedulerService } from './scheduler.service';
+import { ScheduleModule as NestScheduleModule } from '@nestjs/schedule';
+import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
+import { OccupancyService } from '@app/common/helper/services/occupancy.service';
+import { PowerClampService } from '@app/common/helper/services/power.clamp.service';
+
+@Module({
+  imports: [
+    NestScheduleModule.forRoot(),
+    TypeOrmModule.forFeature([]),
+    DatabaseModule,
+  ],
+  providers: [
+    SchedulerService,
+    SqlLoaderService,
+    PowerClampService,
+    OccupancyService,
+    AqiDataService,
+  ],
+})
+export class SchedulerModule {}

src/scheduler/scheduler.service.ts

@@ -0,0 +1,92 @@
+import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
+import { Injectable } from '@nestjs/common';
+import { Cron, CronExpression } from '@nestjs/schedule';
+import { OccupancyService } from '@app/common/helper/services/occupancy.service';
+import { PowerClampService } from '@app/common/helper/services/power.clamp.service';
+
+@Injectable()
+export class SchedulerService {
+  constructor(
+    private readonly powerClampService: PowerClampService,
+    private readonly occupancyService: OccupancyService,
+    private readonly aqiDataService: AqiDataService,
+  ) {
+    console.log('SchedulerService initialized!');
+  }
+
+  @Cron(CronExpression.EVERY_HOUR)
+  async runHourlyProcedures() {
+    console.log('\n======== Starting Procedures ========');
+    console.log(new Date().toISOString(), 'Scheduler running...');
+
+    try {
+      const results = await Promise.allSettled([
+        this.executeTask(
+          () => this.powerClampService.updateEnergyConsumedHistoricalData(),
+          'Energy Consumption',
+        ),
+        this.executeTask(
+          () => this.occupancyService.updateOccupancyDataProcedures(),
+          'Occupancy Data',
+        ),
+        this.executeTask(
+          () => this.aqiDataService.updateAQISensorHistoricalData(),
+          'AQI Data',
+        ),
+      ]);
+
+      this.logResults(results);
+    } catch (error) {
+      console.error('MAIN SCHEDULER ERROR:', error);
+      if (error.stack) {
+        console.error('Error stack:', error.stack);
+      }
+    }
+  }
+
+  private async executeTask(
+    task: () => Promise<void>,
+    name: string,
+  ): Promise<{ name: string; status: string }> {
+    try {
+      console.log(`[${new Date().toISOString()}] Starting ${name} task...`);
+      await task();
+      console.log(
+        `[${new Date().toISOString()}] ${name} task completed successfully`,
+      );
+      return { name, status: 'success' };
+    } catch (error) {
+      console.error(
+        `[${new Date().toISOString()}] ${name} task failed:`,
+        error.message,
+      );
+      if (error.stack) {
+        console.error('Task error stack:', error.stack);
+      }
+      return { name, status: 'failed' };
+    }
+  }
+
+  private logResults(results: PromiseSettledResult<any>[]) {
+    const successCount = results.filter((r) => r.status === 'fulfilled').length;
+    const failedCount = results.length - successCount;
+
+    console.log('\n======== Task Results ========');
+    console.log(`Successful tasks: ${successCount}`);
+    console.log(`Failed tasks: ${failedCount}`);
+
+    if (failedCount > 0) {
+      console.log('\n======== Failed Tasks Details ========');
+      results.forEach((result, index) => {
+        if (result.status === 'rejected') {
+          console.error(`Task ${index + 1} failed:`, result.reason);
+          if (result.reason.stack) {
+            console.error('Error stack:', result.reason.stack);
+          }
+        }
+      });
+    }
+
+    console.log('\n======== Scheduler Completed ========\n');
+  }
+}

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

@@ -51,8 +51,12 @@ export class SubSpaceModelService {
       for (const [index, dto] of dtos.entries()) {
         const subspaceModel = savedSubspaces[index];
 
-        const processedTags = await this.tagService.processTags(
-          dto.tags,
+        const processedTags = await this.tagService.upsertTags(
+          dto.tags.map((tag) => ({
+            tagName: tag.name,
+            productUuid: tag.productUuid,
+            tagUuid: tag.uuid,
+          })),
           spaceModel.project.uuid,
           queryRunner,
         );

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

@@ -46,7 +46,6 @@ import { CommunityService } from 'src/community/services';
 import { DeviceService } from 'src/device/services';
 import { SceneService } from 'src/scene/services';
 import {
-  SpaceLinkService,
   SpaceService,
   SubspaceDeviceService,
   SubSpaceService,
@@ -64,6 +63,8 @@ import {
 import { SpaceModelService, SubSpaceModelService } from './services';
 import { SpaceModelProductAllocationService } from './services/space-model-product-allocation.service';
 import { SubspaceModelProductAllocationService } from './services/subspace/subspace-model-product-allocation.service';
+import { PresenceSensorDailySpaceRepository } from '@app/common/modules/presence-sensor/repositories';
+import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/repositories';
 
 const CommandHandlers = [
   PropogateUpdateSpaceModelHandler,
@@ -92,7 +93,6 @@ const CommandHandlers = [
     DeviceRepository,
     TuyaService,
     CommunityRepository,
-    SpaceLinkService,
     SpaceLinkRepository,
     InviteSpaceRepository,
     NewTagService,
@@ -122,6 +122,8 @@ const CommandHandlers = [
     SqlLoaderService,
     OccupancyService,
     AqiDataService,
+    PresenceSensorDailySpaceRepository,
+    AqiSpaceDailyPollutantStatsRepository,
   ],
   exports: [CqrsModule, SpaceModelService],
 })

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

@@ -3,7 +3,8 @@ import { ApiProperty } from '@nestjs/swagger';
 import { Type } from 'class-transformer';
 import {
   ArrayUnique,
-  IsBoolean,
+  IsArray,
+  IsMongoId,
   IsNotEmpty,
   IsNumber,
   IsOptional,
@@ -12,7 +13,7 @@ import {
   NotEquals,
   ValidateNested,
 } from 'class-validator';
-import { ProcessTagDto } from 'src/tags/dtos';
+import { CreateProductAllocationDto } from './create-product-allocation.dto';
 import { AddSubspaceDto } from './subspace';
 
 export class AddSpaceDto {
@@ -47,14 +48,6 @@ export class AddSpaceDto {
   @IsOptional()
   public icon?: string;
 
-  @ApiProperty({
-    description: 'Indicates whether the space is private or public',
-    example: false,
-    default: false,
-  })
-  @IsBoolean()
-  isPrivate: boolean;
-
   @ApiProperty({ description: 'X position on canvas', example: 120 })
   @IsNumber()
   x: number;
@@ -64,23 +57,19 @@ export class AddSpaceDto {
   y: number;
 
   @ApiProperty({
-    description: 'UUID of the Space',
+    description: 'UUID of the Space Model',
     example: 'd290f1ee-6c54-4b01-90e6-d701748f0851',
   })
-  @IsString()
+  @IsMongoId()
   @IsOptional()
   spaceModelUuid?: string;
 
-  @ApiProperty({ description: 'Y position on canvas', example: 200 })
-  @IsString()
-  @IsOptional()
-  direction?: string;
-
   @ApiProperty({
     description: 'List of subspaces included in the model',
     type: [AddSubspaceDto],
   })
   @IsOptional()
+  @IsArray()
   @ValidateNested({ each: true })
   @ArrayUnique((subspace) => subspace.subspaceName, {
     message(validationArguments) {
@@ -100,51 +89,21 @@ export class AddSpaceDto {
   subspaces?: AddSubspaceDto[];
 
   @ApiProperty({
-    description: 'List of tags associated with the space model',
-    type: [ProcessTagDto],
+    description: 'List of allocations associated with the space',
+    type: [CreateProductAllocationDto],
   })
+  @IsOptional()
+  @IsArray()
   @ValidateNested({ each: true })
-  @Type(() => ProcessTagDto)
-  tags?: ProcessTagDto[];
-}
+  @Type(() => CreateProductAllocationDto)
+  productAllocations?: CreateProductAllocationDto[];
 
-export class AddUserSpaceDto {
   @ApiProperty({
-    description: 'spaceUuid',
-    required: true,
+    description: 'List of children spaces associated with the space',
+    type: [AddSpaceDto],
   })
-  @IsString()
-  @IsNotEmpty()
-  public spaceUuid: string;
-  @ApiProperty({
-    description: 'userUuid',
-    required: true,
-  })
-  @IsString()
-  @IsNotEmpty()
-  public userUuid: string;
-  constructor(dto: Partial<AddUserSpaceDto>) {
-    Object.assign(this, dto);
-  }
-}
-
-export class AddUserSpaceUsingCodeDto {
-  @ApiProperty({
-    description: 'userUuid',
-    required: true,
-  })
-  @IsString()
-  @IsNotEmpty()
-  public userUuid: string;
-  @ApiProperty({
-    description: 'inviteCode',
-    required: true,
-  })
-  @IsString()
-  @IsNotEmpty()
-  public inviteCode: string;
-
-  constructor(dto: Partial<AddUserSpaceDto>) {
-    Object.assign(this, dto);
-  }
+  @IsOptional()
+  @ValidateNested({ each: true })
+  @Type(() => AddSpaceDto)
+  children?: AddSpaceDto[];
 }

src/space/dtos/create-allocations.dto.ts

@@ -1,14 +1,14 @@
 import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
 import { SubspaceEntity } from '@app/common/modules/space/entities/subspace/subspace.entity';
-import { ProcessTagDto } from 'src/tags/dtos';
 import { QueryRunner } from 'typeorm';
+import { CreateProductAllocationDto } from './create-product-allocation.dto';
 
 export enum AllocationsOwnerType {
   SPACE = 'space',
   SUBSPACE = 'subspace',
 }
 export class BaseCreateAllocationsDto {
-  tags: ProcessTagDto[];
+  productAllocations: CreateProductAllocationDto[];
   projectUuid: string;
   queryRunner: QueryRunner;
   type: AllocationsOwnerType;

src/space/dtos/create-product-allocation.dto.ts

@@ -0,0 +1,36 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+  ValidateIf,
+} from 'class-validator';
+
+export class CreateProductAllocationDto {
+  @ApiProperty({
+    description: 'The name of the tag (if creating a new tag)',
+    example: 'New Tag',
+  })
+  @IsString()
+  @IsNotEmpty()
+  @ValidateIf((o) => !o.tagUuid)
+  tagName: string;
+
+  @ApiProperty({
+    description: 'UUID of the tag (if selecting an existing tag)',
+    example: '123e4567-e89b-12d3-a456-426614174000',
+  })
+  @IsUUID()
+  @IsNotEmpty()
+  @ValidateIf((o) => !o.tagName)
+  tagUuid: string;
+
+  @ApiProperty({
+    description: 'UUID of the product',
+    example: '550e8400-e29b-41d4-a716-446655440000',
+  })
+  @IsUUID()
+  @IsOptional()
+  productUuid: string;
+}

src/space/dtos/index.ts

@@ -1,8 +1,10 @@
 export * from './add.space.dto';
 export * from './community-space.param';
+export * from './create-allocations.dto';
+export * from './create-product-allocation.dto';
 export * from './get.space.param';
-export * from './user-space.param';
-export * from './subspace';
 export * from './project.param.dto';
-export * from './update.space.dto';
+export * from './subspace';
 export * from './tag';
+export * from './update.space.dto';
+export * from './user-space.param';

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

@@ -1,4 +1,5 @@
 import { ApiProperty } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
 import {
   IsArray,
   IsNotEmpty,
@@ -6,8 +7,8 @@ import {
   IsString,
   ValidateNested,
 } from 'class-validator';
-import { Type } from 'class-transformer';
 import { ProcessTagDto } from 'src/tags/dtos';
+import { CreateProductAllocationDto } from '../create-product-allocation.dto';
 
 export class AddSubspaceDto {
   @ApiProperty({
@@ -24,7 +25,7 @@ export class AddSubspaceDto {
   })
   @IsArray()
   @ValidateNested({ each: true })
-  @Type(() => ProcessTagDto)
+  @Type(() => CreateProductAllocationDto)
   @IsOptional()
-  tags?: ProcessTagDto[];
+  productAllocations?: CreateProductAllocationDto[];
 }

src/space/dtos/subspace/index.ts

@@ -1,6 +1,5 @@
-export * from './add.subspace.dto';
-export * from './get.subspace.param';
 export * from './add.subspace-device.param';
-export * from './update.subspace.dto';
+export * from './add.subspace.dto';
 export * from './delete.subspace.dto';
-export * from './modify.subspace.dto';
+export * from './get.subspace.param';
+export * from './update.subspace.dto';

src/space/dtos/subspace/modify.subspace.dto.ts

@@ -1,14 +0,0 @@
-import { ApiPropertyOptional, PartialType } from '@nestjs/swagger';
-import { IsOptional, IsUUID } from 'class-validator';
-import { AddSubspaceDto } from './add.subspace.dto';
-
-export class ModifySubspaceDto extends PartialType(AddSubspaceDto) {
-  @ApiPropertyOptional({
-    description:
-      'UUID of the subspace (will present if updating an existing subspace)',
-    example: '123e4567-e89b-12d3-a456-426614174000',
-  })
-  @IsOptional()
-  @IsUUID()
-  uuid?: string;
-}

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

@@ -1,16 +1,14 @@
-import { ApiProperty } from '@nestjs/swagger';
-import { IsNotEmpty, IsString } from 'class-validator';
+import { ApiPropertyOptional, PartialType } from '@nestjs/swagger';
+import { IsOptional, IsUUID } from 'class-validator';
+import { AddSubspaceDto } from './add.subspace.dto';
 
-export class UpdateSubspaceDto {
-  @ApiProperty({
-    description: 'Name of the subspace',
-    example: 'Living Room',
+export class UpdateSubspaceDto extends PartialType(AddSubspaceDto) {
+  @ApiPropertyOptional({
+    description:
+      'UUID of the subspace (will present if updating an existing subspace)',
+    example: '123e4567-e89b-12d3-a456-426614174000',
   })
-  @IsNotEmpty()
-  @IsString()
-  subspaceName?: string;
-
-  @IsNotEmpty()
-  @IsString()
-  subspaceUuid: string;
+  @IsOptional()
+  @IsUUID()
+  uuid?: string;
 }

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

@@ -9,8 +9,8 @@ import {
   NotEquals,
   ValidateNested,
 } from 'class-validator';
-import { ModifySubspaceDto } from './subspace';
-import { ModifyTagDto } from './tag/modify-tag.dto';
+import { CreateProductAllocationDto } from './create-product-allocation.dto';
+import { UpdateSubspaceDto } from './subspace';
 
 export class UpdateSpaceDto {
   @ApiProperty({
@@ -46,25 +46,24 @@ export class UpdateSpaceDto {
   y?: number;
 
   @ApiPropertyOptional({
-    description: 'List of subspace modifications (add/update/delete)',
-    type: [ModifySubspaceDto],
+    description: 'List of subspace modifications',
+    type: [UpdateSubspaceDto],
   })
   @IsOptional()
   @IsArray()
   @ValidateNested({ each: true })
-  @Type(() => ModifySubspaceDto)
-  subspaces?: ModifySubspaceDto[];
+  @Type(() => UpdateSubspaceDto)
+  subspaces?: UpdateSubspaceDto[];
 
   @ApiPropertyOptional({
-    description:
-      'List of tag modifications (add/update/delete) for the space model',
-    type: [ModifyTagDto],
+    description: 'List of allocations modifications',
+    type: [CreateProductAllocationDto],
   })
   @IsOptional()
   @IsArray()
   @ValidateNested({ each: true })
-  @Type(() => ModifyTagDto)
-  tags?: ModifyTagDto[];
+  @Type(() => CreateProductAllocationDto)
+  productAllocations?: CreateProductAllocationDto[];
 
   @ApiProperty({
     description: 'UUID of the Space',

src/space/handlers/disable-space.handler.ts

@@ -5,11 +5,7 @@ import { DeviceService } from 'src/device/services';
 import { UserSpaceService } from 'src/users/services';
 import { DataSource } from 'typeorm';
 import { DisableSpaceCommand } from '../commands';
-import {
-  SpaceLinkService,
-  SpaceSceneService,
-  SubSpaceService,
-} from '../services';
+import { SpaceSceneService, SubSpaceService } from '../services';
 
 @CommandHandler(DisableSpaceCommand)
 export class DisableSpaceHandler
@@ -19,7 +15,6 @@ export class DisableSpaceHandler
     private readonly subSpaceService: SubSpaceService,
     private readonly userService: UserSpaceService,
     private readonly deviceService: DeviceService,
-    private readonly spaceLinkService: SpaceLinkService,
     private readonly sceneService: SpaceSceneService,
     private readonly dataSource: DataSource,
   ) {}
@@ -39,8 +34,6 @@ export class DisableSpaceHandler
           'subspaces',
           'parent',
           'devices',
-          'outgoingConnections',
-          'incomingConnections',
           'scenes',
           'children',
           'userSpaces',
@@ -79,7 +72,6 @@ export class DisableSpaceHandler
           orphanSpace,
           queryRunner,
         ),
-        this.spaceLinkService.deleteSpaceLink(space, queryRunner),
         this.sceneService.deleteScenes(space, queryRunner),
       ];
 

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

@@ -16,10 +16,10 @@ export class ProductAllocationService {
   ) {}
 
   async createAllocations(dto: CreateAllocationsDto): Promise<void> {
-    const { projectUuid, queryRunner, tags, type } = dto;
+    const { projectUuid, queryRunner, productAllocations, type } = dto;
 
-    const allocationsData = await this.tagService.processTags(
-      tags,
+    const allocationsData = await this.tagService.upsertTags(
+      productAllocations,
       projectUuid,
       queryRunner,
     );
@@ -29,15 +29,17 @@ export class ProductAllocationService {
     const createdTagsByName = new Map(allocationsData.map((t) => [t.name, t]));
 
     // Create the product-tag mapping based on the processed tags
-    const productTagMapping = tags.map(({ uuid, name, productUuid }) => {
-      const inputTag = uuid
-        ? createdTagsByUUID.get(uuid)
-        : createdTagsByName.get(name);
-      return {
-        tag: inputTag?.uuid,
-        product: productUuid,
-      };
-    });
+    const productTagMapping = productAllocations.map(
+      ({ tagUuid, tagName, productUuid }) => {
+        const inputTag = tagUuid
+          ? createdTagsByUUID.get(tagUuid)
+          : createdTagsByName.get(tagName);
+        return {
+          tag: inputTag?.uuid,
+          product: productUuid,
+        };
+      },
+    );
 
     switch (type) {
       case AllocationsOwnerType.SPACE: {

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

@@ -1,121 +1,6 @@
-import { SpaceLinkEntity } from '@app/common/modules/space/entities/space-link.entity';
-import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
-import { SpaceLinkRepository } from '@app/common/modules/space/repositories';
-import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
-import { QueryRunner } from 'typeorm';
+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 {
-  constructor(private readonly spaceLinkRepository: SpaceLinkRepository) {}
-
-  async saveSpaceLink(
-    startSpaceId: string,
-    endSpaceId: string,
-    direction: string,
-    queryRunner: QueryRunner,
-  ): Promise<void> {
-    try {
-      // Check if a link between the startSpace and endSpace already exists
-      const existingLink = await queryRunner.manager.findOne(SpaceLinkEntity, {
-        where: {
-          startSpace: { uuid: startSpaceId },
-          endSpace: { uuid: endSpaceId },
-          disabled: false,
-        },
-      });
-
-      if (existingLink) {
-        // Update the direction if the link exists
-        existingLink.direction = direction;
-        await queryRunner.manager.save(SpaceLinkEntity, existingLink);
-        return;
-      }
-
-      const existingEndSpaceLink = await queryRunner.manager.findOne(
-        SpaceLinkEntity,
-        {
-          where: { endSpace: { uuid: endSpaceId } },
-        },
-      );
-
-      if (
-        existingEndSpaceLink &&
-        existingEndSpaceLink.startSpace.uuid !== startSpaceId
-      ) {
-        throw new Error(
-          `Space with ID ${endSpaceId} is already an endSpace in another link and cannot be reused.`,
-        );
-      }
-
-      // Find start space
-      const startSpace = await queryRunner.manager.findOne(SpaceEntity, {
-        where: { uuid: startSpaceId },
-      });
-
-      if (!startSpace) {
-        throw new HttpException(
-          `Start space with ID ${startSpaceId} not found.`,
-          HttpStatus.NOT_FOUND,
-        );
-      }
-
-      // Find end space
-      const endSpace = await queryRunner.manager.findOne(SpaceEntity, {
-        where: { uuid: endSpaceId },
-      });
-
-      if (!endSpace) {
-        throw new HttpException(
-          `End space with ID ${endSpaceId} not found.`,
-          HttpStatus.NOT_FOUND,
-        );
-      }
-
-      // Create and save the space link
-      const spaceLink = this.spaceLinkRepository.create({
-        startSpace,
-        endSpace,
-        direction,
-      });
-
-      await queryRunner.manager.save(SpaceLinkEntity, spaceLink);
-    } catch (error) {
-      throw new HttpException(
-        error.message ||
-          `Failed to save space link. Internal Server Error: ${error.message}`,
-        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
-  async deleteSpaceLink(
-    space: SpaceEntity,
-    queryRunner: QueryRunner,
-  ): Promise<void> {
-    try {
-      const spaceLinks = await queryRunner.manager.find(SpaceLinkEntity, {
-        where: [
-          { startSpace: space, disabled: false },
-          { endSpace: space, disabled: false },
-        ],
-      });
-
-      if (spaceLinks.length === 0) {
-        return;
-      }
-
-      const linkIds = spaceLinks.map((link) => link.uuid);
-
-      await queryRunner.manager
-        .createQueryBuilder()
-        .update(SpaceLinkEntity)
-        .set({ disabled: true })
-        .whereInIds(linkIds)
-        .execute();
-    } catch (error) {
-      throw new HttpException(
-        `Failed to disable space links for the given space: ${error.message}`,
-        HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
-}
+export class SpaceLinkService {}

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

@@ -16,7 +16,7 @@ import {
   Inject,
   Injectable,
 } from '@nestjs/common';
-import { In } from 'typeorm';
+import { In, QueryRunner } from 'typeorm';
 import { CommunityService } from '../../community/services';
 import { ProjectService } from '../../project/services';
 import { ProjectParam } from '../dtos';
@@ -69,12 +69,17 @@ export class ValidationService {
   async validateCommunityAndProject(
     communityUuid: string,
     projectUuid: string,
+    queryRunner?: QueryRunner,
   ) {
-    const project = await this.projectService.findOne(projectUuid);
-    const community = await this.communityService.getCommunityById({
-      communityUuid,
-      projectUuid,
-    });
+    const project = await this.projectService.findOne(projectUuid, queryRunner);
+
+    const community = await this.communityService.getCommunityById(
+      {
+        communityUuid,
+        projectUuid,
+      },
+      queryRunner,
+    );
 
     return { community: community.data, project: project };
   }
@@ -170,8 +175,14 @@ export class ValidationService {
     return space;
   }
 
-  async validateSpaceModel(spaceModelUuid: string): Promise<SpaceModelEntity> {
-    const queryBuilder = this.spaceModelRepository
+  async validateSpaceModel(
+    spaceModelUuid: string,
+    queryRunner?: QueryRunner,
+  ): Promise<SpaceModelEntity> {
+    const queryBuilder = (
+      queryRunner.manager.getRepository(SpaceModelEntity) ||
+      this.spaceModelRepository
+    )
       .createQueryBuilder('spaceModel')
       .leftJoinAndSelect(
         'spaceModel.subspaceModels',

src/space/services/space.service.ts

@@ -22,7 +22,6 @@ import {
 import { CommandBus } from '@nestjs/cqrs';
 import { DeviceService } from 'src/device/services';
 import { SpaceModelService } from 'src/space-model/services';
-import { ProcessTagDto } from 'src/tags/dtos';
 import { TagService } from 'src/tags/services/tags.service';
 import { DataSource, In, Not, QueryRunner } from 'typeorm';
 import { DisableSpaceCommand } from '../commands';
@@ -32,9 +31,9 @@ import {
   GetSpaceParam,
   UpdateSpaceDto,
 } from '../dtos';
+import { CreateProductAllocationDto } from '../dtos/create-product-allocation.dto';
 import { GetSpaceDto } from '../dtos/get.space.dto';
 import { SpaceWithParentsDto } from '../dtos/space.parents.dto';
-import { SpaceLinkService } from './space-link';
 import { SpaceProductAllocationService } from './space-product-allocation.service';
 import { ValidationService } from './space-validation.service';
 import { SubSpaceService } from './subspace';
@@ -44,7 +43,6 @@ export class SpaceService {
     private readonly dataSource: DataSource,
     private readonly spaceRepository: SpaceRepository,
     private readonly inviteSpaceRepository: InviteSpaceRepository,
-    private readonly spaceLinkService: SpaceLinkService,
     private readonly subSpaceService: SubSpaceService,
     private readonly validationService: ValidationService,
     private readonly tagService: TagService,
@@ -57,50 +55,72 @@ export class SpaceService {
   async createSpace(
     addSpaceDto: AddSpaceDto,
     params: CommunitySpaceParam,
+    queryRunner?: QueryRunner,
+    recursiveCallParentEntity?: SpaceEntity,
   ): Promise<BaseResponseDto> {
-    const { parentUuid, direction, spaceModelUuid, subspaces, tags } =
-      addSpaceDto;
+    const isRecursiveCall = !!queryRunner;
+
+    const {
+      parentUuid,
+      spaceModelUuid,
+      subspaces,
+      productAllocations,
+      children,
+    } = addSpaceDto;
     const { communityUuid, projectUuid } = params;
 
-    const queryRunner = this.dataSource.createQueryRunner();
-
-    await queryRunner.connect();
-    await queryRunner.startTransaction();
+    if (!queryRunner) {
+      queryRunner = this.dataSource.createQueryRunner();
+      await queryRunner.connect();
+      await queryRunner.startTransaction();
+    }
 
     const { community } =
       await this.validationService.validateCommunityAndProject(
         communityUuid,
         projectUuid,
+        queryRunner,
       );
 
-    this.validateSpaceCreationCriteria({ spaceModelUuid, subspaces, tags });
+    this.validateSpaceCreationCriteria({
+      spaceModelUuid,
+      subspaces,
+      productAllocations,
+    });
 
-    const parent = parentUuid
-      ? await this.validationService.validateSpace(parentUuid)
-      : null;
+    const parent =
+      parentUuid && !isRecursiveCall
+        ? await this.validationService.validateSpace(parentUuid)
+        : null;
 
     const spaceModel = spaceModelUuid
       ? await this.validationService.validateSpaceModel(spaceModelUuid)
       : null;
-
     try {
       const space = queryRunner.manager.create(SpaceEntity, {
-        ...addSpaceDto,
+        // todo: find a better way to handle this instead of naming every key
+        spaceName: addSpaceDto.spaceName,
+        icon: addSpaceDto.icon,
+        x: addSpaceDto.x,
+        y: addSpaceDto.y,
         spaceModel,
-        parent: parentUuid ? parent : null,
+        parent: isRecursiveCall
+          ? recursiveCallParentEntity
+          : parentUuid
+            ? parent
+            : null,
         community,
       });
 
       const newSpace = await queryRunner.manager.save(space);
-
-      const subspaceTags =
-        subspaces?.flatMap((subspace) => subspace.tags || []) || [];
-
-      this.checkDuplicateTags([...tags, ...subspaceTags]);
+      this.checkDuplicateTags([
+        ...(productAllocations || []),
+        ...(subspaces?.flatMap(
+          (subspace) => subspace.productAllocations || [],
+        ) || []),
+      ]);
 
       if (spaceModelUuid) {
-        // no need to check for existing dependencies here as validateSpaceCreationCriteria
-        // ensures no tags or subspaces are present along with spaceModelUuid
         await this.spaceModelService.linkToSpace(
           newSpace,
           spaceModel,
@@ -109,15 +129,6 @@ export class SpaceService {
       }
 
       await Promise.all([
-        // todo: remove this logic as we are not using space links anymore
-        direction && parent
-          ? this.spaceLinkService.saveSpaceLink(
-              parent.uuid,
-              newSpace.uuid,
-              direction,
-              queryRunner,
-            )
-          : Promise.resolve(),
         subspaces?.length
           ? this.subSpaceService.createSubspacesFromDto(
               subspaces,
@@ -126,12 +137,32 @@ export class SpaceService {
               projectUuid,
             )
           : Promise.resolve(),
-        tags?.length
-          ? this.createAllocations(tags, projectUuid, queryRunner, newSpace)
+        productAllocations?.length
+          ? this.createAllocations(
+              productAllocations,
+              projectUuid,
+              queryRunner,
+              newSpace,
+            )
           : Promise.resolve(),
       ]);
 
-      await queryRunner.commitTransaction();
+      if (children?.length) {
+        await Promise.all(
+          children.map((child) =>
+            this.createSpace(
+              { ...child, parentUuid: newSpace.uuid },
+              { communityUuid, projectUuid },
+              queryRunner,
+              newSpace,
+            ),
+          ),
+        );
+      }
+
+      if (!isRecursiveCall) {
+        await queryRunner.commitTransaction();
+      }
 
       return new SuccessResponseDto({
         statusCode: HttpStatus.CREATED,
@@ -139,34 +170,34 @@ export class SpaceService {
         message: 'Space created successfully',
       });
     } catch (error) {
-      await queryRunner.rollbackTransaction();
+      !isRecursiveCall ? await queryRunner.rollbackTransaction() : null;
 
       if (error instanceof HttpException) {
         throw error;
       }
       throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
     } finally {
-      await queryRunner.release();
+      !isRecursiveCall ? await queryRunner.release() : null;
     }
   }
-  private checkDuplicateTags(allTags: ProcessTagDto[]) {
+  private checkDuplicateTags(allocations: CreateProductAllocationDto[]) {
     const tagUuidSet = new Set<string>();
     const tagNameProductSet = new Set<string>();
 
-    for (const tag of allTags) {
-      if (tag.uuid) {
-        if (tagUuidSet.has(tag.uuid)) {
+    for (const allocation of allocations) {
+      if (allocation.tagUuid) {
+        if (tagUuidSet.has(allocation.tagUuid)) {
           throw new HttpException(
-            `Duplicate tag UUID found: ${tag.uuid}`,
+            `Duplicate tag UUID found: ${allocation.tagUuid}`,
             HttpStatus.BAD_REQUEST,
           );
         }
-        tagUuidSet.add(tag.uuid);
+        tagUuidSet.add(allocation.tagUuid);
       } else {
-        const tagKey = `${tag.name}-${tag.productUuid}`;
+        const tagKey = `${allocation.tagName}-${allocation.productUuid}`;
         if (tagNameProductSet.has(tagKey)) {
           throw new HttpException(
-            `Duplicate tag found with name "${tag.name}" and product "${tag.productUuid}".`,
+            `Duplicate tag found with name "${allocation.tagName}" and product "${allocation.productUuid}".`,
             HttpStatus.BAD_REQUEST,
           );
         }
@@ -195,12 +226,7 @@ export class SpaceService {
           'children.disabled = :disabled',
           { disabled: false },
         )
-        .leftJoinAndSelect(
-          'space.incomingConnections',
-          'incomingConnections',
-          'incomingConnections.disabled = :incomingConnectionDisabled',
-          { incomingConnectionDisabled: false },
-        )
+
         .leftJoinAndSelect('space.productAllocations', 'productAllocations')
         .leftJoinAndSelect('productAllocations.tag', 'tag')
         .leftJoinAndSelect('productAllocations.product', 'product')
@@ -271,7 +297,6 @@ export class SpaceService {
     }
   }
 
-  // todo refactor this method to eliminate wrong use of tags
   async findOne(params: GetSpaceParam): Promise<BaseResponseDto> {
     const { communityUuid, spaceUuid, projectUuid } = params;
     try {
@@ -282,19 +307,6 @@ export class SpaceService {
 
       const queryBuilder = this.spaceRepository
         .createQueryBuilder('space')
-        .leftJoinAndSelect('space.parent', 'parent')
-        .leftJoinAndSelect(
-          'space.children',
-          'children',
-          'children.disabled = :disabled',
-          { disabled: false },
-        )
-        .leftJoinAndSelect(
-          'space.incomingConnections',
-          'incomingConnections',
-          'incomingConnections.disabled = :incomingConnectionDisabled',
-          { incomingConnectionDisabled: false },
-        )
         .leftJoinAndSelect('space.productAllocations', 'productAllocations')
         .leftJoinAndSelect('productAllocations.tag', 'spaceTag')
         .leftJoinAndSelect('productAllocations.product', 'spaceProduct')
@@ -321,7 +333,12 @@ export class SpaceService {
         .andWhere('space.disabled = :disabled', { disabled: false });
 
       const space = await queryBuilder.getOne();
-
+      if (!space) {
+        throw new HttpException(
+          `Space with ID ${spaceUuid} not found`,
+          HttpStatus.NOT_FOUND,
+        );
+      }
       return new SuccessResponseDto({
         message: `Space with ID ${spaceUuid} successfully fetched`,
         data: space,
@@ -331,7 +348,7 @@ export class SpaceService {
         throw error; // If it's an HttpException, rethrow it
       } else {
         throw new HttpException(
-          'An error occurred while deleting the community',
+          'An error occurred while fetching the space',
           HttpStatus.INTERNAL_SERVER_ERROR,
         );
       }
@@ -423,7 +440,7 @@ export class SpaceService {
 
     const queryRunner = this.dataSource.createQueryRunner();
     const hasSubspace = updateSpaceDto.subspaces?.length > 0;
-    const hasTags = updateSpaceDto.tags?.length > 0;
+    const hasAllocations = updateSpaceDto.productAllocations?.length > 0;
 
     try {
       await queryRunner.connect();
@@ -448,7 +465,7 @@ export class SpaceService {
 
       await this.updateSpaceProperties(space, updateSpaceDto, queryRunner);
 
-      if (hasSubspace || hasTags) {
+      if (hasSubspace || hasAllocations) {
         await queryRunner.manager.update(SpaceEntity, space.uuid, {
           spaceModel: null,
         });
@@ -492,7 +509,7 @@ export class SpaceService {
         await this.subSpaceService.unlinkModels(space.subspaces, queryRunner);
       }
 
-      if (hasTags && space.productAllocations && space.spaceModel) {
+      if (hasAllocations && space.productAllocations && space.spaceModel) {
         await this.spaceProductAllocationService.unlinkModels(
           space,
           queryRunner,
@@ -508,13 +525,13 @@ export class SpaceService {
         );
       }
 
-      if (updateSpaceDto.tags) {
+      if (updateSpaceDto.productAllocations) {
         await queryRunner.manager.delete(SpaceProductAllocationEntity, {
           space: { uuid: space.uuid },
           tag: {
             uuid: Not(
               In(
-                updateSpaceDto.tags
+                updateSpaceDto.productAllocations
                   .filter((tag) => tag.tagUuid)
                   .map((tag) => tag.tagUuid),
               ),
@@ -522,11 +539,7 @@ export class SpaceService {
           },
         });
         await this.createAllocations(
-          updateSpaceDto.tags.map((tag) => ({
-            name: tag.name,
-            uuid: tag.tagUuid,
-            productUuid: tag.productUuid,
-          })),
+          updateSpaceDto.productAllocations,
           projectUuid,
           queryRunner,
           space,
@@ -673,7 +686,7 @@ export class SpaceService {
     }
   }
 
-  private buildSpaceHierarchy(spaces: SpaceEntity[]): SpaceEntity[] {
+  buildSpaceHierarchy(spaces: SpaceEntity[]): SpaceEntity[] {
     const map = new Map<string, SpaceEntity>();
 
     // Step 1: Create a map of spaces by UUID
@@ -702,13 +715,17 @@ export class SpaceService {
 
   private validateSpaceCreationCriteria({
     spaceModelUuid,
-    tags,
+    productAllocations,
     subspaces,
-  }: Pick<AddSpaceDto, 'spaceModelUuid' | 'tags' | 'subspaces'>): void {
-    const hasTagsOrSubspaces =
-      (tags && tags.length > 0) || (subspaces && subspaces.length > 0);
+  }: Pick<
+    AddSpaceDto,
+    'spaceModelUuid' | 'productAllocations' | 'subspaces'
+  >): void {
+    const hasProductsOrSubspaces =
+      (productAllocations && productAllocations.length > 0) ||
+      (subspaces && subspaces.length > 0);
 
-    if (spaceModelUuid && hasTagsOrSubspaces) {
+    if (spaceModelUuid && hasProductsOrSubspaces) {
       throw new HttpException(
         'For space creation choose either space model or products and subspace',
         HttpStatus.CONFLICT,
@@ -717,13 +734,13 @@ export class SpaceService {
   }
 
   private async createAllocations(
-    tags: ProcessTagDto[],
+    productAllocations: CreateProductAllocationDto[],
     projectUuid: string,
     queryRunner: QueryRunner,
     space: SpaceEntity,
   ): Promise<void> {
-    const allocationsData = await this.tagService.processTags(
-      tags,
+    const allocationsData = await this.tagService.upsertTags(
+      productAllocations,
       projectUuid,
       queryRunner,
     );
@@ -733,15 +750,17 @@ export class SpaceService {
     const createdTagsByName = new Map(allocationsData.map((t) => [t.name, t]));
 
     // Create the product-tag mapping based on the processed tags
-    const productTagMapping = tags.map(({ uuid, name, productUuid }) => {
-      const inputTag = uuid
-        ? createdTagsByUUID.get(uuid)
-        : createdTagsByName.get(name);
-      return {
-        tag: inputTag?.uuid,
-        product: productUuid,
-      };
-    });
+    const productTagMapping = productAllocations.map(
+      ({ tagUuid, tagName, productUuid }) => {
+        const inputTag = tagUuid
+          ? createdTagsByUUID.get(tagUuid)
+          : createdTagsByName.get(tagName);
+        return {
+          tag: inputTag?.uuid,
+          product: productUuid,
+        };
+      },
+    );
 
     await this.spaceProductAllocationService.createProductAllocations(
       space,

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

@@ -3,7 +3,7 @@ import { SubspaceProductAllocationEntity } from '@app/common/modules/space/entit
 import { SubspaceEntity } from '@app/common/modules/space/entities/subspace/subspace.entity';
 import { SubspaceProductAllocationRepository } from '@app/common/modules/space/repositories/subspace.repository';
 import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
-import { UpdateSpaceAllocationDto } from 'src/space/interfaces/update-subspace-allocation.dto';
+import { UpdateSubspaceDto } from 'src/space/dtos';
 import { TagService as NewTagService } from 'src/tags/services';
 import { In, Not, QueryRunner } from 'typeorm';
 
@@ -60,31 +60,46 @@ export class SubspaceProductAllocationService {
   }
 
   async updateSubspaceProductAllocationsV2(
-    subSpaces: UpdateSpaceAllocationDto[],
+    subSpaces: UpdateSubspaceDto[],
     projectUuid: string,
     queryRunner: QueryRunner,
   ) {
     await Promise.all(
       subSpaces.map(async (subspace) => {
         await queryRunner.manager.delete(SubspaceProductAllocationEntity, {
-          subspace: { uuid: subspace.uuid },
-          tag: {
-            uuid: Not(
-              In(
-                subspace.tags.filter((tag) => tag.uuid).map((tag) => tag.uuid),
-              ),
-            ),
-          },
+          subspace: subspace.uuid ? { uuid: subspace.uuid } : undefined,
+          tag: subspace.productAllocations
+            ? {
+                uuid: Not(
+                  In(
+                    subspace.productAllocations
+                      .filter((allocation) => allocation.tagUuid)
+                      .map((allocation) => allocation.tagUuid),
+                  ),
+                ),
+              }
+            : undefined,
+          product: subspace.productAllocations
+            ? {
+                uuid: Not(
+                  In(
+                    subspace.productAllocations
+                      .filter((allocation) => allocation.productUuid)
+                      .map((allocation) => allocation.productUuid),
+                  ),
+                ),
+              }
+            : undefined,
         });
+
         const subspaceEntity = await queryRunner.manager.findOne(
           SubspaceEntity,
           {
             where: { uuid: subspace.uuid },
           },
         );
-
-        const processedTags = await this.tagService.processTags(
-          subspace.tags,
+        const processedTags = await this.tagService.upsertTags(
+          subspace.productAllocations,
           projectUuid,
           queryRunner,
         );
@@ -97,11 +112,11 @@ export class SubspaceProductAllocationService {
         );
 
         // Create the product-tag mapping based on the processed tags
-        const productTagMapping = subspace.tags.map(
-          ({ uuid, name, productUuid }) => {
-            const inputTag = uuid
-              ? createdTagsByUUID.get(uuid)
-              : createdTagsByName.get(name);
+        const productTagMapping = subspace.productAllocations.map(
+          ({ tagUuid, tagName, productUuid }) => {
+            const inputTag = tagUuid
+              ? createdTagsByUUID.get(tagUuid)
+              : createdTagsByName.get(tagName);
             return {
               tag: inputTag?.uuid,
               product: productUuid,
@@ -118,71 +133,6 @@ export class SubspaceProductAllocationService {
     );
   }
 
-  // async processDeleteActions(dtos: ModifyTagDto[], queryRunner: QueryRunner) {
-  //   // : Promise<SubspaceProductAllocationEntity[]>
-  //   try {
-  //     // if (!dtos || dtos.length === 0) {
-  //     //   throw new Error('No DTOs provided for deletion.');
-  //     // }
-  //     // const tagUuidsToDelete = dtos
-  //     //   .filter((dto) => dto.action === ModifyAction.DELETE && dto.tagUuid)
-  //     //   .map((dto) => dto.tagUuid);
-  //     // if (tagUuidsToDelete.length === 0) return [];
-  //     // const allocationsToUpdate = await queryRunner.manager.find(
-  //     //   SubspaceProductAllocationEntity,
-  //     //   {
-  //     //     where: { tag: In(tagUuidsToDelete) },
-  //     //   },
-  //     // );
-  //     // if (!allocationsToUpdate || allocationsToUpdate.length === 0) return [];
-  //     // const deletedAllocations: SubspaceProductAllocationEntity[] = [];
-  //     // const allocationUpdates: SubspaceProductAllocationEntity[] = [];
-  //     // for (const allocation of allocationsToUpdate) {
-  //     //   const updatedTags = allocation.tags.filter(
-  //     //     (tag) => !tagUuidsToDelete.includes(tag.uuid),
-  //     //   );
-  //     //   if (updatedTags.length === allocation.tags.length) {
-  //     //     continue;
-  //     //   }
-  //     //   if (updatedTags.length === 0) {
-  //     //     deletedAllocations.push(allocation);
-  //     //   } else {
-  //     //     allocation.tags = updatedTags;
-  //     //     allocationUpdates.push(allocation);
-  //     //   }
-  //     // }
-  //     // if (allocationUpdates.length > 0) {
-  //     //   await queryRunner.manager.save(
-  //     //     SubspaceProductAllocationEntity,
-  //     //     allocationUpdates,
-  //     //   );
-  //     // }
-  //     // if (deletedAllocations.length > 0) {
-  //     //   await queryRunner.manager.remove(
-  //     //     SubspaceProductAllocationEntity,
-  //     //     deletedAllocations,
-  //     //   );
-  //     // }
-  //     // await queryRunner.manager
-  //     //   .createQueryBuilder()
-  //     //   .delete()
-  //     //   .from('subspace_product_tags')
-  //     //   .where(
-  //     //     'subspace_product_allocation_uuid NOT IN ' +
-  //     //       queryRunner.manager
-  //     //         .createQueryBuilder()
-  //     //         .select('allocation.uuid')
-  //     //         .from(SubspaceProductAllocationEntity, 'allocation')
-  //     //         .getQuery() +
-  //     //       ')',
-  //     //   )
-  //     //   .execute();
-  //     // return deletedAllocations;
-  //   } catch (error) {
-  //     throw this.handleError(error, `Failed to delete tags in subspace`);
-  //   }
-  // }
-
   async unlinkModels(
     allocations: SubspaceProductAllocationEntity[],
     queryRunner: QueryRunner,
@@ -205,67 +155,6 @@ export class SubspaceProductAllocationService {
     }
   }
 
-  // private async validateTagWithinSubspace(
-  //   queryRunner: QueryRunner | undefined,
-  //   tag: NewTagEntity & { product: string },
-  //   subspace: SubspaceEntity,
-  //   spaceAllocationsToExclude?: SpaceProductAllocationEntity[],
-  // ): Promise<void> {
-  //   // const existingTagInSpace = await (queryRunner
-  //   //   ? queryRunner.manager.findOne(SpaceProductAllocationEntity, {
-  //   //       where: {
-  //   //         product: { uuid: tag.product },
-  //   //         space: { uuid: subspace.space.uuid },
-  //   //         tag: { uuid: tag.uuid },
-  //   //       },
-  //   //     })
-  //   //   : this.spaceProductAllocationRepository.findOne({
-  //   //       where: {
-  //   //         product: { uuid: tag.product },
-  //   //         space: { uuid: subspace.space.uuid },
-  //   //         tag: { uuid: tag.uuid },
-  //   //       },
-  //   //     }));
-  //   // const isExcluded = spaceAllocationsToExclude?.some(
-  //   //   (excludedAllocation) =>
-  //   //     excludedAllocation.product.uuid === tag.product &&
-  //   //     excludedAllocation.tags.some((t) => t.uuid === tag.uuid),
-  //   // );
-  //   // if (!isExcluded && existingTagInSpace) {
-  //   //   throw new HttpException(
-  //   //     `Tag ${tag.uuid} (Product: ${tag.product}) is already allocated at the space level (${subspace.space.uuid}). Cannot allocate the same tag in a subspace.`,
-  //   //     HttpStatus.BAD_REQUEST,
-  //   //   );
-  //   // }
-  //   // // ?: Check if the tag is already allocated in another "subspace" within the same space
-  //   // const existingTagInSameSpace = await (queryRunner
-  //   //   ? queryRunner.manager.findOne(SubspaceProductAllocationEntity, {
-  //   //       where: {
-  //   //         product: { uuid: tag.product },
-  //   //         subspace: { space: subspace.space },
-  //   //         tag: { uuid: tag.uuid },
-  //   //       },
-  //   //       relations: ['subspace'],
-  //   //     })
-  //   //   : this.subspaceProductAllocationRepository.findOne({
-  //   //       where: {
-  //   //         product: { uuid: tag.product },
-  //   //         subspace: { space: subspace.space },
-  //   //         tag: { uuid: tag.uuid },
-  //   //       },
-  //   //       relations: ['subspace'],
-  //   //     }));
-  //   // if (
-  //   //   existingTagInSameSpace &&
-  //   //   existingTagInSameSpace.subspace.uuid !== subspace.uuid
-  //   // ) {
-  //   //   throw new HttpException(
-  //   //     `Tag ${tag.uuid} (Product: ${tag.product}) is already allocated in another subspace (${existingTagInSameSpace.subspace.uuid}) within the same space (${subspace.space.uuid}).`,
-  //   //     HttpStatus.BAD_REQUEST,
-  //   //   );
-  //   // }
-  // }
-
   private createNewSubspaceAllocation(
     subspace: SubspaceEntity,
     allocationData: { product: string; tag: string },

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

@@ -12,7 +12,7 @@ import {
   AddSubspaceDto,
   GetSpaceParam,
   GetSubSpaceParam,
-  ModifySubspaceDto,
+  UpdateSubspaceDto,
 } from '../../dtos';
 
 import { SubspaceModelEntity } from '@app/common/modules/space-model';
@@ -103,13 +103,13 @@ export class SubSpaceService {
         queryRunner,
       );
       await Promise.all(
-        addSubspaceDtos.map(async ({ tags }, index) => {
+        addSubspaceDtos.map(async ({ productAllocations }, index) => {
           // map the dto to the corresponding subspace
           const subspace = createdSubspaces[index];
           await this.createAllocations({
             projectUuid,
             queryRunner,
-            tags,
+            productAllocations,
             type: AllocationsOwnerType.SUBSPACE,
             subspace,
           });
@@ -145,7 +145,7 @@ export class SubSpaceService {
         space,
       );
       const newSubspace = this.subspaceRepository.create({
-        ...addSubspaceDto,
+        subspaceName: addSubspaceDto.subspaceName,
         space,
       });
 
@@ -305,7 +305,7 @@ export class SubSpaceService {
   } */
 
   async updateSubspaceInSpace(
-    subspaceDtos: ModifySubspaceDto[],
+    subspaceDtos: UpdateSubspaceDto[],
     queryRunner: QueryRunner,
     space: SpaceEntity,
     projectUuid: string,
@@ -324,42 +324,52 @@ export class SubSpaceService {
           disabled: true,
         },
       );
-
       await queryRunner.manager.delete(SubspaceProductAllocationEntity, {
-        subspace: { uuid: Not(In(subspaceDtos.map((dto) => dto.uuid))) },
+        subspace: {
+          uuid: Not(
+            In(subspaceDtos.filter(({ uuid }) => uuid).map(({ uuid }) => uuid)),
+          ),
+        },
       });
 
       // create or update subspaces provided in the list
       const newSubspaces = this.subspaceRepository.create(
-        subspaceDtos.filter((dto) => !dto.uuid),
+        subspaceDtos
+          .filter((dto) => !dto.uuid)
+          .map((dto) => ({
+            subspaceName: dto.subspaceName,
+            space,
+          })),
       );
 
       const updatedSubspaces: SubspaceEntity[] = await queryRunner.manager.save(
         SubspaceEntity,
-        [...newSubspaces, ...subspaceDtos.filter((dto) => dto.uuid)].map(
-          (subspace) => ({ ...subspace, space }),
-        ),
+        [
+          ...newSubspaces,
+          ...subspaceDtos
+            .filter((dto) => dto.uuid)
+            .map((dto) => ({
+              subspaceName: dto.subspaceName,
+              space,
+            })),
+        ],
       );
-
       // create or update allocations for the subspaces
       if (updatedSubspaces.length > 0) {
         await this.subspaceProductAllocationService.updateSubspaceProductAllocationsV2(
-          subspaceDtos.map((dto) => {
-            if (!dto.uuid) {
-              dto.uuid = updatedSubspaces.find(
-                (subspace) => subspace.subspaceName === dto.subspaceName,
-              )?.uuid;
-            }
-            return {
-              tags: dto.tags || [],
-              uuid: dto.uuid,
-            };
-          }),
+          subspaceDtos.map((dto) => ({
+            ...dto,
+            uuid:
+              dto.uuid ||
+              updatedSubspaces.find((s) => s.subspaceName === dto.subspaceName)
+                ?.uuid,
+          })),
           projectUuid,
           queryRunner,
         );
       }
     } catch (error) {
+      console.log(error);
       throw new HttpException(
         `An error occurred while modifying subspaces: ${error.message}`,
         HttpStatus.INTERNAL_SERVER_ERROR,
@@ -478,10 +488,10 @@ export class SubSpaceService {
   }
 
   async createAllocations(dto: CreateAllocationsDto): Promise<void> {
-    const { projectUuid, queryRunner, tags, type } = dto;
-
-    const allocationsData = await this.newTagService.processTags(
-      tags,
+    const { projectUuid, queryRunner, productAllocations, type } = dto;
+    if (!productAllocations) return;
+    const allocationsData = await this.newTagService.upsertTags(
+      productAllocations,
       projectUuid,
       queryRunner,
     );
@@ -491,15 +501,17 @@ export class SubSpaceService {
     const createdTagsByName = new Map(allocationsData.map((t) => [t.name, t]));
 
     // Create the product-tag mapping based on the processed tags
-    const productTagMapping = tags.map(({ uuid, name, productUuid }) => {
-      const inputTag = uuid
-        ? createdTagsByUUID.get(uuid)
-        : createdTagsByName.get(name);
-      return {
-        tag: inputTag?.uuid,
-        product: productUuid,
-      };
-    });
+    const productTagMapping = productAllocations.map(
+      ({ tagUuid, tagName, productUuid }) => {
+        const inputTag = tagUuid
+          ? createdTagsByUUID.get(tagUuid)
+          : createdTagsByName.get(tagName);
+        return {
+          tag: inputTag?.uuid,
+          product: productUuid,
+        };
+      },
+    );
 
     switch (type) {
       case AllocationsOwnerType.SUBSPACE: {

src/space/space.module.ts

@@ -79,7 +79,6 @@ import { SpaceValidationController } from './controllers/space-validation.contro
 import { DisableSpaceHandler } from './handlers';
 import {
   SpaceDeviceService,
-  SpaceLinkService,
   SpaceSceneService,
   SpaceService,
   SpaceUserService,
@@ -89,6 +88,8 @@ import {
 } from './services';
 import { SpaceProductAllocationService } from './services/space-product-allocation.service';
 import { SubspaceProductAllocationService } from './services/subspace/subspace-product-allocation.service';
+import { PresenceSensorDailySpaceRepository } from '@app/common/modules/presence-sensor/repositories';
+import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/repositories';
 
 export const CommandHandlers = [DisableSpaceHandler];
 
@@ -110,7 +111,6 @@ export const CommandHandlers = [DisableSpaceHandler];
     ProductRepository,
     SubSpaceService,
     SpaceDeviceService,
-    SpaceLinkService,
     SubspaceDeviceService,
     SpaceRepository,
     SubspaceRepository,
@@ -163,6 +163,8 @@ export const CommandHandlers = [DisableSpaceHandler];
     SqlLoaderService,
     OccupancyService,
     AqiDataService,
+    PresenceSensorDailySpaceRepository,
+    AqiSpaceDailyPollutantStatsRepository,
   ],
   exports: [SpaceService],
 })

src/tags/services/tags.service.ts

@@ -14,8 +14,8 @@ import {
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
+import { CreateProductAllocationDto } from 'src/space/dtos';
 import { In, QueryRunner } from 'typeorm';
-import { ProcessTagDto } from '../dtos';
 import { CreateTagDto } from '../dtos/tags.dto';
 
 @Injectable()
@@ -68,13 +68,13 @@ export class TagService {
 
   /**
    * Processes an array of tag DTOs, creating or updating tags in the database.
-   * @param tagDtos - The array of tag DTOs to process.
+   * @param allocationDtos - The array of allocations DTOs to process.
    * @param projectUuid - The UUID of the project to associate the tags with.
    * @param queryRunner - Optional TypeORM query runner for transaction management.
    * @returns An array of the processed tag entities.
    */
-  async processTags(
-    tagDtos: ProcessTagDto[],
+  async upsertTags(
+    allocationDtos: CreateProductAllocationDto[],
     projectUuid: string,
     queryRunner?: QueryRunner,
   ): Promise<NewTagEntity[]> {
@@ -82,20 +82,22 @@ export class TagService {
       const dbManager = queryRunner
         ? queryRunner.manager
         : this.tagRepository.manager;
-      if (!tagDtos || tagDtos.length === 0) {
+      if (!allocationDtos || allocationDtos.length === 0) {
         return [];
       }
 
-      const [tagsWithUuid, tagsWithoutUuid]: [
-        Pick<ProcessTagDto, 'uuid' | 'productUuid'>[],
-        Omit<ProcessTagDto, 'uuid'>[],
-      ] = this.splitTagsByUuid(tagDtos);
+      const [allocationsWithTagUuid, allocationsWithoutTagUuid]: [
+        Pick<CreateProductAllocationDto, 'tagUuid' | 'productUuid'>[],
+        Omit<CreateProductAllocationDto, 'tagUuid'>[],
+      ] = this.splitTagsByUuid(allocationDtos);
 
       // create a set of unique existing tag names for the project
       const upsertedTagsByNameResult = await dbManager.upsert(
         NewTagEntity,
         Array.from(
-          new Set<string>(tagsWithoutUuid.map((tag) => tag.name)).values(),
+          new Set<string>(
+            allocationsWithoutTagUuid.map((allocation) => allocation.tagName),
+          ).values(),
         ).map((name) => ({
           name,
           project: { uuid: projectUuid },
@@ -111,20 +113,22 @@ export class TagService {
 
       let foundByUuidTags: NewTagEntity[] = [];
       // Fetch existing tags using UUIDs
-      if (tagsWithUuid.length) {
+      if (allocationsWithTagUuid.length) {
         foundByUuidTags = await dbManager.find(NewTagEntity, {
           where: {
-            uuid: In([...tagsWithUuid.map((tag) => tag.uuid)]),
+            uuid: In([
+              ...allocationsWithTagUuid.map((allocation) => allocation.tagUuid),
+            ]),
             project: { uuid: projectUuid },
           },
         });
       }
 
       // Ensure all provided UUIDs exist in the database
-      if (foundByUuidTags.length !== tagsWithUuid.length) {
+      if (foundByUuidTags.length !== allocationsWithTagUuid.length) {
         const foundUuids = new Set(foundByUuidTags.map((tag) => tag.uuid));
-        const missingUuids = tagsWithUuid.filter(
-          ({ uuid }) => !foundUuids.has(uuid),
+        const missingUuids = allocationsWithTagUuid.filter(
+          ({ tagUuid }) => !foundUuids.has(tagUuid),
         );
 
         throw new HttpException(
@@ -179,20 +183,22 @@ export class TagService {
   }
 
   private splitTagsByUuid(
-    tagDtos: ProcessTagDto[],
-  ): [ProcessTagDto[], ProcessTagDto[]] {
-    return tagDtos.reduce<[ProcessTagDto[], ProcessTagDto[]]>(
-      ([withUuid, withoutUuid], tag) => {
-        if (tag.uuid) {
-          withUuid.push(tag);
+    allocationsDtos: CreateProductAllocationDto[],
+  ): [CreateProductAllocationDto[], CreateProductAllocationDto[]] {
+    return allocationsDtos.reduce<
+      [CreateProductAllocationDto[], CreateProductAllocationDto[]]
+    >(
+      ([withUuid, withoutUuid], allocation) => {
+        if (allocation.tagUuid) {
+          withUuid.push(allocation);
         } else {
-          if (!tag.name || !tag.productUuid) {
+          if (!allocation.tagName || !allocation.productUuid) {
             throw new HttpException(
               `Tag name or product UUID is missing`,
               HttpStatus.BAD_REQUEST,
             );
           }
-          withoutUuid.push(tag);
+          withoutUuid.push(allocation);
         }
         return [withUuid, withoutUuid];
       },

src/users/controllers/user.controller.ts

@@ -1,7 +1,3 @@
-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,
@@ -11,12 +7,10 @@ import {
   Param,
   Patch,
   Put,
-  Req,
   UseGuards,
 } from '@nestjs/common';
-import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { CheckProfilePictureGuard } from 'src/guards/profile.picture.guard';
-import { SuperAdminRoleGuard } from 'src/guards/super.admin.role.guard';
+import { UserService } from '../services/user.service';
+import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
 import { JwtAuthGuard } from '../../../libs/common/src/guards/jwt.auth.guard';
 import {
   UpdateNameDto,
@@ -24,7 +18,11 @@ import {
   UpdateRegionDataDto,
   UpdateTimezoneDataDto,
 } from '../dtos';
-import { UserService } from '../services/user.service';
+import { CheckProfilePictureGuard } from 'src/guards/profile.picture.guard';
+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({
@@ -156,32 +154,6 @@ 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/dtos/add.space.dto.ts

@@ -1,38 +1,5 @@
 import { ApiProperty } from '@nestjs/swagger';
-import {
-  IsBoolean,
-  IsNotEmpty,
-  IsOptional,
-  IsString,
-  IsUUID,
-} from 'class-validator';
-
-export class AddSpaceDto {
-  @ApiProperty({
-    description: 'Name of the space (e.g., Floor 1, Unit 101)',
-    example: 'Unit 101',
-  })
-  @IsString()
-  @IsNotEmpty()
-  spaceName: string;
-
-  @ApiProperty({
-    description: 'UUID of the parent space (if any, for hierarchical spaces)',
-    example: 'f5d7e9c3-44bc-4b12-88f1-1b3cda84752e',
-    required: false,
-  })
-  @IsUUID()
-  @IsOptional()
-  parentUuid?: string;
-
-  @ApiProperty({
-    description: 'Indicates whether the space is private or public',
-    example: false,
-    default: false,
-  })
-  @IsBoolean()
-  isPrivate: boolean;
-}
+import { IsNotEmpty, IsString } from 'class-validator';
 
 export class AddUserSpaceDto {
   @ApiProperty({

src/users/services/user.service.ts

@@ -1,21 +1,21 @@
-import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
-import { removeBase64Prefix } from '@app/common/helper/removeBase64Prefix';
-import { RegionRepository } from '@app/common/modules/region/repositories';
-import { TimeZoneRepository } from '@app/common/modules/timezone/repositories';
-import { UserEntity } from '@app/common/modules/user/entities';
-import { UserRepository } from '@app/common/modules/user/repositories';
-import {
-  BadRequestException,
-  HttpException,
-  HttpStatus,
-  Injectable,
-} from '@nestjs/common';
 import {
   UpdateNameDto,
   UpdateProfilePictureDataDto,
   UpdateRegionDataDto,
   UpdateTimezoneDataDto,
 } from './../dtos/update.user.dto';
+import {
+  BadRequestException,
+  HttpException,
+  HttpStatus,
+  Injectable,
+} from '@nestjs/common';
+import { UserRepository } from '@app/common/modules/user/repositories';
+import { RegionRepository } from '@app/common/modules/region/repositories';
+import { TimeZoneRepository } from '@app/common/modules/timezone/repositories';
+import { removeBase64Prefix } from '@app/common/helper/removeBase64Prefix';
+import { UserEntity } from '@app/common/modules/user/entities';
+import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
 
 @Injectable()
 export class UserService {
@@ -269,12 +269,4 @@ 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 { ProductType } from '@app/common/constants/product-type.enum';
+import { VisitorPasswordRepository } from './../../../libs/common/src/modules/visitor-password/repositories/visitor-password.repository';
 
-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({
-      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(
+  private 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) {
-    // 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) {
+  private 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) {
-    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(
+  private 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> {

src/vistor-password/visitor-password.module.ts

@@ -32,6 +32,8 @@ import { SqlLoaderService } from '@app/common/helper/services/sql-loader.service
 import { OccupancyService } from '@app/common/helper/services/occupancy.service';
 import { CommunityRepository } from '@app/common/modules/community/repositories';
 import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
+import { PresenceSensorDailySpaceRepository } from '@app/common/modules/presence-sensor/repositories';
+import { AqiSpaceDailyPollutantStatsRepository } from '@app/common/modules/aqi/repositories';
 @Module({
   imports: [ConfigModule, DeviceRepositoryModule, DoorLockModule],
   controllers: [VisitorPasswordController],
@@ -61,6 +63,8 @@ import { AqiDataService } from '@app/common/helper/services/aqi.data.service';
     OccupancyService,
     CommunityRepository,
     AqiDataService,
+    PresenceSensorDailySpaceRepository,
+    AqiSpaceDailyPollutantStatsRepository,
   ],
   exports: [VisitorPasswordService],
 })