chore: trigger deploy

* fix: commission device API

* task: add create booking API

* add get All api for dashboard & mobile

* add Find APIs for bookings

* implement sending email updates on update bookable space

* move email interfaces to separate files

.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/pull_request_template.md

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

.github/workflows/main_syncrow(staging).yml

@@ -14,24 +14,24 @@ jobs:
     runs-on: 'ubuntu-latest'
 
     steps:
-    - uses: actions/checkout@v2
+      - uses: actions/checkout@v2
 
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@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: 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
+      - 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:
     runs-on: ubuntu-latest
@@ -41,11 +41,11 @@ jobs:
       url: ${{ steps.deploy-to-webapp.outputs.webapp-url }}
 
     steps:
-    - name: Deploy to Azure Web App
-      id: deploy-to-webapp
-      uses: azure/webapps-deploy@v2
-      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 }}'
+      - name: Deploy to Azure Web App
+        id: deploy-to-webapp
+        uses: azure/webapps-deploy@v2
+        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 }}'

.github/workflows/main_syncrow(stg).yml

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

.github/workflows/pr-description.yml

@@ -0,0 +1,64 @@
+name: 🤖 AI PR Description Commenter (100% Safe with jq)
+
+on:
+  pull_request:
+    types: [opened, edited]
+
+jobs:
+  generate-description:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v4
+
+      - name: Install GitHub CLI and jq
+        run: |
+          sudo apt-get update
+          sudo apt-get install gh jq -y
+
+      - name: Fetch PR Commits
+        id: fetch_commits
+        run: |
+          COMMITS=$(gh pr view ${{ github.event.pull_request.number }} --json commits --jq '.commits[].message' | sed 's/^/- /')
+          echo "commits<<EOF" >> $GITHUB_ENV
+          echo "$COMMITS" >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+        env:
+          GH_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
+
+      - name: Generate PR Description with OpenAI (Safe JSON with jq)
+        run: |
+          REQUEST_BODY=$(jq -n \
+            --arg model "gpt-4o" \
+            --arg content "Given the following commit messages:\n\n${commits}\n\nGenerate a clear and professional pull request description." \
+            '{
+              model: $model,
+              messages: [{ role: "user", content: $content }]
+            }'
+          )
+
+          RESPONSE=$(curl -s https://api.openai.com/v1/chat/completions \
+            -H "Authorization: Bearer $OPENAI_API_KEY" \
+            -H "Content-Type: application/json" \
+            -d "$REQUEST_BODY")
+
+          DESCRIPTION=$(echo "$RESPONSE" | jq -r '.choices[0].message.content')
+
+          echo "---------- OpenAI Raw Response ----------"
+          echo "$RESPONSE"
+          echo "---------- Extracted Description ----------"
+          echo "$DESCRIPTION"
+
+          echo "description<<EOF" >> $GITHUB_ENV
+          echo "$DESCRIPTION" >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          commits: ${{ env.commits }}
+
+      - name: Post AI Generated Description as Comment
+        run: |
+          gh pr comment ${{ github.event.pull_request.number }} --body "${{ env.description }}"
+        env:
+          GH_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}

.github/workflows/production.yml

@@ -0,0 +1,40 @@
+name: 🚀 Production Deployment
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: ⬇️ Checkout Code
+        uses: actions/checkout@v4
+
+      - name: 🐢 Set up Node.js 20.x
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: 🐳 Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: 🔐 Configure AWS Credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: me-central-1
+
+      - name: 🗂️ Write .env file from ENV_FILE Secret
+        run: echo "${{ secrets.ENV_FILE }}" > .env
+
+      - name: 📦 Install Dependencies
+        run: npm install
+
+      - name: 🛠️ Run Production Build & Deploy Script
+        run: |
+          chmod +x ./build.sh
+          ./build.sh

.gitignore

@@ -3,6 +3,9 @@
 /node_modules
 /build
 
+#github 
+/.github/workflows
+
 # Logs
 logs
 *.log
@@ -55,4 +58,9 @@ pids
 # Diagnostic reports (https://nodejs.org/api/report.html)
 report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
 
-config.dev
+config.dev
+cdk.out
+backend-cdk-new.out
+web-cdk.out
+backend-cdk.out
+backend-cdk-final.out

Dockerfile

@@ -1,16 +1,28 @@
-FROM node:20-alpine
+FROM --platform=linux/amd64 node:20-alpine
+
+# curl for health checks
+RUN apk add --no-cache curl
 
 WORKDIR /app
 
+
 COPY package*.json ./
 
-RUN npm install
-RUN npm install -g @nestjs/cli
+RUN npm install --production --ignore-scripts
 
 COPY . .
 
 RUN npm run build
 
-EXPOSE 4000
+RUN addgroup -g 1001 -S nodejs
+RUN adduser -S nestjs -u 1001
 
-CMD ["npm", "run", "start"]
+RUN chown -R nestjs:nodejs /app
+USER nestjs
+
+EXPOSE 3000
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:3000/health || exit 1
+
+CMD ["npm", "run", "start:prod"]

GITHUB_SETUP.md

@@ -0,0 +1,129 @@
+# GitHub Actions Setup Guide
+
+## Required GitHub Secrets
+
+Add these secrets to your GitHub repository (Settings > Secrets and variables > Actions):
+
+### AWS Credentials
+
+```
+AWS_ACCESS_KEY_ID=your-aws-access-key
+AWS_SECRET_ACCESS_KEY=your-aws-secret-key
+```
+
+### JWT Configuration (CRITICAL - Generate secure random strings)
+
+```
+JWT_SECRET=your-super-secure-jwt-secret-key-here
+JWT_SECRET_REFRESH=your-super-secure-refresh-secret-key-here
+SECRET_KEY=your-general-encryption-secret-key-here
+```
+
+### Admin Configuration
+
+```
+SUPER_ADMIN_EMAIL=admin@syncrow.ae
+SUPER_ADMIN_PASSWORD=YourSecureAdminPassword123!
+```
+
+### Tuya IoT Configuration
+
+```
+TUYA_ACCESS_ID=your-tuya-access-id
+TUYA_ACCESS_KEY=your-tuya-access-key
+TRUN_ON_TUYA_SOCKET=true-or-false
+```
+
+### Firebase Configuration
+
+```
+FIREBASE_API_KEY=your-firebase-api-key
+FIREBASE_AUTH_DOMAIN=your-project.firebaseapp.com
+FIREBASE_PROJECT_ID=your-project-id
+FIREBASE_STORAGE_BUCKET=your-project.appspot.com
+FIREBASE_MESSAGING_SENDER_ID=your-sender-id
+FIREBASE_APP_ID=your-app-id
+FIREBASE_MEASUREMENT_ID=your-measurement-id
+FIREBASE_DATABASE_URL=https://your-project.firebaseio.com
+```
+
+### Google OAuth
+
+```
+GOOGLE_CLIENT_ID=your-google-client-id
+GOOGLE_CLIENT_SECRET=your-google-client-secret
+```
+
+### OneSignal Push Notifications
+
+```
+ONESIGNAL_APP_ID=your-onesignal-app-id
+ONESIGNAL_API_KEY=your-onesignal-api-key
+```
+
+### Email Configuration (SMTP)
+
+```
+SMTP_HOST=your-smtp-host
+SMTP_USER=your-smtp-username
+SMTP_PASSWORD=your-smtp-password
+```
+
+### Mailtrap Configuration
+
+```
+MAILTRAP_API_TOKEN=your-mailtrap-api-token
+MAILTRAP_ENABLE_TEMPLATE_UUID=template-uuid
+MAILTRAP_DISABLE_TEMPLATE_UUID=template-uuid
+MAILTRAP_INVITATION_TEMPLATE_UUID=template-uuid
+MAILTRAP_DELETE_USER_TEMPLATE_UUID=template-uuid
+MAILTRAP_EDIT_USER_TEMPLATE_UUID=template-uuid
+```
+
+### Optional Services (leave empty if not used)
+
+```
+AZURE_REDIS_CONNECTIONSTRING=your-redis-connection-string
+DOPPLER_PROJECT=your-doppler-project
+DOPPLER_CONFIG=your-doppler-config
+DOPPLER_ENVIRONMENT=your-doppler-environment
+ACCESS_KEY=your-access-key
+DOCKER_REGISTRY_SERVER_URL=your-registry-url
+DOCKER_REGISTRY_SERVER_USERNAME=your-registry-username
+DOCKER_REGISTRY_SERVER_PASSWORD=your-registry-password
+```
+
+## Setup Steps
+
+1. **Add AWS Credentials**
+   - Create IAM user with ECR, ECS, CloudFormation permissions
+   - Add AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY to GitHub Secrets
+
+2. **Generate JWT Secrets**
+   - Use a secure random string generator
+   - Make JWT_SECRET and JWT_SECRET_REFRESH different values
+   - Keep these values secure and never share them
+
+3. **Configure Services**
+   - Add secrets for each service you're using
+   - Leave unused services empty (they'll default to empty strings)
+
+4. **Test Deployment**
+   - Push to master/main branch
+   - Check GitHub Actions tab for deployment status
+   - Verify API is accessible at https://api.syncos.syncrow.ae
+
+## Security Notes
+
+- Never commit secrets to the repository
+- Use GitHub Secrets for all sensitive values
+- Rotate secrets regularly
+- Monitor GitHub Actions logs for any exposed values
+- Database password is automatically managed by AWS Secrets Manager
+
+## Troubleshooting
+
+- Check GitHub Actions logs for deployment errors
+- Verify all required secrets are set
+- Ensure AWS credentials have sufficient permissions
+- Check ECS service logs in CloudWatch for runtime errors

README.md

@@ -1,17 +1,19 @@
 # Backend
 
 ## Overview
+
 This is the backend for an IoT application built using NestJS. It interfaces with the Tuya IoT cloud platform to manage homes, rooms, devices, ...etc.
-This is the backend APIs project, developed with NestJS for Syncrow IOT Project. 
+This is the backend APIs project, developed with NestJS for Syncrow IOT Project.
 
 ## Database Model
+
 The database uses PostgreSQL and TypeORM. Below is an entity relationship diagram:
 
 The main entities are:
 
 User - Stores user account information
-Home - Represents a  home/space
-Room - Represents a  room/sub-space
+Home - Represents a home/space
+Room - Represents a room/sub-space
 Device - Represents a connected device
 Product - Stores metadata about device products
 Other Entities - sessions, OTPs, etc.
@@ -19,10 +21,11 @@ Other Entities - sessions, OTPs, etc.
 The entities have a one-to-many relationship - a user has multiple homes, a home has multiple rooms, and a room has multiple devices.
 
 ## Architecture
+
 The application is deployed on Azure App Service using Docker containers. There are separate deployment slots for development, staging, and production environments.
 
-
 ## Installation
+
 First, ensure that you have Node.js `v20.11` or newer (LTS ONLY) installed on your system.
 
 To install the project dependencies, run the following command in the project root directory:
@@ -61,8 +64,8 @@ $ npm run test:cov
 
 ![Syncrow ERD Digram](https://github.com/SyncrowIOT/backend/assets/83524184/94273a2b-625c-4a34-9cd4-fb14415ce884)
 
-
 ## Architecture
+
                                        +----------------------------------+
                                        |                                  |
                                        |         Applications             |
@@ -107,3 +110,29 @@ $ npm run test:cov
          |            |  Standby Node    |                |                |
          |            +------------------+----------------+                |
          +-----------------------------------------------------------------+
+
+## CDK Deployment
+
+• Bootstrap CDK (first time only): npx cdk bootstrap aws://482311766496/me-central-1
+• List available stacks: npx cdk list
+• Deploy infrastructure: npx cdk deploy --require-approval never
+• View changes before deploy: npx cdk diff
+• Generate CloudFormation template: npx cdk synth
+• Destroy infrastructure: npx cdk destroy
+• Environment variables are configured in infrastructure/stack.ts
+• After code changes: build Docker image, push to ECR, force ECS deployment
+• Database seeding happens automatically on first deployment with DB_SYNC=true
+• Admin credentials: admin@syncrow.ae / YourSecureAdminPassword123!
+• Production API: https://api.syncos.syncrow.ae
+• Health check: https://api.syncos.syncrow.ae/health
+
+## GitHub Actions Deployment
+
+• Automatic deployment on push to master/main branch
+• Configure GitHub Secrets (see GITHUB_SETUP.md for complete list)
+• Required secrets: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, JWT_SECRET, JWT_SECRET_REFRESH
+• Workflow builds Docker image, pushes to ECR, and deploys CDK stack
+• Environment variables are passed securely via GitHub Secrets
+• Manual deployment: Go to Actions tab and run "Deploy Backend to AWS" workflow
+• Check deployment status in GitHub Actions tab
+• Logs available in CloudWatch under /ecs/syncrow-backend log group

build.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+set -e
+
+ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
+REGION=${AWS_DEFAULT_REGION:-me-central-1}
+REPO_NAME=syncrow-backend
+IMAGE_TAG=latest
+CLUSTER_NAME=syncrow-backend-cluster
+STACK_NAME=SyncrowBackendStack
+CERTIFICATE_ARN="arn:aws:acm:$REGION:$ACCOUNT_ID:certificate/bea1e2ae-84a1-414e-8dbf-4599397e7ed0"
+
+echo "🔐 Logging into ECR..."
+aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin "$ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com"
+
+echo "🐳 Building Docker image..."
+docker build --platform=linux/amd64 -t $REPO_NAME .
+
+echo "🏷️ Tagging image..."
+docker tag $REPO_NAME:$IMAGE_TAG "$ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/$REPO_NAME:$IMAGE_TAG"
+
+echo "📤 Pushing image to ECR..."
+docker push "$ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/$REPO_NAME:$IMAGE_TAG"
+
+echo "🔍 Checking if ECS service exists..."
+SERVICE_ARN=$(aws ecs list-services \
+    --cluster $CLUSTER_NAME \
+    --query 'serviceArns[0]' \
+    --output text \
+    --region $REGION 2>/dev/null || echo "")
+
+echo "📦 Deploying CDK Stack..."
+npx cdk deploy $STACK_NAME \
+    --context certificateArn=$CERTIFICATE_ARN \
+    --require-approval never
+
+if [[ "$SERVICE_ARN" != "" && "$SERVICE_ARN" != "None" ]]; then
+    SERVICE_NAME=$(basename "$SERVICE_ARN")
+    echo "🚀 Redeploying ECS Service: $SERVICE_NAME"
+    aws ecs update-service \
+        --cluster $CLUSTER_NAME \
+        --service $SERVICE_NAME \
+        --force-new-deployment \
+        --region $REGION
+fi
+
+echo "✅ All done."

cdk.context.json

@@ -0,0 +1,29 @@
+{
+  "availability-zones:account=426265406140:region=us-east-2": [
+    "us-east-2a",
+    "us-east-2b",
+    "us-east-2c"
+  ],
+  "availability-zones:account=482311766496:region=us-east-2": [
+    "us-east-2a",
+    "us-east-2b",
+    "us-east-2c"
+  ],
+  "hosted-zone:account=482311766496:domainName=syncrow.me:region=us-east-2": {
+    "Id": "/hostedzone/Z02085662NLJECF4DGJV3",
+    "Name": "syncrow.me."
+  },
+  "availability-zones:account=482311766496:region=me-central-1": [
+    "me-central-1a",
+    "me-central-1b",
+    "me-central-1c"
+  ],
+  "hosted-zone:account=482311766496:domainName=syncrow.me:region=me-central-1": {
+    "Id": "/hostedzone/Z02085662NLJECF4DGJV3",
+    "Name": "syncrow.me."
+  },
+  "hosted-zone:account=482311766496:domainName=syncrow.ae:region=me-central-1": {
+    "Id": "/hostedzone/Z01153152LRHQTA1370P4",
+    "Name": "syncrow.ae."
+  }
+}

cdk.json

@@ -0,0 +1,58 @@
+{
+  "app": "npx ts-node --prefer-ts-exts infrastructure/app.ts",
+  "watch": {
+    "include": [
+      "**"
+    ],
+    "exclude": [
+      "README.md",
+      "cdk*.json",
+      "**/*.d.ts",
+      "**/*.js",
+      "tsconfig.json",
+      "package*.json",
+      "yarn.lock",
+      "node_modules",
+      "test"
+    ]
+  },
+  "context": {
+    "@aws-cdk/aws-lambda:recognizeLayerVersion": true,
+    "@aws-cdk/core:checkSecretUsage": true,
+    "@aws-cdk/core:target-partitions": [
+      "aws",
+      "aws-cn"
+    ],
+    "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": true,
+    "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": true,
+    "@aws-cdk/aws-ecs:arnFormatIncludesClusterName": true,
+    "@aws-cdk/aws-iam:minimizePolicies": true,
+    "@aws-cdk/core:validateSnapshotRemovalPolicy": true,
+    "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": true,
+    "@aws-cdk/aws-s3:createDefaultLoggingPolicy": true,
+    "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": true,
+    "@aws-cdk/aws-apigateway:disableCloudWatchRole": true,
+    "@aws-cdk/core:enablePartitionLiterals": true,
+    "@aws-cdk/aws-events:eventsTargetQueueSameAccount": true,
+    "@aws-cdk/aws-iam:standardizedServicePrincipals": true,
+    "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": true,
+    "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName": true,
+    "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": true,
+    "@aws-cdk/aws-route53-patters:useCertificate": true,
+    "@aws-cdk/customresources:installLatestAwsSdkDefault": false,
+    "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": true,
+    "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup": true,
+    "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId": true,
+    "@aws-cdk/aws-ec2:launchTemplateDefaultUserData": true,
+    "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments": true,
+    "@aws-cdk/aws-redshift:columnId": true,
+    "@aws-cdk/aws-stepfunctions-tasks:enableLogging": true,
+    "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": true,
+    "@aws-cdk/aws-apigateway:requestValidatorUniqueId": true,
+    "@aws-cdk/aws-kms:aliasNameRef": true,
+    "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": true,
+    "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm": true,
+    "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials": true,
+    "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForSourceAction": true
+  }
+}

deploy.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+set -e
+
+ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
+REGION=${AWS_DEFAULT_REGION:-me-central-1}
+
+npx cdk deploy SyncrowBackendStack --context certificateArn=arn:aws:acm:me-central-1:482311766496:certificate/bea1e2ae-84a1-414e-8dbf-4599397e7ed0 --require-approval never
+
+aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com
+
+docker build --platform=linux/amd64 -t syncrow-backend .
+docker tag syncrow-backend:latest $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/syncrow-backend:latest
+docker push $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/syncrow-backend:latest
+
+SERVICE_ARN=$(aws ecs list-services --cluster syncrow-backend-cluster --query 'serviceArns[0]' --output text --region $REGION 2>/dev/null || echo "")
+
+if [ "$SERVICE_ARN" != "" ] && [ "$SERVICE_ARN" != "None" ]; then
+    SERVICE_NAME=$(echo $SERVICE_ARN | cut -d'/' -f3)
+    aws ecs update-service --cluster syncrow-backend-cluster --service $SERVICE_NAME --force-new-deployment --region $REGION
+else
+    npx cdk deploy SyncrowBackendStack --context certificateArn=arn:aws:acm:me-central-1:482311766496:certificate/bea1e2ae-84a1-414e-8dbf-4599397e7ed0 --require-approval never
+fi

infrastructure/app.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import * as cdk from 'aws-cdk-lib';
+import 'source-map-support/register';
+import { BackendStack } from './stack';
+
+const app = new cdk.App();
+
+new BackendStack(app, 'SyncrowBackendStack', {
+  env: {
+    account: process.env.CDK_DEFAULT_ACCOUNT,
+    region: 'me-central-1',
+  },
+  databaseName: 'postgres',
+  certificateArn:
+    'arn:aws:acm:me-central-1:482311766496:certificate/423b343e-402b-4978-89bd-cda25f7a8873',
+});

infrastructure/stack.ts

@@ -0,0 +1,393 @@
+import * as cdk from 'aws-cdk-lib';
+import * as acm from 'aws-cdk-lib/aws-certificatemanager';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as ecr from 'aws-cdk-lib/aws-ecr';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as ecsPatterns from 'aws-cdk-lib/aws-ecs-patterns';
+import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import * as logs from 'aws-cdk-lib/aws-logs';
+import * as rds from 'aws-cdk-lib/aws-rds';
+import * as route53 from 'aws-cdk-lib/aws-route53';
+import { Construct } from 'constructs';
+import * as dotenv from 'dotenv';
+
+export interface BackendStackProps extends cdk.StackProps {
+  vpcId?: string;
+  databaseName?: string;
+  certificateArn?: string;
+}
+
+export class BackendStack extends cdk.Stack {
+  public readonly apiUrl: string;
+  public readonly databaseEndpoint: string;
+  public readonly vpc: ec2.IVpc;
+
+  constructor(scope: Construct, id: string, props?: BackendStackProps) {
+    super(scope, id, props);
+
+    // Load environment variables from .env file
+    dotenv.config({ path: '.env' });
+
+    // VPC - either use existing or create new
+    this.vpc = props?.vpcId
+      ? ec2.Vpc.fromLookup(this, 'ExistingVpc', { vpcId: props.vpcId })
+      : new ec2.Vpc(this, 'SyncrowVpc', {
+          maxAzs: 2,
+          natGateways: 1,
+          subnetConfiguration: [
+            {
+              cidrMask: 24,
+              name: 'public',
+              subnetType: ec2.SubnetType.PUBLIC,
+            },
+            {
+              cidrMask: 24,
+              name: 'private',
+              subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,
+            },
+          ],
+        });
+
+    // Security Groups
+    const dbSecurityGroup = new ec2.SecurityGroup(
+      this,
+      'DatabaseSecurityGroup',
+      {
+        vpc: this.vpc,
+        description: 'Security group for RDS PostgreSQL',
+        allowAllOutbound: false,
+      },
+    );
+
+    const ecsSecurityGroup = new ec2.SecurityGroup(this, 'EcsSecurityGroup', {
+      vpc: this.vpc,
+      description: 'Security group for ECS Fargate service',
+      allowAllOutbound: true,
+    });
+
+    const albSecurityGroup = new ec2.SecurityGroup(this, 'AlbSecurityGroup', {
+      vpc: this.vpc,
+      description: 'Security group for Application Load Balancer',
+      allowAllOutbound: true,
+    });
+
+    // Allow ALB to connect to ECS
+    ecsSecurityGroup.addIngressRule(
+      albSecurityGroup,
+      ec2.Port.tcp(3000),
+      'Allow ALB to connect to ECS service',
+    );
+
+    // Allow ECS to connect to RDS
+    dbSecurityGroup.addIngressRule(
+      ecsSecurityGroup,
+      ec2.Port.tcp(5432),
+      'Allow ECS to connect to PostgreSQL',
+    );
+
+    // Temporary access for admin IP
+    dbSecurityGroup.addIngressRule(
+      ec2.Peer.ipv4('216.126.231.231/32'),
+      ec2.Port.tcp(5432),
+      'Temporary access from admin IP',
+    );
+
+    // Allow HTTP/HTTPS traffic to ALB
+    albSecurityGroup.addIngressRule(
+      ec2.Peer.anyIpv4(),
+      ec2.Port.tcp(80),
+      'Allow HTTP traffic',
+    );
+    albSecurityGroup.addIngressRule(
+      ec2.Peer.anyIpv4(),
+      ec2.Port.tcp(443),
+      'Allow HTTPS traffic',
+    );
+
+    const dbCluster = rds.DatabaseCluster.fromDatabaseClusterAttributes(
+      this,
+      'SyncrowDatabase',
+      {
+        clusterIdentifier: 'syncrow-backend',
+        instanceIdentifiers: ['syncrowdatabase-instance-1'],
+        engine: rds.DatabaseClusterEngine.auroraPostgres({
+          version: rds.AuroraPostgresEngineVersion.VER_16_6,
+        }),
+        port: 5432,
+        securityGroups: [
+          ec2.SecurityGroup.fromSecurityGroupId(
+            this,
+            'ImportedDbSecurityGroup',
+            'sg-07e163f588b2bac25',
+          ),
+        ],
+        clusterEndpointAddress:
+          'syncrow-backend.cluster-criskv1sdkq4.me-central-1.rds.amazonaws.com',
+      },
+    );
+
+    // Import the existing database secret separately
+    const dbSecret = rds.DatabaseSecret.fromSecretCompleteArn(
+      this,
+      'ImportedDbSecret',
+      'arn:aws:secretsmanager:me-central-1:482311766496:secret:rds!cluster-43ec14cd-9301-43e2-aa79-d330a429a126-v0JDQN',
+    );
+
+    // ECR Repository for Docker images - import existing repository
+    const ecrRepository = ecr.Repository.fromRepositoryName(
+      this,
+      'SyncrowBackendRepo',
+      'syncrow-backend',
+    );
+
+    // Output the correct ECR URI for this region
+    new cdk.CfnOutput(this, 'EcrRepositoryUriRegional', {
+      value: ecrRepository.repositoryUri,
+      description: `ECR Repository URI in region ${this.region}`,
+      exportName: `${this.stackName}-EcrRepositoryUriRegional`,
+    });
+
+    // ECS Cluster
+    const cluster = new ecs.Cluster(this, 'SyncrowCluster', {
+      vpc: this.vpc,
+      clusterName: 'syncrow-backend-cluster',
+    });
+
+    // CloudWatch Log Group
+    const logGroup = new logs.LogGroup(this, 'SyncrowBackendLogs', {
+      logGroupName: '/ecs/syncrow-backend',
+      retention: logs.RetentionDays.ONE_WEEK,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+
+    // Use existing wildcard certificate or create new one
+    const apiCertificate = props?.certificateArn
+      ? acm.Certificate.fromCertificateArn(
+          this,
+          'ApiCertificate',
+          props.certificateArn,
+        )
+      : new acm.Certificate(this, 'ApiCertificate', {
+          domainName: 'api.syncos.syncrow.ae',
+          validation: acm.CertificateValidation.fromDns(),
+        });
+
+    // ECS Fargate Service with Application Load Balancer
+    const fargateService =
+      new ecsPatterns.ApplicationLoadBalancedFargateService(
+        this,
+        'SyncrowBackendService',
+        {
+          cluster,
+          memoryLimitMiB: 1024,
+          cpu: 512,
+          desiredCount: 2,
+          domainName: 'api.syncos.syncrow.ae',
+          domainZone: route53.HostedZone.fromLookup(this, 'SyncrowZone', {
+            domainName: 'syncrow.ae',
+          }),
+          certificate: apiCertificate,
+          protocol: elbv2.ApplicationProtocol.HTTPS,
+          redirectHTTP: true,
+          taskImageOptions: {
+            image: ecs.ContainerImage.fromEcrRepository(
+              ecrRepository,
+              'latest',
+            ),
+            containerPort: 3000,
+            enableLogging: true,
+            environment: {
+              // App settings
+              NODE_ENV: process.env.NODE_ENV || 'production',
+              PORT: process.env.PORT || '3000',
+              BASE_URL: process.env.BASE_URL || '',
+
+              // Database connection (CDK provides these automatically)
+              AZURE_POSTGRESQL_HOST: dbCluster.clusterEndpoint.hostname,
+              AZURE_POSTGRESQL_PORT: '5432',
+              AZURE_POSTGRESQL_DATABASE: props?.databaseName || 'postgres',
+              AZURE_POSTGRESQL_USER: 'postgres',
+              AZURE_POSTGRESQL_SSL: process.env.AZURE_POSTGRESQL_SSL || 'false',
+              AZURE_POSTGRESQL_SYNC:
+                process.env.AZURE_POSTGRESQL_SYNC || 'false',
+
+              // JWT Configuration - CRITICAL: These must be set
+              JWT_SECRET:
+                process.env.JWT_SECRET ||
+                'syncrow-jwt-secret-key-2025-production-environment-very-secure-random-string',
+              JWT_SECRET_REFRESH:
+                process.env.JWT_SECRET_REFRESH ||
+                'syncrow-refresh-secret-key-2025-production-environment-different-secure-string',
+              JWT_EXPIRE_TIME: process.env.JWT_EXPIRE_TIME || '1h',
+              JWT_EXPIRE_TIME_REFRESH:
+                process.env.JWT_EXPIRE_TIME_REFRESH || '7d',
+
+              // Firebase Configuration
+              FIREBASE_API_KEY: process.env.FIREBASE_API_KEY || '',
+              FIREBASE_AUTH_DOMAIN: process.env.FIREBASE_AUTH_DOMAIN || '',
+              FIREBASE_PROJECT_ID: process.env.FIREBASE_PROJECT_ID || '',
+              FIREBASE_STORAGE_BUCKET:
+                process.env.FIREBASE_STORAGE_BUCKET || '',
+              FIREBASE_MESSAGING_SENDER_ID:
+                process.env.FIREBASE_MESSAGING_SENDER_ID || '',
+              FIREBASE_APP_ID: process.env.FIREBASE_APP_ID || '',
+              FIREBASE_MEASUREMENT_ID:
+                process.env.FIREBASE_MEASUREMENT_ID || '',
+              FIREBASE_DATABASE_URL: process.env.FIREBASE_DATABASE_URL || '',
+
+              // Tuya IoT Configuration
+              TUYA_EU_URL:
+                process.env.TUYA_EU_URL || 'https://openapi.tuyaeu.com',
+              TUYA_ACCESS_ID: process.env.TUYA_ACCESS_ID || '',
+              TUYA_ACCESS_KEY: process.env.TUYA_ACCESS_KEY || '',
+              TRUN_ON_TUYA_SOCKET: process.env.TRUN_ON_TUYA_SOCKET || '',
+
+              // Email Configuration
+              SMTP_HOST: process.env.SMTP_HOST || '',
+              SMTP_PORT: process.env.SMTP_PORT || '587',
+              SMTP_SECURE: process.env.SMTP_SECURE || 'true',
+              SMTP_USER: process.env.SMTP_USER || '',
+              SMTP_PASSWORD: process.env.SMTP_PASSWORD || '',
+
+              // Mailtrap Configuration
+              MAILTRAP_API_TOKEN: process.env.MAILTRAP_API_TOKEN || '',
+              MAILTRAP_INVITATION_TEMPLATE_UUID:
+                process.env.MAILTRAP_INVITATION_TEMPLATE_UUID || '',
+              MAILTRAP_EDIT_USER_TEMPLATE_UUID:
+                process.env.MAILTRAP_EDIT_USER_TEMPLATE_UUID || '',
+              MAILTRAP_DISABLE_TEMPLATE_UUID:
+                process.env.MAILTRAP_DISABLE_TEMPLATE_UUID || '',
+              MAILTRAP_ENABLE_TEMPLATE_UUID:
+                process.env.MAILTRAP_ENABLE_TEMPLATE_UUID || '',
+              MAILTRAP_DELETE_USER_TEMPLATE_UUID:
+                process.env.MAILTRAP_DELETE_USER_TEMPLATE_UUID || '',
+
+              // OneSignal Push Notifications
+              ONESIGNAL_APP_ID: process.env.ONESIGNAL_APP_ID || '',
+              ONESIGNAL_API_KEY: process.env.ONESIGNAL_API_KEY || '',
+
+              // Admin Configuration
+              SUPER_ADMIN_EMAIL:
+                process.env.SUPER_ADMIN_EMAIL || 'admin@yourdomain.com',
+              SUPER_ADMIN_PASSWORD:
+                process.env.SUPER_ADMIN_PASSWORD ||
+                'YourSecureAdminPassword123!',
+
+              // Google OAuth
+              GOOGLE_CLIENT_ID: process.env.GOOGLE_CLIENT_ID || '',
+              GOOGLE_CLIENT_SECRET: process.env.GOOGLE_CLIENT_SECRET || '',
+
+              // Other Configuration
+              OTP_LIMITER: process.env.OTP_LIMITER || '5',
+              SECRET_KEY:
+                process.env.SECRET_KEY ||
+                'another-random-secret-key-for-general-encryption',
+              ACCESS_KEY: process.env.ACCESS_KEY || '',
+              DB_SYNC: process.env.DB_SYNC || 'txsrue',
+
+              // Redis (used?)
+              AZURE_REDIS_CONNECTIONSTRING:
+                process.env.AZURE_REDIS_CONNECTIONSTRING || '',
+
+              // Docker Registry (for deployment)
+              DOCKER_REGISTRY_SERVER_URL:
+                process.env.DOCKER_REGISTRY_SERVER_URL || '',
+              DOCKER_REGISTRY_SERVER_USERNAME:
+                process.env.DOCKER_REGISTRY_SERVER_USERNAME || '',
+              DOCKER_REGISTRY_SERVER_PASSWORD:
+                process.env.DOCKER_REGISTRY_SERVER_PASSWORD || '',
+
+              // Doppler (if used for secrets management)
+              DOPPLER_PROJECT: process.env.DOPPLER_PROJECT || '',
+              DOPPLER_CONFIG: process.env.DOPPLER_CONFIG || '',
+              DOPPLER_ENVIRONMENT: process.env.DOPPLER_ENVIRONMENT || '',
+
+              // Azure specific
+              WEBSITES_ENABLE_APP_SERVICE_STORAGE:
+                process.env.WEBSITES_ENABLE_APP_SERVICE_STORAGE || 'false',
+            },
+            secrets: {
+              AZURE_POSTGRESQL_PASSWORD: ecs.Secret.fromSecretsManager(
+                dbSecret,
+                'password',
+              ),
+            },
+            logDriver: ecs.LogDrivers.awsLogs({
+              streamPrefix: 'syncrow-backend',
+              logGroup,
+            }),
+          },
+          publicLoadBalancer: true,
+          securityGroups: [ecsSecurityGroup],
+        },
+      );
+
+    // Add security group to load balancer after creation
+    fargateService.loadBalancer.addSecurityGroup(albSecurityGroup);
+
+    // Configure health check
+    fargateService.targetGroup.configureHealthCheck({
+      path: '/health',
+      healthyHttpCodes: '200',
+      interval: cdk.Duration.seconds(30),
+      timeout: cdk.Duration.seconds(5),
+      healthyThresholdCount: 2,
+      unhealthyThresholdCount: 3,
+    });
+
+    // Auto Scaling
+    const scalableTarget = fargateService.service.autoScaleTaskCount({
+      minCapacity: 1,
+      maxCapacity: 10,
+    });
+
+    scalableTarget.scaleOnCpuUtilization('CpuScaling', {
+      targetUtilizationPercent: 70,
+      scaleInCooldown: cdk.Duration.minutes(5),
+      scaleOutCooldown: cdk.Duration.minutes(2),
+    });
+
+    scalableTarget.scaleOnMemoryUtilization('MemoryScaling', {
+      targetUtilizationPercent: 80,
+      scaleInCooldown: cdk.Duration.minutes(5),
+      scaleOutCooldown: cdk.Duration.minutes(2),
+    });
+
+    // Grant ECS task access to RDS credentials
+    dbSecret.grantRead(fargateService.taskDefinition.taskRole);
+
+    this.apiUrl = 'https://api.syncos.syncrow.ae';
+    this.databaseEndpoint = dbCluster.clusterEndpoint.hostname;
+
+    // Outputs
+    new cdk.CfnOutput(this, 'ApiUrl', {
+      value: this.apiUrl,
+      description: 'Application Load Balancer URL',
+      exportName: `${this.stackName}-ApiUrl`,
+    });
+
+    new cdk.CfnOutput(this, 'DatabaseEndpoint', {
+      value: this.databaseEndpoint,
+      description: 'RDS Cluster Endpoint',
+      exportName: `${this.stackName}-DatabaseEndpoint`,
+    });
+
+    new cdk.CfnOutput(this, 'EcrRepositoryUri', {
+      value: ecrRepository.repositoryUri,
+      description: 'ECR Repository URI',
+      exportName: `${this.stackName}-EcrRepositoryUri`,
+    });
+
+    new cdk.CfnOutput(this, 'ClusterName', {
+      value: cluster.clusterName,
+      description: 'ECS Cluster Name',
+      exportName: `${this.stackName}-ClusterName`,
+    });
+
+    new cdk.CfnOutput(this, 'ServiceName', {
+      value: fargateService.service.serviceName,
+      description: 'ECS Service Name',
+      exportName: `${this.stackName}-ServiceName`,
+    });
+  }
+}

libs/common/src/auth/interfaces/auth.interface.ts

@@ -5,4 +5,5 @@ export class AuthInterface {
   sessionId: string;
   id: number;
   role?: object;
+  project?: object;
 }

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

@@ -1,18 +1,19 @@
+import { PlatformType } from '@app/common/constants/platform-type.enum';
+import { RoleType } from '@app/common/constants/role.type.enum';
+import { UserEntity } from '@app/common/modules/user/entities';
 import {
   BadRequestException,
   Injectable,
   UnauthorizedException,
 } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
 import { JwtService } from '@nestjs/jwt';
 import * as argon2 from 'argon2';
-import { HelperHashService } from '../../helper/services';
-import { UserRepository } from '../../../../common/src/modules/user/repositories';
-import { UserSessionRepository } from '../../../../common/src/modules/session/repositories/session.repository';
-import { UserSessionEntity } from '../../../../common/src/modules/session/entities';
-import { ConfigService } from '@nestjs/config';
 import { OAuth2Client } from 'google-auth-library';
-import { PlatformType } from '@app/common/constants/platform-type.enum';
-import { RoleType } from '@app/common/constants/role.type.enum';
+import { UserSessionEntity } from '../../../../common/src/modules/session/entities';
+import { UserSessionRepository } from '../../../../common/src/modules/session/repositories/session.repository';
+import { UserRepository } from '../../../../common/src/modules/user/repositories';
+import { HelperHashService } from '../../helper/services';
 
 @Injectable()
 export class AuthService {
@@ -32,24 +33,25 @@ export class AuthService {
     pass: string,
     regionUuid?: string,
     platform?: PlatformType,
-  ): Promise<any> {
+  ): Promise<Omit<UserEntity, 'password'>> {
     const user = await this.userRepository.findOne({
       where: {
         email,
         region: regionUuid ? { uuid: regionUuid } : undefined,
       },
-      relations: ['roleType'],
+      relations: ['roleType', 'project'],
     });
-    if (
-      platform === PlatformType.WEB &&
-      (user.roleType.type === RoleType.SPACE_OWNER ||
-        user.roleType.type === RoleType.SPACE_MEMBER)
-    ) {
-      throw new UnauthorizedException('Access denied for web platform');
-    }
     if (!user) {
       throw new BadRequestException('Invalid credentials');
     }
+    if (
+      platform === PlatformType.WEB &&
+      [RoleType.SPACE_OWNER, RoleType.SPACE_MEMBER].includes(
+        user.roleType.type as RoleType,
+      )
+    ) {
+      throw new UnauthorizedException('Access denied for web platform');
+    }
 
     if (!user.isUserVerified) {
       throw new BadRequestException('User is not verified');
@@ -69,29 +71,37 @@ export class AuthService {
     }
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { password, ...result } = user;
-    return result;
+    // const { password, ...result } = user;
+    delete user.password;
+    return user;
   }
 
   async createSession(data): Promise<UserSessionEntity> {
     return await this.sessionRepository.save(data);
   }
 
-  async getTokens(payload) {
+  async getTokens(
+    payload,
+    isRefreshToken = true,
+    accessTokenExpiry = '24h',
+    refreshTokenExpiry = '30d',
+  ) {
     const [accessToken, refreshToken] = await Promise.all([
       this.jwtService.signAsync(payload, {
         secret: this.configService.get<string>('JWT_SECRET'),
-        expiresIn: '24h',
-      }),
-      this.jwtService.signAsync(payload, {
-        secret: this.configService.get<string>('JWT_SECRET'),
-        expiresIn: '7d',
+        expiresIn: accessTokenExpiry,
       }),
+      isRefreshToken
+        ? this.jwtService.signAsync(payload, {
+            secret: this.configService.get<string>('JWT_SECRET'),
+            expiresIn: refreshTokenExpiry,
+          })
+        : null,
     ]);
 
     return {
       accessToken,
-      refreshToken,
+      ...(isRefreshToken ? { refreshToken } : {}),
     };
   }
 
@@ -105,6 +115,8 @@ export class AuthService {
       googleCode: user.googleCode,
       hasAcceptedWebAgreement: user.hasAcceptedWebAgreement,
       hasAcceptedAppAgreement: user.hasAcceptedAppAgreement,
+      project: user?.project,
+      bookingPoints: user?.bookingPoints,
     };
     if (payload.googleCode) {
       const profile = await this.getProfile(payload.googleCode);

libs/common/src/auth/strategies/jwt.strategy.ts

@@ -32,6 +32,7 @@ export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
         uuid: payload.uuid,
         sessionId: payload.sessionId,
         role: payload?.role,
+        project: payload?.project,
       };
     } else {
       throw new BadRequestException('Unauthorized');

libs/common/src/auth/strategies/refresh-token.strategy.ts

@@ -35,6 +35,7 @@ export class RefreshTokenStrategy extends PassportStrategy(
         uuid: payload.uuid,
         sessionId: payload.sessionId,
         role: payload?.role,
+        project: payload?.project,
       };
     } else {
       throw new BadRequestException('Unauthorized');

libs/common/src/common.module.ts

@@ -1,12 +1,11 @@
 import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { ErrorMessageService } from 'src/error-message/error-message.service';
+import { AuthModule } from './auth/auth.module';
 import { CommonService } from './common.service';
+import config from './config';
 import { DatabaseModule } from './database/database.module';
 import { HelperModule } from './helper/helper.module';
-import { AuthModule } from './auth/auth.module';
-import { ConfigModule } from '@nestjs/config';
-import config from './config';
-import { EmailService } from './util/email.service';
-import { ErrorMessageService } from 'src/error-message/error-message.service';
 import { TuyaService } from './integrations/tuya/services/tuya.service';
 import { SceneDeviceRepository } from './modules/scene-device/repositories';
 import { SpaceRepository } from './modules/space';
@@ -15,6 +14,7 @@ import {
   SubspaceModelRepository,
 } from './modules/space-model';
 import { SubspaceRepository } from './modules/space/repositories/subspace.repository';
+import { EmailService } from './util/email/email.service';
 @Module({
   providers: [
     CommonService,

libs/common/src/config/email.config.ts

@@ -10,6 +10,8 @@ export default registerAs(
     SMTP_USER: process.env.SMTP_USER,
     SMTP_SENDER: process.env.SMTP_SENDER,
     SMTP_PASSWORD: process.env.SMTP_PASSWORD,
+    BATCH_EMAIL_API_URL: process.env.BATCH_EMAIL_API_URL,
+    SEND_EMAIL_API_URL: process.env.SEND_EMAIL_API_URL,
     MAILTRAP_API_TOKEN: process.env.MAILTRAP_API_TOKEN,
     MAILTRAP_INVITATION_TEMPLATE_UUID:
       process.env.MAILTRAP_INVITATION_TEMPLATE_UUID,
@@ -19,5 +21,11 @@ export default registerAs(
       process.env.MAILTRAP_DELETE_USER_TEMPLATE_UUID,
     MAILTRAP_EDIT_USER_TEMPLATE_UUID:
       process.env.MAILTRAP_EDIT_USER_TEMPLATE_UUID,
+    MAILTRAP_SEND_OTP_TEMPLATE_UUID:
+      process.env.MAILTRAP_SEND_OTP_TEMPLATE_UUID,
+    MAILTRAP_SEND_BOOKING_AVAILABILITY_UPDATE_TEMPLATE_UUID:
+      process.env.MAILTRAP_SEND_BOOKING_AVAILABILITY_UPDATE_TEMPLATE_UUID,
+    MAILTRAP_SEND_BOOKING_TIMING_UPDATE_TEMPLATE_UUID:
+      process.env.MAILTRAP_SEND_BOOKING_TIMING_UPDATE_TEMPLATE_UUID,
   }),
 );

libs/common/src/constants/batch-device.enum.ts

@@ -0,0 +1,4 @@
+export enum BatchDeviceTypeEnum {
+  RESET = 'RESET',
+  COMMAND = 'COMMAND',
+}

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

@@ -1,4 +1,17 @@
 export class ControllerRoute {
+  static CLIENT = class {
+    public static readonly ROUTE = 'client';
+
+    static ACTIONS = class {
+      public static readonly REGISTER_NEW_CLIENT_SUMMARY =
+        'Register a new client';
+      public static readonly REGISTER_NEW_CLIENT_DESCRIPTION =
+        'This endpoint registers a new client in the system.';
+      public static readonly LOGIN_CLIENT_SUMMARY = 'Login a client';
+      public static readonly LOGIN_CLIENT_DESCRIPTION =
+        'This endpoint allows a client to log in to the system.';
+    };
+  };
   static PROJECT = class {
     public static readonly ROUTE = 'projects';
     static ACTIONS = class {
@@ -30,6 +43,11 @@ export class ControllerRoute {
         'Get user by uuid in project';
       public static readonly GET_USER_BY_UUID_IN_PROJECT_DESCRIPTION =
         'This endpoint retrieves a user by their unique identifier (UUID) associated with a specific project.';
+
+      public static readonly EXPORT_STRUCTURE_CSV_SUMMARY =
+        'Export project with their full structure to a CSV file';
+      public static readonly EXPORT_STRUCTURE_CSV_DESCRIPTION =
+        'This endpoint exports project along with their associated communities, spaces, and nested space hierarchy into a downloadable CSV file. Useful for backups, reports, or audits';
     };
   };
   static PROJECT_USER = class {
@@ -51,7 +69,47 @@ export class ControllerRoute {
         'Retrieve the list of all regions registered in Syncrow.';
     };
   };
+  static BOOKABLE_SPACES = class {
+    public static readonly ROUTE = 'bookable-spaces';
+    static ACTIONS = class {
+      public static readonly ADD_BOOKABLE_SPACES_SUMMARY =
+        'Add new bookable spaces';
 
+      public static readonly ADD_BOOKABLE_SPACES_DESCRIPTION =
+        'This endpoint allows you to add new bookable spaces by providing the required details.';
+
+      public static readonly GET_ALL_BOOKABLE_SPACES_SUMMARY =
+        'Get all bookable spaces';
+
+      public static readonly GET_ALL_BOOKABLE_SPACES_DESCRIPTION =
+        'This endpoint retrieves all bookable spaces.';
+
+      public static readonly UPDATE_BOOKABLE_SPACES_SUMMARY =
+        'Update existing bookable spaces';
+
+      public static readonly UPDATE_BOOKABLE_SPACES_DESCRIPTION =
+        'This endpoint allows you to update existing bookable spaces by providing the required details.';
+    };
+  };
+  static BOOKING = class {
+    public static readonly ROUTE = 'bookings';
+    static ACTIONS = class {
+      public static readonly ADD_BOOKING_SUMMARY = 'Add new booking';
+
+      public static readonly ADD_BOOKING_DESCRIPTION =
+        'This endpoint allows you to add new booking by providing the required details.';
+
+      public static readonly GET_ALL_BOOKINGS_SUMMARY = 'Get all bookings';
+
+      public static readonly GET_ALL_BOOKINGS_DESCRIPTION =
+        'This endpoint retrieves all bookings.';
+
+      public static readonly GET_MY_BOOKINGS_SUMMARY = 'Get my bookings';
+
+      public static readonly GET_MY_BOOKINGS_DESCRIPTION =
+        'This endpoint retrieves all bookings for the authenticated user.';
+    };
+  };
   static COMMUNITY = class {
     public static readonly ROUTE = '/projects/:projectUuid/communities';
     static ACTIONS = class {
@@ -181,6 +239,11 @@ export class ControllerRoute {
       public static readonly UPDATE_SPACE_DESCRIPTION =
         'Updates a space by its UUID and community ID. You can update the name, parent space, and other properties. If a parent space is provided and not already a parent, its `isParent` flag will be set to true.';
 
+      public static readonly UPDATE_CHILDREN_SPACES_ORDER_OF_A_SPACE_SUMMARY =
+        'Update the order of child spaces under a specific parent space';
+      public static readonly UPDATE_CHILDREN_SPACES_ORDER_OF_A_SPACE_DESCRIPTION =
+        'Updates the order of child spaces under a specific parent space. You can provide a new order for the child spaces.';
+
       public static readonly GET_HEIRARCHY_SUMMARY = 'Get space hierarchy';
       public static readonly GET_HEIRARCHY_DESCRIPTION =
         'This endpoint retrieves the hierarchical structure of spaces under a given space ID. It returns all the child spaces nested within the specified space, organized by their parent-child relationships. ';
@@ -197,7 +260,16 @@ export class ControllerRoute {
         'retrieves all the spaces associated with a given community, organized into a hierarchical structure.';
     };
   };
+  static SPACE_VALIDATION = class {
+    public static readonly ROUTE = '/projects/:projectUuid/spaces';
+    static ACTIONS = class {
+      public static readonly VALIDATE_SPACE_WITH_DEVICES_OR_SUBSPACES_SUMMARY =
+        'Check if a space has devices or sub-spaces';
 
+      public static readonly VALIDATE_SPACE_WITH_DEVICES_OR_SUBSPACES_DESCRIPTION =
+        'Checks if a space has any devices or sub-spaces associated with it.';
+    };
+  };
   static SPACE_SCENE = class {
     public static readonly ROUTE =
       '/projects/:projectUuid/communities/:communityUuid/spaces/:spaceUuid/scenes';
@@ -292,7 +364,7 @@ export class ControllerRoute {
       public static readonly CREATE_SPACE_MODEL_DESCRIPTION =
         'This endpoint allows you to create a new space model within a specified project. A space model defines the structure of spaces, including subspaces, products, and product items, and is uniquely identifiable within the project.';
 
-      public static readonly GET_SPACE_MODEL_SUMMARY = 'Get a New Space Model';
+      public static readonly GET_SPACE_MODEL_SUMMARY = 'Get a Space Model';
       public static readonly GET_SPACE_MODEL_DESCRIPTION =
         'Fetch a space model details';
 
@@ -307,12 +379,20 @@ export class ControllerRoute {
       public static readonly DELETE_SPACE_MODEL_SUMMARY = 'Delete Space Model';
       public static readonly DELETE_SPACE_MODEL_DESCRIPTION =
         'This endpoint allows you to delete a specified Space Model within a project. Deleting a Space Model disables the model and all its associated subspaces and tags, ensuring they are no longer active but remain in the system for auditing.';
+
+      public static readonly LINK_SPACE_MODEL_SUMMARY =
+        'Link a Space Model to spaces';
+      public static readonly LINK_SPACE_MODEL_DESCRIPTION =
+        'This endpoint allows you to link a specified Space Model within a project to multiple spaces. Linking a Space Model applies the model and all its associated subspaces and tags, to the spaces.';
     };
   };
 
   static PRODUCT = class {
     public static readonly ROUTE = 'products';
     static ACTIONS = class {
+      public static readonly CREATE_PRODUCT_SUMMARY = 'Create a new product';
+      public static readonly CREATE_PRODUCT_DESCRIPTION =
+        'This endpoint allows you to create a new product in the system.';
       public static readonly LIST_PRODUCT_SUMMARY = 'Retrieve all products';
       public static readonly LIST_PRODUCT_DESCRIPTION =
         'Fetches a list of all products along with their associated device details';
@@ -320,7 +400,7 @@ export class ControllerRoute {
   };
 
   static TAG = class {
-    public static readonly ROUTE = 'tags';
+    public static readonly ROUTE = '/projects/:projectUuid/tags';
     static ACTIONS = class {
       public static readonly CREATE_TAG_SUMMARY = 'Create a new tag';
       public static readonly CREATE_TAG_DESCRIPTION =
@@ -362,6 +442,11 @@ export class ControllerRoute {
       public static readonly DELETE_USER_SUMMARY = 'Delete user by UUID';
       public static readonly DELETE_USER_DESCRIPTION =
         'This endpoint deletes a user identified by their UUID. Accessible only by users with the Super Admin role.';
+
+      public static readonly DELETE_USER_PROFILE_SUMMARY =
+        'Delete user profile by UUID';
+      public static readonly DELETE_USER_PROFILE_DESCRIPTION =
+        'This endpoint deletes a user profile identified by their UUID. Accessible only by users with the Super Admin role.';
       public static readonly UPDATE_USER_WEB_AGREEMENT_SUMMARY =
         'Update user web agreement by user UUID';
       public static readonly UPDATE_USER_WEB_AGREEMENT_DESCRIPTION =
@@ -430,7 +515,16 @@ export class ControllerRoute {
         'This endpoint retrieves the terms and conditions for the application.';
     };
   };
+  static WEATHER = class {
+    public static readonly ROUTE = 'weather';
 
+    static ACTIONS = class {
+      public static readonly FETCH_WEATHER_DETAILS_SUMMARY =
+        'Fetch Weather Details';
+      public static readonly FETCH_WEATHER_DETAILS_DESCRIPTION =
+        'This endpoint retrieves the current weather details for a specified location like temperature, humidity, etc.';
+    };
+  };
   static PRIVACY_POLICY = class {
     public static readonly ROUTE = 'policy';
 
@@ -455,18 +549,51 @@ export class ControllerRoute {
         'This endpoint retrieves all devices in a specified group within a space, based on the group name and space UUID.';
     };
   };
-  static DEVICE = class {
-    public static readonly ROUTE = 'device';
+  static PowerClamp = class {
+    public static readonly ROUTE = 'power-clamp';
+    static ACTIONS = class {
+      public static readonly GET_ENERGY_SUMMARY =
+        'Get power clamp historical data';
+      public static readonly GET_ENERGY_DESCRIPTION =
+        'This endpoint retrieves the historical data of a power clamp device based on the provided parameters.';
+      public static readonly GET_ENERGY_BY_COMMUNITY_OR_SPACE_SUMMARY =
+        'Get power clamp historical data by community or space';
+      public static readonly GET_ENERGY_BY_COMMUNITY_OR_SPACE_DESCRIPTION =
+        'This endpoint retrieves the historical data of power clamp devices based on the provided community or space UUID.';
+    };
+  };
+
+  static Occupancy = class {
+    public static readonly ROUTE = 'occupancy';
 
     static ACTIONS = class {
-      public static readonly ADD_DEVICE_TO_USER_SUMMARY = 'Add device to user';
-      public static readonly ADD_DEVICE_TO_USER_DESCRIPTION =
-        'This endpoint adds a device to a user in the system.';
+      public static readonly GET_OCCUPANCY_HEAT_MAP_SUMMARY =
+        'Get occupancy heat map data';
+      public static readonly GET_OCCUPANCY_HEAT_MAP_DESCRIPTION =
+        'This endpoint retrieves the occupancy heat map data based on the provided parameters.';
+    };
+  };
+  static AQI = class {
+    public static readonly ROUTE = 'aqi';
 
-      public static readonly GET_DEVICES_BY_USER_SUMMARY =
-        'Get devices by user UUID';
-      public static readonly GET_DEVICES_BY_USER_DESCRIPTION =
-        'This endpoint retrieves all devices associated with a specific user.';
+    static ACTIONS = class {
+      public static readonly GET_AQI_RANGE_DATA_SUMMARY = 'Get AQI range data';
+      public static readonly GET_AQI_RANGE_DATA_DESCRIPTION =
+        'This endpoint retrieves the AQI (Air Quality Index) range data based on the provided parameters.';
+
+      public static readonly GET_AQI_DISTRIBUTION_DATA_SUMMARY =
+        'Get AQI distribution data';
+      public static readonly GET_AQI_DISTRIBUTION_DATA_DESCRIPTION =
+        'This endpoint retrieves the AQI (Air Quality Index) distribution data based on the provided parameters.';
+    };
+  };
+  static DEVICE = class {
+    public static readonly ROUTE = 'devices';
+
+    static ACTIONS = class {
+      public static readonly ADD_DEVICE_SUMMARY = 'Add new device';
+      public static readonly ADD_DEVICE_DESCRIPTION =
+        'This endpoint adds a new device in the system.';
 
       public static readonly GET_DEVICES_BY_SPACE_UUID_SUMMARY =
         'Get devices by space UUID';
@@ -538,18 +665,51 @@ export class ControllerRoute {
         'This endpoint retrieves the status of a specific power clamp device.';
 
       public static readonly ADD_SCENE_TO_DEVICE_SUMMARY =
-        'Add scene to device (4 Scene and 6 Scene devices only)';
+        'Add scene to device';
       public static readonly ADD_SCENE_TO_DEVICE_DESCRIPTION =
         'This endpoint adds a scene to a specific switch device.';
 
       public static readonly GET_SCENES_BY_DEVICE_SUMMARY =
-        'Get scenes by device (4 Scene and 6 Scene devices only)';
+        'Get scenes by device';
       public static readonly GET_SCENES_BY_DEVICE_DESCRIPTION =
         'This endpoint retrieves all scenes associated with a specific switch device.';
       public static readonly DELETE_SCENES_BY_SWITCH_NAME_SUMMARY =
-        'Delete scenes by device uuid and switch name (4 Scene and 6 Scene devices only)';
+        'Delete scenes by device uuid and switch name';
       public static readonly DELETE_SCENES_BY_SWITCH_NAME_DESCRIPTION =
         'This endpoint deletes all scenes associated with a specific switch device.';
+
+      public static readonly POPULATE_TUYA_CONST_UUID_SUMMARY =
+        'Populate Tuya const UUID';
+      public static readonly POPULATE_TUYA_CONST_UUID_DESCRIPTION =
+        'This endpoint populates the Tuya const UUID for all devices.';
+    };
+  };
+  static DEVICE_COMMISSION = class {
+    public static readonly ROUTE = '/projects/:projectUuid/devices/commission';
+
+    static ACTIONS = class {
+      public static readonly ADD_ALL_DEVICES_SUMMARY = 'Add all devices';
+      public static readonly ADD_ALL_DEVICES_DESCRIPTION =
+        'This endpoint add all devices in the system from tuya.';
+    };
+  };
+  static DEVICE_PROJECT = class {
+    public static readonly ROUTE = '/projects/:projectUuid/devices';
+    static ACTIONS = class {
+      public static readonly GET_ALL_DEVICES_SUMMARY = 'Get all devices';
+      public static readonly GET_ALL_DEVICES_DESCRIPTION =
+        'This endpoint retrieves all devices in the system.';
+    };
+  };
+  static DEVICE_SPACE_COMMUNITY = class {
+    public static readonly ROUTE = 'devices-space-community';
+
+    static ACTIONS = class {
+      public static readonly GET_ALL_DEVICES_BY_SPACE_OR_COMMUNITY_WITH_RECURSIVE_CHILD_SUMMARY =
+        'Get all devices by space or community with recursive child';
+
+      public static readonly GET_ALL_DEVICES_BY_SPACE_OR_COMMUNITY_WITH_RECURSIVE_CHILD_DESCRIPTION =
+        'This endpoint retrieves all devices in the system by space or community with recursive child.';
     };
   };
 
@@ -601,18 +761,13 @@ export class ControllerRoute {
   };
 
   static AUTOMATION = class {
-    public static readonly ROUTE = 'automation';
+    public static readonly ROUTE = '/projects/:projectUuid/automations';
 
     static ACTIONS = class {
       public static readonly ADD_AUTOMATION_SUMMARY = 'Add automation';
       public static readonly ADD_AUTOMATION_DESCRIPTION =
         'This endpoint creates a new automation based on the provided details.';
 
-      public static readonly GET_AUTOMATION_BY_SPACE_SUMMARY =
-        'Get automation by space';
-      public static readonly GET_AUTOMATION_BY_SPACE_DESCRIPTION =
-        'This endpoint retrieves the automations associated with a particular space.';
-
       public static readonly GET_AUTOMATION_DETAILS_SUMMARY =
         'Get automation details';
       public static readonly GET_AUTOMATION_DETAILS_DESCRIPTION =
@@ -633,6 +788,17 @@ export class ControllerRoute {
     };
   };
 
+  static AUTOMATION_SPACE = class {
+    public static readonly ROUTE =
+      '/projects/:projectUuid/communities/:communityUuid/spaces/:spaceUuid/automations';
+    static ACTIONS = class {
+      public static readonly GET_AUTOMATION_BY_SPACE_SUMMARY =
+        'Get automation by space';
+      public static readonly GET_AUTOMATION_BY_SPACE_DESCRIPTION =
+        'This endpoint retrieves the automations associated with a particular space.';
+    };
+  };
+
   static DOOR_LOCK = class {
     public static readonly ROUTE = 'door-lock';
 
@@ -692,29 +858,15 @@ export class ControllerRoute {
     };
   };
   static VISITOR_PASSWORD = class {
-    public static readonly ROUTE = 'visitor-password';
+    public static readonly ROUTE = 'visitor-passwords';
+    public static readonly PROJECT_ROUTE =
+      '/projects/:projectUuid/visitor-password';
 
     static ACTIONS = class {
-      public static readonly ADD_ONLINE_TEMP_PASSWORD_MULTIPLE_TIME_SUMMARY =
-        'Add online temporary passwords (multiple-time)';
-      public static readonly ADD_ONLINE_TEMP_PASSWORD_MULTIPLE_TIME_DESCRIPTION =
-        'This endpoint adds multiple online temporary passwords for door locks.';
-
-      public static readonly ADD_ONLINE_TEMP_PASSWORD_ONE_TIME_SUMMARY =
-        'Add online temporary password (one-time)';
-      public static readonly ADD_ONLINE_TEMP_PASSWORD_ONE_TIME_DESCRIPTION =
-        'This endpoint adds a one-time online temporary password for a door lock.';
-
-      public static readonly ADD_OFFLINE_TEMP_PASSWORD_ONE_TIME_SUMMARY =
-        'Add offline temporary password (one-time)';
-      public static readonly ADD_OFFLINE_TEMP_PASSWORD_ONE_TIME_DESCRIPTION =
-        'This endpoint adds a one-time offline temporary password for a door lock.';
-
-      public static readonly ADD_OFFLINE_TEMP_PASSWORD_MULTIPLE_TIME_SUMMARY =
-        'Add offline temporary passwords (multiple-time)';
-      public static readonly ADD_OFFLINE_TEMP_PASSWORD_MULTIPLE_TIME_DESCRIPTION =
-        'This endpoint adds multiple offline temporary passwords for door locks.';
-
+      public static readonly ADD_VISITOR_PASSWORD_SUMMARY =
+        'Add visitor password';
+      public static readonly ADD_VISITOR_PASSWORD_DESCRIPTION =
+        'This endpoint allows you to add a visitor password based on the operation type.';
       public static readonly GET_VISITOR_PASSWORD_SUMMARY =
         'Get visitor passwords';
       public static readonly GET_VISITOR_PASSWORD_DESCRIPTION =

libs/common/src/constants/device-type.enum.ts

@@ -0,0 +1,3 @@
+export enum DeviceTypeEnum {
+  DOOR_LOCK = 'DOOR_LOCK',
+}

libs/common/src/constants/mail-trap.ts

@@ -1,3 +0,0 @@
-export const SEND_EMAIL_API_URL_PROD = 'https://send.api.mailtrap.io/api/send/';
-export const SEND_EMAIL_API_URL_DEV =
-  'https://sandbox.api.mailtrap.io/api/send/2634012';

libs/common/src/constants/pollutants.enum.ts

@@ -0,0 +1,8 @@
+export enum PollutantType {
+  AQI = 'aqi',
+  PM25 = 'pm25',
+  PM10 = 'pm10',
+  VOC = 'voc',
+  CO2 = 'co2',
+  CH2O = 'ch2o',
+}

libs/common/src/constants/power.clamp.enargy.enum.ts

@@ -0,0 +1,6 @@
+export enum PowerClampEnergyEnum {
+  ENERGY_CONSUMED = 'EnergyConsumed',
+  ENERGY_CONSUMED_A = 'EnergyConsumedA',
+  ENERGY_CONSUMED_B = 'EnergyConsumedB',
+  ENERGY_CONSUMED_C = 'EnergyConsumedC',
+}

libs/common/src/constants/presence.sensor.enum.ts

@@ -0,0 +1,4 @@
+export enum PresenceSensorEnum {
+  PRESENCE_STATE = 'presence_state',
+  SENSITIVITY = 'sensitivity',
+}

libs/common/src/constants/product-type.enum.ts

@@ -15,8 +15,10 @@ export enum ProductType {
   WL = 'WL',
   GD = 'GD',
   CUR = 'CUR',
+  CUR_2 = 'CUR_2',
   PC = 'PC',
   FOUR_S = '4S',
   SIX_S = '6S',
   SOS = 'SOS',
+  AQI = 'AQI',
 }

libs/common/src/constants/role-permissions.ts

@@ -3,12 +3,14 @@ import { RoleType } from './role.type.enum';
 export const RolePermissions = {
   [RoleType.SUPER_ADMIN]: [
     'DEVICE_SINGLE_CONTROL',
+    'COMMISSION_DEVICE',
     'DEVICE_VIEW',
     'DEVICE_DELETE',
     'DEVICE_UPDATE',
     'DEVICE_BATCH_CONTROL',
     'DEVICE_LOCATION_VIEW',
     'DEVICE_LOCATION_UPDATE',
+    'DEVICE_ADD',
     'COMMUNITY_VIEW',
     'COMMUNITY_ADD',
     'COMMUNITY_UPDATE',
@@ -23,6 +25,7 @@ export const RolePermissions = {
     'SPACE_MODEL_VIEW',
     'SPACE_MODEL_UPDATE',
     'SPACE_MODEL_DELETE',
+    'SPACE_MODEL_LINK',
     'SPACE_ASSIGN_USER_TO_SPACE',
     'SPACE_DELETE_USER_FROM_SPACE',
     'SUBSPACE_VIEW',
@@ -52,12 +55,16 @@ export const RolePermissions = {
     'VISITOR_PASSWORD_DELETE',
     'USER_ADD',
     'SPACE_MEMBER_ADD',
+    'COMMISSION_DEVICE',
+    'PRODUCT_ADD',
   ],
   [RoleType.ADMIN]: [
+    'COMMISSION_DEVICE',
     'DEVICE_SINGLE_CONTROL',
     'DEVICE_VIEW',
     'DEVICE_DELETE',
     'DEVICE_UPDATE',
+    'DEVICE_ADD',
     'DEVICE_BATCH_CONTROL',
     'DEVICE_LOCATION_VIEW',
     'DEVICE_LOCATION_UPDATE',
@@ -75,6 +82,7 @@ export const RolePermissions = {
     'SPACE_MODEL_VIEW',
     'SPACE_MODEL_UPDATE',
     'SPACE_MODEL_DELETE',
+    'SPACE_MODEL_LINK',
     'SPACE_ASSIGN_USER_TO_SPACE',
     'SPACE_DELETE_USER_FROM_SPACE',
     'SUBSPACE_VIEW',
@@ -104,6 +112,8 @@ export const RolePermissions = {
     'VISITOR_PASSWORD_DELETE',
     'USER_ADD',
     'SPACE_MEMBER_ADD',
+    'COMMISSION_DEVICE',
+    'PRODUCT_ADD',
   ],
   [RoleType.SPACE_MEMBER]: [
     'DEVICE_SINGLE_CONTROL',
@@ -119,6 +129,7 @@ export const RolePermissions = {
     'SCENES_CONTROL',
   ],
   [RoleType.SPACE_OWNER]: [
+    'COMMISSION_DEVICE',
     'DEVICE_SINGLE_CONTROL',
     'DEVICE_VIEW',
     'DEVICE_DELETE',
@@ -161,5 +172,6 @@ export const RolePermissions = {
     'VISITOR_PASSWORD_DELETE',
     'USER_ADD',
     'SPACE_MEMBER_ADD',
+    'COMMISSION_DEVICE',
   ],
 };

libs/common/src/constants/sql-query-path.ts

@@ -0,0 +1,2 @@
+export const SQL_QUERIES_PATH = 'libs/common/src/sql/queries';
+export const SQL_PROCEDURES_PATH = 'libs/common/src/sql/procedures';

libs/common/src/constants/visitor-password.enum.ts

@@ -0,0 +1,6 @@
+export enum VisitorPasswordEnum {
+  ONLINE_ONE_TIME = 'ONLINE_ONE_TIME',
+  ONLINE_MULTIPLE_TIME = 'ONLINE_MULTIPLE_TIME',
+  OFFLINE_ONE_TIME = 'OFFLINE_ONE_TIME',
+  OFFLINE_MULTIPLE_TIME = 'OFFLINE_MULTIPLE_TIME',
+}

libs/common/src/context/request-context.ts

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+export interface RequestContextStore {
+  requestId?: string;
+  userId?: string;
+}
+
+export const requestContext = new AsyncLocalStorage<RequestContextStore>();

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

@@ -1,113 +1,145 @@
 import { Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { TypeOrmModule } from '@nestjs/typeorm';
-import { SnakeNamingStrategy } from './strategies';
-import { UserEntity } from '../modules/user/entities/user.entity';
-import { UserSessionEntity } from '../modules/session/entities/session.entity';
-import { UserOtpEntity } from '../modules/user/entities';
-import { ProductEntity } from '../modules/product/entities';
 import { DeviceEntity } from '../modules/device/entities';
 import { PermissionTypeEntity } from '../modules/permission/entities';
+import { ProductEntity } from '../modules/product/entities';
+import { UserSessionEntity } from '../modules/session/entities/session.entity';
+import { UserOtpEntity } from '../modules/user/entities';
+import { UserEntity } from '../modules/user/entities/user.entity';
+import { SnakeNamingStrategy } from './strategies';
 
-import { UserSpaceEntity } from '../modules/user/entities';
-import { DeviceUserPermissionEntity } from '../modules/device/entities';
-import { RoleTypeEntity } from '../modules/role-type/entities';
-import { UserNotificationEntity } from '../modules/user/entities';
-import { DeviceNotificationEntity } from '../modules/device/entities';
-import { RegionEntity } from '../modules/region/entities';
-import { TimeZoneEntity } from '../modules/timezone/entities';
-import { VisitorPasswordEntity } from '../modules/visitor-password/entities';
+import { TypeOrmWinstonLogger } from '@app/common/logger/services/typeorm.logger';
+import { createLogger } from 'winston';
+import { winstonLoggerOptions } from '../logger/services/winston.logger';
+import { AqiSpaceDailyPollutantStatsEntity } from '../modules/aqi/entities';
+import { AutomationEntity } from '../modules/automation/entities';
+import { BookableSpaceEntity } from '../modules/booking/entities/bookable-space.entity';
+import { BookingEntity } from '../modules/booking/entities/booking.entity';
+import { ClientEntity } from '../modules/client/entities';
 import { CommunityEntity } from '../modules/community/entities';
 import { DeviceStatusLogEntity } from '../modules/device-status-log/entities';
-import { SceneEntity, SceneIconEntity } from '../modules/scene/entities';
-import { SceneDeviceEntity } from '../modules/scene-device/entities';
-import { ProjectEntity } from '../modules/project/entities';
 import {
-  SpaceModelEntity,
-  SubspaceModelEntity,
-  TagModel,
-  SpaceModelProductAllocationEntity,
-  SubspaceModelProductAllocationEntity,
-} from '../modules/space-model/entities';
+  DeviceNotificationEntity,
+  DeviceUserPermissionEntity,
+} from '../modules/device/entities';
 import {
   InviteUserEntity,
   InviteUserSpaceEntity,
 } from '../modules/Invite-user/entities';
+import { SpaceDailyOccupancyDurationEntity } from '../modules/occupancy/entities';
+import {
+  PowerClampDailyEntity,
+  PowerClampHourlyEntity,
+  PowerClampMonthlyEntity,
+} from '../modules/power-clamp/entities/power-clamp.entity';
+import {
+  PresenceSensorDailyDeviceEntity,
+  PresenceSensorDailySpaceEntity,
+} from '../modules/presence-sensor/entities';
+import { ProjectEntity } from '../modules/project/entities';
+import { RegionEntity } from '../modules/region/entities';
+import { RoleTypeEntity } from '../modules/role-type/entities';
+import { SceneDeviceEntity } from '../modules/scene-device/entities';
+import { SceneEntity, SceneIconEntity } from '../modules/scene/entities';
+import {
+  SpaceModelEntity,
+  SpaceModelProductAllocationEntity,
+  SubspaceModelEntity,
+  SubspaceModelProductAllocationEntity,
+} from '../modules/space-model/entities';
 import { InviteSpaceEntity } from '../modules/space/entities/invite-space.entity';
-import { AutomationEntity } from '../modules/automation/entities';
 import { SpaceProductAllocationEntity } from '../modules/space/entities/space-product-allocation.entity';
-import { NewTagEntity } from '../modules/tag/entities/tag.entity';
 import { SpaceEntity } from '../modules/space/entities/space.entity';
-import { SpaceLinkEntity } from '../modules/space/entities/space-link.entity';
 import { SubspaceProductAllocationEntity } from '../modules/space/entities/subspace/subspace-product-allocation.entity';
 import { SubspaceEntity } from '../modules/space/entities/subspace/subspace.entity';
-import { TagEntity } from '../modules/space/entities/tag.entity';
+import { NewTagEntity } from '../modules/tag/entities/tag.entity';
+import { TimeZoneEntity } from '../modules/timezone/entities';
+import {
+  UserNotificationEntity,
+  UserSpaceEntity,
+} from '../modules/user/entities';
+import { VisitorPasswordEntity } from '../modules/visitor-password/entities';
 @Module({
   imports: [
     TypeOrmModule.forRootAsync({
       imports: [ConfigModule],
       inject: [ConfigService],
-      useFactory: (configService: ConfigService) => ({
-        name: 'default',
-        type: 'postgres',
-        host: configService.get('DB_HOST'),
-        port: configService.get('DB_PORT'),
-        username: configService.get('DB_USER'),
-        password: configService.get('DB_PASSWORD'),
-        database: configService.get('DB_NAME'),
-        entities: [
-          NewTagEntity,
-          ProjectEntity,
-          UserEntity,
-          UserSessionEntity,
-          UserOtpEntity,
-          ProductEntity,
-          DeviceUserPermissionEntity,
-          DeviceEntity,
-          PermissionTypeEntity,
-          CommunityEntity,
-          SpaceEntity,
-          SpaceLinkEntity,
-          SubspaceEntity,
-          TagEntity,
-          UserSpaceEntity,
-          DeviceUserPermissionEntity,
-          RoleTypeEntity,
-          UserNotificationEntity,
-          DeviceNotificationEntity,
-          RegionEntity,
-          TimeZoneEntity,
-          VisitorPasswordEntity,
-          DeviceStatusLogEntity,
-          SceneEntity,
-          SceneIconEntity,
-          SceneDeviceEntity,
-          SpaceModelEntity,
-          SubspaceModelEntity,
-          TagModel,
-          InviteUserEntity,
-          InviteUserSpaceEntity,
-          InviteSpaceEntity,
-          AutomationEntity,
-          SpaceModelProductAllocationEntity,
-          SubspaceModelProductAllocationEntity,
-          SpaceProductAllocationEntity,
-          SubspaceProductAllocationEntity,
-        ],
-        namingStrategy: new SnakeNamingStrategy(),
-        synchronize: Boolean(JSON.parse(configService.get('DB_SYNC'))),
-        logging: false,
-        extra: {
-          charset: 'utf8mb4',
-          max: 20, // set pool max size
-          idleTimeoutMillis: 5000, // close idle clients after 5 second
-          connectionTimeoutMillis: 11_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)
-        },
-        continuationLocalStorage: true,
-        ssl: Boolean(JSON.parse(configService.get('DB_SSL'))),
-      }),
+      useFactory: (configService: ConfigService) => {
+        const winstonLogger = createLogger(winstonLoggerOptions);
+        const typeOrmLogger = new TypeOrmWinstonLogger(winstonLogger);
+        return {
+          name: 'default',
+          type: 'postgres',
+          host: configService.get('DB_HOST'),
+          port: configService.get('DB_PORT'),
+          username: configService.get('DB_USER'),
+          password: configService.get('DB_PASSWORD'),
+          database: configService.get('DB_NAME'),
+          entities: [
+            NewTagEntity,
+            ProjectEntity,
+            UserEntity,
+            UserSessionEntity,
+            UserOtpEntity,
+            ProductEntity,
+            DeviceUserPermissionEntity,
+            DeviceEntity,
+            PermissionTypeEntity,
+            CommunityEntity,
+            SpaceEntity,
+            SubspaceEntity,
+            UserSpaceEntity,
+            DeviceUserPermissionEntity,
+            RoleTypeEntity,
+            UserNotificationEntity,
+            DeviceNotificationEntity,
+            RegionEntity,
+            TimeZoneEntity,
+            VisitorPasswordEntity,
+            DeviceStatusLogEntity,
+            SceneEntity,
+            SceneIconEntity,
+            SceneDeviceEntity,
+            SpaceModelEntity,
+            SubspaceModelEntity,
+            InviteUserEntity,
+            InviteUserSpaceEntity,
+            InviteSpaceEntity,
+            AutomationEntity,
+            SpaceModelProductAllocationEntity,
+            SubspaceModelProductAllocationEntity,
+            SpaceProductAllocationEntity,
+            SubspaceProductAllocationEntity,
+            ClientEntity,
+            PowerClampHourlyEntity,
+            PowerClampDailyEntity,
+            PowerClampMonthlyEntity,
+            PresenceSensorDailyDeviceEntity,
+            PresenceSensorDailySpaceEntity,
+            AqiSpaceDailyPollutantStatsEntity,
+            SpaceDailyOccupancyDurationEntity,
+            BookableSpaceEntity,
+            BookingEntity,
+          ],
+          namingStrategy: new SnakeNamingStrategy(),
+          synchronize: Boolean(JSON.parse(configService.get('DB_SYNC'))),
+          logging: ['query', 'error', 'warn', 'schema', 'migration'],
+
+          logger: typeOrmLogger,
+          extra: {
+            charset: 'utf8mb4',
+            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)
+          },
+          continuationLocalStorage: true,
+          ssl: Boolean(JSON.parse(configService.get('DB_SSL'))),
+        };
+      },
     }),
   ],
+  providers: [TypeOrmWinstonLogger],
 })
 export class DatabaseModule {}

libs/common/src/dto/community-space.param.ts

@@ -0,0 +1,12 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ProjectParam } from './project-param.dto';
+import { IsUUID } from 'class-validator';
+
+export class CommunityParam extends ProjectParam {
+  @ApiProperty({
+    description: 'UUID of the community this space belongs to',
+    example: 'd290f1ee-6c54-4b01-90e6-d701748f0851',
+  })
+  @IsUUID()
+  communityUuid: string;
+}

libs/common/src/dto/get.space.param.ts

@@ -0,0 +1,12 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsUUID } from 'class-validator';
+import { CommunityParam } from './community-space.param';
+
+export class GetSpaceParam extends CommunityParam {
+  @ApiProperty({
+    description: 'UUID of the Space',
+    example: 'd290f1ee-6c54-4b01-90e6-d701748f0851',
+  })
+  @IsUUID()
+  spaceUuid: string;
+}

libs/common/src/dto/pagination-with-search.request.dto.ts

@@ -0,0 +1,13 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsOptional } from 'class-validator';
+import { PaginationRequestGetListDto } from './pagination.request.dto';
+
+export class PaginationRequestWithSearchGetListDto extends PaginationRequestGetListDto {
+  @IsOptional()
+  @ApiProperty({
+    name: 'search',
+    required: false,
+    description: 'Search for community or space name',
+  })
+  search?: string;
+}

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

@@ -1,11 +1,24 @@
-import { 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({
+    example: true,
+    description: 'include spaces',
+    required: false,
+    default: false,
+  })
+  @IsOptional()
+  @IsBoolean()
+  @Transform((value) => {
+    return value.obj.includeSpaces === BooleanValues.TRUE;
+  })
+  public includeSpaces?: boolean = false;
+
   @IsOptional()
   @IsPageRequestParam({
     message: 'Page must be bigger than 0',
@@ -27,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/dto/project-param.dto.ts

@@ -1,7 +1,7 @@
 import { ApiProperty } from '@nestjs/swagger';
 import { IsUUID } from 'class-validator';
 
-export class GetTagsParam {
+export class ProjectParam {
   @ApiProperty({
     description: 'UUID of the Project',
     example: 'd290f1ee-6c54-4b01-90e6-d701748f0851',

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

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

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

@@ -1,21 +1,29 @@
+import { DeviceStatusLogRepository } from '@app/common/modules/device-status-log/repositories';
+import { DeviceRepository } from '@app/common/modules/device/repositories';
 import {
   HttpException,
   HttpStatus,
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
-import { AddDeviceStatusDto } from '../dtos/add.devices-status.dto';
-import { DeviceRepository } from '@app/common/modules/device/repositories';
-import { GetDeviceDetailsFunctionsStatusInterface } from 'src/device/interfaces/get.device.interface';
-import { TuyaContext } from '@tuya/tuya-connector-nodejs';
 import { ConfigService } from '@nestjs/config';
+import { TuyaContext } from '@tuya/tuya-connector-nodejs';
+import {
+  Database,
+  DataSnapshot,
+  get,
+  ref,
+  runTransaction,
+} from 'firebase/database';
+import { GetDeviceDetailsFunctionsStatusInterface } from 'src/device/interfaces/get.device.interface';
 import { firebaseDataBase } from '../../firebase.config';
-import { Database, DataSnapshot, get, ref, set } from 'firebase/database';
-import { DeviceStatusLogRepository } from '@app/common/modules/device-status-log/repositories';
+import { AddDeviceStatusDto } from '../dtos/add.devices-status.dto';
 @Injectable()
 export class DeviceStatusFirebaseService {
   private tuya: TuyaContext;
   private firebaseDb: Database;
+  private readonly isDevEnv: boolean;
+
   constructor(
     private readonly configService: ConfigService,
     private readonly deviceRepository: DeviceRepository,
@@ -32,6 +40,8 @@ export class DeviceStatusFirebaseService {
 
     // Initialize firebaseDb using firebaseDataBase function
     this.firebaseDb = firebaseDataBase(this.configService);
+    this.isDevEnv =
+      this.configService.get<string>('NODE_ENV') === 'development';
   }
   async addDeviceStatusByDeviceUuid(
     deviceTuyaUuid: string,
@@ -46,7 +56,7 @@ export class DeviceStatusFirebaseService {
           const deviceStatusSaved = await this.createDeviceStatusFirebase({
             deviceUuid: device.uuid,
             deviceTuyaUuid: deviceTuyaUuid,
-            status: deviceStatus.status,
+            status: deviceStatus?.status,
             productUuid: deviceStatus.productUuid,
             productType: deviceStatus.productType,
           });
@@ -61,24 +71,107 @@ export class DeviceStatusFirebaseService {
       );
     }
   }
-  async addDeviceStatusToFirebase(
-    addDeviceStatusDto: AddDeviceStatusDto,
-  ): Promise<AddDeviceStatusDto | null> {
-    try {
-      const device = await this.getDeviceByDeviceTuyaUuid(
-        addDeviceStatusDto.deviceTuyaUuid,
+  async addBatchDeviceStatusToOurDb(
+    batch: {
+      deviceTuyaUuid: string;
+      status: any;
+      log: any;
+      device: any;
+    }[],
+  ): Promise<void> {
+    console.log(`🔁 Preparing logs from batch of ${batch.length} items...`);
+
+    const allLogs = [];
+
+    for (const item of batch) {
+      const device = item.device;
+
+      if (!device?.uuid) {
+        console.log(`⛔ Skipped unknown device: ${item.deviceTuyaUuid}`);
+        continue;
+      }
+
+      // Determine properties based on environment
+      const properties =
+        this.isDevEnv && Array.isArray(item.log?.properties)
+          ? item.log.properties
+          : Array.isArray(item.status)
+            ? item.status
+            : null;
+
+      if (!properties) {
+        console.log(
+          `⛔ Skipped invalid status/properties for device: ${item.deviceTuyaUuid}`,
+        );
+        continue;
+      }
+
+      const logs = properties.map((property) =>
+        this.deviceStatusLogRepository.create({
+          deviceId: device.uuid,
+          deviceTuyaId: item.deviceTuyaUuid,
+          productId: device.productDevice?.uuid,
+          log: item.log,
+          code: property.code,
+          value: property.value,
+          eventId: item.log?.dataId,
+          eventTime: new Date(
+            this.isDevEnv ? property.time : property.t,
+          ).toISOString(),
+        }),
       );
 
+      allLogs.push(...logs);
+    }
+
+    console.log(`📝 Total logs to insert: ${allLogs.length}`);
+
+    const 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')
+          .values(chunk)
+          .orIgnore()
+          .execute();
+
+        insertedCount += result.identifiers.length;
+        console.log(
+          `✅ Inserted ${result.identifiers.length} / ${chunk.length} logs (chunk)`,
+        );
+      } catch (error) {
+        console.error('❌ Insert error (skipped chunk):', error.message);
+      }
+    }
+
+    console.log(`✅ Total logs inserted: ${insertedCount} / ${allLogs.length}`);
+  }
+
+  async addDeviceStatusToFirebase(
+    addDeviceStatusDto: AddDeviceStatusDto & { device?: any },
+  ): Promise<AddDeviceStatusDto | null> {
+    try {
+      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,
         });
       }
       // 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;
     }
   }
@@ -92,6 +185,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);
@@ -106,7 +208,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(
@@ -154,56 +256,49 @@ export class DeviceStatusFirebaseService {
       this.firebaseDb,
       `device-status/${addDeviceStatusDto.deviceUuid}`,
     );
-    const snapshot: DataSnapshot = await get(dataRef);
-    const existingData = snapshot.val() || {};
 
-    // Assign default values if fields are not present
-    if (!existingData.deviceTuyaUuid) {
-      existingData.deviceTuyaUuid = addDeviceStatusDto.deviceTuyaUuid;
-    }
-    if (!existingData.productUuid) {
-      existingData.productUuid = addDeviceStatusDto.productUuid;
-    }
-    if (!existingData.productType) {
-      existingData.productType = addDeviceStatusDto.productType;
-    }
-    if (!existingData.status) {
-      existingData.status = [];
-    }
+    // Use a transaction to handle concurrent updates
+    await runTransaction(dataRef, (existingData) => {
+      if (!existingData) {
+        existingData = {};
+      }
 
-    // Create a map to track existing status codes
-    const statusMap = new Map(
-      existingData.status.map((item) => [item.code, item.value]),
-    );
+      // Assign default values if fields are not present
+      if (!existingData.deviceTuyaUuid) {
+        existingData.deviceTuyaUuid = addDeviceStatusDto.deviceTuyaUuid;
+      }
+      if (!existingData.productUuid) {
+        existingData.productUuid = addDeviceStatusDto.productUuid;
+      }
+      if (!existingData.productType) {
+        existingData.productType = addDeviceStatusDto.productType;
+      }
+      if (!existingData?.status) {
+        existingData.status = [];
+      }
 
-    // Update or add status codes
+      // Create a map to track existing status codes
+      const statusMap = new Map(
+        existingData?.status.map((item) => [item.code, item.value]),
+      );
 
-    for (const statusItem of addDeviceStatusDto.status) {
-      statusMap.set(statusItem.code, statusItem.value);
-    }
+      // Update or add status codes
 
-    // Convert the map back to an array format
-    existingData.status = Array.from(statusMap, ([code, value]) => ({
-      code,
-      value,
-    }));
-    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(),
-      });
+      for (const statusItem of addDeviceStatusDto?.status) {
+        statusMap.set(statusItem.code, statusItem.value);
+      }
+
+      // Convert the map back to an array format
+      existingData.status = Array.from(statusMap, ([code, value]) => ({
+        code,
+        value,
+      }));
+
+      return existingData;
     });
-    await this.deviceStatusLogRepository.save(newLogs);
-    // Save the updated data to Firebase
-    await set(dataRef, existingData);
 
     // Return the updated data
-    return existingData;
+    const snapshot: DataSnapshot = await get(dataRef);
+    return snapshot.val();
   }
 }

libs/common/src/firebase/firebase.config.ts

@@ -3,21 +3,32 @@ import { getDatabase } from 'firebase/database';
 import { ConfigService } from '@nestjs/config';
 
 export const initializeFirebaseApp = (configService: ConfigService) => {
-  const firebaseConfig = {
-    apiKey: configService.get<string>('FIREBASE_API_KEY'),
-    authDomain: configService.get<string>('FIREBASE_AUTH_DOMAIN'),
-    projectId: configService.get<string>('FIREBASE_PROJECT_ID'),
-    storageBucket: configService.get<string>('FIREBASE_STORAGE_BUCKET'),
-    messagingSenderId: configService.get<string>(
-      'FIREBASE_MESSAGING_SENDER_ID',
-    ),
-    appId: configService.get<string>('FIREBASE_APP_ID'),
-    measurementId: configService.get<string>('FIREBASE_MEASUREMENT_ID'),
-    databaseURL: configService.get<string>('FIREBASE_DATABASE_URL'),
-  };
+  try {
+    const firebaseConfig = {
+      apiKey: configService.get<string>('FIREBASE_API_KEY'),
+      authDomain: configService.get<string>('FIREBASE_AUTH_DOMAIN'),
+      projectId: configService.get<string>('FIREBASE_PROJECT_ID'),
+      storageBucket: configService.get<string>('FIREBASE_STORAGE_BUCKET'),
+      messagingSenderId: configService.get<string>(
+        'FIREBASE_MESSAGING_SENDER_ID',
+      ),
+      appId: configService.get<string>('FIREBASE_APP_ID'),
+      measurementId: configService.get<string>('FIREBASE_MEASUREMENT_ID'),
+      databaseURL: configService.get<string>('FIREBASE_DATABASE_URL'),
+    };
 
-  const app = initializeApp(firebaseConfig);
-  return getDatabase(app);
+    // Check if required Firebase config is available
+    if (!firebaseConfig.projectId || firebaseConfig.projectId === 'placeholder-project') {
+      console.warn('Firebase configuration not available, Firebase features will be disabled');
+      return null;
+    }
+
+    const app = initializeApp(firebaseConfig);
+    return getDatabase(app);
+  } catch (error) {
+    console.warn('Firebase initialization failed, Firebase features will be disabled:', error.message);
+    return null;
+  }
 };
 
 export const firebaseDataBase = (configService: ConfigService) =>

libs/common/src/helper/date-format.ts

@@ -0,0 +1,38 @@
+export function toDDMMYYYY(dateString?: string | null): string | null {
+  if (!dateString) return null;
+
+  // Ensure dateString is valid format YYYY-MM-DD
+  const regex = /^\d{4}-\d{2}-\d{2}$/;
+  if (!regex.test(dateString)) {
+    throw new Error(
+      `Invalid date format: ${dateString}. Expected format is YYYY-MM-DD`,
+    );
+  }
+
+  const [year, month, day] = dateString.split('-');
+  return `${day}-${month}-${year}`;
+}
+export function toMMYYYY(dateString?: string | null): string | null {
+  if (!dateString) return null;
+
+  // Ensure dateString is valid format YYYY-MM
+  const regex = /^\d{4}-\d{2}$/;
+  if (!regex.test(dateString)) {
+    throw new Error(
+      `Invalid date format: ${dateString}. Expected format is YYYY-MM`,
+    );
+  }
+
+  const [year, month] = dateString.split('-');
+  return `${month}-${year}`;
+}
+export function filterByMonth(data: any[], monthDate: string) {
+  const [year, month] = monthDate.split('-').map(Number);
+
+  return data.filter((item) => {
+    const itemDate = new Date(item.date);
+    return (
+      itemDate.getUTCFullYear() === year && itemDate.getUTCMonth() + 1 === month
+    );
+  });
+}

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

@@ -8,10 +8,14 @@ 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';
+import { SosHandlerService } from './services/sos.handler.service';
 
 @Global()
 @Module({
@@ -25,6 +29,8 @@ import { CommunityRepository } from '../modules/community/repositories';
     DeviceMessagesService,
     DeviceNotificationRepository,
     CommunityRepository,
+    SosHandlerService,
+    DeviceRepository,
   ],
   exports: [
     HelperHashService,

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

@@ -0,0 +1,66 @@
+import { Injectable } from '@nestjs/common';
+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,
+  ) {}
+
+  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 update AQI sensor historical data:', err);
+      throw err;
+    }
+  }
+  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> {
+    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 {
+    return this.sqlLoader.loadQuery(folderName, fileName, SQL_PROCEDURES_PATH);
+  }
+}

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

@@ -0,0 +1,71 @@
+import { Injectable } from '@nestjs/common';
+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,
+  ) {}
+
+  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 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 executeProcedureWithRetry(
+    procedureFileName: string,
+    params: (string | number | null)[],
+    folderName: string,
+    retries = 3,
+  ): Promise<void> {
+    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 {
+    return this.sqlLoader.loadQuery(folderName, fileName, SQL_PROCEDURES_PATH);
+  }
+}

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

@@ -0,0 +1,84 @@
+import { Injectable } from '@nestjs/common';
+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 {
+  constructor(
+    private readonly sqlLoader: SqlLoaderService,
+    private readonly dataSource: DataSource,
+  ) {}
+
+  async updateEnergyConsumedHistoricalData(): Promise<void> {
+    try {
+      const { dateStr, monthYear } = this.getFormattedDates();
+
+      // 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 update energy consumption data:', err);
+      throw err;
+    }
+  }
+
+  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> {
+    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 {
+    return this.sqlLoader.loadQuery(folderName, fileName, SQL_PROCEDURES_PATH);
+  }
+}

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

@@ -0,0 +1,67 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { DeviceStatusFirebaseService } from '@app/common/firebase/devices-status/services/devices-status.service';
+
+@Injectable()
+export class SosHandlerService {
+  private readonly logger = new Logger(SosHandlerService.name);
+
+  constructor(
+    private readonly deviceStatusFirebaseService: DeviceStatusFirebaseService,
+  ) {}
+
+  isSosTriggered(status: any): boolean {
+    return (
+      Array.isArray(status) &&
+      status.some((item) => item.code === 'sos' && item.value === 'sos')
+    );
+  }
+
+  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: 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: 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);
+        }
+      }, 2000);
+    } catch (err) {
+      this.logger.error('Failed to send SOS true value', err);
+    }
+  }
+}

libs/common/src/helper/services/sql-loader.service.ts

@@ -0,0 +1,22 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+@Injectable()
+export class SqlLoaderService {
+  private readonly logger = new Logger(SqlLoaderService.name);
+  private readonly sqlRootPath = join(__dirname, '../sql/queries');
+
+  loadQuery(module: string, queryName: string, path: string): string {
+    const filePath = join(process.cwd(), path, module, `${queryName}.sql`);
+    try {
+      return readFileSync(filePath, 'utf8');
+    } catch (error) {
+      this.logger.error(
+        `Failed to load SQL query: ${module}/${queryName}`,
+        error.stack,
+      );
+      throw new Error(`SQL query not found: ${module}/${queryName}`);
+    }
+  }
+}

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

@@ -1,17 +1,33 @@
-import { Injectable } 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 { Injectable, OnModuleInit } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import * as NodeCache from 'node-cache';
+import TuyaWebsocket from '../../config/tuya-web-socket-config';
+import { SosHandlerService } from './sos.handler.service';
 
 @Injectable()
-export class TuyaWebSocketService {
-  private client: any; // Adjust type according to your TuyaWebsocket client
+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,
     private readonly deviceStatusFirebaseService: DeviceStatusFirebaseService,
+    private readonly sosHandlerService: SosHandlerService,
   ) {
-    // Initialize the TuyaWebsocket client
+    this.isDevEnv =
+      this.configService.get<string>('NODE_ENV') === 'development';
+
     this.client = new TuyaWebsocket({
       accessId: this.configService.get<string>('tuya-config.TUYA_ACCESS_ID'),
       accessKey: this.configService.get<string>('tuya-config.TUYA_ACCESS_KEY'),
@@ -21,34 +37,80 @@ 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');
     });
 
     this.client.message(async (ws: WebSocket, message: any) => {
       try {
-        await this.deviceStatusFirebaseService.addDeviceStatusToFirebase({
-          deviceTuyaUuid: message.payload.data.bizData.devId,
-          status: message.payload.data.bizData.properties,
-          log: message.payload.data.bizData,
-        });
+        const { devId, status, logData } = this.extractMessageData(message);
+        // console.log(
+        //   `📬 Received message for device: ${devId}, status:`,
+        //   status,
+        //   logData,
+        // );
+        if (!Array.isArray(status)) {
+          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.handleSosEventFirebase(devId, logData);
+        } else {
+          await this.deviceStatusFirebaseService.addDeviceStatusToFirebase({
+            deviceTuyaUuid: devId,
+            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');
     });
@@ -69,4 +131,64 @@ 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;
+    logData: any;
+  } {
+    // console.log('Received message:', message);
+
+    const payloadData = message.payload.data;
+
+    if (this.isDevEnv) {
+      return {
+        devId: payloadData.bizData?.devId,
+        status: payloadData.bizData?.properties,
+        logData: payloadData.bizData,
+      };
+    } else {
+      return {
+        devId: payloadData.devId,
+        status: payloadData.status,
+        logData: payloadData,
+      };
+    }
+  }
+
+  // private logDeviceData(devId: string, status: any, logData: any): void {
+  //   console.log('Device ID:', devId);
+  //   console.log('Status:', status);
+  //   console.log('Full Data:', logData);
+  // }
 }

libs/common/src/helper/timeToMinutes.ts

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

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

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

libs/common/src/logger/logger.module.ts

@@ -0,0 +1,12 @@
+// src/common/logger/logger.module.ts
+import { Module } from '@nestjs/common';
+import { WinstonModule } from 'nest-winston';
+import { winstonLoggerOptions } from './services/winston.logger';
+import { TypeOrmWinstonLogger } from './services/typeorm.logger';
+
+@Module({
+  imports: [WinstonModule.forRoot(winstonLoggerOptions)],
+  providers: [TypeOrmWinstonLogger],
+  exports: [TypeOrmWinstonLogger],
+})
+export class LoggerModule {}

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

@@ -0,0 +1,72 @@
+import { Logger as WinstonLogger } from 'winston';
+import { Logger as TypeOrmLogger } from 'typeorm';
+import { requestContext } from '@app/common/context/request-context';
+
+const ERROR_THRESHOLD = 2000;
+
+export class TypeOrmWinstonLogger implements TypeOrmLogger {
+  constructor(private readonly logger: WinstonLogger) {}
+
+  private getContext() {
+    const context = requestContext.getStore();
+    return {
+      requestId: context?.requestId ?? 'N/A',
+      userId: context?.userId ?? null,
+    };
+  }
+
+  private extractTable(query: string): string {
+    const match =
+      query.match(/from\s+["`]?(\w+)["`]?/i) ||
+      query.match(/into\s+["`]?(\w+)["`]?/i);
+    return match?.[1] ?? 'unknown';
+  }
+
+  logQuery(query: string, parameters?: any[]) {
+    const context = this.getContext();
+    this.logger.debug(`[DB][QUERY] ${query}`, {
+      ...context,
+      table: this.extractTable(query),
+      parameters,
+    });
+  }
+
+  logQueryError(error: string | Error, query: string, parameters?: any[]) {
+    const context = this.getContext();
+    this.logger.error(`[DB][ERROR] ${query}`, {
+      ...context,
+      table: this.extractTable(query),
+      parameters,
+      error,
+    });
+  }
+
+  logQuerySlow(time: number, query: string, parameters?: any[]) {
+    const context = this.getContext();
+    const severity = time > ERROR_THRESHOLD ? 'error' : 'warn';
+    const label = severity === 'error' ? 'VERY SLOW' : 'SLOW';
+
+    this.logger[severity](`[DB][${label} > ${time}ms] ${query}`, {
+      ...context,
+      table: this.extractTable(query),
+      parameters,
+      duration: `${time}ms`,
+      severity,
+    });
+  }
+
+  logSchemaBuild(message: string) {
+    this.logger.info(`[DB][SCHEMA] ${message}`);
+  }
+
+  logMigration(message: string) {
+    this.logger.info(`[DB][MIGRATION] ${message}`);
+  }
+
+  log(level: 'log' | 'info' | 'warn', message: any) {
+    this.logger.log({
+      level,
+      message: `[DB] ${message}`,
+    });
+  }
+}

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

@@ -0,0 +1,26 @@
+import { utilities as nestWinstonModuleUtilities } from 'nest-winston';
+import * as winston from 'winston';
+
+export const winstonLoggerOptions: winston.LoggerOptions = {
+  level:
+    process.env.AZURE_POSTGRESQL_DATABASE === 'development' ? 'debug' : 'error',
+  transports: [
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        nestWinstonModuleUtilities.format.nestLike('MyApp', {
+          prettyPrint: true,
+        }),
+      ),
+    }),
+    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(),
+    }),
+  ],
+};

libs/common/src/middleware/request-context.middleware.ts

@@ -0,0 +1,14 @@
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { requestContext } from '../context/request-context';
+import { v4 as uuidv4 } from 'uuid';
+
+@Injectable()
+export class RequestContextMiddleware implements NestMiddleware {
+  use(req: any, res: any, next: () => void) {
+    const context = {
+      requestId: req.headers['x-request-id'] || uuidv4(),
+    };
+
+    requestContext.run(context, () => next());
+  }
+}

libs/common/src/models/typeOrmCustom.model.ts

@@ -16,7 +16,14 @@ export interface TypeORMCustomModelFindAllQuery {
   where?: { [key: string]: unknown };
   select?: string[];
   includeDisable?: boolean | string;
+  includeSpaces?: boolean;
 }
+
+export interface ExtendedTypeORMCustomModelFindAllQuery
+  extends TypeORMCustomModelFindAllQuery {
+  search?: string;
+}
+
 interface CustomFindAllQuery {
   page?: number;
   size?: number;

libs/common/src/modules/Invite-user/dtos/Invite-user.dto.ts

@@ -1,6 +1,6 @@
 import { RoleType } from '@app/common/constants/role.type.enum';
 import { UserStatusEnum } from '@app/common/constants/user-status.enum';
-import { IsEnum, IsNotEmpty, IsString } from 'class-validator';
+import { IsEnum, IsNotEmpty, IsOptional, IsString } from 'class-validator';
 
 export class InviteUserDto {
   @IsString()
@@ -12,8 +12,12 @@ export class InviteUserDto {
   public email: string;
 
   @IsString()
-  @IsNotEmpty()
-  public jobTitle: string;
+  @IsOptional()
+  public jobTitle?: string;
+
+  @IsString()
+  @IsOptional()
+  public companyName?: string;
 
   @IsEnum(UserStatusEnum)
   @IsNotEmpty()

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

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

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

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

libs/common/src/modules/aqi/dtos/aqi.dto.ts

@@ -0,0 +1,82 @@
+import { IsNotEmpty, IsNumber, IsString } from 'class-validator';
+
+export class AqiSpaceDailyPollutantStatsDto {
+  @IsString()
+  @IsNotEmpty()
+  public uuid: string;
+
+  @IsNotEmpty()
+  @IsString()
+  spaceUuid: string;
+
+  @IsNotEmpty()
+  @IsString()
+  eventDay: string;
+
+  @IsNotEmpty()
+  @IsNumber()
+  eventHour: number;
+
+  @IsNumber()
+  pm1Min: number;
+
+  @IsNumber()
+  pm1Avg: number;
+
+  @IsNumber()
+  pm1Max: number;
+
+  @IsNumber()
+  pm10Min: number;
+
+  @IsNumber()
+  pm10Avg: number;
+
+  @IsNumber()
+  pm10Max: number;
+
+  @IsNumber()
+  pm25Min: number;
+
+  @IsNumber()
+  pm25Avg: number;
+
+  @IsNumber()
+  pm25Max: number;
+
+  @IsNumber()
+  ch2oMin: number;
+
+  @IsNumber()
+  ch2oAvg: number;
+
+  @IsNumber()
+  ch2oMax: number;
+
+  @IsNumber()
+  vocMin: number;
+
+  @IsNumber()
+  vocAvg: number;
+
+  @IsNumber()
+  vocMax: number;
+
+  @IsNumber()
+  co2Min: number;
+
+  @IsNumber()
+  co2Avg: number;
+
+  @IsNumber()
+  co2Max: number;
+
+  @IsNumber()
+  aqiMin: number;
+
+  @IsNumber()
+  aqiAvg: number;
+
+  @IsNumber()
+  aqiMax: number;
+}

libs/common/src/modules/aqi/dtos/index.ts

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

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

@@ -0,0 +1,184 @@
+import { Column, Entity, ManyToOne, Unique } from 'typeorm';
+import { AbstractEntity } from '../../abstract/entities/abstract.entity';
+import { SpaceEntity } from '../../space/entities/space.entity';
+import { AqiSpaceDailyPollutantStatsDto } from '../dtos';
+
+@Entity({ name: 'space-daily-pollutant-stats' })
+@Unique(['spaceUuid', 'eventDate'])
+export class AqiSpaceDailyPollutantStatsEntity extends AbstractEntity<AqiSpaceDailyPollutantStatsDto> {
+  @Column({ nullable: false })
+  public spaceUuid: string;
+
+  @ManyToOne(() => SpaceEntity, (space) => space.aqiSensorDaily)
+  space: SpaceEntity;
+
+  @Column({ type: 'date', nullable: false })
+  public eventDate: Date;
+
+  @Column('float', { nullable: true })
+  public goodAqiPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public moderateAqiPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthySensitiveAqiPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthyAqiPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public veryUnhealthyAqiPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public hazardousAqiPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public dailyAvgAqi?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMaxAqi?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMinAqi?: number;
+
+  @Column('float', { nullable: true })
+  public goodPm25Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public moderatePm25Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthySensitivePm25Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthyPm25Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public veryUnhealthyPm25Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public hazardousPm25Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public dailyAvgPm25?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMaxPm25?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMinPm25?: number;
+
+  @Column('float', { nullable: true })
+  public goodPm10Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public moderatePm10Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthySensitivePm10Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthyPm10Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public veryUnhealthyPm10Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public hazardousPm10Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public dailyAvgPm10?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMaxPm10?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMinPm10?: number;
+
+  @Column('float', { nullable: true })
+  public goodVocPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public moderateVocPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthySensitiveVocPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthyVocPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public veryUnhealthyVocPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public hazardousVocPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public dailyAvgVoc?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMaxVoc?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMinVoc?: number;
+
+  @Column('float', { nullable: true })
+  public goodCo2Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public moderateCo2Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthySensitiveCo2Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthyCo2Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public veryUnhealthyCo2Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public hazardousCo2Percentage?: number;
+
+  @Column('float', { nullable: true })
+  public dailyAvgCo2?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMaxCo2?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMinCo2?: number;
+
+  @Column('float', { nullable: true })
+  public goodCh2oPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public moderateCh2oPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthySensitiveCh2oPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public unhealthyCh2oPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public veryUnhealthyCh2oPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public hazardousCh2oPercentage?: number;
+
+  @Column('float', { nullable: true })
+  public dailyAvgCh2o?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMaxCh2o?: number;
+
+  @Column('float', { nullable: true })
+  public dailyMinCh2o?: number;
+
+  constructor(partial: Partial<AqiSpaceDailyPollutantStatsEntity>) {
+    super();
+    Object.assign(this, partial);
+  }
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,44 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  ManyToOne,
+  UpdateDateColumn,
+} from 'typeorm';
+import { AbstractEntity } from '../../abstract/entities/abstract.entity';
+import { SpaceEntity } from '../../space/entities/space.entity';
+import { UserEntity } from '../../user/entities';
+
+@Entity('booking')
+export class BookingEntity extends AbstractEntity {
+  @Column({
+    type: 'uuid',
+    default: () => 'gen_random_uuid()',
+    nullable: false,
+  })
+  public uuid: string;
+
+  @ManyToOne(() => SpaceEntity, (space) => space.bookableConfig)
+  space: SpaceEntity;
+
+  @ManyToOne(() => UserEntity, (user) => user.bookings)
+  user: UserEntity;
+
+  @Column({ type: Date, nullable: false })
+  date: Date;
+
+  @Column({ type: 'time' })
+  startTime: string;
+
+  @Column({ type: 'time' })
+  endTime: string;
+
+  @Column({ type: 'int', default: null })
+  cost?: number;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

libs/common/src/modules/booking/repositories/bookable-space.repository.ts

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

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

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

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

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ClientEntity } from './entities';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([ClientEntity])],
+  exports: [TypeOrmModule],
+})
+export class ClientRepositoryModule {}

libs/common/src/modules/client/dtos/client.dto.ts

@@ -0,0 +1,20 @@
+import { IsArray, IsNotEmpty, IsString } from 'class-validator';
+
+export class ClientDto {
+  @IsString()
+  @IsNotEmpty()
+  public uuid: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public clientId: string;
+  @IsString()
+  @IsNotEmpty()
+  public clientSecret: string;
+  @IsString()
+  @IsNotEmpty()
+  public redirectUri: string;
+  @IsArray()
+  @IsNotEmpty()
+  public scopes: string[];
+}

libs/common/src/modules/client/dtos/index.ts

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

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

@@ -0,0 +1,46 @@
+import { Entity, Column, Unique, OneToMany } from 'typeorm';
+import { AbstractEntity } from '../../abstract/entities/abstract.entity';
+import { ClientDto } from '../dtos';
+import { UserEntity } from '../../user/entities';
+
+@Entity({ name: 'clients' })
+@Unique(['clientId'])
+export class ClientEntity extends AbstractEntity<ClientDto> {
+  @Column({
+    type: 'uuid',
+    default: () => 'gen_random_uuid()',
+    nullable: false,
+  })
+  public uuid: string;
+
+  @Column({
+    length: 255,
+    nullable: false,
+  })
+  name: string;
+
+  @Column({
+    length: 255,
+    nullable: false,
+    unique: true,
+  })
+  clientId: string;
+
+  @Column({
+    length: 255,
+    nullable: false,
+  })
+  clientSecret: string;
+
+  @Column({
+    length: 255,
+    nullable: false,
+  })
+  redirectUri: string;
+
+  @Column('simple-array')
+  scopes: string[];
+
+  @OneToMany(() => UserEntity, (user) => user.client)
+  users: UserEntity[];
+}

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

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

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

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

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

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

libs/common/src/modules/device-status-log/entities/device-status-log.entity.ts

@@ -2,15 +2,15 @@ import { SourceType } from '@app/common/constants/source-type.enum';
 import { Entity, Column, PrimaryColumn, Unique } from 'typeorm';
 
 @Entity('device-status-log')
-@Unique('event_time_idx', ['eventTime'])
+@Unique('event_time_idx', ['eventTime', 'deviceId', 'code', 'value'])
 export class DeviceStatusLogEntity {
-  @Column({ type: 'int', generated: true, unsigned: true })
+  @PrimaryColumn({ type: 'int', generated: true, unsigned: true })
   id: number;
 
   @Column({ type: 'text' })
   eventId: string;
 
-  @PrimaryColumn({ type: 'timestamptz' })
+  @Column({ type: 'timestamptz' })
   eventTime: Date;
 
   @Column({

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

@@ -1,25 +1,24 @@
 import {
   Column,
   Entity,
+  Index,
+  JoinColumn,
   ManyToOne,
   OneToMany,
   Unique,
-  Index,
-  JoinColumn,
-  OneToOne,
-  JoinTable,
 } from 'typeorm';
 import { AbstractEntity } from '../../abstract/entities/abstract.entity';
-import { DeviceDto, DeviceUserPermissionDto } from '../dtos/device.dto';
-import { ProductEntity } from '../../product/entities';
-import { UserEntity } from '../../user/entities';
-import { DeviceNotificationDto } from '../dtos';
 import { PermissionTypeEntity } from '../../permission/entities';
+import { PowerClampHourlyEntity } from '../../power-clamp/entities/power-clamp.entity';
+import { PresenceSensorDailyDeviceEntity } from '../../presence-sensor/entities';
+import { ProductEntity } from '../../product/entities';
 import { SceneDeviceEntity } from '../../scene-device/entities';
 import { SpaceEntity } from '../../space/entities/space.entity';
 import { SubspaceEntity } from '../../space/entities/subspace/subspace.entity';
-import { TagEntity } from '../../space/entities/tag.entity';
 import { NewTagEntity } from '../../tag';
+import { UserEntity } from '../../user/entities';
+import { DeviceNotificationDto } from '../dtos';
+import { DeviceDto, DeviceUserPermissionDto } from '../dtos/device.dto';
 
 @Entity({ name: 'device' })
 @Unique(['deviceTuyaUuid'])
@@ -29,16 +28,21 @@ export class DeviceEntity extends AbstractEntity<DeviceDto> {
   })
   deviceTuyaUuid: string;
 
+  @Column({
+    nullable: true,
+  })
+  deviceTuyaConstUuid: string;
+
   @Column({
     nullable: true,
     default: true,
     type: 'boolean',
   })
   isActive: boolean;
-
-  @ManyToOne(() => UserEntity, (user) => user.userSpaces, { nullable: false })
-  user: UserEntity;
-
+  @Column({
+    nullable: false,
+  })
+  name: string;
   @OneToMany(
     () => DeviceUserPermissionEntity,
     (permission) => permission.device,
@@ -79,15 +83,13 @@ export class DeviceEntity extends AbstractEntity<DeviceDto> {
   @OneToMany(() => SceneDeviceEntity, (sceneDevice) => sceneDevice.device, {})
   sceneDevices: SceneDeviceEntity[];
 
-  @OneToOne(() => TagEntity, (tag) => tag.device, {
-    nullable: true,
-  })
-  tag: TagEntity;
-
-  @OneToMany(() => NewTagEntity, (tag) => tag.devices)
-  @JoinTable({ name: 'device_tags' })
-  public tags: NewTagEntity[];
-
+  @ManyToOne(() => NewTagEntity, (tag) => tag.devices)
+  @JoinColumn({ name: 'tag_uuid' })
+  public tag: NewTagEntity;
+  @OneToMany(() => PowerClampHourlyEntity, (powerClamp) => powerClamp.device)
+  powerClampHourly: PowerClampHourlyEntity[];
+  @OneToMany(() => PresenceSensorDailyDeviceEntity, (sensor) => sensor.device)
+  presenceSensorDaily: PresenceSensorDailyDeviceEntity[];
   constructor(partial: Partial<DeviceEntity>) {
     super();
     Object.assign(this, partial);
@@ -114,6 +116,7 @@ export class DeviceNotificationEntity extends AbstractEntity<DeviceNotificationD
 
   @ManyToOne(() => UserEntity, (user) => user.userPermission, {
     nullable: false,
+    onDelete: 'CASCADE',
   })
   user: UserEntity;
 
@@ -152,6 +155,7 @@ export class DeviceUserPermissionEntity extends AbstractEntity<DeviceUserPermiss
 
   @ManyToOne(() => UserEntity, (user) => user.userPermission, {
     nullable: false,
+    onDelete: 'CASCADE',
   })
   user: UserEntity;
   constructor(partial: Partial<DeviceUserPermissionEntity>) {

libs/common/src/modules/occupancy/dtos/index.ts

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

libs/common/src/modules/occupancy/dtos/occupancy.dto.ts

@@ -0,0 +1,23 @@
+import { IsNotEmpty, IsNumber, IsString } from 'class-validator';
+
+export class SpaceDailyOccupancyDurationDto {
+  @IsString()
+  @IsNotEmpty()
+  public uuid: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public spaceUuid: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public eventDate: string;
+
+  @IsNumber()
+  @IsNotEmpty()
+  public occupancyPercentage: number;
+
+  @IsNumber()
+  @IsNotEmpty()
+  public occupiedSeconds: number;
+}

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

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

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

@@ -0,0 +1,32 @@
+import { Column, Entity, ManyToOne, Unique } from 'typeorm';
+import { AbstractEntity } from '../../abstract/entities/abstract.entity';
+import { SpaceEntity } from '../../space/entities/space.entity';
+import { SpaceDailyOccupancyDurationDto } from '../dtos';
+
+@Entity({ name: 'space-daily-occupancy-duration' })
+@Unique(['spaceUuid', 'eventDate'])
+export class SpaceDailyOccupancyDurationEntity extends AbstractEntity<SpaceDailyOccupancyDurationDto> {
+  @Column({ nullable: false })
+  public spaceUuid: string;
+
+  @Column({ nullable: false, type: 'date' })
+  public eventDate: string;
+
+  public CountTotalPresenceDetected: number;
+
+  @ManyToOne(() => SpaceEntity, (space) => space.presenceSensorDaily)
+  space: SpaceEntity;
+
+  @Column({ type: 'int' })
+  occupancyPercentage: number;
+
+  @Column({ type: 'int', nullable: true })
+  occupiedSeconds?: number;
+
+  @Column({ type: 'int', nullable: true })
+  deviceCount?: number;
+  constructor(partial: Partial<SpaceDailyOccupancyDurationEntity>) {
+    super();
+    Object.assign(this, partial);
+  }
+}

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

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

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

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

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

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

libs/common/src/modules/power-clamp/dtos/index.ts

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

libs/common/src/modules/power-clamp/dtos/power-clamp.dto.ts

@@ -0,0 +1,43 @@
+import { IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+export class PowerClampDto {
+  @IsString()
+  @IsNotEmpty()
+  public uuid: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public deviceUuid: string;
+
+  @IsString()
+  @IsOptional()
+  public hour?: string;
+
+  @IsString()
+  @IsOptional()
+  public day?: string;
+
+  @IsString()
+  @IsOptional()
+  public month?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public energyConsumedKw: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public energyConsumedA: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public energyConsumedB: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public energyConsumedC: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public prodType: string;
+}

libs/common/src/modules/power-clamp/entities/index.ts

@@ -0,0 +1 @@
+export * from './power-clamp.entity';

libs/common/src/modules/power-clamp/entities/power-clamp.entity.ts

@@ -0,0 +1,95 @@
+import { Column, Entity, ManyToOne, Unique } from 'typeorm';
+import { AbstractEntity } from '../../abstract/entities/abstract.entity';
+import { PowerClampDto } from '../dtos';
+import { DeviceEntity } from '../../device/entities/device.entity';
+
+@Entity({ name: 'power-clamp-energy-consumed-hourly' })
+@Unique(['deviceUuid', 'date', 'hour'])
+export class PowerClampHourlyEntity extends AbstractEntity<PowerClampDto> {
+  @Column({ nullable: false })
+  public deviceUuid: string;
+
+  @Column({ nullable: false })
+  public hour: string;
+
+  @Column({ nullable: false, type: 'date' })
+  public date: string;
+
+  @Column({ nullable: true })
+  public energyConsumedKw: string;
+
+  @Column({ nullable: false })
+  public energyConsumedA: string;
+
+  @Column({ nullable: false })
+  public energyConsumedB: string;
+
+  @Column({ nullable: false })
+  public energyConsumedC: string;
+
+  @ManyToOne(() => DeviceEntity, (device) => device.powerClampHourly)
+  device: DeviceEntity;
+
+  constructor(partial: Partial<PowerClampHourlyEntity>) {
+    super();
+    Object.assign(this, partial);
+  }
+}
+@Entity({ name: 'power-clamp-energy-consumed-daily' })
+@Unique(['deviceUuid', 'date'])
+export class PowerClampDailyEntity extends AbstractEntity<PowerClampDto> {
+  @Column({ nullable: false })
+  public deviceUuid: string;
+
+  @Column({ nullable: false, type: 'date' })
+  public date: string;
+
+  @Column({ nullable: true })
+  public energyConsumedKw: string;
+
+  @Column({ nullable: false })
+  public energyConsumedA: string;
+
+  @Column({ nullable: false })
+  public energyConsumedB: string;
+
+  @Column({ nullable: false })
+  public energyConsumedC: string;
+
+  @ManyToOne(() => DeviceEntity, (device) => device.powerClampHourly)
+  device: DeviceEntity;
+
+  constructor(partial: Partial<PowerClampHourlyEntity>) {
+    super();
+    Object.assign(this, partial);
+  }
+}
+@Entity({ name: 'power-clamp-energy-consumed-monthly' })
+@Unique(['deviceUuid', 'month'])
+export class PowerClampMonthlyEntity extends AbstractEntity<PowerClampDto> {
+  @Column({ nullable: false })
+  public deviceUuid: string;
+
+  @Column({ nullable: false })
+  public month: string;
+
+  @Column({ nullable: true })
+  public energyConsumedKw: string;
+
+  @Column({ nullable: false })
+  public energyConsumedA: string;
+
+  @Column({ nullable: false })
+  public energyConsumedB: string;
+
+  @Column({ nullable: false })
+  public energyConsumedC: string;
+
+  @ManyToOne(() => DeviceEntity, (device) => device.powerClampHourly)
+  device: DeviceEntity;
+
+  constructor(partial: Partial<PowerClampHourlyEntity>) {
+    super();
+    Object.assign(this, partial);
+  }
+}

libs/common/src/modules/power-clamp/power-clamp.repository.module.ts

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

libs/common/src/modules/power-clamp/repositories/index.ts

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

libs/common/src/modules/power-clamp/repositories/power-clamp.repository.ts

@@ -0,0 +1,28 @@
+import { DataSource, Repository } from 'typeorm';
+import { Injectable } from '@nestjs/common';
+import {
+  PowerClampDailyEntity,
+  PowerClampHourlyEntity,
+  PowerClampMonthlyEntity,
+} from '../entities/power-clamp.entity';
+
+@Injectable()
+export class PowerClampHourlyRepository extends Repository<PowerClampHourlyEntity> {
+  constructor(private dataSource: DataSource) {
+    super(PowerClampHourlyEntity, dataSource.createEntityManager());
+  }
+}
+
+@Injectable()
+export class PowerClampDailyRepository extends Repository<PowerClampDailyEntity> {
+  constructor(private dataSource: DataSource) {
+    super(PowerClampDailyEntity, dataSource.createEntityManager());
+  }
+}
+
+@Injectable()
+export class PowerClampMonthlyRepository extends Repository<PowerClampMonthlyEntity> {
+  constructor(private dataSource: DataSource) {
+    super(PowerClampMonthlyEntity, dataSource.createEntityManager());
+  }
+}

libs/common/src/modules/presence-sensor/dtos/index.ts

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

libs/common/src/modules/presence-sensor/dtos/presence-sensor.dto.ts

@@ -0,0 +1,27 @@
+import { IsNotEmpty, IsNumber, IsString } from 'class-validator';
+
+export class PresenceSensorDto {
+  @IsString()
+  @IsNotEmpty()
+  public uuid: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public deviceUuid: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public eventDate: string;
+
+  @IsNumber()
+  @IsNotEmpty()
+  public CountMotionDetected: number;
+
+  @IsNumber()
+  @IsNotEmpty()
+  public CountPresenceDetected: number;
+
+  @IsNumber()
+  @IsNotEmpty()
+  public CountTotalPresenceDetected: number;
+}

libs/common/src/modules/presence-sensor/entities/index.ts

@@ -0,0 +1 @@
+export * from './presence-sensor.entity';

libs/common/src/modules/presence-sensor/entities/presence-sensor.entity.ts

@@ -0,0 +1,58 @@
+import { Column, Entity, ManyToOne, Unique } from 'typeorm';
+import { AbstractEntity } from '../../abstract/entities/abstract.entity';
+import { PresenceSensorDto } from '../dtos';
+import { DeviceEntity } from '../../device/entities/device.entity';
+import { SpaceEntity } from '../../space/entities/space.entity';
+
+@Entity({ name: 'presence-sensor-daily-device-detection' })
+@Unique(['deviceUuid', 'eventDate'])
+export class PresenceSensorDailyDeviceEntity extends AbstractEntity<PresenceSensorDto> {
+  @Column({ nullable: false })
+  public deviceUuid: string;
+
+  @Column({ nullable: false, type: 'date' })
+  public eventDate: string;
+
+  @Column({ nullable: false })
+  public CountMotionDetected: number;
+
+  @Column({ nullable: false })
+  public CountPresenceDetected: number;
+
+  @Column({ nullable: false })
+  public CountTotalPresenceDetected: number;
+
+  @ManyToOne(() => DeviceEntity, (device) => device.presenceSensorDaily)
+  device: DeviceEntity;
+
+  constructor(partial: Partial<PresenceSensorDailyDeviceEntity>) {
+    super();
+    Object.assign(this, partial);
+  }
+}
+@Entity({ name: 'presence-sensor-daily-space-detection' })
+@Unique(['spaceUuid', 'eventDate'])
+export class PresenceSensorDailySpaceEntity extends AbstractEntity<PresenceSensorDto> {
+  @Column({ nullable: false })
+  public spaceUuid: string;
+
+  @Column({ nullable: false, type: 'date' })
+  public eventDate: string;
+
+  @Column({ nullable: false })
+  public CountMotionDetected: number;
+
+  @Column({ nullable: false })
+  public CountPresenceDetected: number;
+
+  @Column({ nullable: false })
+  public CountTotalPresenceDetected: number;
+
+  @ManyToOne(() => SpaceEntity, (space) => space.presenceSensorDaily)
+  space: SpaceEntity;
+
+  constructor(partial: Partial<PresenceSensorDailySpaceEntity>) {
+    super();
+    Object.assign(this, partial);
+  }
+}

libs/common/src/modules/presence-sensor/presence-sensor.repository.module.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import {
+  PresenceSensorDailyDeviceEntity,
+  PresenceSensorDailySpaceEntity,
+} from './entities/presence-sensor.entity';
+
+@Module({
+  providers: [],
+  exports: [],
+  controllers: [],
+  imports: [
+    TypeOrmModule.forFeature([
+      PresenceSensorDailyDeviceEntity,
+      PresenceSensorDailySpaceEntity,
+    ]),
+  ],
+})
+export class PresenceSensorRepositoryModule {}