fix: better layering in docker image

* chore: dummy data script

* fix: lint issues

* chore: removed print statment

.deepsource.toml

@@ -1,23 +0,0 @@
-version = 1
-
-exclude_patterns = [  
-  "bin/**",  
-  "**/node_modules/",  
-  "**/*.min.js"  
-]
-
-[[analyzers]]
-name = "shell"
-
-[[analyzers]]
-name = "javascript"
-
-  [analyzers.meta]
-  plugins = ["react"]
-  environment = ["nodejs"]
-
-[[analyzers]]
-name = "python"
-
-  [analyzers.meta]
-  runtime_version = "3.x.x"

.env.example

@@ -1,14 +1,12 @@
 # Database Settings
-PGUSER="plane"
-PGPASSWORD="plane"
-PGHOST="plane-db"
-PGDATABASE="plane"
-DATABASE_URL=postgresql://${PGUSER}:${PGPASSWORD}@${PGHOST}/${PGDATABASE}
+POSTGRES_USER="plane"
+POSTGRES_PASSWORD="plane"
+POSTGRES_DB="plane"
+PGDATA="/var/lib/postgresql/data"
 
 # Redis Settings
 REDIS_HOST="plane-redis"
 REDIS_PORT="6379"
-REDIS_URL="redis://${REDIS_HOST}:6379/"
 
 # AWS Settings
 AWS_REGION=""

.github/ISSUE_TEMPLATE/--bug-report.yaml

@@ -1,7 +1,8 @@
 name: Bug report
 description: Create a bug report to help us improve Plane
 title: "[bug]: "
-labels: [bug, need testing]
+labels: [🐛bug]
+assignees: [srinivaspendem, pushya22]
 body:
 - type: markdown
   attributes:
@@ -44,7 +45,7 @@ body:
       - Deploy preview
   validations:
     required: true
-  type: dropdown
+- type: dropdown
   id: browser
   attributes:
     label: Browser

.github/ISSUE_TEMPLATE/--feature-request.yaml

@@ -1,7 +1,8 @@
 name: Feature request
 description: Suggest a feature to improve Plane
 title: "[feature]: "
-labels: [feature]
+labels: [✨feature]
+assignees: [srinivaspendem, pushya22]
 body:
 - type: markdown
   attributes:

.github/workflows/auto-merge.yml

@@ -0,0 +1,84 @@
+name: Auto Merge or Create PR on Push
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - "sync/**"
+
+env:
+  CURRENT_BRANCH: ${{ github.ref_name }}
+  SOURCE_BRANCH: ${{ secrets.SYNC_SOURCE_BRANCH_NAME }} # The sync branch such as "sync/ce"
+  TARGET_BRANCH: ${{ secrets.SYNC_TARGET_BRANCH_NAME }} # The target branch that you would like to merge changes like develop
+  GITHUB_TOKEN: ${{ secrets.ACCESS_TOKEN }} # Personal access token required to modify contents and workflows
+  REVIEWER: ${{ secrets.SYNC_PR_REVIEWER }}
+
+jobs:
+  Check_Branch:
+    runs-on: ubuntu-latest
+    outputs:
+      BRANCH_MATCH: ${{ steps.check-branch.outputs.MATCH }}
+    steps:
+      - name: Check if current branch matches the secret
+        id: check-branch
+        run: |
+          if [ "$CURRENT_BRANCH" = "$SOURCE_BRANCH" ]; then
+            echo "MATCH=true" >> $GITHUB_OUTPUT
+          else
+            echo "MATCH=false" >> $GITHUB_OUTPUT
+          fi
+
+  Auto_Merge:
+    if: ${{ needs.Check_Branch.outputs.BRANCH_MATCH == 'true' }}
+    needs: [Check_Branch]
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+      contents: write
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4.1.1
+        with:
+          fetch-depth: 0 # Fetch all history for all branches and tags
+
+      - name: Setup Git
+        run: |
+          git config user.name "GitHub Actions"
+          git config user.email "actions@github.com"
+
+      - name: Setup GH CLI and Git Config
+        run: |
+          type -p curl >/dev/null || (sudo apt update && sudo apt install curl -y)
+          curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
+          sudo chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg
+          echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
+          sudo apt update
+          sudo apt install gh -y
+
+      - name: Check for merge conflicts
+        id: conflicts
+        run: |
+          git fetch origin $TARGET_BRANCH
+          git checkout $TARGET_BRANCH
+          # Attempt to merge the main branch into the current branch
+          if $(git merge --no-commit --no-ff $SOURCE_BRANCH); then
+            echo "No merge conflicts detected."
+            echo "HAS_CONFLICTS=false" >> $GITHUB_ENV
+          else
+            echo "Merge conflicts detected."
+            echo "HAS_CONFLICTS=true" >> $GITHUB_ENV
+            git merge --abort
+          fi
+
+      - name: Merge Change to Target Branch
+        if: env.HAS_CONFLICTS == 'false'
+        run: |
+          git commit -m "Merge branch '$SOURCE_BRANCH' into $TARGET_BRANCH"
+          git push origin $TARGET_BRANCH
+
+      - name: Create PR to Target Branch
+        if: env.HAS_CONFLICTS == 'true'
+        run: |
+          # Replace 'username' with the actual GitHub username of the reviewer.
+          PR_URL=$(gh pr create --base $TARGET_BRANCH --head $SOURCE_BRANCH --title "sync: merge conflicts need to be resolved" --body "" --reviewer $REVIEWER)
+          echo "Pull Request created: $PR_URL"

.github/workflows/build-branch.yml

@@ -1,98 +1,122 @@
 name: Branch Build
 
 on:
-  pull_request:
-    types:
-      - closed
+  workflow_dispatch:
+  push:
     branches:
       - master
       - preview
-      - qa
-      - develop
   release:
     types: [released, prereleased]
 
 env:
-  TARGET_BRANCH: ${{ github.event.pull_request.base.ref || github.event.release.target_commitish }}
+  TARGET_BRANCH: ${{ github.ref_name || github.event.release.target_commitish }}
 
 jobs:
   branch_build_setup:
-    if: ${{ (github.event_name == 'pull_request' && github.event.action =='closed' && github.event.pull_request.merged == true) || github.event_name == 'release' }}
     name: Build-Push Web/Space/API/Proxy Docker Image
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
+    outputs:
+      gh_branch_name: ${{ steps.set_env_variables.outputs.TARGET_BRANCH }}
+      gh_buildx_driver: ${{ steps.set_env_variables.outputs.BUILDX_DRIVER }}
+      gh_buildx_version: ${{ steps.set_env_variables.outputs.BUILDX_VERSION }}
+      gh_buildx_platforms: ${{ steps.set_env_variables.outputs.BUILDX_PLATFORMS }}
+      gh_buildx_endpoint: ${{ steps.set_env_variables.outputs.BUILDX_ENDPOINT }}
+      build_frontend: ${{ steps.changed_files.outputs.frontend_any_changed }}
+      build_space: ${{ steps.changed_files.outputs.space_any_changed }}
+      build_backend: ${{ steps.changed_files.outputs.backend_any_changed }}
+      build_proxy: ${{ steps.changed_files.outputs.proxy_any_changed }}
 
     steps:
-      - name: Check out the repo
-        uses: actions/checkout@v3.3.0
+      - id: set_env_variables
+        name: Set Environment Variables
+        run: |
+          if [ "${{ env.TARGET_BRANCH }}" == "master" ] || [ "${{ github.event_name }}" == "release" ]; then
+            echo "BUILDX_DRIVER=cloud" >> $GITHUB_OUTPUT
+            echo "BUILDX_VERSION=lab:latest" >> $GITHUB_OUTPUT
+            echo "BUILDX_PLATFORMS=linux/amd64,linux/arm64" >> $GITHUB_OUTPUT
+            echo "BUILDX_ENDPOINT=makeplane/plane-dev" >> $GITHUB_OUTPUT
+          else
+            echo "BUILDX_DRIVER=docker-container" >> $GITHUB_OUTPUT
+            echo "BUILDX_VERSION=latest" >> $GITHUB_OUTPUT
+            echo "BUILDX_PLATFORMS=linux/amd64" >> $GITHUB_OUTPUT
+            echo "BUILDX_ENDPOINT=" >> $GITHUB_OUTPUT
+          fi
+          echo "TARGET_BRANCH=${{ env.TARGET_BRANCH }}" >> $GITHUB_OUTPUT
 
-      - name: Uploading Proxy Source
-        uses: actions/upload-artifact@v3
+      - id: checkout_files
+        name: Checkout Files
+        uses: actions/checkout@v4
+
+      - name: Get changed files
+        id: changed_files
+        uses: tj-actions/changed-files@v42
         with:
-          name: proxy-src-code
-          path: ./nginx
-      - name: Uploading Backend Source
-        uses: actions/upload-artifact@v3
-        with:
-          name: backend-src-code
-          path: ./apiserver
-      - name: Uploading Web Source
-        uses: actions/upload-artifact@v3
-        with:
-          name: web-src-code
-          path: |
-            ./
-            !./apiserver
-            !./nginx
-            !./deploy
-            !./space
-      - name: Uploading Space Source
-        uses: actions/upload-artifact@v3
-        with:
-          name: space-src-code
-          path: |
-            ./
-            !./apiserver
-            !./nginx
-            !./deploy
-            !./web
-    outputs:
-      gh_branch_name: ${{ env.TARGET_BRANCH }}
+          files_yaml: |
+            frontend:
+              - web/**
+              - packages/**
+              - 'package.json'
+              - 'yarn.lock'
+              - 'tsconfig.json'
+              - 'turbo.json'
+            space:
+              - space/**
+              - packages/**
+              - 'package.json'
+              - 'yarn.lock'
+              - 'tsconfig.json'
+              - 'turbo.json'
+            backend:
+              - apiserver/**
+            proxy:
+              - nginx/**
 
   branch_build_push_frontend:
+    if: ${{ needs.branch_build_setup.outputs.build_frontend == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     runs-on: ubuntu-20.04
     needs: [branch_build_setup]
     env:
       FRONTEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
     steps:
-      - name: Set Frontend Docker Tag 
+      - name: Set Frontend Docker Tag
         run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend:stable
+          if [ "${{ github.event_name }}" == "release" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend:stable,${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend:${{ github.event.release.tag_name }}
+          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend:latest
           else
             TAG=${{ env.FRONTEND_TAG }}
           fi
           echo "FRONTEND_TAG=${TAG}" >> $GITHUB_ENV
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2.5.0
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v2.1.0
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Downloading Web Source Code
-        uses: actions/download-artifact@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
         with:
-          name: web-src-code
+          driver: ${{ env.BUILDX_DRIVER }}
+          version: ${{ env.BUILDX_VERSION }}
+          endpoint: ${{ env.BUILDX_ENDPOINT }}
+
+      - name: Check out the repo
+        uses: actions/checkout@v4
 
       - name: Build and Push Frontend to Docker Container Registry
-        uses: docker/build-push-action@v4.0.0
+        uses: docker/build-push-action@v5.1.0
         with:
           context: .
           file: ./web/Dockerfile.web
-          platforms: linux/amd64
+          platforms: ${{ env.BUILDX_PLATFORMS }}
           tags: ${{ env.FRONTEND_TAG }}
           push: true
         env:
@@ -101,40 +125,50 @@ jobs:
           DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
 
   branch_build_push_space:
+    if: ${{ needs.branch_build_setup.outputs.build_space == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     runs-on: ubuntu-20.04
     needs: [branch_build_setup]
     env:
       SPACE_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-space:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
     steps:
-      - name: Set Space Docker Tag 
+      - name: Set Space Docker Tag
         run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-space:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space:stable
+          if [ "${{ github.event_name }}" == "release" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space:stable,${{ secrets.DOCKERHUB_USERNAME }}/plane-space:${{ github.event.release.tag_name }}
+          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space:latest
           else
             TAG=${{ env.SPACE_TAG }}
           fi
           echo "SPACE_TAG=${TAG}" >> $GITHUB_ENV
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2.5.0
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v2.1.0
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Downloading Space Source Code
-        uses: actions/download-artifact@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
         with:
-          name: space-src-code
+          driver: ${{ env.BUILDX_DRIVER }}
+          version: ${{ env.BUILDX_VERSION }}
+          endpoint: ${{ env.BUILDX_ENDPOINT }}
+
+      - name: Check out the repo
+        uses: actions/checkout@v4
 
       - name: Build and Push Space to Docker Hub
-        uses: docker/build-push-action@v4.0.0
+        uses: docker/build-push-action@v5.1.0
         with:
           context: .
           file: ./space/Dockerfile.space
-          platforms: linux/amd64
+          platforms: ${{ env.BUILDX_PLATFORMS }}
           tags: ${{ env.SPACE_TAG }}
           push: true
         env:
@@ -143,40 +177,50 @@ jobs:
           DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
 
   branch_build_push_backend:
+    if: ${{ needs.branch_build_setup.outputs.build_backend == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     runs-on: ubuntu-20.04
     needs: [branch_build_setup]
     env:
       BACKEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-backend:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
     steps:
-      - name: Set Backend Docker Tag 
+      - name: Set Backend Docker Tag
         run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-backend:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend:stable
+          if [ "${{ github.event_name }}" == "release" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend:stable,${{ secrets.DOCKERHUB_USERNAME }}/plane-backend:${{ github.event.release.tag_name }}
+          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend:latest
           else
             TAG=${{ env.BACKEND_TAG }}
           fi
           echo "BACKEND_TAG=${TAG}" >> $GITHUB_ENV
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2.5.0
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v2.1.0
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Downloading Backend Source Code
-        uses: actions/download-artifact@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
         with:
-          name: backend-src-code
+          driver: ${{ env.BUILDX_DRIVER }}
+          version: ${{ env.BUILDX_VERSION }}
+          endpoint: ${{ env.BUILDX_ENDPOINT }}
+
+      - name: Check out the repo
+        uses: actions/checkout@v4
 
       - name: Build and Push Backend to Docker Hub
-        uses: docker/build-push-action@v4.0.0
+        uses: docker/build-push-action@v5.1.0
         with:
-          context: .
-          file: ./Dockerfile.api
-          platforms: linux/amd64
+          context: ./apiserver
+          file: ./apiserver/Dockerfile.api
+          platforms: ${{ env.BUILDX_PLATFORMS }}
           push: true
           tags: ${{ env.BACKEND_TAG }}
         env:
@@ -185,41 +229,50 @@ jobs:
           DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
 
   branch_build_push_proxy:
+    if: ${{ needs.branch_build_setup.outputs.build_proxy == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     runs-on: ubuntu-20.04
     needs: [branch_build_setup]
     env:
       PROXY_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
     steps:
-      - name: Set Proxy Docker Tag 
+      - name: Set Proxy Docker Tag
         run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy:stable
+          if [ "${{ github.event_name }}" == "release" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy:stable,${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy:${{ github.event.release.tag_name }}
+          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy:latest
           else
             TAG=${{ env.PROXY_TAG }}
           fi
           echo "PROXY_TAG=${TAG}" >> $GITHUB_ENV
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2.5.0
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v2.1.0
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Downloading Proxy Source Code
-        uses: actions/download-artifact@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
         with:
-          name: proxy-src-code
+          driver: ${{ env.BUILDX_DRIVER }}
+          version: ${{ env.BUILDX_VERSION }}
+          endpoint: ${{ env.BUILDX_ENDPOINT }}
+
+      - name: Check out the repo
+        uses: actions/checkout@v4
 
       - name: Build and Push Plane-Proxy to Docker Hub
-        uses: docker/build-push-action@v4.0.0
+        uses: docker/build-push-action@v5.1.0
         with:
-          context: .
-          file: ./Dockerfile
-          platforms: linux/amd64
+          context: ./nginx
+          file: ./nginx/Dockerfile
+          platforms: ${{ env.BUILDX_PLATFORMS }}
           tags: ${{ env.PROXY_TAG }}
           push: true
         env:

.github/workflows/build-test-pull-request.yml

@@ -1,48 +1,104 @@
-name: Build Pull Request Contents
+name: Build and Lint on Pull Request
 
-on: 
+on:
+  workflow_dispatch:
   pull_request:
     types: ["opened", "synchronize"]
 
 jobs:
-  build-pull-request-contents:
-    name: Build Pull Request Contents
-    runs-on: ubuntu-20.04
-    permissions:
-      pull-requests: read
-
+  get-changed-files:
+    runs-on: ubuntu-latest
+    outputs:
+      apiserver_changed: ${{ steps.changed-files.outputs.apiserver_any_changed }}
+      web_changed: ${{ steps.changed-files.outputs.web_any_changed }}
+      space_changed: ${{ steps.changed-files.outputs.deploy_any_changed }}
     steps:
-      - name: Checkout Repository to Actions
-        uses: actions/checkout@v3.3.0
-
-      - name: Setup Node.js 18.x
-        uses: actions/setup-node@v2
-        with:
-          node-version: 18.x
-          cache: 'yarn'
-      
+      - uses: actions/checkout@v3
       - name: Get changed files
         id: changed-files
-        uses: tj-actions/changed-files@v38
+        uses: tj-actions/changed-files@v41
         with:
           files_yaml: |
             apiserver:
               - apiserver/**
             web:
               - web/**
+              - packages/**
+              - 'package.json'
+              - 'yarn.lock'
+              - 'tsconfig.json'
+              - 'turbo.json'
             deploy:
               - space/**
+              - packages/**
+              - 'package.json'
+              - 'yarn.lock'
+              - 'tsconfig.json'
+              - 'turbo.json'
 
-      - name: Build Plane's Main App
-        if: steps.changed-files.outputs.web_any_changed == 'true'
-        run: |
-          yarn
-          yarn build --filter=web
+  lint-apiserver:
+    needs: get-changed-files
+    runs-on: ubuntu-latest
+    if: needs.get-changed-files.outputs.apiserver_changed == 'true'
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.x' # Specify the Python version you need
+      - name: Install Pylint
+        run: python -m pip install ruff
+      - name: Install Apiserver Dependencies
+        run: cd apiserver && pip install -r requirements.txt
+      - name: Lint apiserver
+        run: ruff check --fix apiserver
 
-      - name: Build Plane's Deploy App
-        if: steps.changed-files.outputs.deploy_any_changed == 'true'
-        run: |
-          yarn 
-          yarn build --filter=space
+  lint-web:
+    needs: get-changed-files
+    if: needs.get-changed-files.outputs.web_changed == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: 18.x
+      - run: yarn install
+      - run: yarn lint --filter=web
 
+  lint-space:
+    needs: get-changed-files
+    if: needs.get-changed-files.outputs.space_changed == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: 18.x
+      - run: yarn install
+      - run: yarn lint --filter=space
 
+  build-web:
+    needs: lint-web
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: 18.x
+      - run: yarn install
+      - run: yarn build --filter=web
+
+  build-space:
+    needs: lint-space
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: 18.x
+      - run: yarn install
+      - run: yarn build --filter=space

.github/workflows/check-version.yml

@@ -0,0 +1,45 @@
+name: Version Change Before Release
+
+on:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  check-version:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.head_ref }}
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+
+      - name: Get PR Branch version
+        run: echo "PR_VERSION=$(node -p "require('./package.json').version")" >> $GITHUB_ENV
+
+      - name: Fetch base branch
+        run: git fetch origin master:master
+
+      - name: Get Master Branch version
+        run: |
+          git checkout master
+          echo "MASTER_VERSION=$(node -p "require('./package.json').version")" >> $GITHUB_ENV
+
+      - name: Get master branch version and compare
+        run: |
+          echo "Comparing versions: PR version is $PR_VERSION, Master version is $MASTER_VERSION"
+          if [ "$PR_VERSION" == "$MASTER_VERSION" ]; then
+            echo "Version in PR branch is the same as in master. Failing the CI."
+            exit 1
+          else
+            echo "Version check passed. Versions are different."
+          fi
+        env:
+          PR_VERSION: ${{ env.PR_VERSION }}
+          MASTER_VERSION: ${{ env.MASTER_VERSION }}

.github/workflows/codeql.yml

@@ -1,13 +1,13 @@
 name: "CodeQL"
 
 on:
+  workflow_dispatch:
   push:
-    branches: [ 'develop', 'hot-fix', 'stage-release' ]
+    branches: ["develop", "preview", "master"]
   pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ 'develop' ]
+    branches: ["develop", "preview", "master"]
   schedule:
-    - cron: '53 19 * * 5'
+    - cron: "53 19 * * 5"
 
 jobs:
   analyze:
@@ -21,45 +21,44 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        language: [ 'python', 'javascript' ]
+        language: ["python", "javascript"]
         # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
         # Use only 'java' to analyze code written in Java, Kotlin or both
         # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
         # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
 
     steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
+      - name: Checkout repository
+        uses: actions/checkout@v3
 
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: ${{ matrix.language }}
+          # If you wish to specify custom queries, you can do so here or in a config file.
+          # By default, queries listed here will override any specified in a config file.
+          # Prefix the list here with "+" to use these queries and those in the config file.
 
-        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
+          # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+          # queries: security-extended,security-and-quality
 
+      # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
+      # If this step fails, then you should remove it and run the build manually (see below)
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v2
 
-    # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
+      # ℹ️ Command-line programs to run using the OS shell.
+      # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
 
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+      #   If the Autobuild fails above, remove it and uncomment the following three lines.
+      #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
 
-    #   If the Autobuild fails above, remove it and uncomment the following three lines.
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+      # - run: |
+      #     echo "Run, Build Application using script"
+      #     ./location_of_script_within_repo/buildscript.sh
 
-    # - run: |
-    #     echo "Run, Build Application using script"
-    #     ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
-      with:
-        category: "/language:${{matrix.language}}"
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2
+        with:
+          category: "/language:${{matrix.language}}"

.github/workflows/create-sync-pr.yml

@@ -1,42 +1,28 @@
-name: Create PR in Plane EE Repository to sync the changes
+name: Create Sync Action
 
 on:
-  pull_request:
+  workflow_dispatch:
+  push:
     branches:
-      - master
-    types:
-      - closed
+      - preview
+
+env:
+  SOURCE_BRANCH_NAME: ${{ github.ref_name }}
 
 jobs:
-  create_pr:
-    # Only run the job when a PR is merged
-    if: github.event.pull_request.merged == true
+  sync_changes:
     runs-on: ubuntu-latest
     permissions:
       pull-requests: write
       contents: read
     steps:
-      - name: Check SOURCE_REPO
-        id: check_repo
-        env:
-          SOURCE_REPO: ${{ secrets.SOURCE_REPO_NAME }}
-        run: |
-          echo "::set-output name=is_correct_repo::$(if [[ "$SOURCE_REPO" == "makeplane/plane" ]]; then echo 'true'; else echo 'false'; fi)"
-
       - name: Checkout Code
-        if: steps.check_repo.outputs.is_correct_repo == 'true'
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4.1.1
         with:
           persist-credentials: false
           fetch-depth: 0
 
-      - name: Set up Branch Name
-        if: steps.check_repo.outputs.is_correct_repo == 'true'
-        run: |
-          echo "SOURCE_BRANCH_NAME=${{ github.head_ref }}" >> $GITHUB_ENV
-
       - name: Setup GH CLI
-        if: steps.check_repo.outputs.is_correct_repo == 'true'
         run: |
           type -p curl >/dev/null || (sudo apt update && sudo apt install curl -y)
           curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
@@ -45,35 +31,25 @@ jobs:
           sudo apt update
           sudo apt install gh -y
 
-      - name: Create Pull Request
-        if: steps.check_repo.outputs.is_correct_repo == 'true'
+      - name: Push Changes to Target Repo A
         env:
           GH_TOKEN: ${{ secrets.ACCESS_TOKEN }}
         run: |
-          TARGET_REPO="${{ secrets.TARGET_REPO_NAME }}"
-          TARGET_BRANCH="${{ secrets.TARGET_REPO_BRANCH }}"
+          TARGET_REPO="${{ secrets.TARGET_REPO_A }}"
+          TARGET_BRANCH="${{ secrets.TARGET_REPO_A_BRANCH_NAME }}"
           SOURCE_BRANCH="${{ env.SOURCE_BRANCH_NAME }}"
 
           git checkout $SOURCE_BRANCH
-          git remote add target "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
-          git push target $SOURCE_BRANCH:$SOURCE_BRANCH
+          git remote add target-origin-a "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
+          git push target-origin-a $SOURCE_BRANCH:$TARGET_BRANCH
 
-          PR_TITLE="${{ github.event.pull_request.title }}"
-          PR_BODY="${{ github.event.pull_request.body }}"
+      - name: Push Changes to Target Repo B
+        env:
+          GH_TOKEN: ${{ secrets.ACCESS_TOKEN }}
+        run: |
+          TARGET_REPO="${{ secrets.TARGET_REPO_B }}"
+          TARGET_BRANCH="${{ secrets.TARGET_REPO_B_BRANCH_NAME }}"
+          SOURCE_BRANCH="${{ env.SOURCE_BRANCH_NAME }}"
 
-          # Remove double quotes
-          PR_TITLE_CLEANED="${PR_TITLE//\"/}"
-          PR_BODY_CLEANED="${PR_BODY//\"/}"
-
-          # Construct PR_BODY_CONTENT using a here-document
-          PR_BODY_CONTENT=$(cat <<EOF
-          $PR_BODY_CLEANED
-          EOF
-          )
-
-          gh pr create \
-            --base $TARGET_BRANCH \
-            --head $SOURCE_BRANCH \
-            --title "[SYNC] $PR_TITLE_CLEANED" \
-            --body "$PR_BODY_CONTENT" \
-            --repo $TARGET_REPO
+          git remote add target-origin-b "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
+          git push target-origin-b $SOURCE_BRANCH:$TARGET_BRANCH

.github/workflows/feature-deployment.yml

@@ -0,0 +1,199 @@
+name: Feature Preview
+
+on:
+  workflow_dispatch:
+    inputs:
+      web-build:
+        required: false
+        description: 'Build Web'
+        type: boolean
+        default: true
+      space-build:
+        required: false
+        description: 'Build Space'
+        type: boolean
+        default: false
+
+env:
+  BUILD_WEB: ${{ github.event.inputs.web-build }}
+  BUILD_SPACE: ${{ github.event.inputs.space-build }}
+
+jobs:
+  setup-feature-build:
+    name: Feature Build Setup
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        run: |
+          echo "BUILD_WEB=$BUILD_WEB" 
+          echo "BUILD_SPACE=$BUILD_SPACE"
+    outputs:
+      web-build: ${{ env.BUILD_WEB}} 
+      space-build: ${{env.BUILD_SPACE}}
+
+  feature-build-web:
+    if: ${{ needs.setup-feature-build.outputs.web-build == 'true' }}
+    needs: setup-feature-build
+    name: Feature Build Web
+    runs-on: ubuntu-latest
+    env:
+      AWS_ACCESS_KEY_ID: ${{ vars.FEATURE_PREVIEW_AWS_ACCESS_KEY_ID }}
+      AWS_SECRET_ACCESS_KEY: ${{ secrets.FEATURE_PREVIEW_AWS_SECRET_ACCESS_KEY }}
+      AWS_BUCKET: ${{ vars.FEATURE_PREVIEW_AWS_BUCKET }}
+      NEXT_PUBLIC_API_BASE_URL: ${{ vars.FEATURE_PREVIEW_NEXT_PUBLIC_API_BASE_URL }}
+    steps:
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+      - name: Install AWS cli
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y python3-pip
+          pip3 install awscli
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          path: plane
+      - name: Install Dependencies
+        run: |
+          cd $GITHUB_WORKSPACE/plane
+          yarn install
+      - name: Build Web
+        id: build-web
+        run: |
+          cd $GITHUB_WORKSPACE/plane
+          yarn build --filter=web
+          cd $GITHUB_WORKSPACE
+
+          TAR_NAME="web.tar.gz"
+          tar -czf $TAR_NAME ./plane
+
+          FILE_EXPIRY=$(date -u -d "+2 days" +"%Y-%m-%dT%H:%M:%SZ")
+          aws s3 cp $TAR_NAME s3://${{ env.AWS_BUCKET }}/${{github.sha}}/$TAR_NAME --expires $FILE_EXPIRY
+     
+  feature-build-space:
+    if: ${{ needs.setup-feature-build.outputs.space-build == 'true' }}
+    needs: setup-feature-build
+    name: Feature Build Space
+    runs-on: ubuntu-latest
+    env:
+      AWS_ACCESS_KEY_ID: ${{ vars.FEATURE_PREVIEW_AWS_ACCESS_KEY_ID }}
+      AWS_SECRET_ACCESS_KEY: ${{ secrets.FEATURE_PREVIEW_AWS_SECRET_ACCESS_KEY }}
+      AWS_BUCKET: ${{ vars.FEATURE_PREVIEW_AWS_BUCKET }}
+      NEXT_PUBLIC_DEPLOY_WITH_NGINX: 1
+      NEXT_PUBLIC_API_BASE_URL: ${{ vars.FEATURE_PREVIEW_NEXT_PUBLIC_API_BASE_URL }}
+    outputs:
+      do-build: ${{ needs.setup-feature-build.outputs.space-build }}
+      s3-url: ${{ steps.build-space.outputs.S3_PRESIGNED_URL }}
+    steps:
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+      - name: Install AWS cli
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y python3-pip
+          pip3 install awscli
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          path: plane
+      - name: Install Dependencies
+        run: |
+          cd $GITHUB_WORKSPACE/plane
+          yarn install
+      - name: Build Space
+        id: build-space
+        run: |
+          cd $GITHUB_WORKSPACE/plane
+          yarn build --filter=space
+          cd $GITHUB_WORKSPACE
+
+          TAR_NAME="space.tar.gz"
+          tar -czf $TAR_NAME ./plane
+
+          FILE_EXPIRY=$(date -u -d "+2 days" +"%Y-%m-%dT%H:%M:%SZ")
+          aws s3 cp $TAR_NAME s3://${{ env.AWS_BUCKET }}/${{github.sha}}/$TAR_NAME --expires $FILE_EXPIRY
+
+  feature-deploy:
+    if: ${{ always() && (needs.setup-feature-build.outputs.web-build == 'true' || needs.setup-feature-build.outputs.space-build == 'true') }}
+    needs: [feature-build-web, feature-build-space]
+    name: Feature Deploy
+    runs-on: ubuntu-latest
+    env:
+      AWS_ACCESS_KEY_ID: ${{ vars.FEATURE_PREVIEW_AWS_ACCESS_KEY_ID }}
+      AWS_SECRET_ACCESS_KEY: ${{ secrets.FEATURE_PREVIEW_AWS_SECRET_ACCESS_KEY }}
+      AWS_BUCKET: ${{ vars.FEATURE_PREVIEW_AWS_BUCKET }}
+      KUBE_CONFIG_FILE: ${{ secrets.FEATURE_PREVIEW_KUBE_CONFIG }}
+    steps:
+      - name: Install AWS cli
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y python3-pip
+          pip3 install awscli
+      - name: Tailscale
+        uses: tailscale/github-action@v2
+        with:
+          oauth-client-id: ${{ secrets.TAILSCALE_OAUTH_CLIENT_ID }}
+          oauth-secret: ${{ secrets.TAILSCALE_OAUTH_SECRET }}
+          tags: tag:ci
+      - name: Kubectl Setup
+        run: |
+          curl -LO "https://dl.k8s.io/release/${{ vars.FEATURE_PREVIEW_KUBE_VERSION }}/bin/linux/amd64/kubectl"
+          chmod +x kubectl
+
+          mkdir -p ~/.kube
+          echo "$KUBE_CONFIG_FILE" > ~/.kube/config
+          chmod 600 ~/.kube/config
+      - name: HELM Setup
+        run: |
+          curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
+          chmod 700 get_helm.sh
+          ./get_helm.sh
+      - name: App Deploy
+        run: |
+          WEB_S3_URL=""
+          if [ ${{ env.BUILD_WEB }} == true ]; then
+            WEB_S3_URL=$(aws s3 presign s3://${{ vars.FEATURE_PREVIEW_AWS_BUCKET }}/${{github.sha}}/web.tar.gz --expires-in 3600)
+          fi
+
+          SPACE_S3_URL=""
+          if [ ${{ env.BUILD_SPACE }} == true ]; then
+            SPACE_S3_URL=$(aws s3 presign s3://${{ vars.FEATURE_PREVIEW_AWS_BUCKET }}/${{github.sha}}/space.tar.gz --expires-in 3600)
+          fi
+
+          if [ ${{ env.BUILD_WEB }} == true ] || [ ${{ env.BUILD_SPACE }} == true ]; then
+
+            helm --kube-insecure-skip-tls-verify repo add feature-preview ${{ vars.FEATURE_PREVIEW_HELM_CHART_URL }} 
+
+            APP_NAMESPACE="${{ vars.FEATURE_PREVIEW_NAMESPACE }}"
+            DEPLOY_SCRIPT_URL="${{ vars.FEATURE_PREVIEW_DEPLOY_SCRIPT_URL }}"
+
+            METADATA=$(helm --kube-insecure-skip-tls-verify install feature-preview/${{ vars.FEATURE_PREVIEW_HELM_CHART_NAME }} \
+                --generate-name \
+                --namespace $APP_NAMESPACE \
+                --set ingress.primaryDomain=${{vars.FEATURE_PREVIEW_PRIMARY_DOMAIN || 'feature.plane.tools' }} \
+                --set web.image=${{vars.FEATURE_PREVIEW_DOCKER_BASE}} \
+                --set web.enabled=${{ env.BUILD_WEB || false }} \
+                --set web.artifact_url=$WEB_S3_URL \
+                --set space.image=${{vars.FEATURE_PREVIEW_DOCKER_BASE}} \
+                --set space.enabled=${{ env.BUILD_SPACE || false }} \
+                --set space.artifact_url=$SPACE_S3_URL \
+                --set shared_config.deploy_script_url=$DEPLOY_SCRIPT_URL \
+                --set shared_config.api_base_url=${{vars.FEATURE_PREVIEW_NEXT_PUBLIC_API_BASE_URL}} \
+                --output json \
+                --timeout 1000s)
+
+            APP_NAME=$(echo $METADATA | jq -r '.name')
+
+            INGRESS_HOSTNAME=$(kubectl get ingress -n feature-builds --insecure-skip-tls-verify \
+                -o jsonpath='{.items[?(@.metadata.annotations.meta\.helm\.sh\/release-name=="'$APP_NAME'")]}' | \
+                jq -r '.spec.rules[0].host')
+
+            echo "****************************************"
+            echo "APP NAME ::: $APP_NAME"
+            echo "INGRESS HOSTNAME ::: $INGRESS_HOSTNAME"
+            echo "****************************************"
+          fi

.gitignore

@@ -1,3 +1,7 @@
+pg_data
+redis_data
+minio_data
+
 node_modules
 .next
 
@@ -51,6 +55,7 @@ staticfiles
 mediafiles
 .env
 .DS_Store
+logs/
 
 node_modules/
 assets/dist/

CONTRIBUTING.md

@@ -33,8 +33,8 @@ The backend is a django project which is kept inside apiserver
 1. Clone the repo
 
 ```bash
-git clone https://github.com/makeplane/plane
-cd plane
+git clone https://github.com/makeplane/plane.git [folder-name]
+cd [folder-name]
 chmod +x setup.sh
 ```
 
@@ -44,32 +44,10 @@ chmod +x setup.sh
 ./setup.sh
 ```
 
-3. Define `NEXT_PUBLIC_API_BASE_URL=http://localhost` in **web/.env** and **space/.env** file
+3. Start the containers
 
 ```bash
-echo "\nNEXT_PUBLIC_API_BASE_URL=http://localhost\n" >> ./web/.env
-```
-
-```bash
-echo "\nNEXT_PUBLIC_API_BASE_URL=http://localhost\n" >> ./space/.env
-```
-
-4. Run Docker compose up
-
-```bash
-docker compose up -d
-```
-
-5. Install dependencies
-
-```bash
-yarn install
-```
-
-6. Run the web app in development mode
-
-```bash
-yarn dev
+docker compose -f docker-compose-local.yml up
 ```
 
 ## Missing a Feature?

Dockerfile

@@ -1,129 +1,110 @@
-FROM node:18-alpine AS builder
-RUN apk add --no-cache libc6-compat
-# Set working directory
-WORKDIR /app
-ENV NEXT_PUBLIC_API_BASE_URL=http://NEXT_PUBLIC_API_BASE_URL_PLACEHOLDER
+FROM git.orionkindel.com/tpl/asdf:bookworm AS system
 
-RUN yarn global add turbo
-RUN apk add tree
-COPY . .
+ARG S6_OVERLAY_VERSION=3.1.6.2
 
-RUN turbo prune --scope=app --scope=plane-deploy --docker
-CMD tree -I node_modules/
+ADD https://github.com/just-containers/s6-overlay/releases/download/v${S6_OVERLAY_VERSION}/s6-overlay-noarch.tar.xz /tmp
+RUN tar -C / -Jxpf /tmp/s6-overlay-noarch.tar.xz
 
-# Add lockfile and package.json's of isolated subworkspace
-FROM node:18-alpine AS installer
+ADD https://github.com/just-containers/s6-overlay/releases/download/v${S6_OVERLAY_VERSION}/s6-overlay-x86_64.tar.xz /tmp
+RUN tar -C / -Jxpf /tmp/s6-overlay-x86_64.tar.xz
 
-RUN apk add --no-cache libc6-compat
-WORKDIR /app
-ARG NEXT_PUBLIC_API_BASE_URL=http://localhost:8000
-# First install the dependencies (as they change less often)
-COPY .gitignore .gitignore
-COPY --from=builder /app/out/json/ .
-COPY --from=builder /app/out/yarn.lock ./yarn.lock
-RUN yarn install
+RUN apt-get update
+RUN apt-get install -y \
+    build-essential \
+    zlib1g-dev \
+    libncurses5-dev \
+    libgdbm-dev \
+    libnss3-dev \
+    libssl-dev \
+    libreadline-dev \
+    libffi-dev \
+    libsqlite3-dev \
+    wget \
+    libbz2-dev \
+    uuid-dev \
+    nginx \
+    procps
 
-# # Build the project
-COPY --from=builder /app/out/full/ .
-COPY turbo.json turbo.json
-COPY replace-env-vars.sh /usr/local/bin/
-USER root
-RUN chmod +x /usr/local/bin/replace-env-vars.sh
+RUN asdf plugin add nodejs \
+    && asdf plugin add python \
+    && asdf plugin add postgres 
 
-RUN yarn turbo run build
+RUN --mount=type=cache,target=/.asdf-build \
+    export ASDF_DOWNLOAD_PATH=/.asdf-build \
+    && export TMPDIR=/.asdf-build \
+    && export POSTGRES_SKIP_INITDB=y \
+    && asdf install nodejs 20.9.0 \
+    && asdf install python 3.11.1 \
+    && asdf install postgres 15.3
 
-ENV NEXT_PUBLIC_API_BASE_URL=$NEXT_PUBLIC_API_BASE_URL \
-    BUILT_NEXT_PUBLIC_API_BASE_URL=$NEXT_PUBLIC_API_BASE_URL
+RUN asdf global nodejs 20.9.0 \
+    && asdf global postgres 15.3 \
+    && asdf global python 3.11.1
 
-RUN /usr/local/bin/replace-env-vars.sh http://NEXT_PUBLIC_WEBAPP_URL_PLACEHOLDER ${NEXT_PUBLIC_API_BASE_URL}
+RUN useradd -m postgres && passwd -d postgres
 
-FROM python:3.11.1-alpine3.17 AS backend
+ADD https://dl.min.io/server/minio/release/linux-amd64/minio /usr/bin
+RUN chmod +x /usr/bin/minio
 
-# set environment variables
-ENV PYTHONDONTWRITEBYTECODE 1
-ENV PYTHONUNBUFFERED 1
-ENV PIP_DISABLE_PIP_VERSION_CHECK=1 
+RUN set -eo pipefail; \
+    curl -fsSL https://packages.redis.io/gpg | gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg; \
+    echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb bookworm main" | tee /etc/apt/sources.list.d/redis.list; \
+    apt-get update; \
+    apt-get install -y redis
 
-WORKDIR /code
+FROM system AS next_prebuild
 
-RUN apk --no-cache add \
-    "libpq~=15" \
-    "libxslt~=1.1" \
-    "nodejs-current~=19" \
-    "xmlsec~=1.2" \
-    "nginx" \
-    "nodejs" \
-    "npm" \
-    "supervisor"
+RUN npm i -g yarn
+RUN --mount=type=cache,target=/.yarn-cache \
+    yarn config set cache-folder /.yarn-cache
 
-COPY apiserver/requirements.txt ./
-COPY apiserver/requirements ./requirements
-RUN apk add --no-cache libffi-dev
-RUN apk add --no-cache --virtual .build-deps \
-    "bash~=5.2" \
-    "g++~=12.2" \
-    "gcc~=12.2" \
-    "cargo~=1.64" \
-    "git~=2" \
-    "make~=4.3" \
-    "postgresql13-dev~=13" \
-    "libc-dev" \
-    "linux-headers" \
-    && \
-    pip install -r requirements.txt --compile --no-cache-dir \
-    && \
-    apk del .build-deps
+COPY package.json turbo.json yarn.lock app.json ./
+COPY packages packages
+COPY web web
+COPY space space
 
-# Add in Django deps and generate Django's static files
-COPY apiserver/manage.py manage.py
-COPY apiserver/plane plane/
-COPY apiserver/templates templates/
+RUN --mount=type=cache,target=/.yarn-cache \
+    yarn install
 
-RUN apk --no-cache add "bash~=5.2"
-COPY apiserver/bin ./bin/
+FROM next_prebuild AS next_build
 
-RUN chmod +x ./bin/takeoff ./bin/worker
-RUN chmod -R 777 /code
+RUN --mount=type=cache,target=/.yarn-cache \
+    --mount=type=cache,target=/web/.next \
+    --mount=type=cache,target=/space/.next \
+    yarn build && \
+    cp -R /web/.next /web/_next && \
+    cp -R /space/.next /space/_next
 
-# Expose container port and run entry point script
+RUN mv /web/_next /web/.next && \
+    mv /space/_next /space/.next && \
+    cp -R /web/.next/standalone/web/* /web/ && \
+    cp -R /space/.next/standalone/space/* /space/
 
-WORKDIR /app
+FROM next_build AS api_build
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PIP_DISABLE_PIP_VERSION_CHECK=1
 
-# Don't run production as root
-RUN addgroup --system --gid 1001 plane
-RUN adduser --system --uid 1001 captain
+COPY apiserver apiserver
+RUN --mount=type=cache,target=/root/.cache/pip \
+    cd /apiserver \
+    && pip install -r requirements.txt --compile
 
-COPY --from=installer /app/apps/app/next.config.js .
-COPY --from=installer /app/apps/app/package.json .
-COPY --from=installer /app/apps/space/next.config.js .
-COPY --from=installer /app/apps/space/package.json .
+FROM api_build AS s6
 
-COPY --from=installer --chown=captain:plane /app/apps/app/.next/standalone ./
+COPY docker/etc/ /etc/
 
-COPY --from=installer --chown=captain:plane /app/apps/app/.next/static ./apps/app/.next/static
+RUN chmod -R 777 /root \
+    && chmod -R 777 /root/.asdf \
+    && chmod -x /root/.asdf/lib/commands/* \
+    && chmod -R 777 /apiserver \
+    && chmod -R 777 /web \
+    && chmod -R 777 /space \
+    && ln $(asdf which postgres) /usr/bin/postgres \
+    && ln $(asdf which initdb) /usr/bin/initdb \
+    && ln $(asdf which node) /usr/bin/node \
+    && ln $(asdf which npm) /usr/bin/npm \
+    && ln $(asdf which python) /usr/bin/python
 
-COPY --from=installer --chown=captain:plane /app/apps/space/.next/standalone ./
-COPY --from=installer --chown=captain:plane /app/apps/space/.next ./apps/space/.next
-
-ENV NEXT_TELEMETRY_DISABLED 1
-
-# RUN rm /etc/nginx/conf.d/default.conf
-#######################################################################
-COPY nginx/nginx-single-docker-image.conf /etc/nginx/http.d/default.conf
-#######################################################################
-
-COPY nginx/supervisor.conf /code/supervisor.conf
-
-ARG NEXT_PUBLIC_API_BASE_URL=http://localhost:8000
-ENV NEXT_PUBLIC_API_BASE_URL=$NEXT_PUBLIC_API_BASE_URL \
-    BUILT_NEXT_PUBLIC_API_BASE_URL=$NEXT_PUBLIC_API_BASE_URL
-
-USER root
-COPY replace-env-vars.sh /usr/local/bin/
-COPY start.sh /usr/local/bin/
-RUN chmod +x /usr/local/bin/replace-env-vars.sh
-RUN chmod +x /usr/local/bin/start.sh
-
-EXPOSE 80
-
-CMD ["supervisord","-c","/code/supervisor.conf"]
+ENV S6_KEEP_ENV=1
+ENTRYPOINT ["/init"]

ENV_SETUP.md

@@ -49,25 +49,10 @@ NGINX_PORT=80
 ​
 
 ```
-# Enable/Disable OAUTH - default 0 for selfhosted instance
-NEXT_PUBLIC_ENABLE_OAUTH=0
 # Public boards deploy URL
 NEXT_PUBLIC_DEPLOY_URL="http://localhost/spaces"
 ```
 
-​
-
-## {PROJECT_FOLDER}/spaces/.env.example
-
-​
-
-```
-# Flag to toggle OAuth
-NEXT_PUBLIC_ENABLE_OAUTH=0
-```
-
-​
-
 ## {PROJECT_FOLDER}/apiserver/.env
 
 ​

README.md

@@ -7,7 +7,7 @@
 </p>
 
 <h3 align="center"><b>Plane</b></h3>
-<p align="center"><b>Flexible, extensible open-source project management</b></p>
+<p align="center"><b>Open-source project management that unlocks customer value.</b></p>
 
 <p align="center">
 <a href="https://discord.com/invite/A92xrEGCge">
@@ -16,6 +16,13 @@
 <img alt="Commit activity per month" src="https://img.shields.io/github/commit-activity/m/makeplane/plane?style=for-the-badge" />
 </p>
 
+<p align="center">
+    <a href="https://dub.sh/plane-website-readme"><b>Website</b></a> •
+    <a href="https://git.new/releases"><b>Releases</b></a> •
+    <a href="https://dub.sh/planepowershq"><b>Twitter</b></a> •
+    <a href="https://dub.sh/planedocs"><b>Documentation</b></a>
+</p>
+
 <p>
     <a href="https://app.plane.so/#gh-light-mode-only" target="_blank">
       <img
@@ -33,56 +40,90 @@
     </a>
 </p>
 
-Meet [Plane](https://plane.so). An open-source software development tool to manage issues, sprints, and product roadmaps with peace of mind 🧘‍♀️.
+Meet [Plane](https://dub.sh/plane-website-readme). An open-source software development tool to manage issues, sprints, and product roadmaps with peace of mind. 🧘‍♀️
 
-> Plane is still in its early days, not everything will be perfect yet, and hiccups may happen. Please let us know of any suggestions, ideas, or bugs that you encounter on our [Discord](https://discord.com/invite/A92xrEGCge) or GitHub issues, and we will use your feedback to improve on our upcoming releases.
+> Plane is still in its early days, not everything will be perfect yet, and hiccups may happen. Please let us know of any suggestions, ideas, or bugs that you encounter on our [Discord](https://discord.com/invite/A92xrEGCge) or GitHub issues, and we will use your feedback to improve in our upcoming releases.
 
-The easiest way to get started with Plane is by creating a [Plane Cloud](https://app.plane.so) account. Plane Cloud offers a hosted solution for Plane. If you prefer to self-host Plane, please refer to our [deployment documentation](https://docs.plane.so/self-hosting).
+## ⚡ Installation
 
-## ⚡️ Contributors Quick Start
+The easiest way to get started with Plane is by creating a [Plane Cloud](https://app.plane.so) account where we offer a hosted solution for users.
 
-### Prerequisite
+If you want more control over your data, prefer to self-host Plane, please refer to our [deployment documentation](https://docs.plane.so/docker-compose).
 
-Development system must have docker engine installed and running.
+| Installation Methods | Documentation Link                                                                                                                                           |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Docker               | [![Docker](https://img.shields.io/badge/docker-%230db7ed.svg?style=for-the-badge&logo=docker&logoColor=white)](https://docs.plane.so/self-hosting/methods/docker-compose)         |
+| Kubernetes           | [![Kubernetes](https://img.shields.io/badge/kubernetes-%23326ce5.svg?style=for-the-badge&logo=kubernetes&logoColor=white)](https://docs.plane.so/kubernetes) |
 
-### Steps
-
-Setting up local environment is extremely easy and straight forward. Follow the below step and you will be ready to contribute
-
-1. Clone the code locally using `git clone https://github.com/makeplane/plane.git`
-1. Switch to the code folder `cd plane`
-1. Create your feature or fix branch you plan to work on using `git checkout -b <feature-branch-name>`
-1. Open terminal and run `./setup.sh`
-1. Open the code on VSCode or similar equivalent IDE
-1. Review the `.env` files available in various folders. Visit [Environment Setup](./ENV_SETUP.md) to know about various environment variables used in system
-1. Run the docker command to initiate various services `docker compose -f docker-compose-local.yml up -d`
-
-You are ready to make changes to the code. Do not forget to refresh the browser (in case id does not auto-reload)
-
-Thats it!
-
-## 🍙 Self Hosting
-
-For self hosting environment setup, visit the [Self Hosting](https://docs.plane.so/self-hosting) documentation page
+`Instance admin` can configure instance settings using our [God-mode](https://docs.plane.so/instance-admin) feature.
 
 ## 🚀 Features
 
-- **Issue Planning and Tracking**: Quickly create issues and add details using a powerful rich text editor that supports file uploads. Add sub-properties and references to issues for better organization and tracking.
-- **Issue Attachments**: Collaborate effectively by attaching files to issues, making it easy for your team to find and share important project-related documents.
-- **Layouts**: Customize your project view with your preferred layout - choose from List, Kanban, or Calendar to visualize your project in a way that makes sense to you.
-- **Cycles**: Plan sprints with Cycles to keep your team on track and productive. Gain insights into your project's progress with burn-down charts and other useful features.
-- **Modules**: Break down your large projects into smaller, more manageable modules. Assign modules between teams to easily track and plan your project's progress.
+- **Issues**: Quickly create issues and add details using a powerful rich text editor that supports file uploads. Add sub-properties and references to problems for better organization and tracking.
+
+- **Cycles**:
+  Keep up your team's momentum with Cycles. Gain insights into your project's progress with burn-down charts and other valuable features.
+
+- **Modules**: Break down your large projects into smaller, more manageable modules. Assign modules between teams to track and plan your project's progress easily.
+
 - **Views**: Create custom filters to display only the issues that matter to you. Save and share your filters in just a few clicks.
-- **Pages**: Plane pages function as an AI-powered notepad, allowing you to easily document issues, cycle plans, and module details, and then synchronize them with your issues.
-- **Command K**: Enjoy a better user experience with the new Command + K menu. Easily manage and navigate through your projects from one convenient location.
-- **GitHub Sync**: Streamline your planning process by syncing your GitHub issues with Plane. Keep all your issues in one place for better tracking and collaboration.
+
+- **Pages**: Plane pages, equipped with AI and a rich text editor, let you jot down your thoughts on the fly. Format your text, upload images, hyperlink, or sync your existing ideas into an actionable item or issue.
+
+- **Analytics**: Get insights into all your Plane data in real-time. Visualize issue data to spot trends, remove blockers, and progress your work.
+
+- **Drive** (_coming soon_): The drive helps you share documents, images, videos, or any other files that make sense to you or your team and align on the problem/solution.
+
+## 🛠️ Quick start for contributors
+
+> Development system must have docker engine installed and running.
+
+Setting up local environment is extremely easy and straight forward. Follow the below step and you will be ready to contribute - 
+
+1. Clone the code locally using:
+   ```
+   git clone https://github.com/makeplane/plane.git
+   ```
+2. Switch to the code folder:
+   ```
+   cd plane
+   ```
+3. Create your feature or fix branch you plan to work on using:
+   ```
+   git checkout -b <feature-branch-name>
+   ```
+4. Open terminal and run:
+   ```
+   ./setup.sh
+   ```
+5. Open the code on VSCode or similar equivalent IDE.
+6. Review the `.env` files available in various folders.
+   Visit [Environment Setup](./ENV_SETUP.md) to know about various environment variables used in system.
+7. Run the docker command to initiate services:
+   ```
+   docker compose -f docker-compose-local.yml up -d
+   ```
+
+You are ready to make changes to the code. Do not forget to refresh the browser (in case it does not auto-reload).
+
+Thats it!
+
+## ❤️ Community
+
+The Plane community can be found on [GitHub Discussions](https://github.com/orgs/makeplane/discussions), and our [Discord server](https://discord.com/invite/A92xrEGCge). Our [Code of conduct](https://github.com/makeplane/plane/blob/master/CODE_OF_CONDUCT.md) applies to all Plane community chanels.
+
+Ask questions, report bugs, join discussions, voice ideas, make feature requests, or share your projects.
+
+### Repo Activity
+
+![Plane Repo Activity](https://repobeats.axiom.co/api/embed/2523c6ed2f77c082b7908c33e2ab208981d76c39.svg "Repobeats analytics image")
 
 ## 📸 Screenshots
 
 <p>
     <a href="https://plane.so" target="_blank">
       <img
-        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_views_dark_mode.webp"
+        src="https://ik.imagekit.io/w2okwbtu2/Issues_rNZjrGgFl.png?updatedAt=1709298765880"
         alt="Plane Views"
         width="100%"
       />
@@ -91,8 +132,7 @@ For self hosting environment setup, visit the [Self Hosting](https://docs.plane.
 <p>
     <a href="https://plane.so" target="_blank">
       <img
-        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_issue_detail_dark_mode.webp"
-        alt="Plane Issue Details"
+        src="https://ik.imagekit.io/w2okwbtu2/Cycles_jCDhqmTl9.png?updatedAt=1709298780697"
         width="100%"
       />
     </a>
@@ -100,7 +140,7 @@ For self hosting environment setup, visit the [Self Hosting](https://docs.plane.
   <p>
     <a href="https://plane.so" target="_blank">
       <img
-        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_cycles_modules_dark_mode.webp"
+        src="https://ik.imagekit.io/w2okwbtu2/Modules_PSCVsbSfI.png?updatedAt=1709298796783"
         alt="Plane Cycles and Modules"
         width="100%"
       />
@@ -109,7 +149,7 @@ For self hosting environment setup, visit the [Self Hosting](https://docs.plane.
   <p>
     <a href="https://plane.so" target="_blank">
       <img
-        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_analytics_dark_mode.webp"
+        src="https://ik.imagekit.io/w2okwbtu2/Views_uxXsRatS4.png?updatedAt=1709298834522"
         alt="Plane Analytics"
         width="100%"
       />
@@ -118,7 +158,7 @@ For self hosting environment setup, visit the [Self Hosting](https://docs.plane.
    <p>
     <a href="https://plane.so" target="_blank">
       <img
-        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_pages_dark_mode.webp"
+        src="https://ik.imagekit.io/w2okwbtu2/Analytics_0o22gLRtp.png?updatedAt=1709298834389"
         alt="Plane Pages"
         width="100%"
       />
@@ -128,7 +168,7 @@ For self hosting environment setup, visit the [Self Hosting](https://docs.plane.
    <p>
     <a href="https://plane.so" target="_blank">
       <img
-        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_commad_k_dark_mode.webp"
+        src="https://ik.imagekit.io/w2okwbtu2/Drive_LlfeY4xn3.png?updatedAt=1709298837917"
         alt="Plane Command Menu"
         width="100%"
       />
@@ -136,20 +176,23 @@ For self hosting environment setup, visit the [Self Hosting](https://docs.plane.
   </p>
 </p>
 
-## 📚Documentation
-
-For full documentation, visit [docs.plane.so](https://docs.plane.so/)
-
-To see how to Contribute, visit [here](https://github.com/makeplane/plane/blob/master/CONTRIBUTING.md).
-
-## ❤️ Community
-
-The Plane community can be found on GitHub Discussions, where you can ask questions, voice ideas, and share your projects.
-
-To chat with other community members you can join the [Plane Discord](https://discord.com/invite/A92xrEGCge).
-
-Our [Code of Conduct](https://github.com/makeplane/plane/blob/master/CODE_OF_CONDUCT.md) applies to all Plane community channels.
-
 ## ⛓️ Security
 
-If you believe you have found a security vulnerability in Plane, we encourage you to responsibly disclose this and not open a public issue. We will investigate all legitimate reports. Email engineering@plane.so to disclose any security vulnerabilities.
+If you believe you have found a security vulnerability in Plane, we encourage you to responsibly disclose this and not open a public issue. We will investigate all legitimate reports.
+
+Email squawk@plane.so to disclose any security vulnerabilities.
+
+## ❤️ Contribute
+
+There are many ways to contribute to Plane, including:
+
+- Submitting [bugs](https://github.com/makeplane/plane/issues/new?assignees=srinivaspendem%2Cpushya22&labels=%F0%9F%90%9Bbug&projects=&template=--bug-report.yaml&title=%5Bbug%5D%3A+) and [feature requests](https://github.com/makeplane/plane/issues/new?assignees=srinivaspendem%2Cpushya22&labels=%E2%9C%A8feature&projects=&template=--feature-request.yaml&title=%5Bfeature%5D%3A+) for various components.
+- Reviewing [the documentation](https://docs.plane.so/) and submitting [pull requests](https://github.com/makeplane/plane), from fixing typos to adding new features.
+- Speaking or writing about Plane or any other ecosystem integration and [letting us know](https://discord.com/invite/A92xrEGCge)!
+- Upvoting [popular feature requests](https://github.com/makeplane/plane/issues) to show your support.
+
+### We couldn't have done this without you.
+
+<a href="https://github.com/makeplane/plane/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=makeplane/plane" />
+</a>

SECURITY.md

@@ -0,0 +1,44 @@
+# Security Policy
+
+This document outlines security procedures and vulnerabilities reporting for the Plane project.
+
+At Plane, we safeguarding the security of our systems with top priority. Despite our efforts, vulnerabilities may still exist. We greatly appreciate your assistance in identifying and reporting any such vulnerabilities to help us maintain the integrity of our systems and protect our clients.
+
+To report a security vulnerability, please email us directly at security@plane.so with a detailed description of the vulnerability and steps to reproduce it. Please refrain from disclosing the vulnerability publicly until we have had an opportunity to review and address it.
+
+## Out of Scope Vulnerabilities
+
+We appreciate your help in identifying vulnerabilities. However, please note that the following types of vulnerabilities are considered out of scope:
+
+- Attacks requiring MITM or physical access to a user's device.
+- Content spoofing and text injection issues without demonstrating an attack vector or ability to modify HTML/CSS.
+- Email spoofing.
+- Missing DNSSEC, CAA, CSP headers.
+- Lack of Secure or HTTP only flag on non-sensitive cookies.
+
+## Reporting Process
+
+If you discover a vulnerability, please adhere to the following reporting process:
+
+1. Email your findings to security@plane.so.
+2. Refrain from running automated scanners on our infrastructure or dashboard without prior consent. Contact us to set up a sandbox environment if necessary.
+3. Do not exploit the vulnerability for malicious purposes, such as downloading excessive data or altering user data.
+4. Maintain confidentiality and refrain from disclosing the vulnerability until it has been resolved.
+5. Avoid using physical security attacks, social engineering, distributed denial of service, spam, or third-party applications.
+
+When reporting a vulnerability, please provide sufficient information to allow us to reproduce and address the issue promptly. Include the IP address or URL of the affected system, along with a detailed description of the vulnerability.
+
+## Our Commitment
+
+We are committed to promptly addressing reported vulnerabilities and maintaining open communication throughout the resolution process. Here's what you can expect from us:
+
+- **Response Time:** We will acknowledge receipt of your report within three business days and provide an expected resolution date.
+- **Legal Protection:** We will not pursue legal action against you for reporting vulnerabilities, provided you adhere to the reporting guidelines.
+- **Confidentiality:** Your report will be treated with strict confidentiality. We will not disclose your personal information to third parties without your consent.
+- **Progress Updates:** We will keep you informed of our progress in resolving the reported vulnerability.
+- **Recognition:** With your permission, we will publicly acknowledge you as the discoverer of the vulnerability.
+- **Timely Resolution:** We strive to resolve all reported vulnerabilities promptly and will actively participate in the publication process once the issue is resolved.
+
+We appreciate your cooperation in helping us maintain the security of our systems and protecting our clients. Thank you for your contributions to our security efforts.
+
+reference: https://supabase.com/.well-known/security.txt

apiserver/.env.example

@@ -8,16 +8,12 @@ SENTRY_DSN=""
 SENTRY_ENVIRONMENT="development"
 
 # Database Settings
-PGUSER="plane"
-PGPASSWORD="plane"
-PGHOST="plane-db"
-PGDATABASE="plane"
-DATABASE_URL=postgresql://${PGUSER}:${PGPASSWORD}@${PGHOST}/${PGDATABASE}
+POSTGRES_USER="plane"
+POSTGRES_PASSWORD="plane"
+POSTGRES_HOST="plane-db"
+POSTGRES_DB="plane"
+DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}/${POSTGRES_DB}
 
-# Oauth variables
-GOOGLE_CLIENT_ID=""
-GITHUB_CLIENT_ID=""
-GITHUB_CLIENT_SECRET=""
 
 # Redis Settings
 REDIS_HOST="plane-redis"
@@ -34,14 +30,6 @@ AWS_S3_BUCKET_NAME="uploads"
 # Maximum file upload limit
 FILE_SIZE_LIMIT=5242880
 
-# GPT settings
-OPENAI_API_BASE="https://api.openai.com/v1" # deprecated
-OPENAI_API_KEY="sk-" # deprecated
-GPT_ENGINE="gpt-3.5-turbo" # deprecated
-
-# Github
-GITHUB_CLIENT_SECRET="" # For fetching release notes
-
 # Settings related to Docker
 DOCKERIZED=1 # deprecated
 
@@ -51,19 +39,8 @@ USE_MINIO=1
 # Nginx Configuration
 NGINX_PORT=80
 
-
-# SignUps
-ENABLE_SIGNUP="1"
-
-# Enable Email/Password Signup
-ENABLE_EMAIL_PASSWORD="1"
-
-# Enable Magic link Login
-ENABLE_MAGIC_LINK_LOGIN="0"
-
 # Email redirections and minio domain settings
 WEB_URL="http://localhost"
 
 # Gunicorn Workers
 GUNICORN_WORKERS=2
-

apiserver/Dockerfile.api

@@ -32,27 +32,19 @@ RUN apk add --no-cache --virtual .build-deps \
     apk del .build-deps
 
 
-RUN addgroup -S plane && \
-    adduser -S captain -G plane
-
-RUN chown captain.plane /code
-
-USER captain
-
 # Add in Django deps and generate Django's static files
 COPY manage.py manage.py
 COPY plane plane/
 COPY templates templates/
 COPY package.json package.json
-USER root
+
 RUN apk --no-cache add "bash~=5.2"
 COPY ./bin ./bin/
 
+RUN mkdir -p /code/plane/logs
 RUN chmod +x ./bin/takeoff ./bin/worker ./bin/beat
 RUN chmod -R 777 /code
 
-USER captain
-
 # Expose container port and run entry point script
 EXPOSE 8000
 

apiserver/Dockerfile.dev

@@ -27,26 +27,19 @@ WORKDIR /code
 COPY requirements.txt ./requirements.txt
 ADD requirements ./requirements
 
-RUN pip install -r requirements.txt --compile --no-cache-dir
+# Install the local development settings
+RUN pip install -r requirements/local.txt --compile --no-cache-dir
 
-RUN addgroup -S plane && \
-    adduser -S captain -G plane
 
-RUN chown captain.plane /code
+COPY . .
 
-USER captain
-
-# Add in Django deps and generate Django's static files
-
-USER root
-
-# RUN chmod +x ./bin/takeoff ./bin/worker ./bin/beat
+RUN mkdir -p /code/plane/logs
+RUN chmod -R +x /code/bin
 RUN chmod -R 777 /code
 
-USER captain
 
 # Expose container port and run entry point script
 EXPOSE 8000
 
-# CMD [ "./bin/takeoff" ]
+CMD [ "./bin/takeoff.local" ]
 

apiserver/back_migration.py

@@ -26,7 +26,9 @@ def update_description():
             updated_issues.append(issue)
 
         Issue.objects.bulk_update(
-            updated_issues, ["description_html", "description_stripped"], batch_size=100
+            updated_issues,
+            ["description_html", "description_stripped"],
+            batch_size=100,
         )
         print("Success")
     except Exception as e:
@@ -40,7 +42,9 @@ def update_comments():
         updated_issue_comments = []
 
         for issue_comment in issue_comments:
-            issue_comment.comment_html = f"<p>{issue_comment.comment_stripped}</p>"
+            issue_comment.comment_html = (
+                f"<p>{issue_comment.comment_stripped}</p>"
+            )
             updated_issue_comments.append(issue_comment)
 
         IssueComment.objects.bulk_update(
@@ -99,7 +103,9 @@ def updated_issue_sort_order():
             issue.sort_order = issue.sequence_id * random.randint(100, 500)
             updated_issues.append(issue)
 
-        Issue.objects.bulk_update(updated_issues, ["sort_order"], batch_size=100)
+        Issue.objects.bulk_update(
+            updated_issues, ["sort_order"], batch_size=100
+        )
         print("Success")
     except Exception as e:
         print(e)
@@ -137,7 +143,9 @@ def update_project_cover_images():
             project.cover_image = project_cover_images[random.randint(0, 19)]
             updated_projects.append(project)
 
-        Project.objects.bulk_update(updated_projects, ["cover_image"], batch_size=100)
+        Project.objects.bulk_update(
+            updated_projects, ["cover_image"], batch_size=100
+        )
         print("Success")
     except Exception as e:
         print(e)
@@ -174,7 +182,7 @@ def update_label_color():
         labels = Label.objects.filter(color="")
         updated_labels = []
         for label in labels:
-            label.color = "#" + "%06x" % random.randint(0, 0xFFFFFF)
+            label.color = f"#{random.randint(0, 0xFFFFFF+1):06X}"
             updated_labels.append(label)
 
         Label.objects.bulk_update(updated_labels, ["color"], batch_size=100)
@@ -186,7 +194,9 @@ def update_label_color():
 
 def create_slack_integration():
     try:
-        _ = Integration.objects.create(provider="slack", network=2, title="Slack")
+        _ = Integration.objects.create(
+            provider="slack", network=2, title="Slack"
+        )
         print("Success")
     except Exception as e:
         print(e)
@@ -212,12 +222,16 @@ def update_integration_verified():
 
 def update_start_date():
     try:
-        issues = Issue.objects.filter(state__group__in=["started", "completed"])
+        issues = Issue.objects.filter(
+            state__group__in=["started", "completed"]
+        )
         updated_issues = []
         for issue in issues:
             issue.start_date = issue.created_at.date()
             updated_issues.append(issue)
-        Issue.objects.bulk_update(updated_issues, ["start_date"], batch_size=500)
+        Issue.objects.bulk_update(
+            updated_issues, ["start_date"], batch_size=500
+        )
         print("Success")
     except Exception as e:
         print(e)

apiserver/bin/beat

@@ -2,4 +2,7 @@
 set -e
 
 python manage.py wait_for_db
+# Wait for migrations
+python manage.py wait_for_migrations
+# Run the processes
 celery -A plane beat -l info

apiserver/bin/takeoff

@@ -1,7 +1,8 @@
 #!/bin/bash
 set -e
 python manage.py wait_for_db
-python manage.py migrate
+# Wait for migrations
+python manage.py wait_for_migrations
 
 # Create the default bucket
 #!/bin/bash
@@ -20,11 +21,15 @@ SIGNATURE=$(echo "$HOSTNAME$MAC_ADDRESS$CPU_INFO$MEMORY_INFO$DISK_INFO" | sha256
 export MACHINE_SIGNATURE=$SIGNATURE
 
 # Register instance
-python manage.py register_instance $MACHINE_SIGNATURE
+python manage.py register_instance "$MACHINE_SIGNATURE"
+
 # Load the configuration variable
 python manage.py configure_instance
 
 # Create the default bucket
 python manage.py create_bucket
 
-exec gunicorn -w $GUNICORN_WORKERS -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:${PORT:-8000} --max-requests 1200 --max-requests-jitter 1000 --access-logfile -
+# Clear Cache before starting to remove stale values
+python manage.py clear_cache
+
+exec gunicorn -w "$GUNICORN_WORKERS" -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:"${PORT:-8000}" --max-requests 1200 --max-requests-jitter 1000 --access-logfile -

apiserver/bin/takeoff.local

@@ -0,0 +1,35 @@
+#!/bin/bash
+set -e
+python manage.py wait_for_db
+# Wait for migrations
+python manage.py wait_for_migrations
+
+# Create the default bucket
+#!/bin/bash
+
+# Collect system information
+HOSTNAME=$(hostname)
+MAC_ADDRESS=$(ip link show | awk '/ether/ {print $2}' | head -n 1)
+CPU_INFO=$(cat /proc/cpuinfo)
+MEMORY_INFO=$(free -h)
+DISK_INFO=$(df -h)
+
+# Concatenate information and compute SHA-256 hash
+SIGNATURE=$(echo "$HOSTNAME$MAC_ADDRESS$CPU_INFO$MEMORY_INFO$DISK_INFO" | sha256sum | awk '{print $1}')
+
+# Export the variables
+export MACHINE_SIGNATURE=$SIGNATURE
+
+# Register instance
+python manage.py register_instance "$MACHINE_SIGNATURE"
+# Load the configuration variable
+python manage.py configure_instance
+
+# Create the default bucket
+python manage.py create_bucket
+
+# Clear Cache before starting to remove stale values
+python manage.py clear_cache
+
+python manage.py runserver 0.0.0.0:8000 --settings=plane.settings.local
+

apiserver/bin/worker

@@ -2,4 +2,7 @@
 set -e
 
 python manage.py wait_for_db
+# Wait for migrations
+python manage.py wait_for_migrations
+# Run the processes
 celery -A plane worker -l info

apiserver/manage.py

@@ -2,10 +2,10 @@
 import os
 import sys
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     os.environ.setdefault(
-        'DJANGO_SETTINGS_MODULE',
-        'plane.settings.production')
+        "DJANGO_SETTINGS_MODULE", "plane.settings.production"
+    )
     try:
         from django.core.management import execute_from_command_line
     except ImportError as exc:

apiserver/package.json

@@ -1,4 +1,4 @@
 {
-    "name": "plane-api",
-    "version": "0.13.2"
-}
+  "name": "plane-api",
+  "version": "0.17.0"
+}

apiserver/plane/__init__.py

@@ -1,3 +1,3 @@
 from .celery import app as celery_app
 
-__all__ = ('celery_app',)
+__all__ = ("celery_app",)

apiserver/plane/analytics/apps.py

@@ -2,4 +2,4 @@ from django.apps import AppConfig
 
 
 class AnalyticsConfig(AppConfig):
-    name = 'plane.analytics'
+    name = "plane.analytics"

apiserver/plane/api/apps.py

@@ -2,4 +2,4 @@ from django.apps import AppConfig
 
 
 class ApiConfig(AppConfig):
-    name = "plane.api"
+    name = "plane.api"

apiserver/plane/api/middleware/api_authentication.py

@@ -25,7 +25,10 @@ class APIKeyAuthentication(authentication.BaseAuthentication):
     def validate_api_token(self, token):
         try:
             api_token = APIToken.objects.get(
-                Q(Q(expired_at__gt=timezone.now()) | Q(expired_at__isnull=True)),
+                Q(
+                    Q(expired_at__gt=timezone.now())
+                    | Q(expired_at__isnull=True)
+                ),
                 token=token,
                 is_active=True,
             )
@@ -44,4 +47,4 @@ class APIKeyAuthentication(authentication.BaseAuthentication):
 
         # Validate the API token
         user, token = self.validate_api_token(token)
-        return user, token
+        return user, token

apiserver/plane/api/rate_limit.py

@@ -1,17 +1,18 @@
 from rest_framework.throttling import SimpleRateThrottle
 
+
 class ApiKeyRateThrottle(SimpleRateThrottle):
-    scope = 'api_key'
-    rate = '60/minute'
+    scope = "api_key"
+    rate = "60/minute"
 
     def get_cache_key(self, request, view):
         # Retrieve the API key from the request header
-        api_key = request.headers.get('X-Api-Key')
+        api_key = request.headers.get("X-Api-Key")
         if not api_key:
             return None  # Allow the request if there's no API key
 
         # Use the API key as part of the cache key
-        return f'{self.scope}:{api_key}'
+        return f"{self.scope}:{api_key}"
 
     def allow_request(self, request, view):
         allowed = super().allow_request(request, view)
@@ -24,7 +25,7 @@ class ApiKeyRateThrottle(SimpleRateThrottle):
             # Remove old histories
             while history and history[-1] <= now - self.duration:
                 history.pop()
-            
+
             # Calculate the requests
             num_requests = len(history)
 
@@ -35,7 +36,7 @@ class ApiKeyRateThrottle(SimpleRateThrottle):
             reset_time = int(now + self.duration)
 
             # Add headers
-            request.META['X-RateLimit-Remaining'] = max(0, available)
-            request.META['X-RateLimit-Reset'] = reset_time
+            request.META["X-RateLimit-Remaining"] = max(0, available)
+            request.META["X-RateLimit-Reset"] = reset_time
 
-        return allowed
+        return allowed

apiserver/plane/api/serializers/__init__.py

@@ -13,5 +13,9 @@ from .issue import (
 )
 from .state import StateLiteSerializer, StateSerializer
 from .cycle import CycleSerializer, CycleIssueSerializer, CycleLiteSerializer
-from .module import ModuleSerializer, ModuleIssueSerializer, ModuleLiteSerializer
-from .inbox import InboxIssueSerializer
+from .module import (
+    ModuleSerializer,
+    ModuleIssueSerializer,
+    ModuleLiteSerializer,
+)
+from .inbox import InboxIssueSerializer

apiserver/plane/api/serializers/base.py

@@ -66,11 +66,11 @@ class BaseSerializer(serializers.ModelSerializer):
                 if expand in self.fields:
                     # Import all the expandable serializers
                     from . import (
-                        WorkspaceLiteSerializer,
-                        ProjectLiteSerializer,
-                        UserLiteSerializer,
-                        StateLiteSerializer,
                         IssueSerializer,
+                        ProjectLiteSerializer,
+                        StateLiteSerializer,
+                        UserLiteSerializer,
+                        WorkspaceLiteSerializer,
                     )
 
                     # Expansion mapper
@@ -97,9 +97,11 @@ class BaseSerializer(serializers.ModelSerializer):
                             exp_serializer = expansion[expand](
                                 getattr(instance, expand)
                             )
-                            response[expand] = exp_serializer.data
+                        response[expand] = exp_serializer.data
                     else:
                         # You might need to handle this case differently
-                        response[expand] = getattr(instance, f"{expand}_id", None)
+                        response[expand] = getattr(
+                            instance, f"{expand}_id", None
+                        )
 
-        return response
+        return response

apiserver/plane/api/serializers/cycle.py

@@ -23,7 +23,9 @@ class CycleSerializer(BaseSerializer):
             and data.get("end_date", None) is not None
             and data.get("start_date", None) > data.get("end_date", None)
         ):
-            raise serializers.ValidationError("Start date cannot exceed end date")
+            raise serializers.ValidationError(
+                "Start date cannot exceed end date"
+            )
         return data
 
     class Meta:
@@ -55,7 +57,6 @@ class CycleIssueSerializer(BaseSerializer):
 
 
 class CycleLiteSerializer(BaseSerializer):
-
     class Meta:
         model = Cycle
-        fields = "__all__"
+        fields = "__all__"

apiserver/plane/api/serializers/inbox.py

@@ -2,8 +2,8 @@
 from .base import BaseSerializer
 from plane.db.models import InboxIssue
 
-class InboxIssueSerializer(BaseSerializer):
 
+class InboxIssueSerializer(BaseSerializer):
     class Meta:
         model = InboxIssue
         fields = "__all__"
@@ -16,4 +16,4 @@ class InboxIssueSerializer(BaseSerializer):
             "updated_by",
             "created_at",
             "updated_at",
-        ]
+        ]

apiserver/plane/api/serializers/issue.py

@@ -1,31 +1,34 @@
-from lxml import html
-
+from django.core.exceptions import ValidationError
+from django.core.validators import URLValidator
 
 # Django imports
 from django.utils import timezone
+from lxml import html
 
 #  Third party imports
 from rest_framework import serializers
 
 # Module imports
 from plane.db.models import (
-    User,
     Issue,
-    State,
+    IssueActivity,
     IssueAssignee,
-    Label,
+    IssueAttachment,
+    IssueComment,
     IssueLabel,
     IssueLink,
-    IssueComment,
-    IssueAttachment,
-    IssueActivity,
+    Label,
     ProjectMember,
+    State,
+    User,
 )
+
 from .base import BaseSerializer
-from .cycle import CycleSerializer, CycleLiteSerializer
-from .module import ModuleSerializer, ModuleLiteSerializer
-from .user import UserLiteSerializer
+from .cycle import CycleLiteSerializer, CycleSerializer
+from .module import ModuleLiteSerializer, ModuleSerializer
 from .state import StateLiteSerializer
+from .user import UserLiteSerializer
+
 
 class IssueSerializer(BaseSerializer):
     assignees = serializers.ListField(
@@ -66,16 +69,18 @@ class IssueSerializer(BaseSerializer):
             and data.get("target_date", None) is not None
             and data.get("start_date", None) > data.get("target_date", None)
         ):
-            raise serializers.ValidationError("Start date cannot exceed target date")
-        
+            raise serializers.ValidationError(
+                "Start date cannot exceed target date"
+            )
+
         try:
-            if(data.get("description_html", None) is not None):
+            if data.get("description_html", None) is not None:
                 parsed = html.fromstring(data["description_html"])
-                parsed_str = html.tostring(parsed, encoding='unicode')
+                parsed_str = html.tostring(parsed, encoding="unicode")
                 data["description_html"] = parsed_str
-            
-        except Exception as e:
-            raise serializers.ValidationError(f"Invalid HTML: {str(e)}")
+
+        except Exception:
+            raise serializers.ValidationError("Invalid HTML passed")
 
         # Validate assignees are from project
         if data.get("assignees", []):
@@ -96,7 +101,8 @@ class IssueSerializer(BaseSerializer):
         if (
             data.get("state")
             and not State.objects.filter(
-                project_id=self.context.get("project_id"), pk=data.get("state")
+                project_id=self.context.get("project_id"),
+                pk=data.get("state").id,
             ).exists()
         ):
             raise serializers.ValidationError(
@@ -107,7 +113,8 @@ class IssueSerializer(BaseSerializer):
         if (
             data.get("parent")
             and not Issue.objects.filter(
-                workspace_id=self.context.get("workspace_id"), pk=data.get("parent")
+                workspace_id=self.context.get("workspace_id"),
+                pk=data.get("parent").id,
             ).exists()
         ):
             raise serializers.ValidationError(
@@ -238,9 +245,13 @@ class IssueSerializer(BaseSerializer):
                 ]
         if "labels" in self.fields:
             if "labels" in self.expand:
-                data["labels"] = LabelSerializer(instance.labels.all(), many=True).data
+                data["labels"] = LabelSerializer(
+                    instance.labels.all(), many=True
+                ).data
             else:
-                data["labels"] = [str(label.id) for label in instance.labels.all()]
+                data["labels"] = [
+                    str(label.id) for label in instance.labels.all()
+                ]
 
         return data
 
@@ -275,16 +286,42 @@ class IssueLinkSerializer(BaseSerializer):
             "updated_at",
         ]
 
+    def validate_url(self, value):
+        # Check URL format
+        validate_url = URLValidator()
+        try:
+            validate_url(value)
+        except ValidationError:
+            raise serializers.ValidationError("Invalid URL format.")
+
+        # Check URL scheme
+        if not value.startswith(("http://", "https://")):
+            raise serializers.ValidationError("Invalid URL scheme.")
+
+        return value
+
     # Validation if url already exists
     def create(self, validated_data):
         if IssueLink.objects.filter(
-            url=validated_data.get("url"), issue_id=validated_data.get("issue_id")
+            url=validated_data.get("url"),
+            issue_id=validated_data.get("issue_id"),
         ).exists():
             raise serializers.ValidationError(
                 {"error": "URL already exists for this Issue"}
             )
         return IssueLink.objects.create(**validated_data)
 
+    def update(self, instance, validated_data):
+        if IssueLink.objects.filter(
+            url=validated_data.get("url"),
+            issue_id=instance.issue_id,
+        ).exists():
+            raise serializers.ValidationError(
+                {"error": "URL already exists for this Issue"}
+            )
+
+        return super().update(instance, validated_data)
+
 
 class IssueAttachmentSerializer(BaseSerializer):
     class Meta:
@@ -324,13 +361,13 @@ class IssueCommentSerializer(BaseSerializer):
 
     def validate(self, data):
         try:
-            if(data.get("comment_html", None) is not None):
+            if data.get("comment_html", None) is not None:
                 parsed = html.fromstring(data["comment_html"])
-                parsed_str = html.tostring(parsed, encoding='unicode')
+                parsed_str = html.tostring(parsed, encoding="unicode")
                 data["comment_html"] = parsed_str
-            
-        except Exception as e:
-            raise serializers.ValidationError(f"Invalid HTML: {str(e)}")
+
+        except Exception:
+            raise serializers.ValidationError("Invalid HTML passed")
         return data
 
 
@@ -362,7 +399,6 @@ class ModuleIssueSerializer(BaseSerializer):
 
 
 class LabelLiteSerializer(BaseSerializer):
-
     class Meta:
         model = Label
         fields = [

apiserver/plane/api/serializers/module.py

@@ -52,7 +52,9 @@ class ModuleSerializer(BaseSerializer):
             and data.get("target_date", None) is not None
             and data.get("start_date", None) > data.get("target_date", None)
         ):
-            raise serializers.ValidationError("Start date cannot exceed target date")
+            raise serializers.ValidationError(
+                "Start date cannot exceed target date"
+            )
 
         if data.get("members", []):
             data["members"] = ProjectMember.objects.filter(
@@ -65,18 +67,18 @@ class ModuleSerializer(BaseSerializer):
     def create(self, validated_data):
         members = validated_data.pop("members", None)
 
-        project = self.context["project"]
-
-        module = Module.objects.create(**validated_data, project=project)
+        project_id = self.context["project_id"]
+        workspace_id = self.context["workspace_id"]
 
+        module = Module.objects.create(**validated_data, project_id=project_id)
         if members is not None:
             ModuleMember.objects.bulk_create(
                 [
                     ModuleMember(
                         module=module,
-                        member=member,
-                        project=project,
-                        workspace=project.workspace,
+                        member_id=str(member),
+                        project_id=project_id,
+                        workspace_id=workspace_id,
                         created_by=module.created_by,
                         updated_by=module.updated_by,
                     )
@@ -97,7 +99,7 @@ class ModuleSerializer(BaseSerializer):
                 [
                     ModuleMember(
                         module=instance,
-                        member=member,
+                        member_id=str(member),
                         project=instance.project,
                         workspace=instance.project.workspace,
                         created_by=instance.created_by,
@@ -146,16 +148,16 @@ class ModuleLinkSerializer(BaseSerializer):
     # Validation if url already exists
     def create(self, validated_data):
         if ModuleLink.objects.filter(
-            url=validated_data.get("url"), module_id=validated_data.get("module_id")
+            url=validated_data.get("url"),
+            module_id=validated_data.get("module_id"),
         ).exists():
             raise serializers.ValidationError(
                 {"error": "URL already exists for this Issue"}
             )
         return ModuleLink.objects.create(**validated_data)
-    
+
 
 class ModuleLiteSerializer(BaseSerializer):
-
     class Meta:
         model = Module
-        fields = "__all__"
+        fields = "__all__"

apiserver/plane/api/serializers/project.py

@@ -2,12 +2,16 @@
 from rest_framework import serializers
 
 # Module imports
-from plane.db.models import Project, ProjectIdentifier, WorkspaceMember, State, Estimate
+from plane.db.models import (
+    Project,
+    ProjectIdentifier,
+    WorkspaceMember,
+)
+
 from .base import BaseSerializer
 
 
 class ProjectSerializer(BaseSerializer):
-
     total_members = serializers.IntegerField(read_only=True)
     total_cycles = serializers.IntegerField(read_only=True)
     total_modules = serializers.IntegerField(read_only=True)
@@ -21,7 +25,7 @@ class ProjectSerializer(BaseSerializer):
         fields = "__all__"
         read_only_fields = [
             "id",
-            'emoji',
+            "emoji",
             "workspace",
             "created_at",
             "updated_at",
@@ -59,12 +63,16 @@ class ProjectSerializer(BaseSerializer):
     def create(self, validated_data):
         identifier = validated_data.get("identifier", "").strip().upper()
         if identifier == "":
-            raise serializers.ValidationError(detail="Project Identifier is required")
+            raise serializers.ValidationError(
+                detail="Project Identifier is required"
+            )
 
         if ProjectIdentifier.objects.filter(
             name=identifier, workspace_id=self.context["workspace_id"]
         ).exists():
-            raise serializers.ValidationError(detail="Project Identifier is taken")
+            raise serializers.ValidationError(
+                detail="Project Identifier is taken"
+            )
 
         project = Project.objects.create(
             **validated_data, workspace_id=self.context["workspace_id"]
@@ -89,4 +97,4 @@ class ProjectLiteSerializer(BaseSerializer):
             "emoji",
             "description",
         ]
-        read_only_fields = fields
+        read_only_fields = fields

apiserver/plane/api/serializers/state.py

@@ -7,9 +7,9 @@ class StateSerializer(BaseSerializer):
     def validate(self, data):
         # If the default is being provided then make all other states default False
         if data.get("default", False):
-            State.objects.filter(project_id=self.context.get("project_id")).update(
-                default=False
-            )
+            State.objects.filter(
+                project_id=self.context.get("project_id")
+            ).update(default=False)
         return data
 
     class Meta:
@@ -35,4 +35,4 @@ class StateLiteSerializer(BaseSerializer):
             "color",
             "group",
         ]
-        read_only_fields = fields
+        read_only_fields = fields

apiserver/plane/api/serializers/user.py

@@ -1,5 +1,6 @@
 # Module imports
 from plane.db.models import User
+
 from .base import BaseSerializer
 
 
@@ -10,7 +11,9 @@ class UserLiteSerializer(BaseSerializer):
             "id",
             "first_name",
             "last_name",
+            "email",
             "avatar",
             "display_name",
+            "email",
         ]
-        read_only_fields = fields
+        read_only_fields = fields

apiserver/plane/api/serializers/workspace.py

@@ -5,6 +5,7 @@ from .base import BaseSerializer
 
 class WorkspaceLiteSerializer(BaseSerializer):
     """Lite serializer with only required fields"""
+
     class Meta:
         model = Workspace
         fields = [
@@ -12,4 +13,4 @@ class WorkspaceLiteSerializer(BaseSerializer):
             "slug",
             "id",
         ]
-        read_only_fields = fields
+        read_only_fields = fields

apiserver/plane/api/urls/__init__.py

@@ -12,4 +12,4 @@ urlpatterns = [
     *cycle_patterns,
     *module_patterns,
     *inbox_patterns,
-]
+]

apiserver/plane/api/urls/cycle.py

@@ -4,6 +4,7 @@ from plane.api.views.cycle import (
     CycleAPIEndpoint,
     CycleIssueAPIEndpoint,
     TransferCycleIssueAPIEndpoint,
+    CycleArchiveUnarchiveAPIEndpoint,
 )
 
 urlpatterns = [
@@ -32,4 +33,14 @@ urlpatterns = [
         TransferCycleIssueAPIEndpoint.as_view(),
         name="transfer-issues",
     ),
-]
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:pk>/archive/",
+        CycleArchiveUnarchiveAPIEndpoint.as_view(),
+        name="cycle-archive-unarchive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-cycles/",
+        CycleArchiveUnarchiveAPIEndpoint.as_view(),
+        name="cycle-archive-unarchive",
+    ),
+]

apiserver/plane/api/urls/inbox.py

@@ -14,4 +14,4 @@ urlpatterns = [
         InboxIssueAPIEndpoint.as_view(),
         name="inbox-issue",
     ),
-]
+]

apiserver/plane/api/urls/module.py

@@ -1,6 +1,10 @@
 from django.urls import path
 
-from plane.api.views import ModuleAPIEndpoint, ModuleIssueAPIEndpoint
+from plane.api.views import (
+    ModuleAPIEndpoint,
+    ModuleIssueAPIEndpoint,
+    ModuleArchiveUnarchiveAPIEndpoint,
+)
 
 urlpatterns = [
     path(
@@ -23,4 +27,14 @@ urlpatterns = [
         ModuleIssueAPIEndpoint.as_view(),
         name="module-issues",
     ),
-]
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:pk>/archive/",
+        ModuleArchiveUnarchiveAPIEndpoint.as_view(),
+        name="module-archive-unarchive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-modules/",
+        ModuleArchiveUnarchiveAPIEndpoint.as_view(),
+        name="module-archive-unarchive",
+    ),
+]

apiserver/plane/api/urls/project.py

@@ -1,16 +1,24 @@
 from django.urls import path
 
-from plane.api.views import ProjectAPIEndpoint
+from plane.api.views import (
+    ProjectAPIEndpoint,
+    ProjectArchiveUnarchiveAPIEndpoint,
+)
 
 urlpatterns = [
-        path(
+    path(
         "workspaces/<str:slug>/projects/",
         ProjectAPIEndpoint.as_view(),
         name="project",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/",
+        "workspaces/<str:slug>/projects/<uuid:pk>/",
         ProjectAPIEndpoint.as_view(),
         name="project",
     ),
-]
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archive/",
+        ProjectArchiveUnarchiveAPIEndpoint.as_view(),
+        name="project-archive-unarchive",
+    ),
+]

apiserver/plane/api/urls/state.py

@@ -13,4 +13,4 @@ urlpatterns = [
         StateAPIEndpoint.as_view(),
         name="states",
     ),
-]
+]

apiserver/plane/api/views/__init__.py

@@ -1,4 +1,4 @@
-from .project import ProjectAPIEndpoint
+from .project import ProjectAPIEndpoint, ProjectArchiveUnarchiveAPIEndpoint
 
 from .state import StateAPIEndpoint
 
@@ -14,8 +14,13 @@ from .cycle import (
     CycleAPIEndpoint,
     CycleIssueAPIEndpoint,
     TransferCycleIssueAPIEndpoint,
+    CycleArchiveUnarchiveAPIEndpoint,
 )
 
-from .module import ModuleAPIEndpoint, ModuleIssueAPIEndpoint
+from .module import (
+    ModuleAPIEndpoint,
+    ModuleIssueAPIEndpoint,
+    ModuleArchiveUnarchiveAPIEndpoint,
+)
 
-from .inbox import InboxIssueAPIEndpoint
+from .inbox import InboxIssueAPIEndpoint

apiserver/plane/api/views/base.py

@@ -1,25 +1,27 @@
 # Python imports
+from urllib.parse import urlparse
+
 import zoneinfo
-import json
 
 # Django imports
 from django.conf import settings
-from django.db import IntegrityError
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.db import IntegrityError
+from django.urls import resolve
 from django.utils import timezone
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
 
 # Third party imports
 from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework.permissions import IsAuthenticated
-from rest_framework import status
-from sentry_sdk import capture_exception
 
 # Module imports
 from plane.api.middleware.api_authentication import APIKeyAuthentication
 from plane.api.rate_limit import ApiKeyRateThrottle
-from plane.utils.paginator import BasePaginator
 from plane.bgtasks.webhook_task import send_webhook
+from plane.utils.exception_logger import log_exception
+from plane.utils.paginator import BasePaginator
 
 
 class TimezoneMixin:
@@ -41,7 +43,9 @@ class WebhookMixin:
     bulk = False
 
     def finalize_response(self, request, response, *args, **kwargs):
-        response = super().finalize_response(request, response, *args, **kwargs)
+        response = super().finalize_response(
+            request, response, *args, **kwargs
+        )
 
         # Check for the case should webhook be sent
         if (
@@ -49,6 +53,11 @@ class WebhookMixin:
             and self.request.method in ["POST", "PATCH", "DELETE"]
             and response.status_code in [200, 201, 204]
         ):
+            url = request.build_absolute_uri()
+            parsed_url = urlparse(url)
+            # Extract the scheme and netloc
+            scheme = parsed_url.scheme
+            netloc = parsed_url.netloc
             # Push the object to delay
             send_webhook.delay(
                 event=self.webhook_event,
@@ -57,6 +66,7 @@ class WebhookMixin:
                 action=self.request.method,
                 slug=self.workspace_slug,
                 bulk=self.bulk,
+                current_site=f"{scheme}://{netloc}",
             )
 
         return response
@@ -97,28 +107,23 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
 
             if isinstance(e, ValidationError):
                 return Response(
-                    {
-                        "error": "The provided payload is not valid please try with a valid payload"
-                    },
+                    {"error": "Please provide valid detail"},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
             if isinstance(e, ObjectDoesNotExist):
-                model_name = str(exc).split(" matching query does not exist.")[0]
                 return Response(
-                    {"error": f"{model_name} does not exist."},
+                    {"error": "The requested resource does not exist."},
                     status=status.HTTP_404_NOT_FOUND,
                 )
 
             if isinstance(e, KeyError):
                 return Response(
-                    {"error": f"key {e} does not exist"},
+                    {"error": "The required key does not exist."},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            if settings.DEBUG:
-                print(e)
-            capture_exception(e)
+            log_exception(e)
             return Response(
                 {"error": "Something went wrong please try again later"},
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -140,7 +145,9 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
 
     def finalize_response(self, request, response, *args, **kwargs):
         # Call super to get the default response
-        response = super().finalize_response(request, response, *args, **kwargs)
+        response = super().finalize_response(
+            request, response, *args, **kwargs
+        )
 
         # Add custom headers if they exist in the request META
         ratelimit_remaining = request.META.get("X-RateLimit-Remaining")
@@ -159,18 +166,27 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
 
     @property
     def project_id(self):
-        return self.kwargs.get("project_id", None)
+        project_id = self.kwargs.get("project_id", None)
+        if project_id:
+            return project_id
+
+        if resolve(self.request.path_info).url_name == "project":
+            return self.kwargs.get("pk", None)
 
     @property
     def fields(self):
         fields = [
-            field for field in self.request.GET.get("fields", "").split(",") if field
+            field
+            for field in self.request.GET.get("fields", "").split(",")
+            if field
         ]
         return fields if fields else None
 
     @property
     def expand(self):
         expand = [
-            expand for expand in self.request.GET.get("expand", "").split(",") if expand
+            expand
+            for expand in self.request.GET.get("expand", "").split(",")
+            if expand
         ]
         return expand if expand else None

apiserver/plane/api/views/cycle.py

@@ -2,23 +2,31 @@
 import json
 
 # Django imports
-from django.db.models import Q, Count, Sum, Prefetch, F, OuterRef, Func
-from django.utils import timezone
 from django.core import serializers
+from django.db.models import Count, F, Func, OuterRef, Q, Sum
+from django.utils import timezone
 
 # Third party imports
-from rest_framework.response import Response
 from rest_framework import status
+from rest_framework.response import Response
 
 # Module imports
-from .base import BaseAPIView, WebhookMixin
-from plane.db.models import Cycle, Issue, CycleIssue, IssueLink, IssueAttachment
-from plane.app.permissions import ProjectEntityPermission
 from plane.api.serializers import (
-    CycleSerializer,
     CycleIssueSerializer,
+    CycleSerializer,
 )
+from plane.app.permissions import ProjectEntityPermission
 from plane.bgtasks.issue_activites_task import issue_activity
+from plane.db.models import (
+    Cycle,
+    CycleIssue,
+    Issue,
+    IssueAttachment,
+    IssueLink,
+)
+from plane.utils.analytics_plot import burndown_plot
+
+from .base import BaseAPIView, WebhookMixin
 
 
 class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
@@ -39,7 +47,10 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
         return (
             Cycle.objects.filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
             .select_related("project")
             .select_related("workspace")
             .select_related("owned_by")
@@ -102,7 +113,9 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
                     ),
                 )
             )
-            .annotate(total_estimates=Sum("issue_cycle__issue__estimate_point"))
+            .annotate(
+                total_estimates=Sum("issue_cycle__issue__estimate_point")
+            )
             .annotate(
                 completed_estimates=Sum(
                     "issue_cycle__issue__estimate_point",
@@ -129,7 +142,9 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
 
     def get(self, request, slug, project_id, pk=None):
         if pk:
-            queryset = self.get_queryset().get(pk=pk)
+            queryset = (
+                self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
+            )
             data = CycleSerializer(
                 queryset,
                 fields=self.fields,
@@ -139,7 +154,9 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
                 data,
                 status=status.HTTP_200_OK,
             )
-        queryset = self.get_queryset()
+        queryset = (
+            self.get_queryset().filter(archived_at__isnull=True)
+        )
         cycle_view = request.GET.get("cycle_view", "all")
 
         # Current Cycle
@@ -201,7 +218,8 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
         # Incomplete Cycles
         if cycle_view == "incomplete":
             queryset = queryset.filter(
-                Q(end_date__gte=timezone.now().date()) | Q(end_date__isnull=True),
+                Q(end_date__gte=timezone.now().date())
+                | Q(end_date__isnull=True),
             )
             return self.paginate(
                 request=request,
@@ -234,12 +252,39 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
         ):
             serializer = CycleSerializer(data=request.data)
             if serializer.is_valid():
+                if (
+                    request.data.get("external_id")
+                    and request.data.get("external_source")
+                    and Cycle.objects.filter(
+                        project_id=project_id,
+                        workspace__slug=slug,
+                        external_source=request.data.get("external_source"),
+                        external_id=request.data.get("external_id"),
+                    ).exists()
+                ):
+                    cycle = Cycle.objects.filter(
+                        workspace__slug=slug,
+                        project_id=project_id,
+                        external_source=request.data.get("external_source"),
+                        external_id=request.data.get("external_id"),
+                    ).first()
+                    return Response(
+                        {
+                            "error": "Cycle with the same external id and external source already exists",
+                            "id": str(cycle.id),
+                        },
+                        status=status.HTTP_409_CONFLICT,
+                    )
                 serializer.save(
                     project_id=project_id,
                     owned_by=request.user,
                 )
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+                return Response(
+                    serializer.data, status=status.HTTP_201_CREATED
+                )
+            return Response(
+                serializer.errors, status=status.HTTP_400_BAD_REQUEST
+            )
         else:
             return Response(
                 {
@@ -249,15 +294,27 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
             )
 
     def patch(self, request, slug, project_id, pk):
-        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+        cycle = Cycle.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
+        if cycle.archived_at:
+            return Response(
+                {"error": "Archived cycle cannot be edited"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
 
         request_data = request.data
 
-        if cycle.end_date is not None and cycle.end_date < timezone.now().date():
+        if (
+            cycle.end_date is not None
+            and cycle.end_date < timezone.now().date()
+        ):
             if "sort_order" in request_data:
                 # Can only change sort order
                 request_data = {
-                    "sort_order": request_data.get("sort_order", cycle.sort_order)
+                    "sort_order": request_data.get(
+                        "sort_order", cycle.sort_order
+                    )
                 }
             else:
                 return Response(
@@ -269,17 +326,38 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
 
         serializer = CycleSerializer(cycle, data=request.data, partial=True)
         if serializer.is_valid():
+            if (
+                request.data.get("external_id")
+                and (cycle.external_id != request.data.get("external_id"))
+                and Cycle.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get(
+                        "external_source", cycle.external_source
+                    ),
+                    external_id=request.data.get("external_id"),
+                ).exists()
+            ):
+                return Response(
+                    {
+                        "error": "Cycle with the same external id and external source already exists",
+                        "id": str(cycle.id),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
             serializer.save()
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def delete(self, request, slug, project_id, pk):
         cycle_issues = list(
-            CycleIssue.objects.filter(cycle_id=self.kwargs.get("pk")).values_list(
-                "issue", flat=True
-            )
+            CycleIssue.objects.filter(
+                cycle_id=self.kwargs.get("pk")
+            ).values_list("issue", flat=True)
+        )
+        cycle = Cycle.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
         )
-        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
 
         issue_activity.delay(
             type="cycle.activity.deleted",
@@ -301,6 +379,139 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
+class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get_queryset(self):
+        return (
+            Cycle.objects.filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(archived_at__isnull=False)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("owned_by")
+            .annotate(
+                total_issues=Count(
+                    "issue_cycle",
+                    filter=Q(
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                completed_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="completed",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                cancelled_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="cancelled",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                started_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="started",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                unstarted_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="unstarted",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                backlog_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="backlog",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                total_estimates=Sum("issue_cycle__issue__estimate_point")
+            )
+            .annotate(
+                completed_estimates=Sum(
+                    "issue_cycle__issue__estimate_point",
+                    filter=Q(
+                        issue_cycle__issue__state__group="completed",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                started_estimates=Sum(
+                    "issue_cycle__issue__estimate_point",
+                    filter=Q(
+                        issue_cycle__issue__state__group="started",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .order_by(self.kwargs.get("order_by", "-created_at"))
+            .distinct()
+        )
+
+    def get(self, request, slug, project_id):
+        return self.paginate(
+            request=request,
+            queryset=(self.get_queryset()),
+            on_results=lambda cycles: CycleSerializer(
+                cycles,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+            ).data,
+        )
+
+    def post(self, request, slug, project_id, pk):
+        cycle = Cycle.objects.get(
+            pk=pk, project_id=project_id, workspace__slug=slug
+        )
+        cycle.archived_at = timezone.now()
+        cycle.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def delete(self, request, slug, project_id, pk):
+        cycle = Cycle.objects.get(
+            pk=pk, project_id=project_id, workspace__slug=slug
+        )
+        cycle.archived_at = None
+        cycle.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
 class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
     """
     This viewset automatically provides `list`, `create`,
@@ -319,14 +530,19 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
     def get_queryset(self):
         return (
             CycleIssue.objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("issue_id"))
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("issue_id")
+                )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
             )
             .filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
             .filter(cycle_id=self.kwargs.get("cycle_id"))
             .select_related("project")
             .select_related("workspace")
@@ -337,12 +553,28 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
             .distinct()
         )
 
-    def get(self, request, slug, project_id, cycle_id):
+    def get(self, request, slug, project_id, cycle_id, issue_id=None):
+        # Get
+        if issue_id:
+            cycle_issue = CycleIssue.objects.get(
+                workspace__slug=slug,
+                project_id=project_id,
+                cycle_id=cycle_id,
+                issue_id=issue_id,
+            )
+            serializer = CycleIssueSerializer(
+                cycle_issue, fields=self.fields, expand=self.expand
+            )
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
+        # List
         order_by = request.GET.get("order_by", "created_at")
         issues = (
             Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
             .annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
@@ -364,7 +596,9 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
@@ -387,14 +621,18 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
 
         if not issues:
             return Response(
-                {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
+                {"error": "Issues are required"},
+                status=status.HTTP_400_BAD_REQUEST,
             )
 
         cycle = Cycle.objects.get(
             workspace__slug=slug, project_id=project_id, pk=cycle_id
         )
 
-        if cycle.end_date is not None and cycle.end_date < timezone.now().date():
+        if (
+            cycle.end_date is not None
+            and cycle.end_date < timezone.now().date()
+        ):
             return Response(
                 {
                     "error": "The Cycle has already been completed so no new issues can be added"
@@ -479,7 +717,10 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
 
     def delete(self, request, slug, project_id, cycle_id, issue_id):
         cycle_issue = CycleIssue.objects.get(
-            issue_id=issue_id, workspace__slug=slug, project_id=project_id, cycle_id=cycle_id
+            issue_id=issue_id,
+            workspace__slug=slug,
+            project_id=project_id,
+            cycle_id=cycle_id,
         )
         issue_id = cycle_issue.issue_id
         cycle_issue.delete()
@@ -523,6 +764,209 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
             workspace__slug=slug, project_id=project_id, pk=new_cycle_id
         )
 
+        old_cycle = (
+            Cycle.objects.filter(
+                workspace__slug=slug, project_id=project_id, pk=cycle_id
+            )
+            .annotate(
+                total_issues=Count(
+                    "issue_cycle",
+                    filter=Q(
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                completed_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="completed",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                cancelled_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="cancelled",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                started_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="started",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                unstarted_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="unstarted",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                backlog_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="backlog",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                    ),
+                )
+            )
+        )
+
+        # Pass the new_cycle queryset to burndown_plot
+        completion_chart = burndown_plot(
+            queryset=old_cycle.first(),
+            slug=slug,
+            project_id=project_id,
+            cycle_id=cycle_id,
+        )
+
+        # Get the assignee distribution
+        assignee_distribution = (
+            Issue.objects.filter(
+                issue_cycle__cycle_id=cycle_id,
+                workspace__slug=slug,
+                project_id=project_id,
+            )
+            .annotate(display_name=F("assignees__display_name"))
+            .annotate(assignee_id=F("assignees__id"))
+            .annotate(avatar=F("assignees__avatar"))
+            .values("display_name", "assignee_id", "avatar")
+            .annotate(
+                total_issues=Count(
+                    "id",
+                    filter=Q(archived_at__isnull=True, is_draft=False),
+                ),
+            )
+            .annotate(
+                completed_issues=Count(
+                    "id",
+                    filter=Q(
+                        completed_at__isnull=False,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                pending_issues=Count(
+                    "id",
+                    filter=Q(
+                        completed_at__isnull=True,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .order_by("display_name")
+        )
+        # assignee distribution serialized
+        assignee_distribution_data = [
+            {
+                "display_name": item["display_name"],
+                "assignee_id": (
+                    str(item["assignee_id"]) if item["assignee_id"] else None
+                ),
+                "avatar": item["avatar"],
+                "total_issues": item["total_issues"],
+                "completed_issues": item["completed_issues"],
+                "pending_issues": item["pending_issues"],
+            }
+            for item in assignee_distribution
+        ]
+
+        # Get the label distribution
+        label_distribution = (
+            Issue.objects.filter(
+                issue_cycle__cycle_id=cycle_id,
+                workspace__slug=slug,
+                project_id=project_id,
+            )
+            .annotate(label_name=F("labels__name"))
+            .annotate(color=F("labels__color"))
+            .annotate(label_id=F("labels__id"))
+            .values("label_name", "color", "label_id")
+            .annotate(
+                total_issues=Count(
+                    "id",
+                    filter=Q(archived_at__isnull=True, is_draft=False),
+                )
+            )
+            .annotate(
+                completed_issues=Count(
+                    "id",
+                    filter=Q(
+                        completed_at__isnull=False,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                pending_issues=Count(
+                    "id",
+                    filter=Q(
+                        completed_at__isnull=True,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .order_by("label_name")
+        )
+
+        # Label distribution serilization
+        label_distribution_data = [
+            {
+                "label_name": item["label_name"],
+                "color": item["color"],
+                "label_id": (
+                    str(item["label_id"]) if item["label_id"] else None
+                ),
+                "total_issues": item["total_issues"],
+                "completed_issues": item["completed_issues"],
+                "pending_issues": item["pending_issues"],
+            }
+            for item in label_distribution
+        ]
+
+        current_cycle = Cycle.objects.filter(
+            workspace__slug=slug, project_id=project_id, pk=cycle_id
+        ).first()
+
+        if current_cycle:
+            current_cycle.progress_snapshot = {
+                "total_issues": old_cycle.first().total_issues,
+                "completed_issues": old_cycle.first().completed_issues,
+                "cancelled_issues": old_cycle.first().cancelled_issues,
+                "started_issues": old_cycle.first().started_issues,
+                "unstarted_issues": old_cycle.first().unstarted_issues,
+                "backlog_issues": old_cycle.first().backlog_issues,
+                "distribution": {
+                    "labels": label_distribution_data,
+                    "assignees": assignee_distribution_data,
+                    "completion_chart": completion_chart,
+                },
+            }
+            # Save the snapshot of the current cycle
+            current_cycle.save(update_fields=["progress_snapshot"])
+
         if (
             new_cycle.end_date is not None
             and new_cycle.end_date < timezone.now().date()
@@ -550,4 +994,4 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
             updated_cycles, ["cycle_id"], batch_size=100
         )
 
-        return Response({"message": "Success"}, status=status.HTTP_200_OK)
+        return Response({"message": "Success"}, status=status.HTTP_200_OK)

apiserver/plane/api/views/inbox.py

@@ -2,20 +2,28 @@
 import json
 
 # Django improts
-from django.utils import timezone
-from django.db.models import Q
 from django.core.serializers.json import DjangoJSONEncoder
+from django.db.models import Q
+from django.utils import timezone
 
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
 
 # Module imports
-from .base import BaseAPIView
-from plane.app.permissions import ProjectLitePermission
 from plane.api.serializers import InboxIssueSerializer, IssueSerializer
-from plane.db.models import InboxIssue, Issue, State, ProjectMember, Project, Inbox
+from plane.app.permissions import ProjectLitePermission
 from plane.bgtasks.issue_activites_task import issue_activity
+from plane.db.models import (
+    Inbox,
+    InboxIssue,
+    Issue,
+    Project,
+    ProjectMember,
+    State,
+)
+
+from .base import BaseAPIView
 
 
 class InboxIssueAPIEndpoint(BaseAPIView):
@@ -43,7 +51,8 @@ class InboxIssueAPIEndpoint(BaseAPIView):
         ).first()
 
         project = Project.objects.get(
-            workspace__slug=self.kwargs.get("slug"), pk=self.kwargs.get("project_id")
+            workspace__slug=self.kwargs.get("slug"),
+            pk=self.kwargs.get("project_id"),
         )
 
         if inbox is None and not project.inbox_view:
@@ -51,7 +60,8 @@ class InboxIssueAPIEndpoint(BaseAPIView):
 
         return (
             InboxIssue.objects.filter(
-                Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
+                Q(snoozed_till__gte=timezone.now())
+                | Q(snoozed_till__isnull=True),
                 workspace__slug=self.kwargs.get("slug"),
                 project_id=self.kwargs.get("project_id"),
                 inbox_id=inbox.id,
@@ -87,7 +97,8 @@ class InboxIssueAPIEndpoint(BaseAPIView):
     def post(self, request, slug, project_id):
         if not request.data.get("issue", {}).get("name", False):
             return Response(
-                {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
+                {"error": "Name is required"},
+                status=status.HTTP_400_BAD_REQUEST,
             )
 
         inbox = Inbox.objects.filter(
@@ -109,7 +120,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
             )
 
         # Check for valid priority
-        if not request.data.get("issue", {}).get("priority", "none") in [
+        if request.data.get("issue", {}).get("priority", "none") not in [
             "low",
             "medium",
             "high",
@@ -117,16 +128,18 @@ class InboxIssueAPIEndpoint(BaseAPIView):
             "none",
         ]:
             return Response(
-                {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
+                {"error": "Invalid priority"},
+                status=status.HTTP_400_BAD_REQUEST,
             )
 
         # Create or get state
         state, _ = State.objects.get_or_create(
             name="Triage",
-            group="backlog",
+            group="triage",
             description="Default state for managing all Inbox Issues",
             project_id=project_id,
             color="#ff7700",
+            is_triage=True,
         )
 
         # create an issue
@@ -222,10 +235,14 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                     "description_html": issue_data.get(
                         "description_html", issue.description_html
                     ),
-                    "description": issue_data.get("description", issue.description),
+                    "description": issue_data.get(
+                        "description", issue.description
+                    ),
                 }
 
-            issue_serializer = IssueSerializer(issue, data=issue_data, partial=True)
+            issue_serializer = IssueSerializer(
+                issue, data=issue_data, partial=True
+            )
 
             if issue_serializer.is_valid():
                 current_instance = issue
@@ -266,7 +283,9 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                         project_id=project_id,
                     )
                     state = State.objects.filter(
-                        group="cancelled", workspace__slug=slug, project_id=project_id
+                        group="cancelled",
+                        workspace__slug=slug,
+                        project_id=project_id,
                     ).first()
                     if state is not None:
                         issue.state = state
@@ -281,20 +300,25 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                     )
 
                     # Update the issue state only if it is in triage state
-                    if issue.state.name == "Triage":
+                    if issue.state.is_triage:
                         # Move to default state
                         state = State.objects.filter(
-                            workspace__slug=slug, project_id=project_id, default=True
+                            workspace__slug=slug,
+                            project_id=project_id,
+                            default=True,
                         ).first()
                         if state is not None:
                             issue.state = state
                             issue.save()
 
                 return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+            return Response(
+                serializer.errors, status=status.HTTP_400_BAD_REQUEST
+            )
         else:
             return Response(
-                InboxIssueSerializer(inbox_issue).data, status=status.HTTP_200_OK
+                InboxIssueSerializer(inbox_issue).data,
+                status=status.HTTP_200_OK,
             )
 
     def delete(self, request, slug, project_id, issue_id):

apiserver/plane/api/views/issue.py

@@ -1,22 +1,22 @@
 # Python imports
 import json
-from itertools import chain
+
+from django.core.serializers.json import DjangoJSONEncoder
 
 # Django imports
 from django.db import IntegrityError
 from django.db.models import (
-    OuterRef,
-    Func,
-    Q,
-    F,
     Case,
-    When,
-    Value,
     CharField,
-    Max,
     Exists,
+    F,
+    Func,
+    Max,
+    OuterRef,
+    Q,
+    Value,
+    When,
 )
-from django.core.serializers.json import DjangoJSONEncoder
 from django.utils import timezone
 
 # Third party imports
@@ -24,30 +24,31 @@ from rest_framework import status
 from rest_framework.response import Response
 
 # Module imports
-from .base import BaseAPIView, WebhookMixin
-from plane.app.permissions import (
-    ProjectEntityPermission,
-    ProjectMemberPermission,
-    ProjectLitePermission,
-)
-from plane.db.models import (
-    Issue,
-    IssueAttachment,
-    IssueLink,
-    Project,
-    Label,
-    ProjectMember,
-    IssueComment,
-    IssueActivity,
-)
-from plane.bgtasks.issue_activites_task import issue_activity
 from plane.api.serializers import (
+    IssueActivitySerializer,
+    IssueCommentSerializer,
+    IssueLinkSerializer,
     IssueSerializer,
     LabelSerializer,
-    IssueLinkSerializer,
-    IssueCommentSerializer,
-    IssueActivitySerializer,
 )
+from plane.app.permissions import (
+    ProjectEntityPermission,
+    ProjectLitePermission,
+    ProjectMemberPermission,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from plane.db.models import (
+    Issue,
+    IssueActivity,
+    IssueAttachment,
+    IssueComment,
+    IssueLink,
+    Label,
+    Project,
+    ProjectMember,
+)
+
+from .base import BaseAPIView, WebhookMixin
 
 
 class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
@@ -67,7 +68,9 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
     def get_queryset(self):
         return (
             Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
@@ -86,7 +89,9 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
     def get(self, request, slug, project_id, pk=None):
         if pk:
             issue = Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
@@ -102,7 +107,13 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
 
         # Custom ordering for priority and state
         priority_order = ["urgent", "high", "medium", "low", "none"]
-        state_order = ["backlog", "unstarted", "started", "completed", "cancelled"]
+        state_order = [
+            "backlog",
+            "unstarted",
+            "started",
+            "completed",
+            "cancelled",
+        ]
 
         order_by_param = request.GET.get("order_by", "-created_at")
 
@@ -117,7 +128,9 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
@@ -127,7 +140,9 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
         # Priority Ordering
         if order_by_param == "priority" or order_by_param == "-priority":
             priority_order = (
-                priority_order if order_by_param == "priority" else priority_order[::-1]
+                priority_order
+                if order_by_param == "priority"
+                else priority_order[::-1]
             )
             issue_queryset = issue_queryset.annotate(
                 priority_order=Case(
@@ -175,7 +190,9 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
                     else order_by_param
                 )
             ).order_by(
-                "-max_values" if order_by_param.startswith("-") else "max_values"
+                "-max_values"
+                if order_by_param.startswith("-")
+                else "max_values"
             )
         else:
             issue_queryset = issue_queryset.order_by(order_by_param)
@@ -204,12 +221,38 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
         )
 
         if serializer.is_valid():
+            if (
+                request.data.get("external_id")
+                and request.data.get("external_source")
+                and Issue.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get("external_source"),
+                    external_id=request.data.get("external_id"),
+                ).exists()
+            ):
+                issue = Issue.objects.filter(
+                    workspace__slug=slug,
+                    project_id=project_id,
+                    external_id=request.data.get("external_id"),
+                    external_source=request.data.get("external_source"),
+                ).first()
+                return Response(
+                    {
+                        "error": "Issue with the same external id and external source already exists",
+                        "id": str(issue.id),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
+
             serializer.save()
 
             # Track the issue
             issue_activity.delay(
                 type="issue.activity.created",
-                requested_data=json.dumps(self.request.data, cls=DjangoJSONEncoder),
+                requested_data=json.dumps(
+                    self.request.data, cls=DjangoJSONEncoder
+                ),
                 actor_id=str(request.user.id),
                 issue_id=str(serializer.data.get("id", None)),
                 project_id=str(project_id),
@@ -220,13 +263,44 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def patch(self, request, slug, project_id, pk=None):
-        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+        issue = Issue.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
+        project = Project.objects.get(pk=project_id)
         current_instance = json.dumps(
             IssueSerializer(issue).data, cls=DjangoJSONEncoder
         )
         requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
-        serializer = IssueSerializer(issue, data=request.data, partial=True)
+        serializer = IssueSerializer(
+            issue,
+            data=request.data,
+            context={
+                "project_id": project_id,
+                "workspace_id": project.workspace_id,
+            },
+            partial=True,
+        )
         if serializer.is_valid():
+            if (
+                str(request.data.get("external_id"))
+                and (issue.external_id != str(request.data.get("external_id")))
+                and Issue.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get(
+                        "external_source", issue.external_source
+                    ),
+                    external_id=request.data.get("external_id"),
+                ).exists()
+            ):
+                return Response(
+                    {
+                        "error": "Issue with the same external id and external source already exists",
+                        "id": str(issue.id),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
+
             serializer.save()
             issue_activity.delay(
                 type="issue.activity.updated",
@@ -241,7 +315,9 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def delete(self, request, slug, project_id, pk=None):
-        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+        issue = Issue.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
         current_instance = json.dumps(
             IssueSerializer(issue).data, cls=DjangoJSONEncoder
         )
@@ -275,7 +351,11 @@ class LabelAPIEndpoint(BaseAPIView):
         return (
             Label.objects.filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(project__archived_at__isnull=True)
             .select_related("project")
             .select_related("workspace")
             .select_related("parent")
@@ -287,13 +367,49 @@ class LabelAPIEndpoint(BaseAPIView):
         try:
             serializer = LabelSerializer(data=request.data)
             if serializer.is_valid():
+                if (
+                    request.data.get("external_id")
+                    and request.data.get("external_source")
+                    and Label.objects.filter(
+                        project_id=project_id,
+                        workspace__slug=slug,
+                        external_source=request.data.get("external_source"),
+                        external_id=request.data.get("external_id"),
+                    ).exists()
+                ):
+                    label = Label.objects.filter(
+                        workspace__slug=slug,
+                        project_id=project_id,
+                        external_id=request.data.get("external_id"),
+                        external_source=request.data.get("external_source"),
+                    ).first()
+                    return Response(
+                        {
+                            "error": "Label with the same external id and external source already exists",
+                            "id": str(label.id),
+                        },
+                        status=status.HTTP_409_CONFLICT,
+                    )
+
                 serializer.save(project_id=project_id)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError:
+                return Response(
+                    serializer.data, status=status.HTTP_201_CREATED
+                )
             return Response(
-                {"error": "Label with the same name already exists in the project"},
-                status=status.HTTP_400_BAD_REQUEST,
+                serializer.errors, status=status.HTTP_400_BAD_REQUEST
+            )
+        except IntegrityError:
+            label = Label.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                name=request.data.get("name"),
+            ).first()
+            return Response(
+                {
+                    "error": "Label with the same name already exists in the project",
+                    "id": str(label.id),
+                },
+                status=status.HTTP_409_CONFLICT,
             )
 
     def get(self, request, slug, project_id, pk=None):
@@ -309,17 +425,39 @@ class LabelAPIEndpoint(BaseAPIView):
                 ).data,
             )
         label = self.get_queryset().get(pk=pk)
-        serializer = LabelSerializer(label, fields=self.fields, expand=self.expand,)
+        serializer = LabelSerializer(
+            label,
+            fields=self.fields,
+            expand=self.expand,
+        )
         return Response(serializer.data, status=status.HTTP_200_OK)
 
     def patch(self, request, slug, project_id, pk=None):
         label = self.get_queryset().get(pk=pk)
         serializer = LabelSerializer(label, data=request.data, partial=True)
         if serializer.is_valid():
+            if (
+                str(request.data.get("external_id"))
+                and (label.external_id != str(request.data.get("external_id")))
+                and Issue.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get(
+                        "external_source", label.external_source
+                    ),
+                    external_id=request.data.get("external_id"),
+                ).exists()
+            ):
+                return Response(
+                    {
+                        "error": "Label with the same external id and external source already exists",
+                        "id": str(label.id),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
             serializer.save()
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-    
 
     def delete(self, request, slug, project_id, pk=None):
         label = self.get_queryset().get(pk=pk)
@@ -346,7 +484,11 @@ class IssueLinkAPIEndpoint(BaseAPIView):
             IssueLink.objects.filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
             .filter(issue_id=self.kwargs.get("issue_id"))
-            .filter(project__project_projectmember__member=self.request.user)
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(project__archived_at__isnull=True)
             .order_by(self.kwargs.get("order_by", "-created_at"))
             .distinct()
         )
@@ -386,7 +528,9 @@ class IssueLinkAPIEndpoint(BaseAPIView):
             )
             issue_activity.delay(
                 type="link.activity.created",
-                requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
+                requested_data=json.dumps(
+                    serializer.data, cls=DjangoJSONEncoder
+                ),
                 actor_id=str(self.request.user.id),
                 issue_id=str(self.kwargs.get("issue_id")),
                 project_id=str(self.kwargs.get("project_id")),
@@ -398,14 +542,19 @@ class IssueLinkAPIEndpoint(BaseAPIView):
 
     def patch(self, request, slug, project_id, issue_id, pk):
         issue_link = IssueLink.objects.get(
-            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
+            workspace__slug=slug,
+            project_id=project_id,
+            issue_id=issue_id,
+            pk=pk,
         )
         requested_data = json.dumps(request.data, cls=DjangoJSONEncoder)
         current_instance = json.dumps(
             IssueLinkSerializer(issue_link).data,
             cls=DjangoJSONEncoder,
         )
-        serializer = IssueLinkSerializer(issue_link, data=request.data, partial=True)
+        serializer = IssueLinkSerializer(
+            issue_link, data=request.data, partial=True
+        )
         if serializer.is_valid():
             serializer.save()
             issue_activity.delay(
@@ -422,7 +571,10 @@ class IssueLinkAPIEndpoint(BaseAPIView):
 
     def delete(self, request, slug, project_id, issue_id, pk):
         issue_link = IssueLink.objects.get(
-            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
+            workspace__slug=slug,
+            project_id=project_id,
+            issue_id=issue_id,
+            pk=pk,
         )
         current_instance = json.dumps(
             IssueLinkSerializer(issue_link).data,
@@ -457,14 +609,17 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
 
     def get_queryset(self):
         return (
-            IssueComment.objects.filter(workspace__slug=self.kwargs.get("slug"))
+            IssueComment.objects.filter(
+                workspace__slug=self.kwargs.get("slug")
+            )
             .filter(project_id=self.kwargs.get("project_id"))
             .filter(issue_id=self.kwargs.get("issue_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("issue")
-            .select_related("actor")
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(project__archived_at__isnull=True)
+            .select_related("workspace", "project", "issue", "actor")
             .annotate(
                 is_member=Exists(
                     ProjectMember.objects.filter(
@@ -500,6 +655,31 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
         )
 
     def post(self, request, slug, project_id, issue_id):
+        # Validation check if the issue already exists
+        if (
+            request.data.get("external_id")
+            and request.data.get("external_source")
+            and IssueComment.objects.filter(
+                project_id=project_id,
+                workspace__slug=slug,
+                external_source=request.data.get("external_source"),
+                external_id=request.data.get("external_id"),
+            ).exists()
+        ):
+            issue_comment = IssueComment.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                external_id=request.data.get("external_id"),
+                external_source=request.data.get("external_source"),
+            ).first()
+            return Response(
+                {
+                    "error": "Issue Comment with the same external id and external source already exists",
+                    "id": str(issue_comment.id),
+                },
+                status=status.HTTP_409_CONFLICT,
+            )
+
         serializer = IssueCommentSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save(
@@ -509,7 +689,9 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
             )
             issue_activity.delay(
                 type="comment.activity.created",
-                requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
+                requested_data=json.dumps(
+                    serializer.data, cls=DjangoJSONEncoder
+                ),
                 actor_id=str(self.request.user.id),
                 issue_id=str(self.kwargs.get("issue_id")),
                 project_id=str(self.kwargs.get("project_id")),
@@ -521,13 +703,41 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
 
     def patch(self, request, slug, project_id, issue_id, pk):
         issue_comment = IssueComment.objects.get(
-            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
+            workspace__slug=slug,
+            project_id=project_id,
+            issue_id=issue_id,
+            pk=pk,
         )
         requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
         current_instance = json.dumps(
             IssueCommentSerializer(issue_comment).data,
             cls=DjangoJSONEncoder,
         )
+
+        # Validation check if the issue already exists
+        if (
+            request.data.get("external_id")
+            and (
+                issue_comment.external_id
+                != str(request.data.get("external_id"))
+            )
+            and IssueComment.objects.filter(
+                project_id=project_id,
+                workspace__slug=slug,
+                external_source=request.data.get(
+                    "external_source", issue_comment.external_source
+                ),
+                external_id=request.data.get("external_id"),
+            ).exists()
+        ):
+            return Response(
+                {
+                    "error": "Issue Comment with the same external id and external source already exists",
+                    "id": str(issue_comment.id),
+                },
+                status=status.HTTP_409_CONFLICT,
+            )
+
         serializer = IssueCommentSerializer(
             issue_comment, data=request.data, partial=True
         )
@@ -547,7 +757,10 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
 
     def delete(self, request, slug, project_id, issue_id, pk):
         issue_comment = IssueComment.objects.get(
-            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
+            workspace__slug=slug,
+            project_id=project_id,
+            issue_id=issue_id,
+            pk=pk,
         )
         current_instance = json.dumps(
             IssueCommentSerializer(issue_comment).data,
@@ -579,10 +792,12 @@ class IssueActivityAPIEndpoint(BaseAPIView):
             .filter(
                 ~Q(field__in=["comment", "vote", "reaction", "draft"]),
                 project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
             )
+            .filter(project__archived_at__isnull=True)
             .select_related("actor", "workspace", "issue", "project")
         ).order_by(request.GET.get("order_by", "created_at"))
- 
+
         if pk:
             issue_activities = issue_activities.get(pk=pk)
             serializer = IssueActivitySerializer(issue_activities)

apiserver/plane/api/views/module.py

@@ -2,32 +2,33 @@
 import json
 
 # Django imports
-from django.db.models import Count, Prefetch, Q, F, Func, OuterRef
-from django.utils import timezone
 from django.core import serializers
+from django.db.models import Count, F, Func, OuterRef, Prefetch, Q
+from django.utils import timezone
 
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
 
 # Module imports
-from .base import BaseAPIView, WebhookMixin
+from plane.api.serializers import (
+    IssueSerializer,
+    ModuleIssueSerializer,
+    ModuleSerializer,
+)
 from plane.app.permissions import ProjectEntityPermission
+from plane.bgtasks.issue_activites_task import issue_activity
 from plane.db.models import (
-    Project,
-    Module,
-    ModuleLink,
     Issue,
-    ModuleIssue,
     IssueAttachment,
     IssueLink,
+    Module,
+    ModuleIssue,
+    ModuleLink,
+    Project,
 )
-from plane.api.serializers import (
-    ModuleSerializer,
-    ModuleIssueSerializer,
-    IssueSerializer,
-)
-from plane.bgtasks.issue_activites_task import issue_activity
+
+from .base import BaseAPIView, WebhookMixin
 
 
 class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
@@ -55,7 +56,9 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
             .prefetch_related(
                 Prefetch(
                     "link_module",
-                    queryset=ModuleLink.objects.select_related("module", "created_by"),
+                    queryset=ModuleLink.objects.select_related(
+                        "module", "created_by"
+                    ),
                 )
             )
             .annotate(
@@ -65,6 +68,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
                     ),
+                    distinct=True,
                 ),
             )
             .annotate(
@@ -75,6 +79,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
                     ),
+                    distinct=True,
                 )
             )
             .annotate(
@@ -85,6 +90,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
                     ),
+                    distinct=True,
                 )
             )
             .annotate(
@@ -95,6 +101,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
                     ),
+                    distinct=True,
                 )
             )
             .annotate(
@@ -105,6 +112,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
                     ),
+                    distinct=True,
                 )
             )
             .annotate(
@@ -115,32 +123,95 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
                     ),
+                    distinct=True,
                 )
             )
             .order_by(self.kwargs.get("order_by", "-created_at"))
         )
 
     def post(self, request, slug, project_id):
-        project = Project.objects.get(workspace__slug=slug, pk=project_id)
-        serializer = ModuleSerializer(data=request.data, context={"project": project})
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+        serializer = ModuleSerializer(
+            data=request.data,
+            context={
+                "project_id": project_id,
+                "workspace_id": project.workspace_id,
+            },
+        )
         if serializer.is_valid():
+            if (
+                request.data.get("external_id")
+                and request.data.get("external_source")
+                and Module.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get("external_source"),
+                    external_id=request.data.get("external_id"),
+                ).exists()
+            ):
+                module = Module.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get("external_source"),
+                    external_id=request.data.get("external_id"),
+                ).first()
+                return Response(
+                    {
+                        "error": "Module with the same external id and external source already exists",
+                        "id": str(module.id),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
             serializer.save()
             module = Module.objects.get(pk=serializer.data["id"])
             serializer = ModuleSerializer(module)
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-    
+
     def patch(self, request, slug, project_id, pk):
-        module = Module.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
-        serializer = ModuleSerializer(module, data=request.data)
+        module = Module.objects.get(
+            pk=pk, project_id=project_id, workspace__slug=slug
+        )
+        if module.archived_at:
+            return Response(
+                {"error": "Archived module cannot be edited"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        serializer = ModuleSerializer(
+            module,
+            data=request.data,
+            context={"project_id": project_id},
+            partial=True,
+        )
         if serializer.is_valid():
+            if (
+                request.data.get("external_id")
+                and (module.external_id != request.data.get("external_id"))
+                and Module.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get(
+                        "external_source", module.external_source
+                    ),
+                    external_id=request.data.get("external_id"),
+                ).exists()
+            ):
+                return Response(
+                    {
+                        "error": "Module with the same external id and external source already exists",
+                        "id": str(module.id),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
             serializer.save()
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def get(self, request, slug, project_id, pk=None):
         if pk:
-            queryset = self.get_queryset().get(pk=pk)
+            queryset = (
+                self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
+            )
             data = ModuleSerializer(
                 queryset,
                 fields=self.fields,
@@ -152,7 +223,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
             )
         return self.paginate(
             request=request,
-            queryset=(self.get_queryset()),
+            queryset=(self.get_queryset().filter(archived_at__isnull=True)),
             on_results=lambda modules: ModuleSerializer(
                 modules,
                 many=True,
@@ -162,9 +233,13 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
         )
 
     def delete(self, request, slug, project_id, pk):
-        module = Module.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+        module = Module.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
         module_issues = list(
-            ModuleIssue.objects.filter(module_id=pk).values_list("issue", flat=True)
+            ModuleIssue.objects.filter(module_id=pk).values_list(
+                "issue", flat=True
+            )
         )
         issue_activity.delay(
             type="module.activity.deleted",
@@ -204,7 +279,9 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
     def get_queryset(self):
         return (
             ModuleIssue.objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("issue"))
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("issue")
+                )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
@@ -212,7 +289,11 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
             .filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
             .filter(module_id=self.kwargs.get("module_id"))
-            .filter(project__project_projectmember__member=self.request.user)
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(project__archived_at__isnull=True)
             .select_related("project")
             .select_related("workspace")
             .select_related("module")
@@ -228,7 +309,9 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
         issues = (
             Issue.issue_objects.filter(issue_module__module_id=module_id)
             .annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
@@ -250,7 +333,9 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
@@ -271,7 +356,8 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
         issues = request.data.get("issues", [])
         if not len(issues):
             return Response(
-                {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
+                {"error": "Issues are required"},
+                status=status.HTTP_400_BAD_REQUEST,
             )
         module = Module.objects.get(
             workspace__slug=slug, project_id=project_id, pk=module_id
@@ -354,7 +440,10 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
 
     def delete(self, request, slug, project_id, module_id, issue_id):
         module_issue = ModuleIssue.objects.get(
-            workspace__slug=slug, project_id=project_id, module_id=module_id, issue_id=issue_id
+            workspace__slug=slug,
+            project_id=project_id,
+            module_id=module_id,
+            issue_id=issue_id,
         )
         module_issue.delete()
         issue_activity.delay(
@@ -371,4 +460,124 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
             current_instance=None,
             epoch=int(timezone.now().timestamp()),
         )
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get_queryset(self):
+        return (
+            Module.objects.filter(project_id=self.kwargs.get("project_id"))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(archived_at__isnull=False)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("lead")
+            .prefetch_related("members")
+            .prefetch_related(
+                Prefetch(
+                    "link_module",
+                    queryset=ModuleLink.objects.select_related(
+                        "module", "created_by"
+                    ),
+                )
+            )
+            .annotate(
+                total_issues=Count(
+                    "issue_module",
+                    filter=Q(
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                    ),
+                    distinct=True,
+                ),
+            )
+            .annotate(
+                completed_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="completed",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                cancelled_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="cancelled",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                started_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="started",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                unstarted_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="unstarted",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                backlog_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="backlog",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                    ),
+                    distinct=True,
+                )
+            )
+            .order_by(self.kwargs.get("order_by", "-created_at"))
+        )
+
+    def get(self, request, slug, project_id):
+        return self.paginate(
+            request=request,
+            queryset=(self.get_queryset()),
+            on_results=lambda modules: ModuleSerializer(
+                modules,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+            ).data,
+        )
+
+    def post(self, request, slug, project_id, pk):
+        module = Module.objects.get(
+            pk=pk, project_id=project_id, workspace__slug=slug
+        )
+        module.archived_at = timezone.now()
+        module.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def delete(self, request, slug, project_id, pk):
+        module = Module.objects.get(
+            pk=pk, project_id=project_id, workspace__slug=slug
+        )
+        module.archived_at = None
+        module.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/project.py

@@ -1,27 +1,29 @@
 # Django imports
 from django.db import IntegrityError
-from django.db.models import Exists, OuterRef, Q, F, Func, Subquery, Prefetch
+from django.db.models import Exists, F, Func, OuterRef, Prefetch, Q, Subquery
+from django.utils import timezone
 
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
 from rest_framework.serializers import ValidationError
 
+from plane.api.serializers import ProjectSerializer
+from plane.app.permissions import ProjectBasePermission
+
 # Module imports
 from plane.db.models import (
-    Workspace,
-    Project,
-    ProjectFavorite,
-    ProjectMember,
-    ProjectDeployBoard,
-    State,
     Cycle,
-    Module,
-    IssueProperty,
     Inbox,
+    IssueProperty,
+    Module,
+    Project,
+    ProjectDeployBoard,
+    ProjectMember,
+    State,
+    Workspace,
 )
-from plane.app.permissions import ProjectBasePermission
-from plane.api.serializers import ProjectSerializer
+
 from .base import BaseAPIView, WebhookMixin
 
 
@@ -39,9 +41,18 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
     def get_queryset(self):
         return (
             Project.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(Q(project_projectmember__member=self.request.user) | Q(network=2))
+            .filter(
+                Q(
+                    project_projectmember__member=self.request.user,
+                    project_projectmember__is_active=True,
+                )
+                | Q(network=2)
+            )
             .select_related(
-                "workspace", "workspace__owner", "default_assignee", "project_lead"
+                "workspace",
+                "workspace__owner",
+                "default_assignee",
+                "project_lead",
             )
             .annotate(
                 is_member=Exists(
@@ -94,8 +105,8 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
             .distinct()
         )
 
-    def get(self, request, slug, project_id=None):
-        if project_id is None:
+    def get(self, request, slug, pk=None):
+        if pk is None:
             sort_order_query = ProjectMember.objects.filter(
                 member=request.user,
                 project_id=OuterRef("pk"),
@@ -120,11 +131,18 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                 request=request,
                 queryset=(projects),
                 on_results=lambda projects: ProjectSerializer(
-                    projects, many=True, fields=self.fields, expand=self.expand,
+                    projects,
+                    many=True,
+                    fields=self.fields,
+                    expand=self.expand,
                 ).data,
             )
-        project = self.get_queryset().get(workspace__slug=slug, pk=project_id)
-        serializer = ProjectSerializer(project, fields=self.fields, expand=self.expand,)
+        project = self.get_queryset().get(workspace__slug=slug, pk=pk)
+        serializer = ProjectSerializer(
+            project,
+            fields=self.fields,
+            expand=self.expand,
+        )
         return Response(serializer.data, status=status.HTTP_200_OK)
 
     def post(self, request, slug):
@@ -137,8 +155,10 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                 serializer.save()
 
                 # Add the user as Administrator to the project
-                project_member = ProjectMember.objects.create(
-                    project_id=serializer.data["id"], member=request.user, role=20
+                _ = ProjectMember.objects.create(
+                    project_id=serializer.data["id"],
+                    member=request.user,
+                    role=20,
                 )
                 # Also create the issue property for the user
                 _ = IssueProperty.objects.create(
@@ -211,9 +231,15 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                     ]
                 )
 
-                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
+                project = (
+                    self.get_queryset()
+                    .filter(pk=serializer.data["id"])
+                    .first()
+                )
                 serializer = ProjectSerializer(project)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
+                return Response(
+                    serializer.data, status=status.HTTP_201_CREATED
+                )
             return Response(
                 serializer.errors,
                 status=status.HTTP_400_BAD_REQUEST,
@@ -224,20 +250,27 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                     {"name": "The project name is already taken"},
                     status=status.HTTP_410_GONE,
                 )
-        except Workspace.DoesNotExist as e:
+        except Workspace.DoesNotExist:
             return Response(
-                {"error": "Workspace does not exist"}, status=status.HTTP_404_NOT_FOUND
+                {"error": "Workspace does not exist"},
+                status=status.HTTP_404_NOT_FOUND,
             )
-        except ValidationError as e:
+        except ValidationError:
             return Response(
                 {"identifier": "The project identifier is already taken"},
                 status=status.HTTP_410_GONE,
             )
 
-    def patch(self, request, slug, project_id=None):
+    def patch(self, request, slug, pk):
         try:
             workspace = Workspace.objects.get(slug=slug)
-            project = Project.objects.get(pk=project_id)
+            project = Project.objects.get(pk=pk)
+
+            if project.archived_at:
+                return Response(
+                    {"error": "Archived project cannot be updated"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
 
             serializer = ProjectSerializer(
                 project,
@@ -250,22 +283,31 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                 serializer.save()
                 if serializer.data["inbox_view"]:
                     Inbox.objects.get_or_create(
-                        name=f"{project.name} Inbox", project=project, is_default=True
+                        name=f"{project.name} Inbox",
+                        project=project,
+                        is_default=True,
                     )
 
                     # Create the triage state in Backlog group
                     State.objects.get_or_create(
                         name="Triage",
-                        group="backlog",
+                        group="triage",
                         description="Default state for managing all Inbox Issues",
-                        project_id=project_id,
+                        project_id=pk,
                         color="#ff7700",
+                        is_triage=True,
                     )
 
-                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
+                project = (
+                    self.get_queryset()
+                    .filter(pk=serializer.data["id"])
+                    .first()
+                )
                 serializer = ProjectSerializer(project)
                 return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+            return Response(
+                serializer.errors, status=status.HTTP_400_BAD_REQUEST
+            )
         except IntegrityError as e:
             if "already exists" in str(e):
                 return Response(
@@ -274,15 +316,35 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                 )
         except (Project.DoesNotExist, Workspace.DoesNotExist):
             return Response(
-                {"error": "Project does not exist"}, status=status.HTTP_404_NOT_FOUND
+                {"error": "Project does not exist"},
+                status=status.HTTP_404_NOT_FOUND,
             )
-        except ValidationError as e:
+        except ValidationError:
             return Response(
                 {"identifier": "The project identifier is already taken"},
                 status=status.HTTP_410_GONE,
             )
 
+    def delete(self, request, slug, pk):
+        project = Project.objects.get(pk=pk, workspace__slug=slug)
+        project.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ProjectArchiveUnarchiveAPIEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    def post(self, request, slug, project_id):
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+        project.archived_at = timezone.now()
+        project.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
     def delete(self, request, slug, project_id):
         project = Project.objects.get(pk=project_id, workspace__slug=slug)
-        project.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        project.archived_at = None
+        project.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/state.py

@@ -1,18 +1,16 @@
-# Python imports
-from itertools import groupby
-
 # Django imports
-from django.db.models import Q
+from django.db import IntegrityError
 
 # Third party imports
-from rest_framework.response import Response
 from rest_framework import status
+from rest_framework.response import Response
+
+from plane.api.serializers import StateSerializer
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import Issue, State
 
 # Module imports
 from .base import BaseAPIView
-from plane.api.serializers import StateSerializer
-from plane.app.permissions import ProjectEntityPermission
-from plane.db.models import State, Issue
 
 
 class StateAPIEndpoint(BaseAPIView):
@@ -26,23 +24,73 @@ class StateAPIEndpoint(BaseAPIView):
         return (
             State.objects.filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .filter(~Q(name="Triage"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(is_triage=False)
+            .filter(project__archived_at__isnull=True)
             .select_related("project")
             .select_related("workspace")
             .distinct()
         )
 
     def post(self, request, slug, project_id):
-        serializer = StateSerializer(data=request.data, context={"project_id": project_id})
-        if serializer.is_valid():
-            serializer.save(project_id=project_id)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        try:
+            serializer = StateSerializer(
+                data=request.data, context={"project_id": project_id}
+            )
+            if serializer.is_valid():
+                if (
+                    request.data.get("external_id")
+                    and request.data.get("external_source")
+                    and State.objects.filter(
+                        project_id=project_id,
+                        workspace__slug=slug,
+                        external_source=request.data.get("external_source"),
+                        external_id=request.data.get("external_id"),
+                    ).exists()
+                ):
+                    state = State.objects.filter(
+                        workspace__slug=slug,
+                        project_id=project_id,
+                        external_id=request.data.get("external_id"),
+                        external_source=request.data.get("external_source"),
+                    ).first()
+                    return Response(
+                        {
+                            "error": "State with the same external id and external source already exists",
+                            "id": str(state.id),
+                        },
+                        status=status.HTTP_409_CONFLICT,
+                    )
+
+                serializer.save(project_id=project_id)
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(
+                serializer.errors, status=status.HTTP_400_BAD_REQUEST
+            )
+        except IntegrityError:
+            state = State.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                name=request.data.get("name"),
+            ).first()
+            return Response(
+                {
+                    "error": "State with the same name already exists in the project",
+                    "id": str(state.id),
+                },
+                status=status.HTTP_409_CONFLICT,
+            )
 
     def get(self, request, slug, project_id, state_id=None):
         if state_id:
-            serializer = StateSerializer(self.get_queryset().get(pk=state_id))
+            serializer = StateSerializer(
+                self.get_queryset().get(pk=state_id),
+                fields=self.fields,
+                expand=self.expand,
+            )
             return Response(serializer.data, status=status.HTTP_200_OK)
         return self.paginate(
             request=request,
@@ -57,21 +105,26 @@ class StateAPIEndpoint(BaseAPIView):
 
     def delete(self, request, slug, project_id, state_id):
         state = State.objects.get(
-            ~Q(name="Triage"),
+            is_triage=False,
             pk=state_id,
             project_id=project_id,
             workspace__slug=slug,
         )
 
         if state.default:
-            return Response({"error": "Default state cannot be deleted"}, status=status.HTTP_400_BAD_REQUEST)
+            return Response(
+                {"error": "Default state cannot be deleted"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
 
         # Check for any issues in the state
         issue_exist = Issue.issue_objects.filter(state=state_id).exists()
 
         if issue_exist:
             return Response(
-                {"error": "The state is not empty, only empty states can be deleted"},
+                {
+                    "error": "The state is not empty, only empty states can be deleted"
+                },
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
@@ -79,9 +132,30 @@ class StateAPIEndpoint(BaseAPIView):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
     def patch(self, request, slug, project_id, state_id=None):
-        state = State.objects.get(workspace__slug=slug, project_id=project_id, pk=state_id)
+        state = State.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=state_id
+        )
         serializer = StateSerializer(state, data=request.data, partial=True)
         if serializer.is_valid():
+            if (
+                str(request.data.get("external_id"))
+                and (state.external_id != str(request.data.get("external_id")))
+                and State.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get(
+                        "external_source", state.external_source
+                    ),
+                    external_id=request.data.get("external_id"),
+                ).exists()
+            ):
+                return Response(
+                    {
+                        "error": "State with the same external id and external source already exists",
+                        "id": str(state.id),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
             serializer.save()
             return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/app/middleware/api_authentication.py

@@ -25,7 +25,10 @@ class APIKeyAuthentication(authentication.BaseAuthentication):
     def validate_api_token(self, token):
         try:
             api_token = APIToken.objects.get(
-                Q(Q(expired_at__gt=timezone.now()) | Q(expired_at__isnull=True)),
+                Q(
+                    Q(expired_at__gt=timezone.now())
+                    | Q(expired_at__isnull=True)
+                ),
                 token=token,
                 is_active=True,
             )

apiserver/plane/app/permissions/__init__.py

@@ -1,4 +1,3 @@
-
 from .workspace import (
     WorkSpaceBasePermission,
     WorkspaceOwnerPermission,
@@ -13,5 +12,3 @@ from .project import (
     ProjectMemberPermission,
     ProjectLitePermission,
 )
-
-

apiserver/plane/app/permissions/project.py

@@ -1,8 +1,8 @@
 # Third Party imports
-from rest_framework.permissions import BasePermission, SAFE_METHODS
+from rest_framework.permissions import SAFE_METHODS, BasePermission
 
 # Module import
-from plane.db.models import WorkspaceMember, ProjectMember
+from plane.db.models import ProjectMember, WorkspaceMember
 
 # Permission Mappings
 Admin = 20

apiserver/plane/app/serializers/__init__.py

@@ -17,6 +17,7 @@ from .workspace import (
     WorkspaceThemeSerializer,
     WorkspaceMemberAdminSerializer,
     WorkspaceMemberMeSerializer,
+    WorkspaceUserPropertiesSerializer,
 )
 from .project import (
     ProjectSerializer,
@@ -31,14 +32,20 @@ from .project import (
     ProjectDeployBoardSerializer,
     ProjectMemberAdminSerializer,
     ProjectPublicMemberSerializer,
+    ProjectMemberRoleSerializer,
 )
 from .state import StateSerializer, StateLiteSerializer
-from .view import GlobalViewSerializer, IssueViewSerializer, IssueViewFavoriteSerializer
+from .view import (
+    GlobalViewSerializer,
+    IssueViewSerializer,
+    IssueViewFavoriteSerializer,
+)
 from .cycle import (
     CycleSerializer,
     CycleIssueSerializer,
     CycleFavoriteSerializer,
     CycleWriteSerializer,
+    CycleUserPropertiesSerializer,
 )
 from .asset import FileAssetSerializer
 from .issue import (
@@ -52,6 +59,7 @@ from .issue import (
     IssueFlatSerializer,
     IssueStateSerializer,
     IssueLinkSerializer,
+    IssueInboxSerializer,
     IssueLiteSerializer,
     IssueAttachmentSerializer,
     IssueSubscriberSerializer,
@@ -61,44 +69,57 @@ from .issue import (
     IssueRelationSerializer,
     RelatedIssueSerializer,
     IssuePublicSerializer,
+    IssueDetailSerializer,
+    IssueReactionLiteSerializer,
+    IssueAttachmentLiteSerializer,
+    IssueLinkLiteSerializer,
 )
 
 from .module import (
+    ModuleDetailSerializer,
     ModuleWriteSerializer,
     ModuleSerializer,
     ModuleIssueSerializer,
     ModuleLinkSerializer,
     ModuleFavoriteSerializer,
+    ModuleUserPropertiesSerializer,
 )
 
 from .api import APITokenSerializer, APITokenReadSerializer
 
-from .integration import (
-    IntegrationSerializer,
-    WorkspaceIntegrationSerializer,
-    GithubIssueSyncSerializer,
-    GithubRepositorySerializer,
-    GithubRepositorySyncSerializer,
-    GithubCommentSyncSerializer,
-    SlackProjectSyncSerializer,
-)
-
 from .importer import ImporterSerializer
 
-from .page import PageSerializer, PageLogSerializer, SubPageSerializer, PageFavoriteSerializer
+from .page import (
+    PageSerializer,
+    PageLogSerializer,
+    SubPageSerializer,
+    PageFavoriteSerializer,
+)
 
 from .estimate import (
     EstimateSerializer,
     EstimatePointSerializer,
     EstimateReadSerializer,
+    WorkspaceEstimateSerializer,
 )
 
-from .inbox import InboxSerializer, InboxIssueSerializer, IssueStateInboxSerializer
+from .inbox import (
+    InboxSerializer,
+    InboxIssueSerializer,
+    IssueStateInboxSerializer,
+    InboxIssueLiteSerializer,
+    InboxIssueDetailSerializer,
+)
 
 from .analytic import AnalyticViewSerializer
 
-from .notification import NotificationSerializer
+from .notification import (
+    NotificationSerializer,
+    UserNotificationPreferenceSerializer,
+)
 
 from .exporter import ExporterHistorySerializer
 
-from .webhook import WebhookSerializer, WebhookLogSerializer
+from .webhook import WebhookSerializer, WebhookLogSerializer
+
+from .dashboard import DashboardSerializer, WidgetSerializer

apiserver/plane/app/serializers/api.py

@@ -3,7 +3,6 @@ from plane.db.models import APIToken, APIActivityLog
 
 
 class APITokenSerializer(BaseSerializer):
-    
     class Meta:
         model = APIToken
         fields = "__all__"
@@ -18,14 +17,12 @@ class APITokenSerializer(BaseSerializer):
 
 
 class APITokenReadSerializer(BaseSerializer):
-
     class Meta:
         model = APIToken
-        exclude = ('token',)
+        exclude = ("token",)
 
 
 class APIActivityLogSerializer(BaseSerializer):
-
     class Meta:
         model = APIActivityLog
         fields = "__all__"

apiserver/plane/app/serializers/base.py

@@ -4,16 +4,17 @@ from rest_framework import serializers
 class BaseSerializer(serializers.ModelSerializer):
     id = serializers.PrimaryKeyRelatedField(read_only=True)
 
-class DynamicBaseSerializer(BaseSerializer):
 
+class DynamicBaseSerializer(BaseSerializer):
     def __init__(self, *args, **kwargs):
         # If 'fields' is provided in the arguments, remove it and store it separately.
         # This is done so as not to pass this custom argument up to the superclass.
-        fields = kwargs.pop("fields", None)
+        fields = kwargs.pop("fields", [])
+        self.expand = kwargs.pop("expand", []) or []
+        fields = self.expand
 
         # Call the initialization of the superclass.
         super().__init__(*args, **kwargs)
-
         # If 'fields' was provided, filter the fields of the serializer accordingly.
         if fields is not None:
             self.fields = self._filter_fields(fields)
@@ -31,7 +32,7 @@ class DynamicBaseSerializer(BaseSerializer):
             # loop through its keys and values.
             if isinstance(field_name, dict):
                 for key, value in field_name.items():
-                    # If the value of this nested field is a list, 
+                    # If the value of this nested field is a list,
                     # perform a recursive filter on it.
                     if isinstance(value, list):
                         self._filter_fields(self.fields[key], value)
@@ -47,12 +48,134 @@ class DynamicBaseSerializer(BaseSerializer):
             elif isinstance(item, dict):
                 allowed.append(list(item.keys())[0])
 
-        # Convert the current serializer's fields and the allowed fields to sets.
-        existing = set(self.fields)
-        allowed = set(allowed)
+        for field in allowed:
+            if field not in self.fields:
+                from . import (
+                    WorkspaceLiteSerializer,
+                    ProjectLiteSerializer,
+                    UserLiteSerializer,
+                    StateLiteSerializer,
+                    IssueSerializer,
+                    LabelSerializer,
+                    CycleIssueSerializer,
+                    IssueLiteSerializer,
+                    IssueRelationSerializer,
+                    InboxIssueLiteSerializer,
+                    IssueReactionLiteSerializer,
+                    IssueAttachmentLiteSerializer,
+                    IssueLinkLiteSerializer,
+                )
 
-        # Remove fields from the serializer that aren't in the 'allowed' list.
-        for field_name in (existing - allowed):
-            self.fields.pop(field_name)
+                # Expansion mapper
+                expansion = {
+                    "user": UserLiteSerializer,
+                    "workspace": WorkspaceLiteSerializer,
+                    "project": ProjectLiteSerializer,
+                    "default_assignee": UserLiteSerializer,
+                    "project_lead": UserLiteSerializer,
+                    "state": StateLiteSerializer,
+                    "created_by": UserLiteSerializer,
+                    "issue": IssueSerializer,
+                    "actor": UserLiteSerializer,
+                    "owned_by": UserLiteSerializer,
+                    "members": UserLiteSerializer,
+                    "assignees": UserLiteSerializer,
+                    "labels": LabelSerializer,
+                    "issue_cycle": CycleIssueSerializer,
+                    "parent": IssueLiteSerializer,
+                    "issue_relation": IssueRelationSerializer,
+                    "issue_inbox": InboxIssueLiteSerializer,
+                    "issue_reactions": IssueReactionLiteSerializer,
+                    "issue_attachment": IssueAttachmentLiteSerializer,
+                    "issue_link": IssueLinkLiteSerializer,
+                    "sub_issues": IssueLiteSerializer,
+                }
+
+                self.fields[field] = expansion[field](
+                    many=(
+                        True
+                        if field
+                        in [
+                            "members",
+                            "assignees",
+                            "labels",
+                            "issue_cycle",
+                            "issue_relation",
+                            "issue_inbox",
+                            "issue_reactions",
+                            "issue_attachment",
+                            "issue_link",
+                            "sub_issues",
+                        ]
+                        else False
+                    )
+                )
 
         return self.fields
+
+    def to_representation(self, instance):
+        response = super().to_representation(instance)
+
+        # Ensure 'expand' is iterable before processing
+        if self.expand:
+            for expand in self.expand:
+                if expand in self.fields:
+                    # Import all the expandable serializers
+                    from . import (
+                        WorkspaceLiteSerializer,
+                        ProjectLiteSerializer,
+                        UserLiteSerializer,
+                        StateLiteSerializer,
+                        IssueSerializer,
+                        LabelSerializer,
+                        CycleIssueSerializer,
+                        IssueRelationSerializer,
+                        InboxIssueLiteSerializer,
+                        IssueLiteSerializer,
+                        IssueReactionLiteSerializer,
+                        IssueAttachmentLiteSerializer,
+                        IssueLinkLiteSerializer,
+                    )
+
+                    # Expansion mapper
+                    expansion = {
+                        "user": UserLiteSerializer,
+                        "workspace": WorkspaceLiteSerializer,
+                        "project": ProjectLiteSerializer,
+                        "default_assignee": UserLiteSerializer,
+                        "project_lead": UserLiteSerializer,
+                        "state": StateLiteSerializer,
+                        "created_by": UserLiteSerializer,
+                        "issue": IssueSerializer,
+                        "actor": UserLiteSerializer,
+                        "owned_by": UserLiteSerializer,
+                        "members": UserLiteSerializer,
+                        "assignees": UserLiteSerializer,
+                        "labels": LabelSerializer,
+                        "issue_cycle": CycleIssueSerializer,
+                        "parent": IssueLiteSerializer,
+                        "issue_relation": IssueRelationSerializer,
+                        "issue_inbox": InboxIssueLiteSerializer,
+                        "issue_reactions": IssueReactionLiteSerializer,
+                        "issue_attachment": IssueAttachmentLiteSerializer,
+                        "issue_link": IssueLinkLiteSerializer,
+                        "sub_issues": IssueLiteSerializer,
+                    }
+                    # Check if field in expansion then expand the field
+                    if expand in expansion:
+                        if isinstance(response.get(expand), list):
+                            exp_serializer = expansion[expand](
+                                getattr(instance, expand), many=True
+                            )
+                        else:
+                            exp_serializer = expansion[expand](
+                                getattr(instance, expand)
+                            )
+                        response[expand] = exp_serializer.data
+                    else:
+                        # You might need to handle this case differently
+                        response[expand] = getattr(
+                            instance, f"{expand}_id", None
+                        )
+
+        return response

apiserver/plane/app/serializers/cycle.py

@@ -3,11 +3,13 @@ from rest_framework import serializers
 
 # Module imports
 from .base import BaseSerializer
-from .user import UserLiteSerializer
 from .issue import IssueStateSerializer
-from .workspace import WorkspaceLiteSerializer
-from .project import ProjectLiteSerializer
-from plane.db.models import Cycle, CycleIssue, CycleFavorite
+from plane.db.models import (
+    Cycle,
+    CycleIssue,
+    CycleFavorite,
+    CycleUserProperties,
+)
 
 
 class CycleWriteSerializer(BaseSerializer):
@@ -17,69 +19,67 @@ class CycleWriteSerializer(BaseSerializer):
             and data.get("end_date", None) is not None
             and data.get("start_date", None) > data.get("end_date", None)
         ):
-            raise serializers.ValidationError("Start date cannot exceed end date")
+            raise serializers.ValidationError(
+                "Start date cannot exceed end date"
+            )
         return data
 
     class Meta:
         model = Cycle
         fields = "__all__"
-
-
-class CycleSerializer(BaseSerializer):
-    owned_by = UserLiteSerializer(read_only=True)
-    is_favorite = serializers.BooleanField(read_only=True)
-    total_issues = serializers.IntegerField(read_only=True)
-    cancelled_issues = serializers.IntegerField(read_only=True)
-    completed_issues = serializers.IntegerField(read_only=True)
-    started_issues = serializers.IntegerField(read_only=True)
-    unstarted_issues = serializers.IntegerField(read_only=True)
-    backlog_issues = serializers.IntegerField(read_only=True)
-    assignees = serializers.SerializerMethodField(read_only=True)
-    total_estimates = serializers.IntegerField(read_only=True)
-    completed_estimates = serializers.IntegerField(read_only=True)
-    started_estimates = serializers.IntegerField(read_only=True)
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-
-    def validate(self, data):
-        if (
-            data.get("start_date", None) is not None
-            and data.get("end_date", None) is not None
-            and data.get("start_date", None) > data.get("end_date", None)
-        ):
-            raise serializers.ValidationError("Start date cannot exceed end date")
-        return data
-
-    def get_assignees(self, obj):
-        members = [
-            {
-                "avatar": assignee.avatar,
-                "display_name": assignee.display_name,
-                "id": assignee.id,
-            }
-            for issue_cycle in obj.issue_cycle.prefetch_related(
-                "issue__assignees"
-            ).all()
-            for assignee in issue_cycle.issue.assignees.all()
-        ]
-        # Use a set comprehension to return only the unique objects
-        unique_objects = {frozenset(item.items()) for item in members}
-
-        # Convert the set back to a list of dictionaries
-        unique_list = [dict(item) for item in unique_objects]
-
-        return unique_list
-
-    class Meta:
-        model = Cycle
-        fields = "__all__"
         read_only_fields = [
             "workspace",
             "project",
             "owned_by",
+            "archived_at",
         ]
 
 
+class CycleSerializer(BaseSerializer):
+    # favorite
+    is_favorite = serializers.BooleanField(read_only=True)
+    total_issues = serializers.IntegerField(read_only=True)
+    # state group wise distribution
+    cancelled_issues = serializers.IntegerField(read_only=True)
+    completed_issues = serializers.IntegerField(read_only=True)
+    started_issues = serializers.IntegerField(read_only=True)
+    unstarted_issues = serializers.IntegerField(read_only=True)
+    backlog_issues = serializers.IntegerField(read_only=True)
+
+    # active | draft | upcoming | completed
+    status = serializers.CharField(read_only=True)
+
+    class Meta:
+        model = Cycle
+        fields = [
+            # necessary fields
+            "id",
+            "workspace_id",
+            "project_id",
+            # model fields
+            "name",
+            "description",
+            "start_date",
+            "end_date",
+            "owned_by_id",
+            "view_props",
+            "sort_order",
+            "external_source",
+            "external_id",
+            "progress_snapshot",
+            # meta fields
+            "is_favorite",
+            "total_issues",
+            "cancelled_issues",
+            "completed_issues",
+            "started_issues",
+            "unstarted_issues",
+            "backlog_issues",
+            "status",
+        ]
+        read_only_fields = fields
+
+
 class CycleIssueSerializer(BaseSerializer):
     issue_detail = IssueStateSerializer(read_only=True, source="issue")
     sub_issues_count = serializers.IntegerField(read_only=True)
@@ -105,3 +105,14 @@ class CycleFavoriteSerializer(BaseSerializer):
             "project",
             "user",
         ]
+
+
+class CycleUserPropertiesSerializer(BaseSerializer):
+    class Meta:
+        model = CycleUserProperties
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "cycle" "user",
+        ]

apiserver/plane/app/serializers/dashboard.py

@@ -0,0 +1,21 @@
+# Module imports
+from .base import BaseSerializer
+from plane.db.models import Dashboard, Widget
+
+# Third party frameworks
+from rest_framework import serializers
+
+
+class DashboardSerializer(BaseSerializer):
+    class Meta:
+        model = Dashboard
+        fields = "__all__"
+
+
+class WidgetSerializer(BaseSerializer):
+    is_visible = serializers.BooleanField(read_only=True)
+    widget_filters = serializers.JSONField(read_only=True)
+
+    class Meta:
+        model = Widget
+        fields = ["id", "key", "is_visible", "widget_filters"]

apiserver/plane/app/serializers/estimate.py

@@ -2,11 +2,18 @@
 from .base import BaseSerializer
 
 from plane.db.models import Estimate, EstimatePoint
-from plane.app.serializers import WorkspaceLiteSerializer, ProjectLiteSerializer
+from plane.app.serializers import (
+    WorkspaceLiteSerializer,
+    ProjectLiteSerializer,
+)
+
+from rest_framework import serializers
 
 
 class EstimateSerializer(BaseSerializer):
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+    workspace_detail = WorkspaceLiteSerializer(
+        read_only=True, source="workspace"
+    )
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
 
     class Meta:
@@ -19,6 +26,16 @@ class EstimateSerializer(BaseSerializer):
 
 
 class EstimatePointSerializer(BaseSerializer):
+    def validate(self, data):
+        if not data:
+            raise serializers.ValidationError("Estimate points are required")
+        value = data.get("value")
+        if value and len(value) > 20:
+            raise serializers.ValidationError(
+                "Value can't be more than 20 characters"
+            )
+        return data
+
     class Meta:
         model = EstimatePoint
         fields = "__all__"
@@ -31,7 +48,9 @@ class EstimatePointSerializer(BaseSerializer):
 
 class EstimateReadSerializer(BaseSerializer):
     points = EstimatePointSerializer(read_only=True, many=True)
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+    workspace_detail = WorkspaceLiteSerializer(
+        read_only=True, source="workspace"
+    )
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
 
     class Meta:
@@ -42,3 +61,16 @@ class EstimateReadSerializer(BaseSerializer):
             "name",
             "description",
         ]
+
+
+class WorkspaceEstimateSerializer(BaseSerializer):
+    points = EstimatePointSerializer(read_only=True, many=True)
+
+    class Meta:
+        model = Estimate
+        fields = "__all__"
+        read_only_fields = [
+            "points",
+            "name",
+            "description",
+        ]

apiserver/plane/app/serializers/exporter.py

@@ -5,7 +5,9 @@ from .user import UserLiteSerializer
 
 
 class ExporterHistorySerializer(BaseSerializer):
-    initiated_by_detail = UserLiteSerializer(source="initiated_by", read_only=True)
+    initiated_by_detail = UserLiteSerializer(
+        source="initiated_by", read_only=True
+    )
 
     class Meta:
         model = ExporterHistory

apiserver/plane/app/serializers/importer.py

@@ -7,9 +7,13 @@ from plane.db.models import Importer
 
 
 class ImporterSerializer(BaseSerializer):
-    initiated_by_detail = UserLiteSerializer(source="initiated_by", read_only=True)
+    initiated_by_detail = UserLiteSerializer(
+        source="initiated_by", read_only=True
+    )
     project_detail = ProjectLiteSerializer(source="project", read_only=True)
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+    workspace_detail = WorkspaceLiteSerializer(
+        source="workspace", read_only=True
+    )
 
     class Meta:
         model = Importer

apiserver/plane/app/serializers/inbox.py

@@ -3,7 +3,11 @@ from rest_framework import serializers
 
 # Module imports
 from .base import BaseSerializer
-from .issue import IssueFlatSerializer, LabelLiteSerializer
+from .issue import (
+    IssueInboxSerializer,
+    LabelLiteSerializer,
+    IssueDetailSerializer,
+)
 from .project import ProjectLiteSerializer
 from .state import StateLiteSerializer
 from .user import UserLiteSerializer
@@ -24,17 +28,62 @@ class InboxSerializer(BaseSerializer):
 
 
 class InboxIssueSerializer(BaseSerializer):
-    issue_detail = IssueFlatSerializer(source="issue", read_only=True)
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+    issue = IssueInboxSerializer(read_only=True)
 
     class Meta:
         model = InboxIssue
-        fields = "__all__"
+        fields = [
+            "id",
+            "status",
+            "duplicate_to",
+            "snoozed_till",
+            "source",
+            "issue",
+            "created_by",
+        ]
         read_only_fields = [
             "project",
             "workspace",
         ]
 
+    def to_representation(self, instance):
+        # Pass the annotated fields to the Issue instance if they exist
+        if hasattr(instance, "label_ids"):
+            instance.issue.label_ids = instance.label_ids
+        return super().to_representation(instance)
+
+
+class InboxIssueDetailSerializer(BaseSerializer):
+    issue = IssueDetailSerializer(read_only=True)
+    duplicate_issue_detail = IssueInboxSerializer(
+        read_only=True, source="duplicate_to"
+    )
+
+    class Meta:
+        model = InboxIssue
+        fields = [
+            "id",
+            "status",
+            "duplicate_to",
+            "snoozed_till",
+            "duplicate_issue_detail",
+            "source",
+            "issue",
+        ]
+        read_only_fields = [
+            "project",
+            "workspace",
+        ]
+
+    def to_representation(self, instance):
+        # Pass the annotated fields to the Issue instance if they exist
+        if hasattr(instance, "assignee_ids"):
+            instance.issue.assignee_ids = instance.assignee_ids
+        if hasattr(instance, "label_ids"):
+            instance.issue.label_ids = instance.label_ids
+
+        return super().to_representation(instance)
+
 
 class InboxIssueLiteSerializer(BaseSerializer):
     class Meta:
@@ -46,10 +95,13 @@ class InboxIssueLiteSerializer(BaseSerializer):
 class IssueStateInboxSerializer(BaseSerializer):
     state_detail = StateLiteSerializer(read_only=True, source="state")
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
-    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
+    label_details = LabelLiteSerializer(
+        read_only=True, source="labels", many=True
+    )
+    assignee_details = UserLiteSerializer(
+        read_only=True, source="assignees", many=True
+    )
     sub_issues_count = serializers.IntegerField(read_only=True)
-    bridge_id = serializers.UUIDField(read_only=True)
     issue_inbox = InboxIssueLiteSerializer(read_only=True, many=True)
 
     class Meta:

apiserver/plane/app/serializers/integration/__init__.py

@@ -1,8 +0,0 @@
-from .base import IntegrationSerializer, WorkspaceIntegrationSerializer
-from .github import (
-    GithubRepositorySerializer,
-    GithubRepositorySyncSerializer,
-    GithubIssueSyncSerializer,
-    GithubCommentSyncSerializer,
-)
-from .slack import SlackProjectSyncSerializer

apiserver/plane/app/serializers/integration/base.py

@@ -1,20 +0,0 @@
-# Module imports
-from plane.app.serializers import BaseSerializer
-from plane.db.models import Integration, WorkspaceIntegration
-
-
-class IntegrationSerializer(BaseSerializer):
-    class Meta:
-        model = Integration
-        fields = "__all__"
-        read_only_fields = [
-            "verified",
-        ]
-
-
-class WorkspaceIntegrationSerializer(BaseSerializer):
-    integration_detail = IntegrationSerializer(read_only=True, source="integration")
-
-    class Meta:
-        model = WorkspaceIntegration
-        fields = "__all__"

apiserver/plane/app/serializers/integration/github.py

@@ -1,45 +0,0 @@
-# Module imports
-from plane.app.serializers import BaseSerializer
-from plane.db.models import (
-    GithubIssueSync,
-    GithubRepository,
-    GithubRepositorySync,
-    GithubCommentSync,
-)
-
-
-class GithubRepositorySerializer(BaseSerializer):
-    class Meta:
-        model = GithubRepository
-        fields = "__all__"
-
-
-class GithubRepositorySyncSerializer(BaseSerializer):
-    repo_detail = GithubRepositorySerializer(source="repository")
-
-    class Meta:
-        model = GithubRepositorySync
-        fields = "__all__"
-
-
-class GithubIssueSyncSerializer(BaseSerializer):
-    class Meta:
-        model = GithubIssueSync
-        fields = "__all__"
-        read_only_fields = [
-            "project",
-            "workspace",
-            "repository_sync",
-        ]
-
-
-class GithubCommentSyncSerializer(BaseSerializer):
-    class Meta:
-        model = GithubCommentSync
-        fields = "__all__"
-        read_only_fields = [
-            "project",
-            "workspace",
-            "repository_sync",
-            "issue_sync",
-        ]

apiserver/plane/app/serializers/integration/slack.py

@@ -1,14 +0,0 @@
-# Module imports
-from plane.app.serializers import BaseSerializer
-from plane.db.models import SlackProjectSync
-
-
-class SlackProjectSyncSerializer(BaseSerializer):
-    class Meta:
-        model = SlackProjectSync
-        fields = "__all__"
-        read_only_fields = [
-            "project",
-            "workspace",
-            "workspace_integration",
-        ]

apiserver/plane/app/serializers/issue.py

@@ -1,5 +1,7 @@
 # Django imports
 from django.utils import timezone
+from django.core.validators import URLValidator
+from django.core.exceptions import ValidationError
 
 # Third Party imports
 from rest_framework import serializers
@@ -7,7 +9,7 @@ from rest_framework import serializers
 # Module imports
 from .base import BaseSerializer, DynamicBaseSerializer
 from .user import UserLiteSerializer
-from .state import StateSerializer, StateLiteSerializer
+from .state import StateLiteSerializer
 from .project import ProjectLiteSerializer
 from .workspace import WorkspaceLiteSerializer
 from plane.db.models import (
@@ -30,6 +32,7 @@ from plane.db.models import (
     CommentReaction,
     IssueVote,
     IssueRelation,
+    State,
 )
 
 
@@ -69,19 +72,26 @@ class IssueProjectLiteSerializer(BaseSerializer):
 ##TODO: Find a better way to write this serializer
 ## Find a better approach to save manytomany?
 class IssueCreateSerializer(BaseSerializer):
-    state_detail = StateSerializer(read_only=True, source="state")
-    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-
-    assignees = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
+    # ids
+    state_id = serializers.PrimaryKeyRelatedField(
+        source="state",
+        queryset=State.objects.all(),
+        required=False,
+        allow_null=True,
+    )
+    parent_id = serializers.PrimaryKeyRelatedField(
+        source="parent",
+        queryset=Issue.objects.all(),
+        required=False,
+        allow_null=True,
+    )
+    label_ids = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
         write_only=True,
         required=False,
     )
-
-    labels = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
+    assignee_ids = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
         write_only=True,
         required=False,
     )
@@ -100,8 +110,10 @@ class IssueCreateSerializer(BaseSerializer):
 
     def to_representation(self, instance):
         data = super().to_representation(instance)
-        data['assignees'] = [str(assignee.id) for assignee in instance.assignees.all()]
-        data['labels'] = [str(label.id) for label in instance.labels.all()]
+        assignee_ids = self.initial_data.get("assignee_ids")
+        data["assignee_ids"] = assignee_ids if assignee_ids else []
+        label_ids = self.initial_data.get("label_ids")
+        data["label_ids"] = label_ids if label_ids else []
         return data
 
     def validate(self, data):
@@ -110,12 +122,14 @@ class IssueCreateSerializer(BaseSerializer):
             and data.get("target_date", None) is not None
             and data.get("start_date", None) > data.get("target_date", None)
         ):
-            raise serializers.ValidationError("Start date cannot exceed target date")
+            raise serializers.ValidationError(
+                "Start date cannot exceed target date"
+            )
         return data
 
     def create(self, validated_data):
-        assignees = validated_data.pop("assignees", None)
-        labels = validated_data.pop("labels", None)
+        assignees = validated_data.pop("assignee_ids", None)
+        labels = validated_data.pop("label_ids", None)
 
         project_id = self.context["project_id"]
         workspace_id = self.context["workspace_id"]
@@ -173,8 +187,8 @@ class IssueCreateSerializer(BaseSerializer):
         return issue
 
     def update(self, instance, validated_data):
-        assignees = validated_data.pop("assignees", None)
-        labels = validated_data.pop("labels", None)
+        assignees = validated_data.pop("assignee_ids", None)
+        labels = validated_data.pop("label_ids", None)
 
         # Related models
         project_id = instance.project_id
@@ -225,14 +239,15 @@ class IssueActivitySerializer(BaseSerializer):
     actor_detail = UserLiteSerializer(read_only=True, source="actor")
     issue_detail = IssueFlatSerializer(read_only=True, source="issue")
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+    workspace_detail = WorkspaceLiteSerializer(
+        read_only=True, source="workspace"
+    )
 
     class Meta:
         model = IssueActivity
         fields = "__all__"
 
 
-
 class IssuePropertySerializer(BaseSerializer):
     class Meta:
         model = IssueProperty
@@ -245,12 +260,17 @@ class IssuePropertySerializer(BaseSerializer):
 
 
 class LabelSerializer(BaseSerializer):
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
-
     class Meta:
         model = Label
-        fields = "__all__"
+        fields = [
+            "parent",
+            "name",
+            "color",
+            "id",
+            "project_id",
+            "workspace_id",
+            "sort_order",
+        ]
         read_only_fields = [
             "workspace",
             "project",
@@ -268,7 +288,6 @@ class LabelLiteSerializer(BaseSerializer):
 
 
 class IssueLabelSerializer(BaseSerializer):
-
     class Meta:
         model = IssueLabel
         fields = "__all__"
@@ -279,33 +298,50 @@ class IssueLabelSerializer(BaseSerializer):
 
 
 class IssueRelationSerializer(BaseSerializer):
-    issue_detail = IssueProjectLiteSerializer(read_only=True, source="related_issue")
+    id = serializers.UUIDField(source="related_issue.id", read_only=True)
+    project_id = serializers.PrimaryKeyRelatedField(
+        source="related_issue.project_id", read_only=True
+    )
+    sequence_id = serializers.IntegerField(
+        source="related_issue.sequence_id", read_only=True
+    )
+    name = serializers.CharField(source="related_issue.name", read_only=True)
+    relation_type = serializers.CharField(read_only=True)
 
     class Meta:
         model = IssueRelation
         fields = [
-            "issue_detail",
+            "id",
+            "project_id",
+            "sequence_id",
             "relation_type",
-            "related_issue",
-            "issue",
-            "id"
+            "name",
         ]
         read_only_fields = [
             "workspace",
             "project",
         ]
 
+
 class RelatedIssueSerializer(BaseSerializer):
-    issue_detail = IssueProjectLiteSerializer(read_only=True, source="issue")
+    id = serializers.UUIDField(source="issue.id", read_only=True)
+    project_id = serializers.PrimaryKeyRelatedField(
+        source="issue.project_id", read_only=True
+    )
+    sequence_id = serializers.IntegerField(
+        source="issue.sequence_id", read_only=True
+    )
+    name = serializers.CharField(source="issue.name", read_only=True)
+    relation_type = serializers.CharField(read_only=True)
 
     class Meta:
         model = IssueRelation
         fields = [
-            "issue_detail",
+            "id",
+            "project_id",
+            "sequence_id",
             "relation_type",
-            "related_issue",
-            "issue",
-            "id"
+            "name",
         ]
         read_only_fields = [
             "workspace",
@@ -397,16 +433,57 @@ class IssueLinkSerializer(BaseSerializer):
             "issue",
         ]
 
+    def validate_url(self, value):
+        # Check URL format
+        validate_url = URLValidator()
+        try:
+            validate_url(value)
+        except ValidationError:
+            raise serializers.ValidationError("Invalid URL format.")
+
+        # Check URL scheme
+        if not value.startswith(('http://', 'https://')):
+            raise serializers.ValidationError("Invalid URL scheme.")
+
+        return value
+
     # Validation if url already exists
     def create(self, validated_data):
         if IssueLink.objects.filter(
-            url=validated_data.get("url"), issue_id=validated_data.get("issue_id")
+            url=validated_data.get("url"),
+            issue_id=validated_data.get("issue_id"),
         ).exists():
             raise serializers.ValidationError(
                 {"error": "URL already exists for this Issue"}
             )
         return IssueLink.objects.create(**validated_data)
 
+    def update(self, instance, validated_data):
+        if IssueLink.objects.filter(
+            url=validated_data.get("url"),
+            issue_id=instance.issue_id,
+        ).exists():
+            raise serializers.ValidationError(
+                {"error": "URL already exists for this Issue"}
+            )
+
+        return super().update(instance, validated_data)
+
+
+class IssueLinkLiteSerializer(BaseSerializer):
+    class Meta:
+        model = IssueLink
+        fields = [
+            "id",
+            "issue_id",
+            "title",
+            "url",
+            "metadata",
+            "created_by_id",
+            "created_at",
+        ]
+        read_only_fields = fields
+
 
 class IssueAttachmentSerializer(BaseSerializer):
     class Meta:
@@ -423,10 +500,23 @@ class IssueAttachmentSerializer(BaseSerializer):
         ]
 
 
+class IssueAttachmentLiteSerializer(DynamicBaseSerializer):
+    class Meta:
+        model = IssueAttachment
+        fields = [
+            "id",
+            "asset",
+            "attributes",
+            "issue_id",
+            "updated_at",
+            "updated_by_id",
+        ]
+        read_only_fields = fields
+
+
 class IssueReactionSerializer(BaseSerializer):
-    
     actor_detail = UserLiteSerializer(read_only=True, source="actor")
-    
+
     class Meta:
         model = IssueReaction
         fields = "__all__"
@@ -438,16 +528,14 @@ class IssueReactionSerializer(BaseSerializer):
         ]
 
 
-class CommentReactionLiteSerializer(BaseSerializer):
-    actor_detail = UserLiteSerializer(read_only=True, source="actor")
-
+class IssueReactionLiteSerializer(DynamicBaseSerializer):
     class Meta:
-        model = CommentReaction
+        model = IssueReaction
         fields = [
             "id",
+            "actor",
+            "issue",
             "reaction",
-            "comment",
-            "actor_detail",
         ]
 
 
@@ -459,12 +547,18 @@ class CommentReactionSerializer(BaseSerializer):
 
 
 class IssueVoteSerializer(BaseSerializer):
-
     actor_detail = UserLiteSerializer(read_only=True, source="actor")
 
     class Meta:
         model = IssueVote
-        fields = ["issue", "vote", "workspace", "project", "actor", "actor_detail"]
+        fields = [
+            "issue",
+            "vote",
+            "workspace",
+            "project",
+            "actor",
+            "actor_detail",
+        ]
         read_only_fields = fields
 
 
@@ -472,8 +566,10 @@ class IssueCommentSerializer(BaseSerializer):
     actor_detail = UserLiteSerializer(read_only=True, source="actor")
     issue_detail = IssueFlatSerializer(read_only=True, source="issue")
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-    comment_reactions = CommentReactionLiteSerializer(read_only=True, many=True)
+    workspace_detail = WorkspaceLiteSerializer(
+        read_only=True, source="workspace"
+    )
+    comment_reactions = CommentReactionSerializer(read_only=True, many=True)
     is_member = serializers.BooleanField(read_only=True)
 
     class Meta:
@@ -507,12 +603,15 @@ class IssueStateFlatSerializer(BaseSerializer):
 
 # Issue Serializer with state details
 class IssueStateSerializer(DynamicBaseSerializer):
-    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
+    label_details = LabelLiteSerializer(
+        read_only=True, source="labels", many=True
+    )
     state_detail = StateLiteSerializer(read_only=True, source="state")
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
+    assignee_details = UserLiteSerializer(
+        read_only=True, source="assignees", many=True
+    )
     sub_issues_count = serializers.IntegerField(read_only=True)
-    bridge_id = serializers.UUIDField(read_only=True)
     attachment_count = serializers.IntegerField(read_only=True)
     link_count = serializers.IntegerField(read_only=True)
 
@@ -521,67 +620,110 @@ class IssueStateSerializer(DynamicBaseSerializer):
         fields = "__all__"
 
 
-class IssueSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    state_detail = StateSerializer(read_only=True, source="state")
-    parent_detail = IssueStateFlatSerializer(read_only=True, source="parent")
-    label_details = LabelSerializer(read_only=True, source="labels", many=True)
-    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
-    related_issues = IssueRelationSerializer(read_only=True, source="issue_relation", many=True)
-    issue_relations = RelatedIssueSerializer(read_only=True, source="issue_related", many=True)
-    issue_cycle = IssueCycleDetailSerializer(read_only=True)
-    issue_module = IssueModuleDetailSerializer(read_only=True)
-    issue_link = IssueLinkSerializer(read_only=True, many=True)
-    issue_attachment = IssueAttachmentSerializer(read_only=True, many=True)
-    sub_issues_count = serializers.IntegerField(read_only=True)
-    issue_reactions = IssueReactionSerializer(read_only=True, many=True)
+class IssueInboxSerializer(DynamicBaseSerializer):
+    label_ids = serializers.ListField(
+        child=serializers.UUIDField(),
+        required=False,
+    )
 
     class Meta:
         model = Issue
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
+        fields = [
+            "id",
+            "name",
+            "priority",
+            "sequence_id",
+            "project_id",
+            "created_at",
+            "label_ids",
+        ]
+        read_only_fields = fields
+
+
+class IssueSerializer(DynamicBaseSerializer):
+    # ids
+    cycle_id = serializers.PrimaryKeyRelatedField(read_only=True)
+    module_ids = serializers.ListField(
+        child=serializers.UUIDField(),
+        required=False,
+    )
+
+    # Many to many
+    label_ids = serializers.ListField(
+        child=serializers.UUIDField(),
+        required=False,
+    )
+    assignee_ids = serializers.ListField(
+        child=serializers.UUIDField(),
+        required=False,
+    )
+
+    # Count items
+    sub_issues_count = serializers.IntegerField(read_only=True)
+    attachment_count = serializers.IntegerField(read_only=True)
+    link_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = Issue
+        fields = [
+            "id",
+            "name",
+            "state_id",
+            "sort_order",
+            "completed_at",
+            "estimate_point",
+            "priority",
+            "start_date",
+            "target_date",
+            "sequence_id",
+            "project_id",
+            "parent_id",
+            "cycle_id",
+            "module_ids",
+            "label_ids",
+            "assignee_ids",
+            "sub_issues_count",
             "created_at",
             "updated_at",
+            "created_by",
+            "updated_by",
+            "attachment_count",
+            "link_count",
+            "is_draft",
+            "archived_at",
         ]
+        read_only_fields = fields
 
 
 class IssueLiteSerializer(DynamicBaseSerializer):
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    state_detail = StateLiteSerializer(read_only=True, source="state")
-    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
-    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
-    sub_issues_count = serializers.IntegerField(read_only=True)
-    cycle_id = serializers.UUIDField(read_only=True)
-    module_id = serializers.UUIDField(read_only=True)
-    attachment_count = serializers.IntegerField(read_only=True)
-    link_count = serializers.IntegerField(read_only=True)
-    issue_reactions = IssueReactionSerializer(read_only=True, many=True)
-
     class Meta:
         model = Issue
-        fields = "__all__"
-        read_only_fields = [
-            "start_date",
-            "target_date",
-            "completed_at",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
+        fields = [
+            "id",
+            "sequence_id",
+            "project_id",
         ]
+        read_only_fields = fields
+
+
+class IssueDetailSerializer(IssueSerializer):
+    description_html = serializers.CharField()
+    is_subscribed = serializers.BooleanField(read_only=True)
+
+    class Meta(IssueSerializer.Meta):
+        fields = IssueSerializer.Meta.fields + [
+            "description_html",
+            "is_subscribed",
+        ]
+        read_only_fields = fields
 
 
 class IssuePublicSerializer(BaseSerializer):
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
     state_detail = StateLiteSerializer(read_only=True, source="state")
-    reactions = IssueReactionSerializer(read_only=True, many=True, source="issue_reactions")
+    reactions = IssueReactionSerializer(
+        read_only=True, many=True, source="issue_reactions"
+    )
     votes = IssueVoteSerializer(read_only=True, many=True)
 
     class Meta:
@@ -604,7 +746,6 @@ class IssuePublicSerializer(BaseSerializer):
         read_only_fields = fields
 
 
-
 class IssueSubscriberSerializer(BaseSerializer):
     class Meta:
         model = IssueSubscriber

apiserver/plane/app/serializers/module.py

@@ -2,10 +2,8 @@
 from rest_framework import serializers
 
 # Module imports
-from .base import BaseSerializer
-from .user import UserLiteSerializer
+from .base import BaseSerializer, DynamicBaseSerializer
 from .project import ProjectLiteSerializer
-from .workspace import WorkspaceLiteSerializer
 
 from plane.db.models import (
     User,
@@ -14,19 +12,23 @@ from plane.db.models import (
     ModuleIssue,
     ModuleLink,
     ModuleFavorite,
+    ModuleUserProperties,
 )
 
 
 class ModuleWriteSerializer(BaseSerializer):
-    members = serializers.ListField(
+    lead_id = serializers.PrimaryKeyRelatedField(
+        source="lead",
+        queryset=User.objects.all(),
+        required=False,
+        allow_null=True,
+    )
+    member_ids = serializers.ListField(
         child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
         write_only=True,
         required=False,
     )
 
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
-
     class Meta:
         model = Module
         fields = "__all__"
@@ -37,25 +39,32 @@ class ModuleWriteSerializer(BaseSerializer):
             "updated_by",
             "created_at",
             "updated_at",
+            "archived_at",
         ]
-    
+
     def to_representation(self, instance):
         data = super().to_representation(instance)
-        data['members'] = [str(member.id) for member in instance.members.all()]
+        data["member_ids"] = [
+            str(member.id) for member in instance.members.all()
+        ]
         return data
 
     def validate(self, data):
-        if data.get("start_date", None) is not None and data.get("target_date", None) is not None and data.get("start_date", None) > data.get("target_date", None):
-            raise serializers.ValidationError("Start date cannot exceed target date")
-        return data    
+        if (
+            data.get("start_date", None) is not None
+            and data.get("target_date", None) is not None
+            and data.get("start_date", None) > data.get("target_date", None)
+        ):
+            raise serializers.ValidationError(
+                "Start date cannot exceed target date"
+            )
+        return data
 
     def create(self, validated_data):
-        members = validated_data.pop("members", None)
-
+        members = validated_data.pop("member_ids", None)
         project = self.context["project"]
 
         module = Module.objects.create(**validated_data, project=project)
-
         if members is not None:
             ModuleMember.objects.bulk_create(
                 [
@@ -76,7 +85,7 @@ class ModuleWriteSerializer(BaseSerializer):
         return module
 
     def update(self, instance, validated_data):
-        members = validated_data.pop("members", None)
+        members = validated_data.pop("member_ids", None)
 
         if members is not None:
             ModuleMember.objects.filter(module=instance).delete()
@@ -133,8 +142,6 @@ class ModuleIssueSerializer(BaseSerializer):
 
 
 class ModuleLinkSerializer(BaseSerializer):
-    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
-
     class Meta:
         model = ModuleLink
         fields = "__all__"
@@ -151,7 +158,8 @@ class ModuleLinkSerializer(BaseSerializer):
     # Validation if url already exists
     def create(self, validated_data):
         if ModuleLink.objects.filter(
-            url=validated_data.get("url"), module_id=validated_data.get("module_id")
+            url=validated_data.get("url"),
+            module_id=validated_data.get("module_id"),
         ).exists():
             raise serializers.ValidationError(
                 {"error": "URL already exists for this Issue"}
@@ -159,11 +167,10 @@ class ModuleLinkSerializer(BaseSerializer):
         return ModuleLink.objects.create(**validated_data)
 
 
-class ModuleSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    lead_detail = UserLiteSerializer(read_only=True, source="lead")
-    members_detail = UserLiteSerializer(read_only=True, many=True, source="members")
-    link_module = ModuleLinkSerializer(read_only=True, many=True)
+class ModuleSerializer(DynamicBaseSerializer):
+    member_ids = serializers.ListField(
+        child=serializers.UUIDField(), required=False, allow_null=True
+    )
     is_favorite = serializers.BooleanField(read_only=True)
     total_issues = serializers.IntegerField(read_only=True)
     cancelled_issues = serializers.IntegerField(read_only=True)
@@ -174,15 +181,45 @@ class ModuleSerializer(BaseSerializer):
 
     class Meta:
         model = Module
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
+        fields = [
+            # Required fields
+            "id",
+            "workspace_id",
+            "project_id",
+            # Model fields
+            "name",
+            "description",
+            "description_text",
+            "description_html",
+            "start_date",
+            "target_date",
+            "status",
+            "lead_id",
+            "member_ids",
+            "view_props",
+            "sort_order",
+            "external_source",
+            "external_id",
+            # computed fields
+            "is_favorite",
+            "total_issues",
+            "cancelled_issues",
+            "completed_issues",
+            "started_issues",
+            "unstarted_issues",
+            "backlog_issues",
             "created_at",
             "updated_at",
         ]
+        read_only_fields = fields
+
+
+class ModuleDetailSerializer(ModuleSerializer):
+    link_module = ModuleLinkSerializer(read_only=True, many=True)
+    sub_issues = serializers.IntegerField(read_only=True)
+
+    class Meta(ModuleSerializer.Meta):
+        fields = ModuleSerializer.Meta.fields + ["link_module", "sub_issues"]
 
 
 class ModuleFavoriteSerializer(BaseSerializer):
@@ -196,3 +233,10 @@ class ModuleFavoriteSerializer(BaseSerializer):
             "project",
             "user",
         ]
+
+
+class ModuleUserPropertiesSerializer(BaseSerializer):
+    class Meta:
+        model = ModuleUserProperties
+        fields = "__all__"
+        read_only_fields = ["workspace", "project", "module", "user"]

apiserver/plane/app/serializers/notification.py

@@ -1,12 +1,20 @@
 # Module imports
 from .base import BaseSerializer
 from .user import UserLiteSerializer
-from plane.db.models import Notification
+from plane.db.models import Notification, UserNotificationPreference
+
 
 class NotificationSerializer(BaseSerializer):
-    triggered_by_details = UserLiteSerializer(read_only=True, source="triggered_by")
+    triggered_by_details = UserLiteSerializer(
+        read_only=True, source="triggered_by"
+    )
 
     class Meta:
         model = Notification
         fields = "__all__"
 
+
+class UserNotificationPreferenceSerializer(BaseSerializer):
+    class Meta:
+        model = UserNotificationPreference
+        fields = "__all__"

apiserver/plane/app/serializers/page.py

@@ -3,22 +3,32 @@ from rest_framework import serializers
 
 # Module imports
 from .base import BaseSerializer
-from .issue import IssueFlatSerializer, LabelLiteSerializer
+from .issue import LabelLiteSerializer
 from .workspace import WorkspaceLiteSerializer
 from .project import ProjectLiteSerializer
-from plane.db.models import Page, PageLog, PageFavorite, PageLabel, Label, Issue, Module
+from plane.db.models import (
+    Page,
+    PageLog,
+    PageFavorite,
+    PageLabel,
+    Label,
+)
 
 
 class PageSerializer(BaseSerializer):
     is_favorite = serializers.BooleanField(read_only=True)
-    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
+    label_details = LabelLiteSerializer(
+        read_only=True, source="labels", many=True
+    )
     labels = serializers.ListField(
         child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
         write_only=True,
         required=False,
     )
     project_detail = ProjectLiteSerializer(source="project", read_only=True)
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+    workspace_detail = WorkspaceLiteSerializer(
+        source="workspace", read_only=True
+    )
 
     class Meta:
         model = Page
@@ -28,9 +38,10 @@ class PageSerializer(BaseSerializer):
             "project",
             "owned_by",
         ]
+
     def to_representation(self, instance):
         data = super().to_representation(instance)
-        data['labels'] = [str(label.id) for label in instance.labels.all()]
+        data["labels"] = [str(label.id) for label in instance.labels.all()]
         return data
 
     def create(self, validated_data):
@@ -94,7 +105,7 @@ class SubPageSerializer(BaseSerializer):
 
     def get_entity_details(self, obj):
         entity_name = obj.entity_name
-        if entity_name == 'forward_link' or entity_name == 'back_link':
+        if entity_name == "forward_link" or entity_name == "back_link":
             try:
                 page = Page.objects.get(pk=obj.entity_identifier)
                 return PageSerializer(page).data
@@ -104,7 +115,6 @@ class SubPageSerializer(BaseSerializer):
 
 
 class PageLogSerializer(BaseSerializer):
-
     class Meta:
         model = PageLog
         fields = "__all__"

apiserver/plane/app/serializers/project.py

@@ -4,7 +4,10 @@ from rest_framework import serializers
 # Module imports
 from .base import BaseSerializer, DynamicBaseSerializer
 from plane.app.serializers.workspace import WorkspaceLiteSerializer
-from plane.app.serializers.user import UserLiteSerializer, UserAdminLiteSerializer
+from plane.app.serializers.user import (
+    UserLiteSerializer,
+    UserAdminLiteSerializer,
+)
 from plane.db.models import (
     Project,
     ProjectMember,
@@ -17,7 +20,9 @@ from plane.db.models import (
 
 
 class ProjectSerializer(BaseSerializer):
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+    workspace_detail = WorkspaceLiteSerializer(
+        source="workspace", read_only=True
+    )
 
     class Meta:
         model = Project
@@ -29,12 +34,16 @@ class ProjectSerializer(BaseSerializer):
     def create(self, validated_data):
         identifier = validated_data.get("identifier", "").strip().upper()
         if identifier == "":
-            raise serializers.ValidationError(detail="Project Identifier is required")
+            raise serializers.ValidationError(
+                detail="Project Identifier is required"
+            )
 
         if ProjectIdentifier.objects.filter(
             name=identifier, workspace_id=self.context["workspace_id"]
         ).exists():
-            raise serializers.ValidationError(detail="Project Identifier is taken")
+            raise serializers.ValidationError(
+                detail="Project Identifier is taken"
+            )
         project = Project.objects.create(
             **validated_data, workspace_id=self.context["workspace_id"]
         )
@@ -73,7 +82,9 @@ class ProjectSerializer(BaseSerializer):
             return project
 
         # If not same fail update
-        raise serializers.ValidationError(detail="Project Identifier is already taken")
+        raise serializers.ValidationError(
+            detail="Project Identifier is already taken"
+        )
 
 
 class ProjectLiteSerializer(BaseSerializer):
@@ -84,14 +95,19 @@ class ProjectLiteSerializer(BaseSerializer):
             "identifier",
             "name",
             "cover_image",
-            "icon_prop",
-            "emoji",
+            "logo_props",
             "description",
         ]
         read_only_fields = fields
 
 
 class ProjectListSerializer(DynamicBaseSerializer):
+    total_issues = serializers.IntegerField(read_only=True)
+    archived_issues = serializers.IntegerField(read_only=True)
+    archived_sub_issues = serializers.IntegerField(read_only=True)
+    draft_issues = serializers.IntegerField(read_only=True)
+    draft_sub_issues = serializers.IntegerField(read_only=True)
+    sub_issues = serializers.IntegerField(read_only=True)
     is_favorite = serializers.BooleanField(read_only=True)
     total_members = serializers.IntegerField(read_only=True)
     total_cycles = serializers.IntegerField(read_only=True)
@@ -160,6 +176,12 @@ class ProjectMemberAdminSerializer(BaseSerializer):
         fields = "__all__"
 
 
+class ProjectMemberRoleSerializer(DynamicBaseSerializer):
+    class Meta:
+        model = ProjectMember
+        fields = ("id", "role", "member", "project")
+
+
 class ProjectMemberInviteSerializer(BaseSerializer):
     project = ProjectLiteSerializer(read_only=True)
     workspace = WorkspaceLiteSerializer(read_only=True)
@@ -197,7 +219,9 @@ class ProjectMemberLiteSerializer(BaseSerializer):
 
 class ProjectDeployBoardSerializer(BaseSerializer):
     project_details = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+    workspace_detail = WorkspaceLiteSerializer(
+        read_only=True, source="workspace"
+    )
 
     class Meta:
         model = ProjectDeployBoard
@@ -217,4 +241,4 @@ class ProjectPublicMemberSerializer(BaseSerializer):
             "workspace",
             "project",
             "member",
-        ]
+        ]

apiserver/plane/app/serializers/state.py

@@ -6,10 +6,19 @@ from plane.db.models import State
 
 
 class StateSerializer(BaseSerializer):
-
     class Meta:
         model = State
-        fields = "__all__"
+        fields = [
+            "id",
+            "project_id",
+            "workspace_id",
+            "name",
+            "color",
+            "group",
+            "default",
+            "description",
+            "sequence",
+        ]
         read_only_fields = [
             "workspace",
             "project",
@@ -25,4 +34,4 @@ class StateLiteSerializer(BaseSerializer):
             "color",
             "group",
         ]
-        read_only_fields = fields
+        read_only_fields = fields

apiserver/plane/app/serializers/user.py

@@ -4,7 +4,6 @@ from rest_framework import serializers
 # Module import
 from .base import BaseSerializer
 from plane.db.models import User, Workspace, WorkspaceMemberInvite
-from plane.license.models import InstanceAdmin, Instance
 
 
 class UserSerializer(BaseSerializer):
@@ -99,17 +98,20 @@ class UserMeSettingsSerializer(BaseSerializer):
             ).first()
             return {
                 "last_workspace_id": obj.last_workspace_id,
-                "last_workspace_slug": workspace.slug if workspace is not None else "",
+                "last_workspace_slug": (
+                    workspace.slug if workspace is not None else ""
+                ),
                 "fallback_workspace_id": obj.last_workspace_id,
-                "fallback_workspace_slug": workspace.slug
-                if workspace is not None
-                else "",
+                "fallback_workspace_slug": (
+                    workspace.slug if workspace is not None else ""
+                ),
                 "invites": workspace_invites,
             }
         else:
             fallback_workspace = (
                 Workspace.objects.filter(
-                    workspace_member__member_id=obj.id, workspace_member__is_active=True
+                    workspace_member__member_id=obj.id,
+                    workspace_member__is_active=True,
                 )
                 .order_by("created_at")
                 .first()
@@ -117,12 +119,16 @@ class UserMeSettingsSerializer(BaseSerializer):
             return {
                 "last_workspace_id": None,
                 "last_workspace_slug": None,
-                "fallback_workspace_id": fallback_workspace.id
-                if fallback_workspace is not None
-                else None,
-                "fallback_workspace_slug": fallback_workspace.slug
-                if fallback_workspace is not None
-                else None,
+                "fallback_workspace_id": (
+                    fallback_workspace.id
+                    if fallback_workspace is not None
+                    else None
+                ),
+                "fallback_workspace_slug": (
+                    fallback_workspace.slug
+                    if fallback_workspace is not None
+                    else None
+                ),
                 "invites": workspace_invites,
             }
 
@@ -180,7 +186,9 @@ class ChangePasswordSerializer(serializers.Serializer):
 
         if data.get("new_password") != data.get("confirm_password"):
             raise serializers.ValidationError(
-                {"error": "Confirm password should be same as the new password."}
+                {
+                    "error": "Confirm password should be same as the new password."
+                }
             )
 
         return data
@@ -190,4 +198,5 @@ class ResetPasswordSerializer(serializers.Serializer):
     """
     Serializer for password change endpoint.
     """
+
     new_password = serializers.CharField(required=True, min_length=8)

apiserver/plane/app/serializers/view.py

@@ -2,7 +2,7 @@
 from rest_framework import serializers
 
 # Module imports
-from .base import BaseSerializer
+from .base import BaseSerializer, DynamicBaseSerializer
 from .workspace import WorkspaceLiteSerializer
 from .project import ProjectLiteSerializer
 from plane.db.models import GlobalView, IssueView, IssueViewFavorite
@@ -10,7 +10,9 @@ from plane.utils.issue_filters import issue_filters
 
 
 class GlobalViewSerializer(BaseSerializer):
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+    workspace_detail = WorkspaceLiteSerializer(
+        source="workspace", read_only=True
+    )
 
     class Meta:
         model = GlobalView
@@ -38,10 +40,12 @@ class GlobalViewSerializer(BaseSerializer):
         return super().update(instance, validated_data)
 
 
-class IssueViewSerializer(BaseSerializer):
+class IssueViewSerializer(DynamicBaseSerializer):
     is_favorite = serializers.BooleanField(read_only=True)
     project_detail = ProjectLiteSerializer(source="project", read_only=True)
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+    workspace_detail = WorkspaceLiteSerializer(
+        source="workspace", read_only=True
+    )
 
     class Meta:
         model = IssueView

apiserver/plane/app/serializers/webhook.py

@@ -1,5 +1,4 @@
 # Python imports
-import urllib
 import socket
 import ipaddress
 from urllib.parse import urlparse
@@ -10,78 +9,113 @@ from rest_framework import serializers
 # Module imports
 from .base import DynamicBaseSerializer
 from plane.db.models import Webhook, WebhookLog
-from plane.db.models.webhook import validate_domain, validate_schema 
+from plane.db.models.webhook import validate_domain, validate_schema
+
 
 class WebhookSerializer(DynamicBaseSerializer):
     url = serializers.URLField(validators=[validate_schema, validate_domain])
-    
+
     def create(self, validated_data):
         url = validated_data.get("url", None)
 
         # Extract the hostname from the URL
         hostname = urlparse(url).hostname
         if not hostname:
-            raise serializers.ValidationError({"url": "Invalid URL: No hostname found."})
+            raise serializers.ValidationError(
+                {"url": "Invalid URL: No hostname found."}
+            )
 
         # Resolve the hostname to IP addresses
         try:
             ip_addresses = socket.getaddrinfo(hostname, None)
         except socket.gaierror:
-            raise serializers.ValidationError({"url": "Hostname could not be resolved."})
+            raise serializers.ValidationError(
+                {"url": "Hostname could not be resolved."}
+            )
 
         if not ip_addresses:
-            raise serializers.ValidationError({"url": "No IP addresses found for the hostname."})
+            raise serializers.ValidationError(
+                {"url": "No IP addresses found for the hostname."}
+            )
 
         for addr in ip_addresses:
             ip = ipaddress.ip_address(addr[4][0])
             if ip.is_private or ip.is_loopback:
-                raise serializers.ValidationError({"url": "URL resolves to a blocked IP address."})
+                raise serializers.ValidationError(
+                    {"url": "URL resolves to a blocked IP address."}
+                )
 
         # Additional validation for multiple request domains and their subdomains
-        request = self.context.get('request')
-        disallowed_domains = ['plane.so',]  # Add your disallowed domains here
+        request = self.context.get("request")
+        disallowed_domains = [
+            "plane.so",
+        ]  # Add your disallowed domains here
         if request:
-            request_host = request.get_host().split(':')[0]  # Remove port if present
+            request_host = request.get_host().split(":")[
+                0
+            ]  # Remove port if present
             disallowed_domains.append(request_host)
 
         # Check if hostname is a subdomain or exact match of any disallowed domain
-        if any(hostname == domain or hostname.endswith('.' + domain) for domain in disallowed_domains):
-            raise serializers.ValidationError({"url": "URL domain or its subdomain is not allowed."})
+        if any(
+            hostname == domain or hostname.endswith("." + domain)
+            for domain in disallowed_domains
+        ):
+            raise serializers.ValidationError(
+                {"url": "URL domain or its subdomain is not allowed."}
+            )
 
         return Webhook.objects.create(**validated_data)
-    
+
     def update(self, instance, validated_data):
         url = validated_data.get("url", None)
         if url:
             # Extract the hostname from the URL
             hostname = urlparse(url).hostname
             if not hostname:
-                raise serializers.ValidationError({"url": "Invalid URL: No hostname found."})
+                raise serializers.ValidationError(
+                    {"url": "Invalid URL: No hostname found."}
+                )
 
             # Resolve the hostname to IP addresses
             try:
                 ip_addresses = socket.getaddrinfo(hostname, None)
             except socket.gaierror:
-                raise serializers.ValidationError({"url": "Hostname could not be resolved."})
+                raise serializers.ValidationError(
+                    {"url": "Hostname could not be resolved."}
+                )
 
             if not ip_addresses:
-                raise serializers.ValidationError({"url": "No IP addresses found for the hostname."})
+                raise serializers.ValidationError(
+                    {"url": "No IP addresses found for the hostname."}
+                )
 
             for addr in ip_addresses:
                 ip = ipaddress.ip_address(addr[4][0])
                 if ip.is_private or ip.is_loopback:
-                    raise serializers.ValidationError({"url": "URL resolves to a blocked IP address."})
+                    raise serializers.ValidationError(
+                        {"url": "URL resolves to a blocked IP address."}
+                    )
 
             # Additional validation for multiple request domains and their subdomains
-            request = self.context.get('request')
-            disallowed_domains = ['plane.so',]  # Add your disallowed domains here
+            request = self.context.get("request")
+            disallowed_domains = [
+                "plane.so",
+            ]  # Add your disallowed domains here
             if request:
-                request_host = request.get_host().split(':')[0]  # Remove port if present
+                request_host = request.get_host().split(":")[
+                    0
+                ]  # Remove port if present
                 disallowed_domains.append(request_host)
 
             # Check if hostname is a subdomain or exact match of any disallowed domain
-            if any(hostname == domain or hostname.endswith('.' + domain) for domain in disallowed_domains):
-                raise serializers.ValidationError({"url": "URL domain or its subdomain is not allowed."})
+            if any(
+                hostname == domain or hostname.endswith("." + domain)
+                for domain in disallowed_domains
+            ):
+                raise serializers.ValidationError(
+                    {"url": "URL domain or its subdomain is not allowed."}
+                )
 
         return super().update(instance, validated_data)
 
@@ -95,12 +129,7 @@ class WebhookSerializer(DynamicBaseSerializer):
 
 
 class WebhookLogSerializer(DynamicBaseSerializer):
-
     class Meta:
         model = WebhookLog
         fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "webhook"
-        ]
-
+        read_only_fields = ["workspace", "webhook"]

apiserver/plane/app/serializers/workspace.py

@@ -2,7 +2,7 @@
 from rest_framework import serializers
 
 # Module imports
-from .base import BaseSerializer
+from .base import BaseSerializer, DynamicBaseSerializer
 from .user import UserLiteSerializer, UserAdminLiteSerializer
 
 from plane.db.models import (
@@ -13,10 +13,11 @@ from plane.db.models import (
     TeamMember,
     WorkspaceMemberInvite,
     WorkspaceTheme,
+    WorkspaceUserProperties,
 )
 
 
-class WorkSpaceSerializer(BaseSerializer):
+class WorkSpaceSerializer(DynamicBaseSerializer):
     owner = UserLiteSerializer(read_only=True)
     total_members = serializers.IntegerField(read_only=True)
     total_issues = serializers.IntegerField(read_only=True)
@@ -50,6 +51,7 @@ class WorkSpaceSerializer(BaseSerializer):
             "owner",
         ]
 
+
 class WorkspaceLiteSerializer(BaseSerializer):
     class Meta:
         model = Workspace
@@ -61,8 +63,7 @@ class WorkspaceLiteSerializer(BaseSerializer):
         read_only_fields = fields
 
 
-
-class WorkSpaceMemberSerializer(BaseSerializer):
+class WorkSpaceMemberSerializer(DynamicBaseSerializer):
     member = UserLiteSerializer(read_only=True)
     workspace = WorkspaceLiteSerializer(read_only=True)
 
@@ -72,13 +73,12 @@ class WorkSpaceMemberSerializer(BaseSerializer):
 
 
 class WorkspaceMemberMeSerializer(BaseSerializer):
-
     class Meta:
         model = WorkspaceMember
         fields = "__all__"
 
 
-class WorkspaceMemberAdminSerializer(BaseSerializer):
+class WorkspaceMemberAdminSerializer(DynamicBaseSerializer):
     member = UserAdminLiteSerializer(read_only=True)
     workspace = WorkspaceLiteSerializer(read_only=True)
 
@@ -108,7 +108,9 @@ class WorkSpaceMemberInviteSerializer(BaseSerializer):
 
 
 class TeamSerializer(BaseSerializer):
-    members_detail = UserLiteSerializer(read_only=True, source="members", many=True)
+    members_detail = UserLiteSerializer(
+        read_only=True, source="members", many=True
+    )
     members = serializers.ListField(
         child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
         write_only=True,
@@ -145,7 +147,9 @@ class TeamSerializer(BaseSerializer):
             members = validated_data.pop("members")
             TeamMember.objects.filter(team=instance).delete()
             team_members = [
-                TeamMember(member=member, team=instance, workspace=instance.workspace)
+                TeamMember(
+                    member=member, team=instance, workspace=instance.workspace
+                )
                 for member in members
             ]
             TeamMember.objects.bulk_create(team_members, batch_size=10)
@@ -161,3 +165,13 @@ class WorkspaceThemeSerializer(BaseSerializer):
             "workspace",
             "actor",
         ]
+
+
+class WorkspaceUserPropertiesSerializer(BaseSerializer):
+    class Meta:
+        model = WorkspaceUserProperties
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "user",
+        ]

apiserver/plane/app/urls/__init__.py

@@ -3,11 +3,10 @@ from .asset import urlpatterns as asset_urls
 from .authentication import urlpatterns as authentication_urls
 from .config import urlpatterns as configuration_urls
 from .cycle import urlpatterns as cycle_urls
+from .dashboard import urlpatterns as dashboard_urls
 from .estimate import urlpatterns as estimate_urls
 from .external import urlpatterns as external_urls
-from .importer import urlpatterns as importer_urls
 from .inbox import urlpatterns as inbox_urls
-from .integration import urlpatterns as integration_urls
 from .issue import urlpatterns as issue_urls
 from .module import urlpatterns as module_urls
 from .notification import urlpatterns as notification_urls
@@ -28,11 +27,10 @@ urlpatterns = [
     *authentication_urls,
     *configuration_urls,
     *cycle_urls,
+    *dashboard_urls,
     *estimate_urls,
     *external_urls,
-    *importer_urls,
     *inbox_urls,
-    *integration_urls,
     *issue_urls,
     *module_urls,
     *notification_urls,
@@ -45,4 +43,4 @@ urlpatterns = [
     *workspace_urls,
     *api_urls,
     *webhook_urls,
-]
+]

apiserver/plane/app/urls/authentication.py

@@ -31,8 +31,14 @@ urlpatterns = [
     path("sign-in/", SignInEndpoint.as_view(), name="sign-in"),
     path("sign-out/", SignOutEndpoint.as_view(), name="sign-out"),
     # magic sign in
-    path("magic-generate/", MagicGenerateEndpoint.as_view(), name="magic-generate"),
-    path("magic-sign-in/", MagicSignInEndpoint.as_view(), name="magic-sign-in"),
+    path(
+        "magic-generate/",
+        MagicGenerateEndpoint.as_view(),
+        name="magic-generate",
+    ),
+    path(
+        "magic-sign-in/", MagicSignInEndpoint.as_view(), name="magic-sign-in"
+    ),
     path("token/refresh/", TokenRefreshView.as_view(), name="token_refresh"),
     # Password Manipulation
     path(
@@ -52,6 +58,8 @@ urlpatterns = [
     ),
     # API Tokens
     path("api-tokens/", ApiTokenEndpoint.as_view(), name="api-tokens"),
-    path("api-tokens/<uuid:pk>/", ApiTokenEndpoint.as_view(), name="api-tokens"),
+    path(
+        "api-tokens/<uuid:pk>/", ApiTokenEndpoint.as_view(), name="api-tokens"
+    ),
     ## End API Tokens
 ]

apiserver/plane/app/urls/config.py

@@ -1,7 +1,7 @@
 from django.urls import path
 
 
-from plane.app.views import ConfigurationEndpoint
+from plane.app.views import ConfigurationEndpoint, MobileConfigurationEndpoint
 
 urlpatterns = [
     path(
@@ -9,4 +9,9 @@ urlpatterns = [
         ConfigurationEndpoint.as_view(),
         name="configuration",
     ),
-]
+    path(
+        "mobile-configs/",
+        MobileConfigurationEndpoint.as_view(),
+        name="configuration",
+    ),
+]

apiserver/plane/app/urls/cycle.py

@@ -7,6 +7,8 @@ from plane.app.views import (
     CycleDateCheckEndpoint,
     CycleFavoriteViewSet,
     TransferCycleIssueEndpoint,
+    CycleUserPropertiesEndpoint,
+    CycleArchiveUnarchiveEndpoint,
 )
 
 
@@ -44,7 +46,7 @@ urlpatterns = [
         name="project-issue-cycle",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:issue_id>/",
         CycleIssueViewSet.as_view(
             {
                 "get": "retrieve",
@@ -84,4 +86,19 @@ urlpatterns = [
         TransferCycleIssueEndpoint.as_view(),
         name="transfer-issues",
     ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/user-properties/",
+        CycleUserPropertiesEndpoint.as_view(),
+        name="cycle-user-filters",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/archive/",
+        CycleArchiveUnarchiveEndpoint.as_view(),
+        name="cycle-archive-unarchive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-cycles/",
+        CycleArchiveUnarchiveEndpoint.as_view(),
+        name="cycle-archive-unarchive",
+    ),
 ]

apiserver/plane/app/urls/dashboard.py

@@ -0,0 +1,23 @@
+from django.urls import path
+
+
+from plane.app.views import DashboardEndpoint, WidgetsEndpoint
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/dashboard/",
+        DashboardEndpoint.as_view(),
+        name="dashboard",
+    ),
+    path(
+        "workspaces/<str:slug>/dashboard/<uuid:dashboard_id>/",
+        DashboardEndpoint.as_view(),
+        name="dashboard",
+    ),
+    path(
+        "dashboard/<uuid:dashboard_id>/widgets/<uuid:widget_id>/",
+        WidgetsEndpoint.as_view(),
+        name="widgets",
+    ),
+]

apiserver/plane/app/urls/external.py

@@ -2,7 +2,6 @@ from django.urls import path
 
 
 from plane.app.views import UnsplashEndpoint
-from plane.app.views import ReleaseNotesEndpoint
 from plane.app.views import GPTIntegrationEndpoint
 
 
@@ -12,11 +11,6 @@ urlpatterns = [
         UnsplashEndpoint.as_view(),
         name="unsplash",
     ),
-    path(
-        "release-notes/",
-        ReleaseNotesEndpoint.as_view(),
-        name="release-notes",
-    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/ai-assistant/",
         GPTIntegrationEndpoint.as_view(),

apiserver/plane/app/urls/importer.py

@@ -1,37 +0,0 @@
-from django.urls import path
-
-
-from plane.app.views import (
-    ServiceIssueImportSummaryEndpoint,
-    ImportServiceEndpoint,
-    UpdateServiceImportStatusEndpoint,
-)
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/importers/<str:service>/",
-        ServiceIssueImportSummaryEndpoint.as_view(),
-        name="importer-summary",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/importers/<str:service>/",
-        ImportServiceEndpoint.as_view(),
-        name="importer",
-    ),
-    path(
-        "workspaces/<str:slug>/importers/",
-        ImportServiceEndpoint.as_view(),
-        name="importer",
-    ),
-    path(
-        "workspaces/<str:slug>/importers/<str:service>/<uuid:pk>/",
-        ImportServiceEndpoint.as_view(),
-        name="importer",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/service/<str:service>/importers/<uuid:importer_id>/",
-        UpdateServiceImportStatusEndpoint.as_view(),
-        name="importer-status",
-    ),
-]

apiserver/plane/app/urls/inbox.py

@@ -30,7 +30,7 @@ urlpatterns = [
         name="inbox",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
         InboxIssueViewSet.as_view(
             {
                 "get": "list",
@@ -40,7 +40,7 @@ urlpatterns = [
         name="inbox-issue",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:issue_id>/",
         InboxIssueViewSet.as_view(
             {
                 "get": "retrieve",

apiserver/plane/app/urls/integration.py

@@ -1,150 +0,0 @@
-from django.urls import path
-
-
-from plane.app.views import (
-    IntegrationViewSet,
-    WorkspaceIntegrationViewSet,
-    GithubRepositoriesEndpoint,
-    GithubRepositorySyncViewSet,
-    GithubIssueSyncViewSet,
-    GithubCommentSyncViewSet,
-    BulkCreateGithubIssueSyncEndpoint,
-    SlackProjectSyncViewSet,
-)
-
-
-urlpatterns = [
-    path(
-        "integrations/",
-        IntegrationViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
-        name="integrations",
-    ),
-    path(
-        "integrations/<uuid:pk>/",
-        IntegrationViewSet.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="integrations",
-    ),
-    path(
-        "workspaces/<str:slug>/workspace-integrations/",
-        WorkspaceIntegrationViewSet.as_view(
-            {
-                "get": "list",
-            }
-        ),
-        name="workspace-integrations",
-    ),
-    path(
-        "workspaces/<str:slug>/workspace-integrations/<str:provider>/",
-        WorkspaceIntegrationViewSet.as_view(
-            {
-                "post": "create",
-            }
-        ),
-        name="workspace-integrations",
-    ),
-    path(
-        "workspaces/<str:slug>/workspace-integrations/<uuid:pk>/provider/",
-        WorkspaceIntegrationViewSet.as_view(
-            {
-                "get": "retrieve",
-                "delete": "destroy",
-            }
-        ),
-        name="workspace-integrations",
-    ),
-    # Github Integrations
-    path(
-        "workspaces/<str:slug>/workspace-integrations/<uuid:workspace_integration_id>/github-repositories/",
-        GithubRepositoriesEndpoint.as_view(),
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/github-repository-sync/",
-        GithubRepositorySyncViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/github-repository-sync/<uuid:pk>/",
-        GithubRepositorySyncViewSet.as_view(
-            {
-                "get": "retrieve",
-                "delete": "destroy",
-            }
-        ),
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/",
-        GithubIssueSyncViewSet.as_view(
-            {
-                "post": "create",
-                "get": "list",
-            }
-        ),
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/bulk-create-github-issue-sync/",
-        BulkCreateGithubIssueSyncEndpoint.as_view(),
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:pk>/",
-        GithubIssueSyncViewSet.as_view(
-            {
-                "get": "retrieve",
-                "delete": "destroy",
-            }
-        ),
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:issue_sync_id>/github-comment-sync/",
-        GithubCommentSyncViewSet.as_view(
-            {
-                "post": "create",
-                "get": "list",
-            }
-        ),
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:issue_sync_id>/github-comment-sync/<uuid:pk>/",
-        GithubCommentSyncViewSet.as_view(
-            {
-                "get": "retrieve",
-                "delete": "destroy",
-            }
-        ),
-    ),
-    ## End Github Integrations
-    # Slack Integration
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/project-slack-sync/",
-        SlackProjectSyncViewSet.as_view(
-            {
-                "post": "create",
-                "get": "list",
-            }
-        ),
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/project-slack-sync/<uuid:pk>/",
-        SlackProjectSyncViewSet.as_view(
-            {
-                "delete": "destroy",
-                "get": "retrieve",
-            }
-        ),
-    ),
-    ## End Slack Integration
-]

apiserver/plane/app/urls/issue.py

@@ -1,30 +1,32 @@
 from django.urls import path
 
-
 from plane.app.views import (
-    IssueViewSet,
-    LabelViewSet,
     BulkCreateIssueLabelsEndpoint,
     BulkDeleteIssuesEndpoint,
-    BulkImportIssuesEndpoint,
-    UserWorkSpaceIssues,
     SubIssuesEndpoint,
     IssueLinkViewSet,
     IssueAttachmentEndpoint,
+    CommentReactionViewSet,
     ExportIssuesEndpoint,
     IssueActivityEndpoint,
-    IssueCommentViewSet,
-    IssueSubscriberViewSet,
-    IssueReactionViewSet,
-    CommentReactionViewSet,
-    IssueUserDisplayPropertyEndpoint,
     IssueArchiveViewSet,
-    IssueRelationViewSet,
+    IssueCommentViewSet,
     IssueDraftViewSet,
+    IssueListEndpoint,
+    IssueReactionViewSet,
+    IssueRelationViewSet,
+    IssueSubscriberViewSet,
+    IssueUserDisplayPropertyEndpoint,
+    IssueViewSet,
+    LabelViewSet,
 )
 
-
 urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/list/",
+        IssueListEndpoint.as_view(),
+        name="project-issue",
+    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/",
         IssueViewSet.as_view(
@@ -79,16 +81,7 @@ urlpatterns = [
         BulkDeleteIssuesEndpoint.as_view(),
         name="project-issues-bulk",
     ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-import-issues/<str:service>/",
-        BulkImportIssuesEndpoint.as_view(),
-        name="project-issues-bulk",
-    ),
-    path(
-        "workspaces/<str:slug>/my-issues/",
-        UserWorkSpaceIssues.as_view(),
-        name="workspace-issues",
-    ),
+    ##
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/sub-issues/",
         SubIssuesEndpoint.as_view(),
@@ -235,7 +228,7 @@ urlpatterns = [
     ## End Comment Reactions
     ## IssueProperty
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-display-properties/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-properties/",
         IssueUserDisplayPropertyEndpoint.as_view(),
         name="project-issue-display-properties",
     ),
@@ -251,23 +244,15 @@ urlpatterns = [
         name="project-issue-archive",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-issues/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/archive/",
         IssueArchiveViewSet.as_view(
             {
                 "get": "retrieve",
-                "delete": "destroy",
+                "post": "archive",
+                "delete": "unarchive",
             }
         ),
-        name="project-issue-archive",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/unarchive/<uuid:pk>/",
-        IssueArchiveViewSet.as_view(
-            {
-                "post": "unarchive",
-            }
-        ),
-        name="project-issue-archive",
+        name="project-issue-archive-unarchive",
     ),
     ## End Issue Archives
     ## Issue Relation
@@ -275,16 +260,17 @@ urlpatterns = [
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-relation/",
         IssueRelationViewSet.as_view(
             {
+                "get": "list",
                 "post": "create",
             }
         ),
         name="issue-relation",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-relation/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/remove-relation/",
         IssueRelationViewSet.as_view(
             {
-                "delete": "destroy",
+                "post": "remove_relation",
             }
         ),
         name="issue-relation",

apiserver/plane/app/urls/module.py

@@ -6,7 +6,8 @@ from plane.app.views import (
     ModuleIssueViewSet,
     ModuleLinkViewSet,
     ModuleFavoriteViewSet,
-    BulkImportModulesEndpoint,
+    ModuleUserPropertiesEndpoint,
+    ModuleArchiveUnarchiveEndpoint,
 )
 
 
@@ -34,17 +35,26 @@ urlpatterns = [
         name="project-modules",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/modules/",
         ModuleIssueViewSet.as_view(
             {
+                "post": "create_issue_modules",
+            }
+        ),
+        name="issue-module",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/issues/",
+        ModuleIssueViewSet.as_view(
+            {
+                "post": "create_module_issues",
                 "get": "list",
-                "post": "create",
             }
         ),
         name="project-module-issues",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/issues/<uuid:issue_id>/",
         ModuleIssueViewSet.as_view(
             {
                 "get": "retrieve",
@@ -97,8 +107,18 @@ urlpatterns = [
         name="user-favorite-module",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-import-modules/<str:service>/",
-        BulkImportModulesEndpoint.as_view(),
-        name="bulk-modules-create",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/user-properties/",
+        ModuleUserPropertiesEndpoint.as_view(),
+        name="cycle-user-filters",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/archive/",
+        ModuleArchiveUnarchiveEndpoint.as_view(),
+        name="module-archive-unarchive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-modules/",
+        ModuleArchiveUnarchiveEndpoint.as_view(),
+        name="module-archive-unarchive",
     ),
 ]

apiserver/plane/app/urls/notification.py

@@ -5,6 +5,7 @@ from plane.app.views import (
     NotificationViewSet,
     UnreadNotificationEndpoint,
     MarkAllReadNotificationViewSet,
+    UserNotificationPreferenceEndpoint,
 )
 
 
@@ -63,4 +64,9 @@ urlpatterns = [
         ),
         name="mark-all-read-notifications",
     ),
+    path(
+        "users/me/notification-preferences/",
+        UserNotificationPreferenceEndpoint.as_view(),
+        name="user-notification-preferences",
+    ),
 ]

apiserver/plane/app/urls/project.py

@@ -13,6 +13,8 @@ from plane.app.views import (
     UserProjectInvitationsViewset,
     ProjectPublicCoverImagesEndpoint,
     ProjectDeployBoardViewSet,
+    UserProjectRolesEndpoint,
+    ProjectArchiveUnarchiveEndpoint,
 )
 
 
@@ -74,6 +76,11 @@ urlpatterns = [
         ),
         name="user-project-invitations",
     ),
+    path(
+        "users/me/workspaces/<str:slug>/project-roles/",
+        UserProjectRolesEndpoint.as_view(),
+        name="user-project-roles",
+    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/join/<uuid:pk>/",
         ProjectJoinEndpoint.as_view(),
@@ -169,4 +176,9 @@ urlpatterns = [
         ),
         name="project-deploy-board",
     ),
-]
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archive/",
+        ProjectArchiveUnarchiveEndpoint.as_view(),
+        name="project-archive-unarchive",
+    ),
+]

apiserver/plane/app/urls/views.py

@@ -5,7 +5,7 @@ from plane.app.views import (
     IssueViewViewSet,
     GlobalViewViewSet,
     GlobalViewIssuesViewSet,
-    IssueViewFavoriteViewSet,   
+    IssueViewFavoriteViewSet,
 )
 
 

apiserver/plane/app/urls/workspace.py

@@ -18,6 +18,13 @@ from plane.app.views import (
     WorkspaceUserProfileEndpoint,
     WorkspaceUserProfileIssuesEndpoint,
     WorkspaceLabelsEndpoint,
+    WorkspaceProjectMemberEndpoint,
+    WorkspaceUserPropertiesEndpoint,
+    WorkspaceStatesEndpoint,
+    WorkspaceEstimatesEndpoint,
+    ExportWorkspaceUserActivityEndpoint,
+    WorkspaceModulesEndpoint,
+    WorkspaceCyclesEndpoint,
 )
 
 
@@ -92,6 +99,11 @@ urlpatterns = [
         WorkSpaceMemberViewSet.as_view({"get": "list"}),
         name="workspace-member",
     ),
+    path(
+        "workspaces/<str:slug>/project-members/",
+        WorkspaceProjectMemberEndpoint.as_view(),
+        name="workspace-member-roles",
+    ),
     path(
         "workspaces/<str:slug>/members/<uuid:pk>/",
         WorkSpaceMemberViewSet.as_view(
@@ -180,6 +192,11 @@ urlpatterns = [
         WorkspaceUserActivityEndpoint.as_view(),
         name="workspace-user-activity",
     ),
+    path(
+        "workspaces/<str:slug>/user-activity/<uuid:user_id>/export/",
+        ExportWorkspaceUserActivityEndpoint.as_view(),
+        name="export-workspace-user-activity",
+    ),
     path(
         "workspaces/<str:slug>/user-profile/<uuid:user_id>/",
         WorkspaceUserProfileEndpoint.as_view(),
@@ -195,4 +212,29 @@ urlpatterns = [
         WorkspaceLabelsEndpoint.as_view(),
         name="workspace-labels",
     ),
+    path(
+        "workspaces/<str:slug>/user-properties/",
+        WorkspaceUserPropertiesEndpoint.as_view(),
+        name="workspace-user-filters",
+    ),
+    path(
+        "workspaces/<str:slug>/states/",
+        WorkspaceStatesEndpoint.as_view(),
+        name="workspace-state",
+    ),
+    path(
+        "workspaces/<str:slug>/estimates/",
+        WorkspaceEstimatesEndpoint.as_view(),
+        name="workspace-estimate",
+    ),
+    path(
+        "workspaces/<str:slug>/modules/",
+        WorkspaceModulesEndpoint.as_view(),
+        name="workspace-modules",
+    ),
+    path(
+        "workspaces/<str:slug>/cycles/",
+        WorkspaceCyclesEndpoint.as_view(),
+        name="workspace-cycles",
+    ),
 ]

apiserver/plane/app/views/__init__.py

@@ -1,18 +1,27 @@
-from .project import (
+from .project.base import (
     ProjectViewSet,
-    ProjectMemberViewSet,
-    UserProjectInvitationsViewset,
-    ProjectInvitationsViewset,
-    AddTeamToProjectEndpoint,
     ProjectIdentifierEndpoint,
-    ProjectJoinEndpoint,
     ProjectUserViewsEndpoint,
-    ProjectMemberUserEndpoint,
     ProjectFavoritesViewSet,
     ProjectPublicCoverImagesEndpoint,
     ProjectDeployBoardViewSet,
+    ProjectArchiveUnarchiveEndpoint,
 )
-from .user import (
+
+from .project.invite import (
+    UserProjectInvitationsViewset,
+    ProjectInvitationsViewset,
+    ProjectJoinEndpoint,
+)
+
+from .project.member import (
+    ProjectMemberViewSet,
+    AddTeamToProjectEndpoint,
+    ProjectMemberUserEndpoint,
+    UserProjectRolesEndpoint,
+)
+
+from .user.base import (
     UserEndpoint,
     UpdateUserOnBoardedEndpoint,
     UpdateUserTourCompletedEndpoint,
@@ -23,62 +32,122 @@ from .oauth import OauthEndpoint
 
 from .base import BaseAPIView, BaseViewSet, WebhookMixin
 
-from .workspace import (
+from .workspace.base import (
     WorkSpaceViewSet,
     UserWorkSpacesEndpoint,
     WorkSpaceAvailabilityCheckEndpoint,
-    WorkspaceJoinEndpoint,
-    WorkSpaceMemberViewSet,
-    TeamMemberViewSet,
-    WorkspaceInvitationsViewset,
-    UserWorkspaceInvitationsViewSet,
-    UserLastProjectWithWorkspaceEndpoint,
-    WorkspaceMemberUserEndpoint,
-    WorkspaceMemberUserViewsEndpoint,
-    UserActivityGraphEndpoint,
-    UserIssueCompletedGraphEndpoint,
     UserWorkspaceDashboardEndpoint,
     WorkspaceThemeViewSet,
-    WorkspaceUserProfileStatsEndpoint,
-    WorkspaceUserActivityEndpoint,
-    WorkspaceUserProfileEndpoint,
-    WorkspaceUserProfileIssuesEndpoint,
+    ExportWorkspaceUserActivityEndpoint
+)
+
+from .workspace.member import (
+    WorkSpaceMemberViewSet,
+    TeamMemberViewSet,
+    WorkspaceMemberUserEndpoint,
+    WorkspaceProjectMemberEndpoint,
+    WorkspaceMemberUserViewsEndpoint,
+)
+from .workspace.invite import (
+    WorkspaceInvitationsViewset,
+    WorkspaceJoinEndpoint,
+    UserWorkspaceInvitationsViewSet,
+)
+from .workspace.label import (
     WorkspaceLabelsEndpoint,
 )
-from .state import StateViewSet
-from .view import (
+from .workspace.state import (
+    WorkspaceStatesEndpoint,
+)
+from .workspace.user import (
+    UserLastProjectWithWorkspaceEndpoint,
+    WorkspaceUserProfileIssuesEndpoint,
+    WorkspaceUserPropertiesEndpoint,
+    WorkspaceUserProfileEndpoint,
+    WorkspaceUserActivityEndpoint,
+    WorkspaceUserProfileStatsEndpoint,
+    UserActivityGraphEndpoint,
+    UserIssueCompletedGraphEndpoint,
+)
+from .workspace.estimate import (
+    WorkspaceEstimatesEndpoint,
+)
+from .workspace.module import (
+    WorkspaceModulesEndpoint,
+)
+from .workspace.cycle import (
+    WorkspaceCyclesEndpoint,
+)
+
+from .state.base import StateViewSet
+from .view.base import (
     GlobalViewViewSet,
     GlobalViewIssuesViewSet,
     IssueViewViewSet,
     IssueViewFavoriteViewSet,
 )
-from .cycle import (
+from .cycle.base import (
     CycleViewSet,
-    CycleIssueViewSet,
     CycleDateCheckEndpoint,
     CycleFavoriteViewSet,
     TransferCycleIssueEndpoint,
+    CycleArchiveUnarchiveEndpoint,
+    CycleUserPropertiesEndpoint,
 )
-from .asset import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
-from .issue import (
+from .cycle.issue import (
+    CycleIssueViewSet,
+)
+
+from .asset.base import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
+from .issue.base import (
+    IssueListEndpoint,
     IssueViewSet,
-    WorkSpaceIssuesEndpoint,
-    IssueActivityEndpoint,
-    IssueCommentViewSet,
     IssueUserDisplayPropertyEndpoint,
-    LabelViewSet,
     BulkDeleteIssuesEndpoint,
-    UserWorkSpaceIssues,
-    SubIssuesEndpoint,
-    IssueLinkViewSet,
-    BulkCreateIssueLabelsEndpoint,
-    IssueAttachmentEndpoint,
+)
+
+from .issue.activity import (
+    IssueActivityEndpoint,
+)
+
+from .issue.archive import (
     IssueArchiveViewSet,
-    IssueSubscriberViewSet,
+)
+
+from .issue.attachment import (
+    IssueAttachmentEndpoint,
+)
+
+from .issue.comment import (
+    IssueCommentViewSet,
     CommentReactionViewSet,
-    IssueReactionViewSet,
+)
+
+from .issue.draft import IssueDraftViewSet
+
+from .issue.label import (
+    LabelViewSet,
+    BulkCreateIssueLabelsEndpoint,
+)
+
+from .issue.link import (
+    IssueLinkViewSet,
+)
+
+from .issue.relation import (
     IssueRelationViewSet,
-    IssueDraftViewSet,
+)
+
+from .issue.reaction import (
+    IssueReactionViewSet,
+)
+
+from .issue.sub_issue import (
+    SubIssuesEndpoint,
+)
+
+from .issue.subscriber import (
+    IssueSubscriberViewSet,
 )
 
 from .auth_extended import (
@@ -97,35 +166,22 @@ from .authentication import (
     MagicSignInEndpoint,
 )
 
-from .module import (
+from .module.base import (
     ModuleViewSet,
-    ModuleIssueViewSet,
     ModuleLinkViewSet,
     ModuleFavoriteViewSet,
+    ModuleArchiveUnarchiveEndpoint,
+    ModuleUserPropertiesEndpoint,
+)
+
+from .module.issue import (
+    ModuleIssueViewSet,
 )
 
 from .api import ApiTokenEndpoint
 
-from .integration import (
-    WorkspaceIntegrationViewSet,
-    IntegrationViewSet,
-    GithubIssueSyncViewSet,
-    GithubRepositorySyncViewSet,
-    GithubCommentSyncViewSet,
-    GithubRepositoriesEndpoint,
-    BulkCreateGithubIssueSyncEndpoint,
-    SlackProjectSyncViewSet,
-)
 
-from .importer import (
-    ServiceIssueImportSummaryEndpoint,
-    ImportServiceEndpoint,
-    UpdateServiceImportStatusEndpoint,
-    BulkImportIssuesEndpoint,
-    BulkImportModulesEndpoint,
-)
-
-from .page import (
+from .page.base import (
     PageViewSet,
     PageFavoriteViewSet,
     PageLogEndpoint,
@@ -135,16 +191,19 @@ from .page import (
 from .search import GlobalSearchEndpoint, IssueSearchEndpoint
 
 
-from .external import GPTIntegrationEndpoint, ReleaseNotesEndpoint, UnsplashEndpoint
+from .external.base import (
+    GPTIntegrationEndpoint,
+    UnsplashEndpoint,
+)
 
-from .estimate import (
+from .estimate.base import (
     ProjectEstimatePointEndpoint,
     BulkEstimatePointEndpoint,
 )
 
-from .inbox import InboxViewSet, InboxIssueViewSet
+from .inbox.base import InboxViewSet, InboxIssueViewSet
 
-from .analytic import (
+from .analytic.base import (
     AnalyticsEndpoint,
     AnalyticViewViewset,
     SavedAnalyticEndpoint,
@@ -152,18 +211,23 @@ from .analytic import (
     DefaultAnalyticsEndpoint,
 )
 
-from .notification import (
+from .notification.base import (
     NotificationViewSet,
     UnreadNotificationEndpoint,
     MarkAllReadNotificationViewSet,
+    UserNotificationPreferenceEndpoint,
 )
 
-from .exporter import ExportIssuesEndpoint
+from .exporter.base import ExportIssuesEndpoint
 
-from .config import ConfigurationEndpoint
+from .config import ConfigurationEndpoint, MobileConfigurationEndpoint
 
-from .webhook import (
+from .webhook.base import (
     WebhookEndpoint,
     WebhookLogsEndpoint,
     WebhookSecretRegenerateEndpoint,
 )
+
+from .dashboard.base import DashboardEndpoint, WidgetsEndpoint
+
+from .error_404 import custom_404_view

apiserver/plane/app/views/analytic/base.py

@@ -1,6 +1,7 @@
 # Django imports
-from django.db.models import Count, Sum, F, Q
+from django.db.models import Count, Sum, F
 from django.db.models.functions import ExtractMonth
+from django.utils import timezone
 
 # Third party imports
 from rest_framework import status
@@ -9,7 +10,7 @@ from rest_framework.response import Response
 # Module imports
 from plane.app.views import BaseAPIView, BaseViewSet
 from plane.app.permissions import WorkSpaceAdminPermission
-from plane.db.models import Issue, AnalyticView, Workspace, State, Label
+from plane.db.models import Issue, AnalyticView, Workspace
 from plane.app.serializers import AnalyticViewSerializer
 from plane.utils.analytics_plot import build_graph_plot
 from plane.bgtasks.analytic_plot_export import analytic_export_task
@@ -50,8 +51,8 @@ class AnalyticsEndpoint(BaseAPIView):
         if (
             not x_axis
             or not y_axis
-            or not x_axis in valid_xaxis_segment
-            or not y_axis in valid_yaxis
+            or x_axis not in valid_xaxis_segment
+            or y_axis not in valid_yaxis
         ):
             return Response(
                 {
@@ -61,7 +62,9 @@ class AnalyticsEndpoint(BaseAPIView):
             )
 
         # If segment is present it cannot be same as x-axis
-        if segment and (segment not in valid_xaxis_segment or x_axis == segment):
+        if segment and (
+            segment not in valid_xaxis_segment or x_axis == segment
+        ):
             return Response(
                 {
                     "error": "Both segment and x axis cannot be same and segment should be valid"
@@ -110,7 +113,9 @@ class AnalyticsEndpoint(BaseAPIView):
         if x_axis in ["assignees__id"] or segment in ["assignees__id"]:
             assignee_details = (
                 Issue.issue_objects.filter(
-                    workspace__slug=slug, **filters, assignees__avatar__isnull=False
+                    workspace__slug=slug,
+                    **filters,
+                    assignees__avatar__isnull=False,
                 )
                 .order_by("assignees__id")
                 .distinct("assignees__id")
@@ -124,7 +129,9 @@ class AnalyticsEndpoint(BaseAPIView):
             )
 
         cycle_details = {}
-        if x_axis in ["issue_cycle__cycle_id"] or segment in ["issue_cycle__cycle_id"]:
+        if x_axis in ["issue_cycle__cycle_id"] or segment in [
+            "issue_cycle__cycle_id"
+        ]:
             cycle_details = (
                 Issue.issue_objects.filter(
                     workspace__slug=slug,
@@ -186,7 +193,9 @@ class AnalyticViewViewset(BaseViewSet):
 
     def get_queryset(self):
         return self.filter_queryset(
-            super().get_queryset().filter(workspace__slug=self.kwargs.get("slug"))
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
         )
 
 
@@ -196,7 +205,9 @@ class SavedAnalyticEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug, analytic_id):
-        analytic_view = AnalyticView.objects.get(pk=analytic_id, workspace__slug=slug)
+        analytic_view = AnalyticView.objects.get(
+            pk=analytic_id, workspace__slug=slug
+        )
 
         filter = analytic_view.query
         queryset = Issue.issue_objects.filter(**filter)
@@ -255,8 +266,8 @@ class ExportAnalyticsEndpoint(BaseAPIView):
         if (
             not x_axis
             or not y_axis
-            or not x_axis in valid_xaxis_segment
-            or not y_axis in valid_yaxis
+            or x_axis not in valid_xaxis_segment
+            or y_axis not in valid_yaxis
         ):
             return Response(
                 {
@@ -266,7 +277,9 @@ class ExportAnalyticsEndpoint(BaseAPIView):
             )
 
         # If segment is present it cannot be same as x-axis
-        if segment and (segment not in valid_xaxis_segment or x_axis == segment):
+        if segment and (
+            segment not in valid_xaxis_segment or x_axis == segment
+        ):
             return Response(
                 {
                     "error": "Both segment and x axis cannot be same and segment should be valid"
@@ -293,7 +306,9 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
 
     def get(self, request, slug):
         filters = issue_filters(request.GET, "GET")
-        base_issues = Issue.issue_objects.filter(workspace__slug=slug, **filters)
+        base_issues = Issue.issue_objects.filter(
+            workspace__slug=slug, **filters
+        )
 
         total_issues = base_issues.count()
 
@@ -306,7 +321,9 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
         )
 
         open_issues_groups = ["backlog", "unstarted", "started"]
-        open_issues_queryset = state_groups.filter(state__group__in=open_issues_groups)
+        open_issues_queryset = state_groups.filter(
+            state__group__in=open_issues_groups
+        )
 
         open_issues = open_issues_queryset.count()
         open_issues_classified = (
@@ -315,8 +332,9 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
             .order_by("state_group")
         )
 
+        current_year = timezone.now().year
         issue_completed_month_wise = (
-            base_issues.filter(completed_at__isnull=False)
+            base_issues.filter(completed_at__year=current_year)
             .annotate(month=ExtractMonth("completed_at"))
             .values("month")
             .annotate(count=Count("*"))
@@ -361,10 +379,12 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
             .order_by("-count")
         )
 
-        open_estimate_sum = open_issues_queryset.aggregate(sum=Sum("estimate_point"))[
+        open_estimate_sum = open_issues_queryset.aggregate(
+            sum=Sum("estimate_point")
+        )["sum"]
+        total_estimate_sum = base_issues.aggregate(sum=Sum("estimate_point"))[
             "sum"
         ]
-        total_estimate_sum = base_issues.aggregate(sum=Sum("estimate_point"))["sum"]
 
         return Response(
             {