dashboard responsive

chore: update the label of the app sidebar dashboard to home (#3912 )
fix: date filter modal selection (#3913 )
2024-03-11 22:03:08 +05:30 · 2024-03-08 17:59:02 +05:30 · 2024-03-08 17:58:27 +05:30 · 2024-03-08 17:57:48 +05:30 · 2024-03-08 17:38:42 +05:30 · 2024-03-08 17:37:01 +05:30
1371 changed files with 43377 additions and 36041 deletions
@@ -2,7 +2,7 @@ name: Bug report
 description: Create a bug report to help us improve Plane
 title: "[bug]: "
 labels: [🐛bug]
-assignees: [srinivaspendem, pushya-plane]
+assignees: [srinivaspendem, pushya22]
 body:
 - type: markdown
  attributes:
@@ -45,7 +45,7 @@ body:
      - Deploy preview
  validations:
    required: true
-  type: dropdown
+- type: dropdown
  id: browser
  attributes:
    label: Browser
@@ -2,7 +2,7 @@ name: Feature request
 description: Suggest a feature to improve Plane
 title: "[feature]: "
 labels: [✨feature]
-assignees: [srinivaspendem, pushya-plane]
+assignees: [srinivaspendem, pushya22]
 body:
 - type: markdown
  attributes:
@@ -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"
@@ -2,11 +2,6 @@ name: Branch Build

 on:
  workflow_dispatch:
-    inputs:
-      branch_name:
-        description: "Branch Name"
-        required: true
-        default: "preview"
  push:
    branches:
      - master
@@ -16,58 +11,113 @@ on:
    types: [released, prereleased]

 env:
-  TARGET_BRANCH: ${{ inputs.branch_name || github.ref_name || github.event.release.target_commitish }}
+  TARGET_BRANCH: ${{ github.ref_name || github.event.release.target_commitish }}

 jobs:
  branch_build_setup:
    name: Build-Push Web/Space/API/Proxy Docker Image
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v3.3.0
+    runs-on: ubuntu-latest
    outputs:
-      gh_branch_name: ${{ env.TARGET_BRANCH }}
+      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:
+      - 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
+
+      - id: checkout_files
+        name: Checkout Files
+        uses: actions/checkout@v4
+
+      - name: Get changed files
+        id: changed_files
+        uses: tj-actions/changed-files@v42
+        with:
+          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 == '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
        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: Docker Setup QEMU
-        uses: docker/setup-qemu-action@v3.0.0
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3.0.0
-        with:
-          platforms: linux/amd64,linux/arm64
-          buildkitd-flags: "--allow-insecure-entitlement security.insecure"

      - name: Login to Docker Hub
-        uses: docker/login-action@v3.0.0
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: ${{ env.BUILDX_DRIVER }}
+          version: ${{ env.BUILDX_VERSION }}
+          endpoint: ${{ env.BUILDX_ENDPOINT }}
+
      - name: Check out the repo
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v4

      - name: Build and Push Frontend to Docker Container Registry
        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:
@@ -76,46 +126,50 @@ jobs:
          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}

  branch_build_push_space:
+    if: ${{ needs.branch_build_setup.outputs.build_space == 'true' || 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
        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: Docker Setup QEMU
-        uses: docker/setup-qemu-action@v3.0.0
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3.0.0
-        with:
-          platforms: linux/amd64,linux/arm64
-          buildkitd-flags: "--allow-insecure-entitlement security.insecure"
-
      - name: Login to Docker Hub
-        uses: docker/login-action@v3.0.0
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: ${{ env.BUILDX_DRIVER }}
+          version: ${{ env.BUILDX_VERSION }}
+          endpoint: ${{ env.BUILDX_ENDPOINT }}
+
      - name: Check out the repo
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v4

      - name: Build and Push Space to Docker Hub
        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:
@@ -124,46 +178,50 @@ jobs:
          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}

  branch_build_push_backend:
+    if: ${{ needs.branch_build_setup.outputs.build_backend == 'true' || 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
        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: Docker Setup QEMU
-        uses: docker/setup-qemu-action@v3.0.0
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3.0.0
-        with:
-          platforms: linux/amd64,linux/arm64
-          buildkitd-flags: "--allow-insecure-entitlement security.insecure"
-
      - name: Login to Docker Hub
-        uses: docker/login-action@v3.0.0
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: ${{ env.BUILDX_DRIVER }}
+          version: ${{ env.BUILDX_VERSION }}
+          endpoint: ${{ env.BUILDX_ENDPOINT }}
+
      - name: Check out the repo
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v4

      - name: Build and Push Backend to Docker Hub
        uses: docker/build-push-action@v5.1.0
        with:
          context: ./apiserver
          file: ./apiserver/Dockerfile.api
-          platforms: linux/amd64
+          platforms: ${{ env.BUILDX_PLATFORMS }}
          push: true
          tags: ${{ env.BACKEND_TAG }}
        env:
@@ -172,49 +230,54 @@ jobs:
          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}

  branch_build_push_proxy:
+    if: ${{ needs.branch_build_setup.outputs.build_proxy == 'true' || 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
        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: Docker Setup QEMU
-        uses: docker/setup-qemu-action@v3.0.0
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3.0.0
-        with:
-          platforms: linux/amd64,linux/arm64
-          buildkitd-flags: "--allow-insecure-entitlement security.insecure"
-
      - name: Login to Docker Hub
-        uses: docker/login-action@v3.0.0
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: ${{ env.BUILDX_DRIVER }}
+          version: ${{ env.BUILDX_VERSION }}
+          endpoint: ${{ env.BUILDX_ENDPOINT }}
+
      - name: Check out the repo
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v4

      - name: Build and Push Plane-Proxy to Docker Hub
        uses: docker/build-push-action@v5.1.0
        with:
          context: ./nginx
          file: ./nginx/Dockerfile
-          platforms: linux/amd64
+          platforms: ${{ env.BUILDX_PLATFORMS }}
          tags: ${{ env.PROXY_TAG }}
          push: true
        env:
          DOCKER_BUILDKIT: 1
          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
@@ -1,28 +1,19 @@
-name: Build Pull Request Contents
+name: Build and Lint on Pull Request

 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
-        with:
-          token: ${{ secrets.ACCESS_TOKEN }}
-
-      - 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@v41
@@ -32,17 +23,82 @@ jobs:
              - 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
@@ -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 }}
@@ -2,7 +2,7 @@ name: Create Sync Action

 on:
  workflow_dispatch:
-  push: 
+  push:
    branches:
      - preview

@@ -17,7 +17,7 @@ jobs:
      contents: read
    steps:
      - name: Checkout Code
-        uses: actions/checkout@v4.1.1 
+        uses: actions/checkout@v4.1.1
        with:
          persist-credentials: false
          fetch-depth: 0
@@ -31,14 +31,25 @@ jobs:
          sudo apt update
          sudo apt install gh -y

-      - name: Push Changes to Target Repo
+      - name: Push Changes to Target Repo A
        env:
          GH_TOKEN: ${{ secrets.ACCESS_TOKEN }}
        run: |
-          TARGET_REPO="${{ secrets.SYNC_TARGET_REPO_NAME }}"
-          TARGET_BRANCH="${{ secrets.SYNC_TARGET_BRANCH_NAME }}"
+          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-origin "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
-          git push target-origin $SOURCE_BRANCH:$TARGET_BRANCH
+          git remote add target-origin-a "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
+          git push target-origin-a $SOURCE_BRANCH:$TARGET_BRANCH
+
+      - 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 }}"
+
+          git remote add target-origin-b "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
+          git push target-origin-b $SOURCE_BRANCH:$TARGET_BRANCH
@@ -0,0 +1,73 @@
+name: Feature Preview
+
+on:
+  workflow_dispatch:
+    inputs:
+      web-build:
+        required: true
+        type: boolean
+        default: true
+      space-build:
+        required: true
+        type: boolean
+        default: false
+
+jobs:
+  feature-deploy:
+    name: Feature Deploy
+    runs-on: ubuntu-latest
+    env:
+      KUBE_CONFIG_FILE: ${{ secrets.KUBE_CONFIG }}
+      BUILD_WEB: ${{ (github.event.inputs.web-build == '' && true) || github.event.inputs.web-build }}
+      BUILD_SPACE: ${{ (github.event.inputs.space-build == '' && false) || github.event.inputs.space-build }}
+
+    steps:
+      - 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/${{secrets.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: |
+          helm --kube-insecure-skip-tls-verify repo add feature-preview ${{ secrets.FEATURE_PREVIEW_HELM_CHART_URL }} 
+          GIT_BRANCH=${{ github.ref_name }}
+          APP_NAMESPACE=${{ secrets.FEATURE_PREVIEW_NAMESPACE }}
+
+          METADATA=$(helm install feature-preview/${{ secrets.FEATURE_PREVIEW_HELM_CHART_NAME }} \
+              --kube-insecure-skip-tls-verify \
+              --generate-name \
+              --namespace $APP_NAMESPACE \
+              --set shared_config.git_repo=${{github.server_url}}/${{ github.repository }}.git \
+              --set shared_config.git_branch="$GIT_BRANCH" \
+              --set web.enabled=${{ env.BUILD_WEB }} \
+              --set space.enabled=${{ env.BUILD_SPACE }} \
+              --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 "****************************************"
@@ -50,7 +50,6 @@ chmod +x setup.sh
 docker compose -f docker-compose-local.yml up
 ```

-
 ## Missing a Feature?

 If a feature is missing, you can directly _request_ a new one [here](https://github.com/makeplane/plane/issues/new?assignees=&labels=feature&template=feature_request.yml&title=%F0%9F%9A%80+Feature%3A+). You also can do the same by choosing "🚀 Feature" when raising a [New Issue](https://github.com/makeplane/plane/issues/new/choose) on our GitHub Repository.
@@ -53,7 +53,6 @@ NGINX_PORT=80
 NEXT_PUBLIC_DEPLOY_URL="http://localhost/spaces"
 ```

-
 ## {PROJECT_FOLDER}/apiserver/.env


@@ -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="http://www.plane.so"><b>Website</b></a> •
+    <a href="https://github.com/makeplane/plane/releases"><b>Releases</b></a> •
+    <a href="https://twitter.com/planepowers"><b>Twitter</b></a> •
+    <a href="https://docs.plane.so/"><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://plane.so). 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.

-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/docker-compose). 
+## ⚡ 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/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/docker-compose) 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.
+
+## 🛠️ Contributors Quick Start
+
+> 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>
@@ -1,4 +1,4 @@
 {
  "name": "plane-api",
-  "version": "0.15.0"
+  "version": "0.16.0"
 }
@@ -1,8 +1,9 @@
 from lxml import html

-
 # 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
@@ -284,6 +285,20 @@ 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(
@@ -295,6 +310,17 @@ class IssueLinkSerializer(BaseSerializer):
            )
        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:
@@ -6,8 +6,6 @@ from plane.db.models import (
    Project,
    ProjectIdentifier,
    WorkspaceMember,
-    State,
-    Estimate,
 )
 from .base import BaseSerializer

@@ -1,6 +1,7 @@
 # Python imports
 import zoneinfo
-import json
+from urllib.parse import urlparse
+

 # Django imports
 from django.conf import settings
@@ -51,6 +52,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,
@@ -59,6 +65,7 @@ class WebhookMixin:
                action=self.request.method,
                slug=self.workspace_slug,
                bulk=self.bulk,
+                current_site=f"{scheme}://{netloc}",
            )

        return response
@@ -107,13 +114,13 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):

            if isinstance(e, ObjectDoesNotExist):
                return Response(
-                    {"error": f"The required object does not exist."},
+                    {"error": "The required object does not exist."},
                    status=status.HTTP_404_NOT_FOUND,
                )

            if isinstance(e, KeyError):
                return Response(
-                    {"error": f" The required key does not exist."},
+                    {"error": " The required key does not exist."},
                    status=status.HTTP_400_BAD_REQUEST,
                )

@@ -2,7 +2,7 @@
 import json

 # Django imports
-from django.db.models import Q, Count, Sum, Prefetch, F, OuterRef, Func
+from django.db.models import Q, Count, Sum, F, OuterRef, Func
 from django.utils import timezone
 from django.core import serializers

@@ -45,7 +45,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")
@@ -243,6 +246,29 @@ 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,
@@ -289,6 +315,25 @@ 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)
@@ -350,7 +395,10 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
            )
            .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")
@@ -119,7 +119,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",
@@ -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):
@@ -220,6 +221,30 @@ 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
@@ -256,6 +281,26 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
            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",
@@ -263,6 +308,8 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
                actor_id=str(request.user.id),
                issue_id=str(pk),
                project_id=str(project_id),
+                external_id__isnull=False,
+                external_source__isnull=False,
                current_instance=current_instance,
                epoch=int(timezone.now().timestamp()),
            )
@@ -306,7 +353,10 @@ 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,
+            )
            .select_related("project")
            .select_related("workspace")
            .select_related("parent")
@@ -318,6 +368,30 @@ 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
@@ -326,11 +400,17 @@ class LabelAPIEndpoint(BaseAPIView):
                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"
+                    "error": "Label with the same name already exists in the project",
+                    "id": str(label.id),
                },
-                status=status.HTTP_400_BAD_REQUEST,
+                status=status.HTTP_409_CONFLICT,
            )

    def get(self, request, slug, project_id, pk=None):
@@ -357,6 +437,25 @@ class LabelAPIEndpoint(BaseAPIView):
        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)
@@ -386,7 +485,10 @@ 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,
+            )
            .order_by(self.kwargs.get("order_by", "-created_at"))
            .distinct()
        )
@@ -512,11 +614,11 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
            )
            .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,
+            )
+            .select_related("workspace", "project", "issue", "actor")
            .annotate(
                is_member=Exists(
                    ProjectMember.objects.filter(
@@ -552,6 +654,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(
@@ -585,6 +712,31 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
            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
        )
@@ -639,6 +791,7 @@ class IssueActivityAPIEndpoint(BaseAPIView):
            .filter(
                ~Q(field__in=["comment", "vote", "reaction", "draft"]),
                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
            )
            .select_related("actor", "workspace", "issue", "project")
        ).order_by(request.GET.get("order_by", "created_at"))
@@ -132,6 +132,29 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
            },
        )
        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)
@@ -149,8 +172,27 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
            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):
@@ -233,7 +275,10 @@ 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,
+            )
            .select_related("project")
            .select_related("workspace")
            .select_related("module")
@@ -11,7 +11,6 @@ from rest_framework.serializers import ValidationError
 from plane.db.models import (
    Workspace,
    Project,
-    ProjectFavorite,
    ProjectMember,
    ProjectDeployBoard,
    State,
@@ -150,7 +149,7 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                serializer.save()

                # Add the user as Administrator to the project
-                project_member = ProjectMember.objects.create(
+                _ = ProjectMember.objects.create(
                    project_id=serializer.data["id"],
                    member=request.user,
                    role=20,
@@ -245,12 +244,12 @@ 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,
            )
-        except ValidationError as e:
+        except ValidationError:
            return Response(
                {"identifier": "The project identifier is already taken"},
                status=status.HTTP_410_GONE,
@@ -307,7 +306,7 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                {"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,
@@ -1,7 +1,5 @@
-# Python imports
-from itertools import groupby
-
 # Django imports
+from django.db import IntegrityError
 from django.db.models import Q

 # Third party imports
@@ -26,7 +24,10 @@ 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(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
            .filter(~Q(name="Triage"))
            .select_related("project")
            .select_related("workspace")
@@ -34,13 +35,53 @@ class StateAPIEndpoint(BaseAPIView):
        )

    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:
@@ -91,6 +132,25 @@ class StateAPIEndpoint(BaseAPIView):
        )
        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)
@@ -68,9 +68,14 @@ from .issue import (
    IssueRelationSerializer,
    RelatedIssueSerializer,
    IssuePublicSerializer,
+    IssueDetailSerializer,
+    IssueReactionLiteSerializer,
+    IssueAttachmentLiteSerializer,
+    IssueLinkLiteSerializer,
 )

 from .module import (
+    ModuleDetailSerializer,
    ModuleWriteSerializer,
    ModuleSerializer,
    ModuleIssueSerializer,
@@ -81,16 +86,6 @@ from .module import (

 from .api import APITokenSerializer, APITokenReadSerializer

-from .integration import (
-    IntegrationSerializer,
-    WorkspaceIntegrationSerializer,
-    GithubIssueSyncSerializer,
-    GithubRepositorySerializer,
-    GithubRepositorySyncSerializer,
-    GithubCommentSyncSerializer,
-    SlackProjectSyncSerializer,
-)
-
 from .importer import ImporterSerializer

 from .page import (
@@ -116,7 +111,10 @@ from .inbox import (

 from .analytic import AnalyticViewSerializer

-from .notification import NotificationSerializer, UserNotificationPreferenceSerializer
+from .notification import (
+    NotificationSerializer,
+    UserNotificationPreferenceSerializer,
+)

 from .exporter import ExporterHistorySerializer

@@ -58,9 +58,12 @@ class DynamicBaseSerializer(BaseSerializer):
                    IssueSerializer,
                    LabelSerializer,
                    CycleIssueSerializer,
-                    IssueFlatSerializer,
+                    IssueLiteSerializer,
                    IssueRelationSerializer,
-                    InboxIssueLiteSerializer
+                    InboxIssueLiteSerializer,
+                    IssueReactionLiteSerializer,
+                    IssueAttachmentLiteSerializer,
+                    IssueLinkLiteSerializer,
                )

                # Expansion mapper
@@ -79,12 +82,34 @@ class DynamicBaseSerializer(BaseSerializer):
                    "assignees": UserLiteSerializer,
                    "labels": LabelSerializer,
                    "issue_cycle": CycleIssueSerializer,
-                    "parent": IssueSerializer,
+                    "parent": IssueLiteSerializer,
                    "issue_relation": IssueRelationSerializer,
-                    "issue_inbox" : InboxIssueLiteSerializer,
+                    "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"] else False)            
+
+                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

@@ -105,7 +130,11 @@ class DynamicBaseSerializer(BaseSerializer):
                        LabelSerializer,
                        CycleIssueSerializer,
                        IssueRelationSerializer,
-                        InboxIssueLiteSerializer
+                        InboxIssueLiteSerializer,
+                        IssueLiteSerializer,
+                        IssueReactionLiteSerializer,
+                        IssueAttachmentLiteSerializer,
+                        IssueLinkLiteSerializer,
                    )

                    # Expansion mapper
@@ -124,9 +153,13 @@ class DynamicBaseSerializer(BaseSerializer):
                        "assignees": UserLiteSerializer,
                        "labels": LabelSerializer,
                        "issue_cycle": CycleIssueSerializer,
-                        "parent": IssueSerializer,
+                        "parent": IssueLiteSerializer,
                        "issue_relation": IssueRelationSerializer,
-                        "issue_inbox" : InboxIssueLiteSerializer,
+                        "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:
@@ -3,10 +3,7 @@ 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,
@@ -30,61 +27,6 @@ class CycleWriteSerializer(BaseSerializer):
    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")
-    status = serializers.CharField(read_only=True)
-
-    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",
@@ -92,6 +34,51 @@ class CycleSerializer(BaseSerializer):
        ]


+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)
@@ -18,9 +18,4 @@ class WidgetSerializer(BaseSerializer):

    class Meta:
        model = Widget
-        fields = [
-            "id",
-            "key",
-            "is_visible",
-            "widget_filters"
-        ]
+        fields = ["id", "key", "is_visible", "widget_filters"]
@@ -74,5 +74,3 @@ class WorkspaceEstimateSerializer(BaseSerializer):
            "name",
            "description",
        ]
-
-
@@ -1,8 +0,0 @@
-from .base import IntegrationSerializer, WorkspaceIntegrationSerializer
-from .github import (
-    GithubRepositorySerializer,
-    GithubRepositorySyncSerializer,
-    GithubIssueSyncSerializer,
-    GithubCommentSyncSerializer,
-)
-from .slack import SlackProjectSyncSerializer
@@ -1,22 +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__"
@@ -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",
-        ]
@@ -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",
-        ]
@@ -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 (
@@ -31,7 +33,6 @@ from plane.db.models import (
    IssueVote,
    IssueRelation,
    State,
-    Project,
 )


@@ -432,6 +433,20 @@ 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(
@@ -443,6 +458,32 @@ class IssueLinkSerializer(BaseSerializer):
            )
        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:
@@ -459,6 +500,20 @@ 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")

@@ -473,6 +528,17 @@ class IssueReactionSerializer(BaseSerializer):
        ]


+class IssueReactionLiteSerializer(DynamicBaseSerializer):
+    class Meta:
+        model = IssueReaction
+        fields = [
+            "id",
+            "actor_id",
+            "issue_id",
+            "reaction",
+        ]
+
+
 class CommentReactionSerializer(BaseSerializer):
    class Meta:
        model = CommentReaction
@@ -503,9 +569,7 @@ class IssueCommentSerializer(BaseSerializer):
    workspace_detail = WorkspaceLiteSerializer(
        read_only=True, source="workspace"
    )
-    comment_reactions = CommentReactionSerializer(
-        read_only=True, many=True
-    )
+    comment_reactions = CommentReactionSerializer(read_only=True, many=True)
    is_member = serializers.BooleanField(read_only=True)

    class Meta:
@@ -558,18 +622,20 @@ class IssueStateSerializer(DynamicBaseSerializer):

 class IssueSerializer(DynamicBaseSerializer):
    # ids
-    project_id = serializers.PrimaryKeyRelatedField(read_only=True)
-    state_id = serializers.PrimaryKeyRelatedField(read_only=True)
-    parent_id = serializers.PrimaryKeyRelatedField(read_only=True)
    cycle_id = serializers.PrimaryKeyRelatedField(read_only=True)
-    module_id = serializers.PrimaryKeyRelatedField(read_only=True)
+    module_ids = serializers.ListField(
+        child=serializers.UUIDField(),
+        required=False,
+    )

    # Many to many
-    label_ids = serializers.PrimaryKeyRelatedField(
-        read_only=True, many=True, source="labels"
+    label_ids = serializers.ListField(
+        child=serializers.UUIDField(),
+        required=False,
    )
-    assignee_ids = serializers.PrimaryKeyRelatedField(
-        read_only=True, many=True, source="assignees"
+    assignee_ids = serializers.ListField(
+        child=serializers.UUIDField(),
+        required=False,
    )

    # Count items
@@ -577,16 +643,12 @@ class IssueSerializer(DynamicBaseSerializer):
    attachment_count = serializers.IntegerField(read_only=True)
    link_count = serializers.IntegerField(read_only=True)

-    # is_subscribed
-    is_subscribed = serializers.BooleanField(read_only=True)
-
    class Meta:
        model = Issue
        fields = [
            "id",
            "name",
            "state_id",
-            "description_html",
            "sort_order",
            "completed_at",
            "estimate_point",
@@ -597,7 +659,7 @@ class IssueSerializer(DynamicBaseSerializer):
            "project_id",
            "parent_id",
            "cycle_id",
-            "module_id",
+            "module_ids",
            "label_ids",
            "assignee_ids",
            "sub_issues_count",
@@ -607,7 +669,6 @@ class IssueSerializer(DynamicBaseSerializer):
            "updated_by",
            "attachment_count",
            "link_count",
-            "is_subscribed",
            "is_draft",
            "archived_at",
        ]
@@ -615,38 +676,26 @@ class IssueSerializer(DynamicBaseSerializer):


 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()
+
+    class Meta(IssueSerializer.Meta):
+        fields = IssueSerializer.Meta.fields + [
+            "description_html",
+            "is_subscribed",
+        ]
+        read_only_fields = fields


 class IssuePublicSerializer(BaseSerializer):
@@ -3,9 +3,7 @@ from rest_framework import serializers

 # Module imports
 from .base import BaseSerializer, DynamicBaseSerializer
-from .user import UserLiteSerializer
 from .project import ProjectLiteSerializer
-from .workspace import WorkspaceLiteSerializer

 from plane.db.models import (
    User,
@@ -19,17 +17,18 @@ from plane.db.models import (


 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__"
@@ -44,7 +43,9 @@ class ModuleWriteSerializer(BaseSerializer):

    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):
@@ -59,12 +60,10 @@ class ModuleWriteSerializer(BaseSerializer):
        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(
                [
@@ -85,7 +84,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()
@@ -142,8 +141,6 @@ class ModuleIssueSerializer(BaseSerializer):


 class ModuleLinkSerializer(BaseSerializer):
-    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
-
    class Meta:
        model = ModuleLink
        fields = "__all__"
@@ -170,12 +167,9 @@ class ModuleLinkSerializer(BaseSerializer):


 class ModuleSerializer(DynamicBaseSerializer):
-    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"
+    member_ids = serializers.ListField(
+        child=serializers.UUIDField(), required=False, allow_null=True
    )
-    link_module = ModuleLinkSerializer(read_only=True, many=True)
    is_favorite = serializers.BooleanField(read_only=True)
    total_issues = serializers.IntegerField(read_only=True)
    cancelled_issues = serializers.IntegerField(read_only=True)
@@ -186,15 +180,44 @@ class ModuleSerializer(DynamicBaseSerializer):

    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)
+
+    class Meta(ModuleSerializer.Meta):
+        fields = ModuleSerializer.Meta.fields + ["link_module"]


 class ModuleFavoriteSerializer(BaseSerializer):
@@ -15,7 +15,6 @@ class NotificationSerializer(BaseSerializer):


 class UserNotificationPreferenceSerializer(BaseSerializer):
-
    class Meta:
        model = UserNotificationPreference
        fields = "__all__"
@@ -3,7 +3,7 @@ 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 (
@@ -12,8 +12,6 @@ from plane.db.models import (
    PageFavorite,
    PageLabel,
    Label,
-    Issue,
-    Module,
 )


@@ -95,8 +95,7 @@ class ProjectLiteSerializer(BaseSerializer):
            "identifier",
            "name",
            "cover_image",
-            "icon_prop",
-            "emoji",
+            "logo_props",
            "description",
        ]
        read_only_fields = fields
@@ -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,13 +98,13 @@ 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:
@@ -120,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,
            }

@@ -1,5 +1,4 @@
 # Python imports
-import urllib
 import socket
 import ipaddress
 from urllib.parse import urlparse
@@ -6,9 +6,7 @@ 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
@@ -32,9 +30,7 @@ urlpatterns = [
    *dashboard_urls,
    *estimate_urls,
    *external_urls,
-    *importer_urls,
    *inbox_urls,
-    *integration_urls,
    *issue_urls,
    *module_urls,
    *notification_urls,
@@ -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(),
@@ -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",
-    ),
-]
@@ -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
-]
@@ -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(),
@@ -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
@@ -6,7 +6,6 @@ from plane.app.views import (
    ModuleIssueViewSet,
    ModuleLinkViewSet,
    ModuleFavoriteViewSet,
-    BulkImportModulesEndpoint,
    ModuleUserPropertiesEndpoint,
 )

@@ -35,17 +34,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:issue_id>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/issues/<uuid:issue_id>/",
        ModuleIssueViewSet.as_view(
            {
                "get": "retrieve",
@@ -97,11 +105,6 @@ 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",
-    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/user-properties/",
        ModuleUserPropertiesEndpoint.as_view(),
@@ -22,6 +22,9 @@ from plane.app.views import (
    WorkspaceUserPropertiesEndpoint,
    WorkspaceStatesEndpoint,
    WorkspaceEstimatesEndpoint,
+    ExportWorkspaceUserActivityEndpoint,
+    WorkspaceModulesEndpoint,
+    WorkspaceCyclesEndpoint,
 )


@@ -189,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(),
@@ -219,4 +227,14 @@ urlpatterns = [
        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",
+    ),
 ]
@@ -1,19 +1,26 @@
-from .project import (
+from .project.base import (
    ProjectViewSet,
-    ProjectMemberViewSet,
-    UserProjectInvitationsViewset,
-    ProjectInvitationsViewset,
-    AddTeamToProjectEndpoint,
    ProjectIdentifierEndpoint,
-    ProjectJoinEndpoint,
    ProjectUserViewsEndpoint,
-    ProjectMemberUserEndpoint,
    ProjectFavoritesViewSet,
    ProjectPublicCoverImagesEndpoint,
    ProjectDeployBoardViewSet,
+)
+
+from .project.invite import (
+    UserProjectInvitationsViewset,
+    ProjectInvitationsViewset,
+    ProjectJoinEndpoint,
+)
+
+from .project.member import (
+    ProjectMemberViewSet,
+    AddTeamToProjectEndpoint,
+    ProjectMemberUserEndpoint,
    UserProjectRolesEndpoint,
 )
-from .user import (
+
+from .user.base import (
    UserEndpoint,
    UpdateUserOnBoardedEndpoint,
    UpdateUserTourCompletedEndpoint,
@@ -24,67 +31,121 @@ 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,
-    WorkspaceLabelsEndpoint,
+    ExportWorkspaceUserActivityEndpoint
+)
+
+from .workspace.member import (
+    WorkSpaceMemberViewSet,
+    TeamMemberViewSet,
+    WorkspaceMemberUserEndpoint,
    WorkspaceProjectMemberEndpoint,
-    WorkspaceUserPropertiesEndpoint,
+    WorkspaceMemberUserViewsEndpoint,
+)
+from .workspace.invite import (
+    WorkspaceInvitationsViewset,
+    WorkspaceJoinEndpoint,
+    UserWorkspaceInvitationsViewSet,
+)
+from .workspace.label import (
+    WorkspaceLabelsEndpoint,
+)
+from .workspace.state import (
    WorkspaceStatesEndpoint,
+)
+from .workspace.user import (
+    UserLastProjectWithWorkspaceEndpoint,
+    WorkspaceUserProfileIssuesEndpoint,
+    WorkspaceUserPropertiesEndpoint,
+    WorkspaceUserProfileEndpoint,
+    WorkspaceUserActivityEndpoint,
+    WorkspaceUserProfileStatsEndpoint,
+    UserActivityGraphEndpoint,
+    UserIssueCompletedGraphEndpoint,
+)
+from .workspace.estimate import (
    WorkspaceEstimatesEndpoint,
 )
-from .state import StateViewSet
-from .view import (
+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,
    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 (
@@ -103,36 +164,21 @@ from .authentication import (
    MagicSignInEndpoint,
 )

-from .module import (
+from .module.base import (
    ModuleViewSet,
-    ModuleIssueViewSet,
    ModuleLinkViewSet,
    ModuleFavoriteViewSet,
    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,
@@ -142,20 +188,19 @@ from .page import (
 from .search import GlobalSearchEndpoint, IssueSearchEndpoint


-from .external import (
+from .external.base import (
    GPTIntegrationEndpoint,
-    ReleaseNotesEndpoint,
    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,
@@ -163,24 +208,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, MobileConfigurationEndpoint

-from .webhook import (
+from .webhook.base import (
    WebhookEndpoint,
    WebhookLogsEndpoint,
    WebhookSecretRegenerateEndpoint,
 )

-from .dashboard import (
-    DashboardEndpoint,
-    WidgetsEndpoint
-)
+from .dashboard.base import DashboardEndpoint, WidgetsEndpoint
+
+from .error_404 import custom_404_view
@@ -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(
                {
@@ -265,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(
                {
@@ -331,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("*"))
@@ -43,7 +43,7 @@ class ApiTokenEndpoint(BaseAPIView):
        )

    def get(self, request, slug, pk=None):
-        if pk == None:
+        if pk is None:
            api_tokens = APIToken.objects.filter(
                user=request.user, workspace__slug=slug
            )
@@ -4,7 +4,7 @@ from rest_framework.response import Response
 from rest_framework.parsers import MultiPartParser, FormParser, JSONParser

 # Module imports
-from .base import BaseAPIView, BaseViewSet
+from ..base import BaseAPIView, BaseViewSet
 from plane.db.models import FileAsset, Workspace
 from plane.app.serializers import FileAssetSerializer

@@ -16,7 +16,6 @@ from django.contrib.auth.hashers import make_password
 from django.utils.http import urlsafe_base64_decode, urlsafe_base64_encode
 from django.core.validators import validate_email
 from django.core.exceptions import ValidationError
-from django.conf import settings

 ## Third Party Imports
 from rest_framework import status
@@ -172,7 +171,7 @@ class ResetPasswordEndpoint(BaseAPIView):
                serializer.errors, status=status.HTTP_400_BAD_REQUEST
            )

-        except DjangoUnicodeDecodeError as indentifier:
+        except DjangoUnicodeDecodeError:
            return Response(
                {"error": "token is not valid, please check the new one"},
                status=status.HTTP_401_UNAUTHORIZED,
@@ -401,8 +400,8 @@ class EmailCheckEndpoint(BaseAPIView):
                email=email,
                user_agent=request.META.get("HTTP_USER_AGENT"),
                ip=request.META.get("REMOTE_ADDR"),
-                event_name="SIGN_IN",
-                medium="MAGIC_LINK",
+                event_name="Sign up",
+                medium="Magic link",
                first_time=True,
            )
            key, token, current_attempt = generate_magic_token(email=email)
@@ -438,8 +437,8 @@ class EmailCheckEndpoint(BaseAPIView):
                    email=email,
                    user_agent=request.META.get("HTTP_USER_AGENT"),
                    ip=request.META.get("REMOTE_ADDR"),
-                    event_name="SIGN_IN",
-                    medium="MAGIC_LINK",
+                    event_name="Sign in",
+                    medium="Magic link",
                    first_time=False,
                )

@@ -468,8 +467,8 @@ class EmailCheckEndpoint(BaseAPIView):
                    email=email,
                    user_agent=request.META.get("HTTP_USER_AGENT"),
                    ip=request.META.get("REMOTE_ADDR"),
-                    event_name="SIGN_IN",
-                    medium="EMAIL",
+                    event_name="Sign in",
+                    medium="Email",
                    first_time=False,
                )

@@ -7,7 +7,6 @@ import json
 from django.utils import timezone
 from django.core.exceptions import ValidationError
 from django.core.validators import validate_email
-from django.conf import settings
 from django.contrib.auth.hashers import make_password

 # Third party imports
@@ -65,7 +64,7 @@ class SignUpEndpoint(BaseAPIView):
        email = email.strip().lower()
        try:
            validate_email(email)
-        except ValidationError as e:
+        except ValidationError:
            return Response(
                {"error": "Please provide a valid email address."},
                status=status.HTTP_400_BAD_REQUEST,
@@ -151,7 +150,7 @@ class SignInEndpoint(BaseAPIView):
        email = email.strip().lower()
        try:
            validate_email(email)
-        except ValidationError as e:
+        except ValidationError:
            return Response(
                {"error": "Please provide a valid email address."},
                status=status.HTTP_400_BAD_REQUEST,
@@ -238,9 +237,11 @@ class SignInEndpoint(BaseAPIView):
            [
                WorkspaceMember(
                    workspace_id=project_member_invite.workspace_id,
-                    role=project_member_invite.role
-                    if project_member_invite.role in [5, 10, 15]
-                    else 15,
+                    role=(
+                        project_member_invite.role
+                        if project_member_invite.role in [5, 10, 15]
+                        else 15
+                    ),
                    member=user,
                    created_by_id=project_member_invite.created_by_id,
                )
@@ -254,9 +255,11 @@ class SignInEndpoint(BaseAPIView):
            [
                ProjectMember(
                    workspace_id=project_member_invite.workspace_id,
-                    role=project_member_invite.role
-                    if project_member_invite.role in [5, 10, 15]
-                    else 15,
+                    role=(
+                        project_member_invite.role
+                        if project_member_invite.role in [5, 10, 15]
+                        else 15
+                    ),
                    member=user,
                    created_by_id=project_member_invite.created_by_id,
                )
@@ -274,8 +277,8 @@ class SignInEndpoint(BaseAPIView):
            email=email,
            user_agent=request.META.get("HTTP_USER_AGENT"),
            ip=request.META.get("REMOTE_ADDR"),
-            event_name="SIGN_IN",
-            medium="EMAIL",
+            event_name="Sign in",
+            medium="Email",
            first_time=False,
        )

@@ -349,8 +352,8 @@ class MagicSignInEndpoint(BaseAPIView):
                    email=email,
                    user_agent=request.META.get("HTTP_USER_AGENT"),
                    ip=request.META.get("REMOTE_ADDR"),
-                    event_name="SIGN_IN",
-                    medium="MAGIC_LINK",
+                    event_name="Sign in",
+                    medium="Magic link",
                    first_time=False,
                )

@@ -392,9 +395,11 @@ class MagicSignInEndpoint(BaseAPIView):
                    [
                        WorkspaceMember(
                            workspace_id=project_member_invite.workspace_id,
-                            role=project_member_invite.role
-                            if project_member_invite.role in [5, 10, 15]
-                            else 15,
+                            role=(
+                                project_member_invite.role
+                                if project_member_invite.role in [5, 10, 15]
+                                else 15
+                            ),
                            member=user,
                            created_by_id=project_member_invite.created_by_id,
                        )
@@ -408,9 +413,11 @@ class MagicSignInEndpoint(BaseAPIView):
                    [
                        ProjectMember(
                            workspace_id=project_member_invite.workspace_id,
-                            role=project_member_invite.role
-                            if project_member_invite.role in [5, 10, 15]
-                            else 15,
+                            role=(
+                                project_member_invite.role
+                                if project_member_invite.role in [5, 10, 15]
+                                else 15
+                            ),
                            member=user,
                            created_by_id=project_member_invite.created_by_id,
                        )
@@ -1,6 +1,5 @@
 # Python imports
 import zoneinfo
-import json

 # Django imports
 from django.urls import resolve
@@ -8,11 +7,9 @@ from django.conf import settings
 from django.utils import timezone
 from django.db import IntegrityError
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
-from django.core.serializers.json import DjangoJSONEncoder

 # Third part imports
 from rest_framework import status
-from rest_framework import status
 from rest_framework.viewsets import ModelViewSet
 from rest_framework.response import Response
 from rest_framework.exceptions import APIException
@@ -64,6 +61,7 @@ class WebhookMixin:
                action=self.request.method,
                slug=self.workspace_slug,
                bulk=self.bulk,
+                current_site=request.META.get("HTTP_ORIGIN"),
            )

        return response
@@ -118,14 +116,14 @@ class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):

            if isinstance(e, ObjectDoesNotExist):
                return Response(
-                    {"error": f"The required object does not exist."},
+                    {"error": "The required object does not exist."},
                    status=status.HTTP_404_NOT_FOUND,
                )

            if isinstance(e, KeyError):
                capture_exception(e)
                return Response(
-                    {"error": f"The required key does not exist."},
+                    {"error": "The required key does not exist."},
                    status=status.HTTP_400_BAD_REQUEST,
                )

@@ -225,13 +223,13 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):

            if isinstance(e, ObjectDoesNotExist):
                return Response(
-                    {"error": f"The required object does not exist."},
+                    {"error": "The required object does not exist."},
                    status=status.HTTP_404_NOT_FOUND,
                )

            if isinstance(e, KeyError):
                return Response(
-                    {"error": f"The required key does not exist."},
+                    {"error": "The required key does not exist."},
                    status=status.HTTP_400_BAD_REQUEST,
                )

@@ -2,7 +2,6 @@
 import os

 # Django imports
-from django.conf import settings

 # Third party imports
 from rest_framework.permissions import AllowAny
@@ -12,13 +11,14 @@ from rest_framework.response import Response
 # Module imports
 from .base import BaseAPIView
 from plane.license.utils.instance_value import get_configuration_value
-
+from plane.utils.cache import cache_response

 class ConfigurationEndpoint(BaseAPIView):
    permission_classes = [
        AllowAny,
    ]

+    @cache_response(60 * 60 * 2, user=False)
    def get(self, request):
        # Get all the configuration
        (
@@ -66,15 +66,15 @@ class ConfigurationEndpoint(BaseAPIView):
                },
                {
                    "key": "SLACK_CLIENT_ID",
-                    "default": os.environ.get("SLACK_CLIENT_ID", "1"),
+                    "default": os.environ.get("SLACK_CLIENT_ID", None),
                },
                {
                    "key": "POSTHOG_API_KEY",
-                    "default": os.environ.get("POSTHOG_API_KEY", "1"),
+                    "default": os.environ.get("POSTHOG_API_KEY", None),
                },
                {
                    "key": "POSTHOG_HOST",
-                    "default": os.environ.get("POSTHOG_HOST", "1"),
+                    "default": os.environ.get("POSTHOG_HOST", None),
                },
                {
                    "key": "UNSPLASH_ACCESS_KEY",
@@ -136,6 +136,7 @@ class MobileConfigurationEndpoint(BaseAPIView):
        AllowAny,
    ]

+    @cache_response(60 * 60 * 2, user=False)
    def get(self, request):
        (
            GOOGLE_CLIENT_ID,
@@ -181,11 +182,11 @@ class MobileConfigurationEndpoint(BaseAPIView):
                },
                {
                    "key": "POSTHOG_API_KEY",
-                    "default": os.environ.get("POSTHOG_API_KEY", "1"),
+                    "default": os.environ.get("POSTHOG_API_KEY", None),
                },
                {
                    "key": "POSTHOG_HOST",
-                    "default": os.environ.get("POSTHOG_HOST", "1"),
+                    "default": os.environ.get("POSTHOG_HOST", None),
                },
                {
                    "key": "UNSPLASH_ACCESS_KEY",
@@ -10,7 +10,6 @@ from django.db.models import (
    OuterRef,
    Count,
    Prefetch,
-    Sum,
    Case,
    When,
    Value,
@@ -20,19 +19,22 @@ from django.core import serializers
 from django.utils import timezone
 from django.utils.decorators import method_decorator
 from django.views.decorators.gzip import gzip_page
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import UUIDField
+from django.db.models.functions import Coalesce

 # Third party imports
 from rest_framework.response import Response
 from rest_framework import status

 # Module imports
-from . import BaseViewSet, BaseAPIView, WebhookMixin
+from .. import BaseViewSet, BaseAPIView, WebhookMixin
 from plane.app.serializers import (
    CycleSerializer,
    CycleIssueSerializer,
    CycleFavoriteSerializer,
    IssueSerializer,
-    IssueStateSerializer,
    CycleWriteSerializer,
    CycleUserPropertiesSerializer,
 )
@@ -50,7 +52,6 @@ from plane.db.models import (
    IssueAttachment,
    Label,
    CycleUserProperties,
-    IssueSubscriber,
 )
 from plane.bgtasks.issue_activites_task import issue_activity
 from plane.utils.issue_filters import issue_filters
@@ -72,7 +73,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
        )

    def get_queryset(self):
-        subquery = CycleFavorite.objects.filter(
+        favorite_subquery = CycleFavorite.objects.filter(
            user=self.request.user,
            cycle_id=OuterRef("pk"),
            project_id=self.kwargs.get("project_id"),
@@ -83,11 +84,28 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
            .get_queryset()
            .filter(workspace__slug=self.kwargs.get("slug"))
            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("owned_by")
-            .annotate(is_favorite=Exists(subquery))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .select_related("project", "workspace", "owned_by")
+            .prefetch_related(
+                Prefetch(
+                    "issue_cycle__issue__assignees",
+                    queryset=User.objects.only(
+                        "avatar", "first_name", "id"
+                    ).distinct(),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_cycle__issue__labels",
+                    queryset=Label.objects.only(
+                        "name", "color", "id"
+                    ).distinct(),
+                )
+            )
+            .annotate(is_favorite=Exists(favorite_subquery))
            .annotate(
                total_issues=Count(
                    "issue_cycle",
@@ -147,29 +165,6 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                    ),
                )
            )
-            .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,
-                    ),
-                )
-            )
            .annotate(
                status=Case(
                    When(
@@ -189,20 +184,16 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                    output_field=CharField(),
                )
            )
-            .prefetch_related(
-                Prefetch(
-                    "issue_cycle__issue__assignees",
-                    queryset=User.objects.only(
-                        "avatar", "first_name", "id"
-                    ).distinct(),
-                )
-            )
-            .prefetch_related(
-                Prefetch(
-                    "issue_cycle__issue__labels",
-                    queryset=Label.objects.only(
-                        "name", "color", "id"
-                    ).distinct(),
+            .annotate(
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_cycle__issue__assignees__id",
+                        distinct=True,
+                        filter=~Q(
+                            issue_cycle__issue__assignees__id__isnull=True
+                        ),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
                )
            )
            .order_by("-is_favorite", "name")
@@ -212,12 +203,8 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
    def list(self, request, slug, project_id):
        queryset = self.get_queryset()
        cycle_view = request.GET.get("cycle_view", "all")
-        fields = [
-            field
-            for field in request.GET.get("fields", "").split(",")
-            if field
-        ]

+        # Update the order by
        queryset = queryset.order_by("-is_favorite", "-created_at")

        # Current Cycle
@@ -227,9 +214,35 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                end_date__gte=timezone.now(),
            )

-            data = CycleSerializer(queryset, many=True).data
+            data = queryset.values(
+                # 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",
+                "assignee_ids",
+                "status",
+            )

-            if len(data):
+            if data:
                assignee_distribution = (
                    Issue.objects.filter(
                        issue_cycle__cycle_id=data[0]["id"],
@@ -242,13 +255,13 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                    .values("display_name", "assignee_id", "avatar")
                    .annotate(
                        total_issues=Count(
-                            "assignee_id",
+                            "id",
                            filter=Q(archived_at__isnull=True, is_draft=False),
                        ),
                    )
                    .annotate(
                        completed_issues=Count(
-                            "assignee_id",
+                            "id",
                            filter=Q(
                                completed_at__isnull=False,
                                archived_at__isnull=True,
@@ -258,7 +271,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                    )
                    .annotate(
                        pending_issues=Count(
-                            "assignee_id",
+                            "id",
                            filter=Q(
                                completed_at__isnull=True,
                                archived_at__isnull=True,
@@ -281,13 +294,13 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                    .values("label_name", "color", "label_id")
                    .annotate(
                        total_issues=Count(
-                            "label_id",
+                            "id",
                            filter=Q(archived_at__isnull=True, is_draft=False),
                        )
                    )
                    .annotate(
                        completed_issues=Count(
-                            "label_id",
+                            "id",
                            filter=Q(
                                completed_at__isnull=False,
                                archived_at__isnull=True,
@@ -297,7 +310,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                    )
                    .annotate(
                        pending_issues=Count(
-                            "label_id",
+                            "id",
                            filter=Q(
                                completed_at__isnull=True,
                                archived_at__isnull=True,
@@ -312,6 +325,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                    "labels": label_distribution,
                    "completion_chart": {},
                }
+
                if data[0]["start_date"] and data[0]["end_date"]:
                    data[0]["distribution"][
                        "completion_chart"
@@ -324,8 +338,34 @@ class CycleViewSet(WebhookMixin, BaseViewSet):

            return Response(data, status=status.HTTP_200_OK)

-        cycles = CycleSerializer(queryset, many=True).data
-        return Response(cycles, status=status.HTTP_200_OK)
+        data = queryset.values(
+            # 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",
+            "assignee_ids",
+            "status",
+        )
+        return Response(data, status=status.HTTP_200_OK)

    def create(self, request, slug, project_id):
        if (
@@ -335,7 +375,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
            request.data.get("start_date", None) is not None
            and request.data.get("end_date", None) is not None
        ):
-            serializer = CycleSerializer(data=request.data)
+            serializer = CycleWriteSerializer(data=request.data)
            if serializer.is_valid():
                serializer.save(
                    project_id=project_id,
@@ -344,12 +384,36 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                cycle = (
                    self.get_queryset()
                    .filter(pk=serializer.data["id"])
+                    .values(
+                        # 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",
+                        "assignee_ids",
+                        "status",
+                    )
                    .first()
                )
-                serializer = CycleSerializer(cycle)
-                return Response(
-                    serializer.data, status=status.HTTP_201_CREATED
-                )
+                return Response(cycle, status=status.HTTP_201_CREATED)
            return Response(
                serializer.errors, status=status.HTTP_400_BAD_REQUEST
            )
@@ -362,10 +426,10 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
            )

    def partial_update(self, request, slug, project_id, pk):
-        cycle = Cycle.objects.get(
+        queryset = self.get_queryset().filter(
            workspace__slug=slug, project_id=project_id, pk=pk
        )
-
+        cycle = queryset.first()
        request_data = request.data

        if (
@@ -373,7 +437,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
            and cycle.end_date < timezone.now().date()
        ):
            if "sort_order" in request_data:
-                # Can only change sort order
+                # Can only change sort order for a completed cycle``
                request_data = {
                    "sort_order": request_data.get(
                        "sort_order", cycle.sort_order
@@ -392,12 +456,71 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
        )
        if serializer.is_valid():
            serializer.save()
-            return Response(serializer.data, status=status.HTTP_200_OK)
+            cycle = queryset.values(
+                # 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",
+                "assignee_ids",
+                "status",
+            ).first()
+            return Response(cycle, status=status.HTTP_200_OK)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def retrieve(self, request, slug, project_id, pk):
-        queryset = self.get_queryset().get(pk=pk)
-
+        queryset = self.get_queryset().filter(pk=pk)
+        data = (
+            self.get_queryset()
+            .filter(pk=pk)
+            .values(
+                # 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",
+                "assignee_ids",
+                "status",
+            )
+            .first()
+        )
+        queryset = queryset.first()
        # Assignee Distribution
        assignee_distribution = (
            Issue.objects.filter(
@@ -419,13 +542,13 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
            )
            .annotate(
                total_issues=Count(
-                    "assignee_id",
+                    "id",
                    filter=Q(archived_at__isnull=True, is_draft=False),
                ),
            )
            .annotate(
                completed_issues=Count(
-                    "assignee_id",
+                    "id",
                    filter=Q(
                        completed_at__isnull=False,
                        archived_at__isnull=True,
@@ -435,7 +558,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
            )
            .annotate(
                pending_issues=Count(
-                    "assignee_id",
+                    "id",
                    filter=Q(
                        completed_at__isnull=True,
                        archived_at__isnull=True,
@@ -459,13 +582,13 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
            .values("label_name", "color", "label_id")
            .annotate(
                total_issues=Count(
-                    "label_id",
+                    "id",
                    filter=Q(archived_at__isnull=True, is_draft=False),
                ),
            )
            .annotate(
                completed_issues=Count(
-                    "label_id",
+                    "id",
                    filter=Q(
                        completed_at__isnull=False,
                        archived_at__isnull=True,
@@ -475,7 +598,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
            )
            .annotate(
                pending_issues=Count(
-                    "label_id",
+                    "id",
                    filter=Q(
                        completed_at__isnull=True,
                        archived_at__isnull=True,
@@ -486,7 +609,6 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
            .order_by("label_name")
        )

-        data = CycleSerializer(queryset).data
        data["distribution"] = {
            "assignees": assignee_distribution,
            "labels": label_distribution,
@@ -538,232 +660,6 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
        return Response(status=status.HTTP_204_NO_CONTENT)


-class CycleIssueViewSet(WebhookMixin, BaseViewSet):
-    serializer_class = CycleIssueSerializer
-    model = CycleIssue
-
-    webhook_event = "cycle_issue"
-    bulk = True
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    filterset_fields = [
-        "issue__labels__id",
-        "issue__assignees__id",
-    ]
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .annotate(
-                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(cycle_id=self.kwargs.get("cycle_id"))
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("cycle")
-            .select_related("issue", "issue__state", "issue__project")
-            .prefetch_related("issue__assignees", "issue__labels")
-            .distinct()
-        )
-
-    @method_decorator(gzip_page)
-    def list(self, request, slug, project_id, cycle_id):
-        fields = [
-            field
-            for field in request.GET.get("fields", "").split(",")
-            if field
-        ]
-        order_by = request.GET.get("order_by", "created_at")
-        filters = issue_filters(request.query_params, "GET")
-        issues = (
-            Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .filter(project_id=project_id)
-            .filter(workspace__slug=slug)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("state")
-            .select_related("parent")
-            .prefetch_related("assignees")
-            .prefetch_related("labels")
-            .order_by(order_by)
-            .filter(**filters)
-            .annotate(cycle_id=F("issue_cycle__cycle_id"))
-            .annotate(module_id=F("issue_module__module_id"))
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                is_subscribed=Exists(
-                    IssueSubscriber.objects.filter(
-                        subscriber=self.request.user, issue_id=OuterRef("id")
-                    )
-                )
-            )
-        )
-        serializer = IssueSerializer(
-            issues, many=True, fields=fields if fields else None
-        )
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def create(self, request, slug, project_id, cycle_id):
-        issues = request.data.get("issues", [])
-
-        if not len(issues):
-            return Response(
-                {"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()
-        ):
-            return Response(
-                {
-                    "error": "The Cycle has already been completed so no new issues can be added"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get all CycleIssues already created
-        cycle_issues = list(CycleIssue.objects.filter(issue_id__in=issues))
-        update_cycle_issue_activity = []
-        record_to_create = []
-        records_to_update = []
-
-        for issue in issues:
-            cycle_issue = [
-                cycle_issue
-                for cycle_issue in cycle_issues
-                if str(cycle_issue.issue_id) in issues
-            ]
-            # Update only when cycle changes
-            if len(cycle_issue):
-                if cycle_issue[0].cycle_id != cycle_id:
-                    update_cycle_issue_activity.append(
-                        {
-                            "old_cycle_id": str(cycle_issue[0].cycle_id),
-                            "new_cycle_id": str(cycle_id),
-                            "issue_id": str(cycle_issue[0].issue_id),
-                        }
-                    )
-                    cycle_issue[0].cycle_id = cycle_id
-                    records_to_update.append(cycle_issue[0])
-            else:
-                record_to_create.append(
-                    CycleIssue(
-                        project_id=project_id,
-                        workspace=cycle.workspace,
-                        created_by=request.user,
-                        updated_by=request.user,
-                        cycle=cycle,
-                        issue_id=issue,
-                    )
-                )
-
-        CycleIssue.objects.bulk_create(
-            record_to_create,
-            batch_size=10,
-            ignore_conflicts=True,
-        )
-        CycleIssue.objects.bulk_update(
-            records_to_update,
-            ["cycle"],
-            batch_size=10,
-        )
-
-        # Capture Issue Activity
-        issue_activity.delay(
-            type="cycle.activity.created",
-            requested_data=json.dumps({"cycles_list": issues}),
-            actor_id=str(self.request.user.id),
-            issue_id=None,
-            project_id=str(self.kwargs.get("project_id", None)),
-            current_instance=json.dumps(
-                {
-                    "updated_cycle_issues": update_cycle_issue_activity,
-                    "created_cycle_issues": serializers.serialize(
-                        "json", record_to_create
-                    ),
-                }
-            ),
-            epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-
-        # Return all Cycle Issues
-        issues = self.get_queryset().values_list("issue_id", flat=True)
-
-        return Response(
-            IssueSerializer(
-                Issue.objects.filter(pk__in=issues), many=True
-            ).data,
-            status=status.HTTP_200_OK,
-        )
-
-    def destroy(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_activity.delay(
-            type="cycle.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "cycle_id": str(self.kwargs.get("cycle_id")),
-                    "issues": [str(issue_id)],
-                }
-            ),
-            actor_id=str(self.request.user.id),
-            issue_id=str(issue_id),
-            project_id=str(self.kwargs.get("project_id", None)),
-            current_instance=None,
-            epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-        cycle_issue.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
 class CycleDateCheckEndpoint(BaseAPIView):
    permission_classes = [
        ProjectEntityPermission,
@@ -779,6 +675,7 @@ class CycleDateCheckEndpoint(BaseAPIView):
                status=status.HTTP_400_BAD_REQUEST,
            )

+        # Check if any cycle intersects in the given interval
        cycles = Cycle.objects.filter(
            Q(workspace__slug=slug)
            & Q(project_id=project_id)
@@ -788,7 +685,6 @@ class CycleDateCheckEndpoint(BaseAPIView):
                | Q(start_date__gte=start_date, end_date__lte=end_date)
            )
        ).exclude(pk=cycle_id)
-
        if cycles.exists():
            return Response(
                {
@@ -845,10 +741,225 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                status=status.HTTP_400_BAD_REQUEST,
            )

-        new_cycle = Cycle.objects.get(
+        new_cycle = Cycle.objects.filter(
            workspace__slug=slug, project_id=project_id, pk=new_cycle_id
+        ).first()
+
+        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")
+        )
+
+        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
+        ]
+
+        # 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()
+
+        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,
+            },
+        }
+        current_cycle.save(update_fields=["progress_snapshot"])
+
        if (
            new_cycle.end_date is not None
            and new_cycle.end_date < timezone.now().date()
@@ -0,0 +1,312 @@
+# Python imports
+import json
+
+# Django imports
+from django.db.models import (
+    Func,
+    F,
+    Q,
+    OuterRef,
+    Value,
+    UUIDField,
+)
+from django.core import serializers
+from django.utils import timezone
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models.functions import Coalesce
+
+# Third party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet, WebhookMixin
+from plane.app.serializers import (
+    IssueSerializer,
+    CycleIssueSerializer,
+)
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import (
+    Cycle,
+    CycleIssue,
+    Issue,
+    IssueLink,
+    IssueAttachment,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from plane.utils.issue_filters import issue_filters
+
+
+class CycleIssueViewSet(WebhookMixin, BaseViewSet):
+    serializer_class = CycleIssueSerializer
+    model = CycleIssue
+
+    webhook_event = "cycle_issue"
+    bulk = True
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    filterset_fields = [
+        "issue__labels__id",
+        "issue__assignees__id",
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .annotate(
+                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,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(cycle_id=self.kwargs.get("cycle_id"))
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("cycle")
+            .select_related("issue", "issue__state", "issue__project")
+            .prefetch_related("issue__assignees", "issue__labels")
+            .distinct()
+        )
+
+    @method_decorator(gzip_page)
+    def list(self, request, slug, project_id, cycle_id):
+        fields = [
+            field
+            for field in request.GET.get("fields", "").split(",")
+            if field
+        ]
+        order_by = request.GET.get("order_by", "created_at")
+        filters = issue_filters(request.query_params, "GET")
+        queryset = (
+            Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
+            .filter(project_id=project_id)
+            .filter(workspace__slug=slug)
+            .filter(**filters)
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related(
+                "assignees",
+                "labels",
+                "issue_module__module",
+                "issue_cycle__cycle",
+            )
+            .order_by(order_by)
+            .filter(**filters)
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "labels__id",
+                        distinct=True,
+                        filter=~Q(labels__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "assignees__id",
+                        distinct=True,
+                        filter=~Q(assignees__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=~Q(issue_module__module_id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+            .order_by(order_by)
+        )
+        if self.fields:
+            issues = IssueSerializer(
+                queryset, many=True, fields=fields if fields else None
+            ).data
+        else:
+            issues = queryset.values(
+                "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",
+            )
+        return Response(issues, status=status.HTTP_200_OK)
+
+    def create(self, request, slug, project_id, cycle_id):
+        issues = request.data.get("issues", [])
+
+        if not issues:
+            return Response(
+                {"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()
+        ):
+            return Response(
+                {
+                    "error": "The Cycle has already been completed so no new issues can be added"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get all CycleIssues already created
+        cycle_issues = list(
+            CycleIssue.objects.filter(
+                ~Q(cycle_id=cycle_id), issue_id__in=issues
+            )
+        )
+        existing_issues = [
+            str(cycle_issue.issue_id) for cycle_issue in cycle_issues
+        ]
+        new_issues = list(set(issues) - set(existing_issues))
+
+        # New issues to create
+        created_records = CycleIssue.objects.bulk_create(
+            [
+                CycleIssue(
+                    project_id=project_id,
+                    workspace_id=cycle.workspace_id,
+                    created_by_id=request.user.id,
+                    updated_by_id=request.user.id,
+                    cycle_id=cycle_id,
+                    issue_id=issue,
+                )
+                for issue in new_issues
+            ],
+            batch_size=10,
+        )
+
+        # Updated Issues
+        updated_records = []
+        update_cycle_issue_activity = []
+        # Iterate over each cycle_issue in cycle_issues
+        for cycle_issue in cycle_issues:
+            # Update the cycle_issue's cycle_id
+            cycle_issue.cycle_id = cycle_id
+            # Add the modified cycle_issue to the records_to_update list
+            updated_records.append(cycle_issue)
+            # Record the update activity
+            update_cycle_issue_activity.append(
+                {
+                    "old_cycle_id": str(cycle_issue.cycle_id),
+                    "new_cycle_id": str(cycle_id),
+                    "issue_id": str(cycle_issue.issue_id),
+                }
+            )
+
+        # Update the cycle issues
+        CycleIssue.objects.bulk_update(
+            updated_records, ["cycle_id"], batch_size=100
+        )
+        # Capture Issue Activity
+        issue_activity.delay(
+            type="cycle.activity.created",
+            requested_data=json.dumps({"cycles_list": issues}),
+            actor_id=str(self.request.user.id),
+            issue_id=None,
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps(
+                {
+                    "updated_cycle_issues": update_cycle_issue_activity,
+                    "created_cycle_issues": serializers.serialize(
+                        "json", created_records
+                    ),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
+
+    def destroy(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_activity.delay(
+            type="cycle.activity.deleted",
+            requested_data=json.dumps(
+                {
+                    "cycle_id": str(self.kwargs.get("cycle_id")),
+                    "issues": [str(issue_id)],
+                }
+            ),
+            actor_id=str(self.request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        cycle_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -9,12 +9,16 @@ from django.db.models import (
    F,
    Exists,
    OuterRef,
-    Max,
    Subquery,
    JSONField,
    Func,
    Prefetch,
+    IntegerField,
 )
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import UUIDField
+from django.db.models.functions import Coalesce
 from django.utils import timezone

 # Third Party imports
@@ -22,7 +26,7 @@ from rest_framework.response import Response
 from rest_framework import status

 # Module imports
-from . import BaseAPIView
+from .. import BaseAPIView
 from plane.db.models import (
    Issue,
    IssueActivity,
@@ -34,6 +38,8 @@ from plane.db.models import (
    IssueLink,
    IssueAttachment,
    IssueRelation,
+    IssueAssignee,
+    User,
 )
 from plane.app.serializers import (
    IssueActivitySerializer,
@@ -54,6 +60,7 @@ def dashboard_overview_stats(self, request, slug):

    pending_issues_count = Issue.issue_objects.filter(
        ~Q(state__group__in=["completed", "cancelled"]),
+        target_date__lt=timezone.now().date(),
        project__project_projectmember__is_active=True,
        project__project_projectmember__member=request.user,
        workspace__slug=slug,
@@ -100,7 +107,7 @@ def dashboard_assigned_issues(self, request, slug):
        )
        .filter(**filters)
        .select_related("workspace", "project", "state", "parent")
-        .prefetch_related("assignees", "labels")
+        .prefetch_related("assignees", "labels", "issue_module__module")
        .prefetch_related(
            Prefetch(
                "issue_relation",
@@ -110,7 +117,6 @@ def dashboard_assigned_issues(self, request, slug):
            )
        )
        .annotate(cycle_id=F("issue_cycle__cycle_id"))
-        .annotate(module_id=F("issue_module__module_id"))
        .annotate(
            link_count=IssueLink.objects.filter(issue=OuterRef("id"))
            .order_by()
@@ -131,7 +137,32 @@ def dashboard_assigned_issues(self, request, slug):
            .annotate(count=Func(F("id"), function="Count"))
            .values("count")
        )
-        .order_by("created_at")
+        .annotate(
+            label_ids=Coalesce(
+                ArrayAgg(
+                    "labels__id",
+                    distinct=True,
+                    filter=~Q(labels__id__isnull=True),
+                ),
+                Value([], output_field=ArrayField(UUIDField())),
+            ),
+            assignee_ids=Coalesce(
+                ArrayAgg(
+                    "assignees__id",
+                    distinct=True,
+                    filter=~Q(assignees__id__isnull=True),
+                ),
+                Value([], output_field=ArrayField(UUIDField())),
+            ),
+            module_ids=Coalesce(
+                ArrayAgg(
+                    "issue_module__module_id",
+                    distinct=True,
+                    filter=~Q(issue_module__module_id__isnull=True),
+                ),
+                Value([], output_field=ArrayField(UUIDField())),
+            ),
+        )
    )

    # Priority Ordering
@@ -146,6 +177,23 @@ def dashboard_assigned_issues(self, request, slug):
        )
    ).order_by("priority_order")

+    if issue_type == "pending":
+        pending_issues_count = assigned_issues.filter(
+            state__group__in=["backlog", "started", "unstarted"]
+        ).count()
+        pending_issues = assigned_issues.filter(
+            state__group__in=["backlog", "started", "unstarted"]
+        )[:5]
+        return Response(
+            {
+                "issues": IssueSerializer(
+                    pending_issues, many=True, expand=self.expand
+                ).data,
+                "count": pending_issues_count,
+            },
+            status=status.HTTP_200_OK,
+        )
+
    if issue_type == "completed":
        completed_issues_count = assigned_issues.filter(
            state__group__in=["completed"]
@@ -166,11 +214,11 @@ def dashboard_assigned_issues(self, request, slug):
    if issue_type == "overdue":
        overdue_issues_count = assigned_issues.filter(
            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now()
+            target_date__lt=timezone.now(),
        ).count()
        overdue_issues = assigned_issues.filter(
            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now()
+            target_date__lt=timezone.now(),
        )[:5]
        return Response(
            {
@@ -185,11 +233,11 @@ def dashboard_assigned_issues(self, request, slug):
    if issue_type == "upcoming":
        upcoming_issues_count = assigned_issues.filter(
            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now()
+            target_date__gte=timezone.now(),
        ).count()
        upcoming_issues = assigned_issues.filter(
            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now()
+            target_date__gte=timezone.now(),
        )[:5]
        return Response(
            {
@@ -221,9 +269,8 @@ def dashboard_created_issues(self, request, slug):
        )
        .filter(**filters)
        .select_related("workspace", "project", "state", "parent")
-        .prefetch_related("assignees", "labels")
+        .prefetch_related("assignees", "labels", "issue_module__module")
        .annotate(cycle_id=F("issue_cycle__cycle_id"))
-        .annotate(module_id=F("issue_module__module_id"))
        .annotate(
            link_count=IssueLink.objects.filter(issue=OuterRef("id"))
            .order_by()
@@ -244,6 +291,32 @@ def dashboard_created_issues(self, request, slug):
            .annotate(count=Func(F("id"), function="Count"))
            .values("count")
        )
+        .annotate(
+            label_ids=Coalesce(
+                ArrayAgg(
+                    "labels__id",
+                    distinct=True,
+                    filter=~Q(labels__id__isnull=True),
+                ),
+                Value([], output_field=ArrayField(UUIDField())),
+            ),
+            assignee_ids=Coalesce(
+                ArrayAgg(
+                    "assignees__id",
+                    distinct=True,
+                    filter=~Q(assignees__id__isnull=True),
+                ),
+                Value([], output_field=ArrayField(UUIDField())),
+            ),
+            module_ids=Coalesce(
+                ArrayAgg(
+                    "issue_module__module_id",
+                    distinct=True,
+                    filter=~Q(issue_module__module_id__isnull=True),
+                ),
+                Value([], output_field=ArrayField(UUIDField())),
+            ),
+        )
        .order_by("created_at")
    )

@@ -259,6 +332,23 @@ def dashboard_created_issues(self, request, slug):
        )
    ).order_by("priority_order")

+    if issue_type == "pending":
+        pending_issues_count = created_issues.filter(
+            state__group__in=["backlog", "started", "unstarted"]
+        ).count()
+        pending_issues = created_issues.filter(
+            state__group__in=["backlog", "started", "unstarted"]
+        )[:5]
+        return Response(
+            {
+                "issues": IssueSerializer(
+                    pending_issues, many=True, expand=self.expand
+                ).data,
+                "count": pending_issues_count,
+            },
+            status=status.HTTP_200_OK,
+        )
+
    if issue_type == "completed":
        completed_issues_count = created_issues.filter(
            state__group__in=["completed"]
@@ -277,11 +367,11 @@ def dashboard_created_issues(self, request, slug):
    if issue_type == "overdue":
        overdue_issues_count = created_issues.filter(
            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now()
+            target_date__lt=timezone.now(),
        ).count()
        overdue_issues = created_issues.filter(
            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now()
+            target_date__lt=timezone.now(),
        )[:5]
        return Response(
            {
@@ -294,11 +384,11 @@ def dashboard_created_issues(self, request, slug):
    if issue_type == "upcoming":
        upcoming_issues_count = created_issues.filter(
            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now()
+            target_date__gte=timezone.now(),
        ).count()
        upcoming_issues = created_issues.filter(
            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now()
+            target_date__gte=timezone.now(),
        )[:5]
        return Response(
            {
@@ -415,7 +505,9 @@ def dashboard_recent_projects(self, request, slug):
        ).exclude(id__in=unique_project_ids)

        # Append additional project IDs to the existing list
-        unique_project_ids.update(additional_projects.values_list("id", flat=True))
+        unique_project_ids.update(
+            additional_projects.values_list("id", flat=True)
+        )

    return Response(
        list(unique_project_ids)[:4],
@@ -424,90 +516,97 @@ def dashboard_recent_projects(self, request, slug):


 def dashboard_recent_collaborators(self, request, slug):
-    # Fetch all project IDs where the user belongs to
-    user_projects = Project.objects.filter(
-        project_projectmember__member=request.user,
-        project_projectmember__is_active=True,
-        workspace__slug=slug,
-    ).values_list("id", flat=True)
-
-    # Fetch all users who have performed an activity in the projects where the user exists
-    users_with_activities = (
+    # Subquery to count activities for each project member
+    activity_count_subquery = (
        IssueActivity.objects.filter(
            workspace__slug=slug,
-            project_id__in=user_projects,
+            actor=OuterRef("member"),
+            project__project_projectmember__member=request.user,
+            project__project_projectmember__is_active=True,
        )
        .values("actor")
-        .exclude(actor=request.user)
-        .annotate(num_activities=Count("actor"))
-        .order_by("-num_activities")
-    )[:7]
-
-    # Get the count of active issues for each user in users_with_activities
-    users_with_active_issues = []
-    for user_activity in users_with_activities:
-        user_id = user_activity["actor"]
-        active_issue_count = Issue.objects.filter(
-            assignees__in=[user_id],
-            state__group__in=["unstarted", "started"],
-        ).count()
-        users_with_active_issues.append(
-            {"user_id": user_id, "active_issue_count": active_issue_count}
-        )
-
-    # Insert the logged-in user's ID and their active issue count at the beginning
-    active_issue_count = Issue.objects.filter(
-        assignees__in=[request.user],
-        state__group__in=["unstarted", "started"],
-    ).count()
-
-    if users_with_activities.count() < 7:
-        # Calculate the additional collaborators needed
-        additional_collaborators_needed = 7 - users_with_activities.count()
-
-        # Fetch additional collaborators from the project_member table
-        additional_collaborators = list(
-            set(
-                ProjectMember.objects.filter(
-                    ~Q(member=request.user),
-                    project_id__in=user_projects,
-                    workspace__slug=slug,
-                )
-                .exclude(
-                    member__in=[
-                        user["actor"] for user in users_with_activities
-                    ]
-                )
-                .values_list("member", flat=True)
-            )
-        )
-
-        additional_collaborators = additional_collaborators[
-            :additional_collaborators_needed
-        ]
-
-        # Append additional collaborators to the list
-        for collaborator_id in additional_collaborators:
-            active_issue_count = Issue.objects.filter(
-                assignees__in=[collaborator_id],
-                state__group__in=["unstarted", "started"],
-            ).count()
-            users_with_active_issues.append(
-                {
-                    "user_id": str(collaborator_id),
-                    "active_issue_count": active_issue_count,
-                }
-            )
-
-    users_with_active_issues.insert(
-        0,
-        {"user_id": request.user.id, "active_issue_count": active_issue_count},
+        .annotate(num_activities=Count("pk"))
+        .values("num_activities")
    )

-    return Response(users_with_active_issues, status=status.HTTP_200_OK)
+    # Get all project members and annotate them with activity counts
+    project_members_with_activities = (
+        ProjectMember.objects.filter(
+            workspace__slug=slug,
+            project__project_projectmember__member=request.user,
+            project__project_projectmember__is_active=True,
+        )
+        .annotate(
+            num_activities=Coalesce(
+                Subquery(activity_count_subquery),
+                Value(0),
+                output_field=IntegerField(),
+            ),
+            is_current_user=Case(
+                When(member=request.user, then=Value(0)),
+                default=Value(1),
+                output_field=IntegerField(),
+            ),
+        )
+        .values_list("member", flat=True)
+        .order_by("is_current_user", "-num_activities")
+        .distinct()
+    )
+    search = request.query_params.get("search", None)
+    if search:
+        project_members_with_activities = (
+            project_members_with_activities.filter(
+                Q(member__display_name__icontains=search)
+                | Q(member__first_name__icontains=search)
+                | Q(member__last_name__icontains=search)
+            )
+        )
+
+    return self.paginate(
+        request=request,
+        queryset=project_members_with_activities,
+        controller=self.get_results_controller,
+    )


 class DashboardEndpoint(BaseAPIView):
+    def get_results_controller(self, project_members_with_activities):
+        user_active_issue_counts = (
+            User.objects.filter(id__in=project_members_with_activities)
+            .annotate(
+                active_issue_count=Count(
+                    Case(
+                        When(
+                            issue_assignee__issue__state__group__in=[
+                                "unstarted",
+                                "started",
+                            ],
+                            then=1,
+                        ),
+                        output_field=IntegerField(),
+                    )
+                )
+            )
+            .values("active_issue_count", user_id=F("id"))
+        )
+        # Create a dictionary to store the active issue counts by user ID
+        active_issue_counts_dict = {
+            user["user_id"]: user["active_issue_count"]
+            for user in user_active_issue_counts
+        }
+
+        # Preserve the sequence of project members with activities
+        paginated_results = [
+            {
+                "user_id": member_id,
+                "active_issue_count": active_issue_counts_dict.get(
+                    member_id, 0
+                ),
+            }
+            for member_id in project_members_with_activities
+        ]
+        return paginated_results
+
    def create(self, request, slug):
        serializer = DashboardSerializer(data=request.data)
        if serializer.is_valid():
@@ -534,7 +633,9 @@ class DashboardEndpoint(BaseAPIView):
            dashboard_type = request.GET.get("dashboard_type", None)
            if dashboard_type == "home":
                dashboard, created = Dashboard.objects.get_or_create(
-                    type_identifier=dashboard_type, owned_by=request.user, is_default=True
+                    type_identifier=dashboard_type,
+                    owned_by=request.user,
+                    is_default=True,
                )

                if created:
@@ -551,7 +652,9 @@ class DashboardEndpoint(BaseAPIView):

                    updated_dashboard_widgets = []
                    for widget_key in widgets_to_fetch:
-                        widget = Widget.objects.filter(key=widget_key).values_list("id", flat=True)
+                        widget = Widget.objects.filter(
+                            key=widget_key
+                        ).values_list("id", flat=True)
                        if widget:
                            updated_dashboard_widgets.append(
                                DashboardWidget(
@@ -0,0 +1,5 @@
+# views.py
+from django.http import JsonResponse
+
+def custom_404_view(request, exception=None):
+    return JsonResponse({"error": "Page not found."}, status=404)
@@ -3,7 +3,7 @@ from rest_framework.response import Response
 from rest_framework import status

 # Module imports
-from .base import BaseViewSet, BaseAPIView
+from ..base import BaseViewSet, BaseAPIView
 from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import Project, Estimate, EstimatePoint
 from plane.app.serializers import (
@@ -11,7 +11,7 @@ from plane.app.serializers import (
    EstimatePointSerializer,
    EstimateReadSerializer,
 )
-
+from plane.utils.cache import invalidate_cache

 class ProjectEstimatePointEndpoint(BaseAPIView):
    permission_classes = [
@@ -49,6 +49,7 @@ class BulkEstimatePointEndpoint(BaseViewSet):
        serializer = EstimateReadSerializer(estimates, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

+    @invalidate_cache(path="/api/workspaces/:slug/estimates/", url_params=True, user=False)
    def create(self, request, slug, project_id):
        if not request.data.get("estimate", False):
            return Response(
@@ -114,6 +115,7 @@ class BulkEstimatePointEndpoint(BaseViewSet):
            status=status.HTTP_200_OK,
        )

+    @invalidate_cache(path="/api/workspaces/:slug/estimates/", url_params=True, user=False)
    def partial_update(self, request, slug, project_id, estimate_id):
        if not request.data.get("estimate", False):
            return Response(
@@ -182,6 +184,7 @@ class BulkEstimatePointEndpoint(BaseViewSet):
            status=status.HTTP_200_OK,
        )

+    @invalidate_cache(path="/api/workspaces/:slug/estimates/", url_params=True, user=False)
    def destroy(self, request, slug, project_id, estimate_id):
        estimate = Estimate.objects.get(
            pk=estimate_id, workspace__slug=slug, project_id=project_id
@@ -3,7 +3,7 @@ from rest_framework.response import Response
 from rest_framework import status

 # Module imports
-from . import BaseAPIView
+from .. import BaseAPIView
 from plane.app.permissions import WorkSpaceAdminPermission
 from plane.bgtasks.export_task import issue_export_task
 from plane.db.models import Project, ExporterHistory, Workspace
@@ -50,7 +50,7 @@ class ExportIssuesEndpoint(BaseAPIView):
            )
            return Response(
                {
-                    "message": f"Once the export is ready you will be able to download it"
+                    "message": "Once the export is ready you will be able to download it"
                },
                status=status.HTTP_200_OK,
            )
@@ -8,17 +8,15 @@ from rest_framework.response import Response
 from rest_framework import status

 # Django imports
-from django.conf import settings

 # Module imports
-from .base import BaseAPIView
+from ..base import BaseAPIView
 from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import Workspace, Project
 from plane.app.serializers import (
    ProjectLiteSerializer,
    WorkspaceLiteSerializer,
 )
-from plane.utils.integrations.github import get_release_notes
 from plane.license.utils.instance_value import get_configuration_value


@@ -85,12 +83,6 @@ class GPTIntegrationEndpoint(BaseAPIView):
        )


-class ReleaseNotesEndpoint(BaseAPIView):
-    def get(self, request):
-        release_notes = get_release_notes()
-        return Response(release_notes, status=status.HTTP_200_OK)
-
-
 class UnsplashEndpoint(BaseAPIView):
    def get(self, request):
        (UNSPLASH_ACCESS_KEY,) = get_configuration_value(
@@ -1,558 +0,0 @@
-# Python imports
-import uuid
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Django imports
-from django.db.models import Max, Q
-
-# Module imports
-from plane.app.views import BaseAPIView
-from plane.db.models import (
-    WorkspaceIntegration,
-    Importer,
-    APIToken,
-    Project,
-    State,
-    IssueSequence,
-    Issue,
-    IssueActivity,
-    IssueComment,
-    IssueLink,
-    IssueLabel,
-    Workspace,
-    IssueAssignee,
-    Module,
-    ModuleLink,
-    ModuleIssue,
-    Label,
-)
-from plane.app.serializers import (
-    ImporterSerializer,
-    IssueFlatSerializer,
-    ModuleSerializer,
-)
-from plane.utils.integrations.github import get_github_repo_details
-from plane.utils.importers.jira import (
-    jira_project_issue_summary,
-    is_allowed_hostname,
-)
-from plane.bgtasks.importer_task import service_importer
-from plane.utils.html_processor import strip_tags
-from plane.app.permissions import WorkSpaceAdminPermission
-
-
-class ServiceIssueImportSummaryEndpoint(BaseAPIView):
-    def get(self, request, slug, service):
-        if service == "github":
-            owner = request.GET.get("owner", False)
-            repo = request.GET.get("repo", False)
-
-            if not owner or not repo:
-                return Response(
-                    {"error": "Owner and repo are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            workspace_integration = WorkspaceIntegration.objects.get(
-                integration__provider="github", workspace__slug=slug
-            )
-
-            access_tokens_url = workspace_integration.metadata.get(
-                "access_tokens_url", False
-            )
-
-            if not access_tokens_url:
-                return Response(
-                    {
-                        "error": "There was an error during the installation of the GitHub app. To resolve this issue, we recommend reinstalling the GitHub app."
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            issue_count, labels, collaborators = get_github_repo_details(
-                access_tokens_url, owner, repo
-            )
-            return Response(
-                {
-                    "issue_count": issue_count,
-                    "labels": labels,
-                    "collaborators": collaborators,
-                },
-                status=status.HTTP_200_OK,
-            )
-
-        if service == "jira":
-            # Check for all the keys
-            params = {
-                "project_key": "Project key is required",
-                "api_token": "API token is required",
-                "email": "Email is required",
-                "cloud_hostname": "Cloud hostname is required",
-            }
-
-            for key, error_message in params.items():
-                if not request.GET.get(key, False):
-                    return Response(
-                        {"error": error_message},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-
-            project_key = request.GET.get("project_key", "")
-            api_token = request.GET.get("api_token", "")
-            email = request.GET.get("email", "")
-            cloud_hostname = request.GET.get("cloud_hostname", "")
-
-            response = jira_project_issue_summary(
-                email, api_token, project_key, cloud_hostname
-            )
-            if "error" in response:
-                return Response(response, status=status.HTTP_400_BAD_REQUEST)
-            else:
-                return Response(
-                    response,
-                    status=status.HTTP_200_OK,
-                )
-        return Response(
-            {"error": "Service not supported yet"},
-            status=status.HTTP_400_BAD_REQUEST,
-        )
-
-
-class ImportServiceEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkSpaceAdminPermission,
-    ]
-
-    def post(self, request, slug, service):
-        project_id = request.data.get("project_id", False)
-
-        if not project_id:
-            return Response(
-                {"error": "Project ID is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        workspace = Workspace.objects.get(slug=slug)
-
-        if service == "github":
-            data = request.data.get("data", False)
-            metadata = request.data.get("metadata", False)
-            config = request.data.get("config", False)
-            if not data or not metadata or not config:
-                return Response(
-                    {"error": "Data, config and metadata are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            api_token = APIToken.objects.filter(
-                user=request.user, workspace=workspace
-            ).first()
-            if api_token is None:
-                api_token = APIToken.objects.create(
-                    user=request.user,
-                    label="Importer",
-                    workspace=workspace,
-                )
-
-            importer = Importer.objects.create(
-                service=service,
-                project_id=project_id,
-                status="queued",
-                initiated_by=request.user,
-                data=data,
-                metadata=metadata,
-                token=api_token,
-                config=config,
-                created_by=request.user,
-                updated_by=request.user,
-            )
-
-            service_importer.delay(service, importer.id)
-            serializer = ImporterSerializer(importer)
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-        if service == "jira":
-            data = request.data.get("data", False)
-            metadata = request.data.get("metadata", False)
-            config = request.data.get("config", False)
-
-            cloud_hostname = metadata.get("cloud_hostname", False)
-
-            if not cloud_hostname:
-                return Response(
-                    {"error": "Cloud hostname is required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if not is_allowed_hostname(cloud_hostname):
-                return Response(
-                    {"error": "Hostname is not a valid hostname."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if not data or not metadata:
-                return Response(
-                    {"error": "Data, config and metadata are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            api_token = APIToken.objects.filter(
-                user=request.user, workspace=workspace
-            ).first()
-            if api_token is None:
-                api_token = APIToken.objects.create(
-                    user=request.user,
-                    label="Importer",
-                    workspace=workspace,
-                )
-
-            importer = Importer.objects.create(
-                service=service,
-                project_id=project_id,
-                status="queued",
-                initiated_by=request.user,
-                data=data,
-                metadata=metadata,
-                token=api_token,
-                config=config,
-                created_by=request.user,
-                updated_by=request.user,
-            )
-
-            service_importer.delay(service, importer.id)
-            serializer = ImporterSerializer(importer)
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-        return Response(
-            {"error": "Servivce not supported yet"},
-            status=status.HTTP_400_BAD_REQUEST,
-        )
-
-    def get(self, request, slug):
-        imports = (
-            Importer.objects.filter(workspace__slug=slug)
-            .order_by("-created_at")
-            .select_related("initiated_by", "project", "workspace")
-        )
-        serializer = ImporterSerializer(imports, many=True)
-        return Response(serializer.data)
-
-    def delete(self, request, slug, service, pk):
-        importer = Importer.objects.get(
-            pk=pk, service=service, workspace__slug=slug
-        )
-
-        if importer.imported_data is not None:
-            # Delete all imported Issues
-            imported_issues = importer.imported_data.get("issues", [])
-            Issue.issue_objects.filter(id__in=imported_issues).delete()
-
-            # Delete all imported Labels
-            imported_labels = importer.imported_data.get("labels", [])
-            Label.objects.filter(id__in=imported_labels).delete()
-
-            if importer.service == "jira":
-                imported_modules = importer.imported_data.get("modules", [])
-                Module.objects.filter(id__in=imported_modules).delete()
-        importer.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    def patch(self, request, slug, service, pk):
-        importer = Importer.objects.get(
-            pk=pk, service=service, workspace__slug=slug
-        )
-        serializer = ImporterSerializer(
-            importer, data=request.data, partial=True
-        )
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-
-class UpdateServiceImportStatusEndpoint(BaseAPIView):
-    def post(self, request, slug, project_id, service, importer_id):
-        importer = Importer.objects.get(
-            pk=importer_id,
-            workspace__slug=slug,
-            project_id=project_id,
-            service=service,
-        )
-        importer.status = request.data.get("status", "processing")
-        importer.save()
-        return Response(status.HTTP_200_OK)
-
-
-class BulkImportIssuesEndpoint(BaseAPIView):
-    def post(self, request, slug, project_id, service):
-        # Get the project
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-
-        # Get the default state
-        default_state = State.objects.filter(
-            ~Q(name="Triage"), project_id=project_id, default=True
-        ).first()
-        # if there is no default state assign any random state
-        if default_state is None:
-            default_state = State.objects.filter(
-                ~Q(name="Triage"), project_id=project_id
-            ).first()
-
-        # Get the maximum sequence_id
-        last_id = IssueSequence.objects.filter(
-            project_id=project_id
-        ).aggregate(largest=Max("sequence"))["largest"]
-
-        last_id = 1 if last_id is None else last_id + 1
-
-        # Get the maximum sort order
-        largest_sort_order = Issue.objects.filter(
-            project_id=project_id, state=default_state
-        ).aggregate(largest=Max("sort_order"))["largest"]
-
-        largest_sort_order = (
-            65535 if largest_sort_order is None else largest_sort_order + 10000
-        )
-
-        # Get the issues_data
-        issues_data = request.data.get("issues_data", [])
-
-        if not len(issues_data):
-            return Response(
-                {"error": "Issue data is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Issues
-        bulk_issues = []
-        for issue_data in issues_data:
-            bulk_issues.append(
-                Issue(
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    state_id=issue_data.get("state")
-                    if issue_data.get("state", False)
-                    else default_state.id,
-                    name=issue_data.get("name", "Issue Created through Bulk"),
-                    description_html=issue_data.get(
-                        "description_html", "<p></p>"
-                    ),
-                    description_stripped=(
-                        None
-                        if (
-                            issue_data.get("description_html") == ""
-                            or issue_data.get("description_html") is None
-                        )
-                        else strip_tags(issue_data.get("description_html"))
-                    ),
-                    sequence_id=last_id,
-                    sort_order=largest_sort_order,
-                    start_date=issue_data.get("start_date", None),
-                    target_date=issue_data.get("target_date", None),
-                    priority=issue_data.get("priority", "none"),
-                    created_by=request.user,
-                )
-            )
-
-            largest_sort_order = largest_sort_order + 10000
-            last_id = last_id + 1
-
-        issues = Issue.objects.bulk_create(
-            bulk_issues,
-            batch_size=100,
-            ignore_conflicts=True,
-        )
-
-        # Sequences
-        _ = IssueSequence.objects.bulk_create(
-            [
-                IssueSequence(
-                    issue=issue,
-                    sequence=issue.sequence_id,
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                )
-                for issue in issues
-            ],
-            batch_size=100,
-        )
-
-        # Attach Labels
-        bulk_issue_labels = []
-        for issue, issue_data in zip(issues, issues_data):
-            labels_list = issue_data.get("labels_list", [])
-            bulk_issue_labels = bulk_issue_labels + [
-                IssueLabel(
-                    issue=issue,
-                    label_id=label_id,
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    created_by=request.user,
-                )
-                for label_id in labels_list
-            ]
-
-        _ = IssueLabel.objects.bulk_create(
-            bulk_issue_labels, batch_size=100, ignore_conflicts=True
-        )
-
-        # Attach Assignees
-        bulk_issue_assignees = []
-        for issue, issue_data in zip(issues, issues_data):
-            assignees_list = issue_data.get("assignees_list", [])
-            bulk_issue_assignees = bulk_issue_assignees + [
-                IssueAssignee(
-                    issue=issue,
-                    assignee_id=assignee_id,
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    created_by=request.user,
-                )
-                for assignee_id in assignees_list
-            ]
-
-        _ = IssueAssignee.objects.bulk_create(
-            bulk_issue_assignees, batch_size=100, ignore_conflicts=True
-        )
-
-        # Track the issue activities
-        IssueActivity.objects.bulk_create(
-            [
-                IssueActivity(
-                    issue=issue,
-                    actor=request.user,
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    comment=f"imported the issue from {service}",
-                    verb="created",
-                    created_by=request.user,
-                )
-                for issue in issues
-            ],
-            batch_size=100,
-        )
-
-        # Create Comments
-        bulk_issue_comments = []
-        for issue, issue_data in zip(issues, issues_data):
-            comments_list = issue_data.get("comments_list", [])
-            bulk_issue_comments = bulk_issue_comments + [
-                IssueComment(
-                    issue=issue,
-                    comment_html=comment.get("comment_html", "<p></p>"),
-                    actor=request.user,
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    created_by=request.user,
-                )
-                for comment in comments_list
-            ]
-
-        _ = IssueComment.objects.bulk_create(
-            bulk_issue_comments, batch_size=100
-        )
-
-        # Attach Links
-        _ = IssueLink.objects.bulk_create(
-            [
-                IssueLink(
-                    issue=issue,
-                    url=issue_data.get("link", {}).get(
-                        "url", "https://github.com"
-                    ),
-                    title=issue_data.get("link", {}).get(
-                        "title", "Original Issue"
-                    ),
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    created_by=request.user,
-                )
-                for issue, issue_data in zip(issues, issues_data)
-            ]
-        )
-
-        return Response(
-            {"issues": IssueFlatSerializer(issues, many=True).data},
-            status=status.HTTP_201_CREATED,
-        )
-
-
-class BulkImportModulesEndpoint(BaseAPIView):
-    def post(self, request, slug, project_id, service):
-        modules_data = request.data.get("modules_data", [])
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-
-        modules = Module.objects.bulk_create(
-            [
-                Module(
-                    name=module.get("name", uuid.uuid4().hex),
-                    description=module.get("description", ""),
-                    start_date=module.get("start_date", None),
-                    target_date=module.get("target_date", None),
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    created_by=request.user,
-                )
-                for module in modules_data
-            ],
-            batch_size=100,
-            ignore_conflicts=True,
-        )
-
-        modules = Module.objects.filter(
-            id__in=[module.id for module in modules]
-        )
-
-        if len(modules) == len(modules_data):
-            _ = ModuleLink.objects.bulk_create(
-                [
-                    ModuleLink(
-                        module=module,
-                        url=module_data.get("link", {}).get(
-                            "url", "https://plane.so"
-                        ),
-                        title=module_data.get("link", {}).get(
-                            "title", "Original Issue"
-                        ),
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                        created_by=request.user,
-                    )
-                    for module, module_data in zip(modules, modules_data)
-                ],
-                batch_size=100,
-                ignore_conflicts=True,
-            )
-
-            bulk_module_issues = []
-            for module, module_data in zip(modules, modules_data):
-                module_issues_list = module_data.get("module_issues_list", [])
-                bulk_module_issues = bulk_module_issues + [
-                    ModuleIssue(
-                        issue_id=issue,
-                        module=module,
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                        created_by=request.user,
-                    )
-                    for issue in module_issues_list
-                ]
-
-            _ = ModuleIssue.objects.bulk_create(
-                bulk_module_issues, batch_size=100, ignore_conflicts=True
-            )
-
-            serializer = ModuleSerializer(modules, many=True)
-            return Response(
-                {"modules": serializer.data}, status=status.HTTP_201_CREATED
-            )
-
-        else:
-            return Response(
-                {
-                    "message": "Modules created but issues could not be imported"
-                },
-                status=status.HTTP_200_OK,
-            )
@@ -3,15 +3,19 @@ import json

 # Django import
 from django.utils import timezone
-from django.db.models import Q, Count, OuterRef, Func, F, Prefetch
+from django.db.models import Q, Count, OuterRef, Func, F, Prefetch, Exists
 from django.core.serializers.json import DjangoJSONEncoder
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import Value, UUIDField
+from django.db.models.functions import Coalesce

 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response

 # Module imports
-from .base import BaseViewSet
+from ..base import BaseViewSet
 from plane.app.permissions import ProjectBasePermission, ProjectLitePermission
 from plane.db.models import (
    Inbox,
@@ -21,13 +25,15 @@ from plane.db.models import (
    IssueLink,
    IssueAttachment,
    ProjectMember,
+    IssueReaction,
+    IssueSubscriber,
 )
 from plane.app.serializers import (
+    IssueCreateSerializer,
    IssueSerializer,
    InboxSerializer,
    InboxIssueSerializer,
-    IssueCreateSerializer,
-    IssueStateInboxSerializer,
+    IssueDetailSerializer,
 )
 from plane.utils.issue_filters import issue_filters
 from plane.bgtasks.issue_activites_task import issue_activity
@@ -92,10 +98,10 @@ class InboxIssueViewSet(BaseViewSet):
            Issue.objects.filter(
                project_id=self.kwargs.get("project_id"),
                workspace__slug=self.kwargs.get("slug"),
-                issue_inbox__inbox_id=self.kwargs.get("inbox_id")
+                issue_inbox__inbox_id=self.kwargs.get("inbox_id"),
            )
            .select_related("workspace", "project", "state", "parent")
-            .prefetch_related("labels", "assignees")
+            .prefetch_related("assignees", "labels", "issue_module__module")
            .prefetch_related(
                Prefetch(
                    "issue_inbox",
@@ -105,7 +111,6 @@ class InboxIssueViewSet(BaseViewSet):
                )
            )
            .annotate(cycle_id=F("issue_cycle__cycle_id"))
-            .annotate(module_id=F("issue_module__module_id"))
            .annotate(
                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
                .order_by()
@@ -128,14 +133,75 @@ class InboxIssueViewSet(BaseViewSet):
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
            )
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "labels__id",
+                        distinct=True,
+                        filter=~Q(labels__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "assignees__id",
+                        distinct=True,
+                        filter=~Q(assignees__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=~Q(issue_module__module_id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
        ).distinct()

    def list(self, request, slug, project_id, inbox_id):
        filters = issue_filters(request.query_params, "GET")
-        issue_queryset = self.get_queryset().filter(**filters).order_by("issue_inbox__snoozed_till", "issue_inbox__status")
-        issues_data = IssueSerializer(issue_queryset, expand=self.expand, many=True).data
+        issue_queryset = (
+            self.get_queryset()
+            .filter(**filters)
+            .order_by("issue_inbox__snoozed_till", "issue_inbox__status")
+        )
+        if self.expand:
+            issues = IssueSerializer(
+                issue_queryset, expand=self.expand, many=True
+            ).data
+        else:
+            issues = issue_queryset.values(
+                "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",
+            )
        return Response(
-            issues_data,
+            issues,
            status=status.HTTP_200_OK,
        )

@@ -147,7 +213,7 @@ class InboxIssueViewSet(BaseViewSet):
            )

        # 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",
@@ -200,8 +266,8 @@ class InboxIssueViewSet(BaseViewSet):
            source=request.data.get("source", "in-app"),
        )

-        issue = (self.get_queryset().filter(pk=issue.id).first())
-        serializer = IssueSerializer(issue ,expand=self.expand)
+        issue = self.get_queryset().filter(pk=issue.id).first()
+        serializer = IssueSerializer(issue, expand=self.expand)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def partial_update(self, request, slug, project_id, inbox_id, issue_id):
@@ -231,11 +297,7 @@ class InboxIssueViewSet(BaseViewSet):
        issue_data = request.data.pop("issue", False)

        if bool(issue_data):
-            issue = Issue.objects.get(
-                pk=inbox_issue.issue_id,
-                workspace__slug=slug,
-                project_id=project_id,
-            )
+            issue = self.get_queryset().filter(pk=inbox_issue.issue_id).first()
            # Only allow guests and viewers to edit name and description
            if project_member.role <= 10:
                # viewers and guests since only viewers and guests
@@ -321,20 +383,57 @@ class InboxIssueViewSet(BaseViewSet):
                        if state is not None:
                            issue.state = state
                            issue.save()
-                issue = (self.get_queryset().filter(pk=issue_id).first())
-                serializer = IssueSerializer(issue, expand=self.expand)
-                return Response(serializer.data, status=status.HTTP_200_OK)
+                return Response(status=status.HTTP_204_NO_CONTENT)
            return Response(
                serializer.errors, status=status.HTTP_400_BAD_REQUEST
            )
        else:
-            issue = (self.get_queryset().filter(pk=issue_id).first())
-            serializer = IssueSerializer(issue ,expand=self.expand)
+            issue = self.get_queryset().filter(pk=issue_id).first()
+            serializer = IssueSerializer(issue, expand=self.expand)
            return Response(serializer.data, status=status.HTTP_200_OK)

    def retrieve(self, request, slug, project_id, inbox_id, issue_id):
-        issue = self.get_queryset().filter(pk=issue_id).first()
-        serializer = IssueSerializer(issue, expand=self.expand,)
+        issue = (
+            self.get_queryset()
+            .filter(pk=issue_id)
+            .prefetch_related(
+                Prefetch(
+                    "issue_reactions",
+                    queryset=IssueReaction.objects.select_related(
+                        "issue", "actor"
+                    ),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_attachment",
+                    queryset=IssueAttachment.objects.select_related("issue"),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_link",
+                    queryset=IssueLink.objects.select_related("created_by"),
+                )
+            )
+            .annotate(
+                is_subscribed=Exists(
+                    IssueSubscriber.objects.filter(
+                        workspace__slug=slug,
+                        project_id=project_id,
+                        issue_id=OuterRef("pk"),
+                        subscriber=request.user,
+                    )
+                )
+            )
+        ).first()
+        if issue is None:
+            return Response(
+                {"error": "Requested object was not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        serializer = IssueDetailSerializer(issue)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, slug, project_id, inbox_id, issue_id):
@@ -1,9 +0,0 @@
-from .base import IntegrationViewSet, WorkspaceIntegrationViewSet
-from .github import (
-    GithubRepositorySyncViewSet,
-    GithubIssueSyncViewSet,
-    BulkCreateGithubIssueSyncEndpoint,
-    GithubCommentSyncViewSet,
-    GithubRepositoriesEndpoint,
-)
-from .slack import SlackProjectSyncViewSet
@@ -1,181 +0,0 @@
-# Python improts
-import uuid
-import requests
-
-# Django imports
-from django.contrib.auth.hashers import make_password
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-from sentry_sdk import capture_exception
-
-# Module imports
-from plane.app.views import BaseViewSet
-from plane.db.models import (
-    Integration,
-    WorkspaceIntegration,
-    Workspace,
-    User,
-    WorkspaceMember,
-    APIToken,
-)
-from plane.app.serializers import (
-    IntegrationSerializer,
-    WorkspaceIntegrationSerializer,
-)
-from plane.utils.integrations.github import (
-    get_github_metadata,
-    delete_github_installation,
-)
-from plane.app.permissions import WorkSpaceAdminPermission
-from plane.utils.integrations.slack import slack_oauth
-
-
-class IntegrationViewSet(BaseViewSet):
-    serializer_class = IntegrationSerializer
-    model = Integration
-
-    def create(self, request):
-        serializer = IntegrationSerializer(data=request.data)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def partial_update(self, request, pk):
-        integration = Integration.objects.get(pk=pk)
-        if integration.verified:
-            return Response(
-                {"error": "Verified integrations cannot be updated"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        serializer = IntegrationSerializer(
-            integration, data=request.data, partial=True
-        )
-
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def destroy(self, request, pk):
-        integration = Integration.objects.get(pk=pk)
-        if integration.verified:
-            return Response(
-                {"error": "Verified integrations cannot be updated"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        integration.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class WorkspaceIntegrationViewSet(BaseViewSet):
-    serializer_class = WorkspaceIntegrationSerializer
-    model = WorkspaceIntegration
-
-    permission_classes = [
-        WorkSpaceAdminPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .select_related("integration")
-        )
-
-    def create(self, request, slug, provider):
-        workspace = Workspace.objects.get(slug=slug)
-        integration = Integration.objects.get(provider=provider)
-        config = {}
-        if provider == "github":
-            installation_id = request.data.get("installation_id", None)
-            if not installation_id:
-                return Response(
-                    {"error": "Installation ID is required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            metadata = get_github_metadata(installation_id)
-            config = {"installation_id": installation_id}
-
-        if provider == "slack":
-            code = request.data.get("code", False)
-
-            if not code:
-                return Response(
-                    {"error": "Code is required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            slack_response = slack_oauth(code=code)
-
-            metadata = slack_response
-            access_token = metadata.get("access_token", False)
-            team_id = metadata.get("team", {}).get("id", False)
-            if not metadata or not access_token or not team_id:
-                return Response(
-                    {
-                        "error": "Slack could not be installed. Please try again later"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            config = {"team_id": team_id, "access_token": access_token}
-
-        # Create a bot user
-        bot_user = User.objects.create(
-            email=f"{uuid.uuid4().hex}@plane.so",
-            username=uuid.uuid4().hex,
-            password=make_password(uuid.uuid4().hex),
-            is_password_autoset=True,
-            is_bot=True,
-            first_name=integration.title,
-            avatar=integration.avatar_url
-            if integration.avatar_url is not None
-            else "",
-        )
-
-        # Create an API Token for the bot user
-        api_token = APIToken.objects.create(
-            user=bot_user,
-            user_type=1,  # bot user
-            workspace=workspace,
-        )
-
-        workspace_integration = WorkspaceIntegration.objects.create(
-            workspace=workspace,
-            integration=integration,
-            actor=bot_user,
-            api_token=api_token,
-            metadata=metadata,
-            config=config,
-        )
-
-        # Add bot user as a member of workspace
-        _ = WorkspaceMember.objects.create(
-            workspace=workspace_integration.workspace,
-            member=bot_user,
-            role=20,
-        )
-        return Response(
-            WorkspaceIntegrationSerializer(workspace_integration).data,
-            status=status.HTTP_201_CREATED,
-        )
-
-    def destroy(self, request, slug, pk):
-        workspace_integration = WorkspaceIntegration.objects.get(
-            pk=pk, workspace__slug=slug
-        )
-
-        if workspace_integration.integration.provider == "github":
-            installation_id = workspace_integration.config.get(
-                "installation_id", False
-            )
-            if installation_id:
-                delete_github_installation(installation_id=installation_id)
-
-        workspace_integration.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,202 +0,0 @@
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from sentry_sdk import capture_exception
-
-# Module imports
-from plane.app.views import BaseViewSet, BaseAPIView
-from plane.db.models import (
-    GithubIssueSync,
-    GithubRepositorySync,
-    GithubRepository,
-    WorkspaceIntegration,
-    ProjectMember,
-    Label,
-    GithubCommentSync,
-    Project,
-)
-from plane.app.serializers import (
-    GithubIssueSyncSerializer,
-    GithubRepositorySyncSerializer,
-    GithubCommentSyncSerializer,
-)
-from plane.utils.integrations.github import get_github_repos
-from plane.app.permissions import (
-    ProjectBasePermission,
-    ProjectEntityPermission,
-)
-
-
-class GithubRepositoriesEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectBasePermission,
-    ]
-
-    def get(self, request, slug, workspace_integration_id):
-        page = request.GET.get("page", 1)
-        workspace_integration = WorkspaceIntegration.objects.get(
-            workspace__slug=slug, pk=workspace_integration_id
-        )
-
-        if workspace_integration.integration.provider != "github":
-            return Response(
-                {"error": "Not a github integration"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        access_tokens_url = workspace_integration.metadata["access_tokens_url"]
-        repositories_url = (
-            workspace_integration.metadata["repositories_url"]
-            + f"?per_page=100&page={page}"
-        )
-        repositories = get_github_repos(access_tokens_url, repositories_url)
-        return Response(repositories, status=status.HTTP_200_OK)
-
-
-class GithubRepositorySyncViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectBasePermission,
-    ]
-
-    serializer_class = GithubRepositorySyncSerializer
-    model = GithubRepositorySync
-
-    def perform_create(self, serializer):
-        serializer.save(project_id=self.kwargs.get("project_id"))
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-        )
-
-    def create(self, request, slug, project_id, workspace_integration_id):
-        name = request.data.get("name", False)
-        url = request.data.get("url", False)
-        config = request.data.get("config", {})
-        repository_id = request.data.get("repository_id", False)
-        owner = request.data.get("owner", False)
-
-        if not name or not url or not repository_id or not owner:
-            return Response(
-                {"error": "Name, url, repository_id and owner are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get the workspace integration
-        workspace_integration = WorkspaceIntegration.objects.get(
-            pk=workspace_integration_id
-        )
-
-        # Delete the old repository object
-        GithubRepositorySync.objects.filter(
-            project_id=project_id, workspace__slug=slug
-        ).delete()
-        GithubRepository.objects.filter(
-            project_id=project_id, workspace__slug=slug
-        ).delete()
-
-        # Create repository
-        repo = GithubRepository.objects.create(
-            name=name,
-            url=url,
-            config=config,
-            repository_id=repository_id,
-            owner=owner,
-            project_id=project_id,
-        )
-
-        # Create a Label for github
-        label = Label.objects.filter(
-            name="GitHub",
-            project_id=project_id,
-        ).first()
-
-        if label is None:
-            label = Label.objects.create(
-                name="GitHub",
-                project_id=project_id,
-                description="Label to sync Plane issues with GitHub issues",
-                color="#003773",
-            )
-
-        # Create repo sync
-        repo_sync = GithubRepositorySync.objects.create(
-            repository=repo,
-            workspace_integration=workspace_integration,
-            actor=workspace_integration.actor,
-            credentials=request.data.get("credentials", {}),
-            project_id=project_id,
-            label=label,
-        )
-
-        # Add bot as a member in the project
-        _ = ProjectMember.objects.get_or_create(
-            member=workspace_integration.actor, role=20, project_id=project_id
-        )
-
-        # Return Response
-        return Response(
-            GithubRepositorySyncSerializer(repo_sync).data,
-            status=status.HTTP_201_CREATED,
-        )
-
-
-class GithubIssueSyncViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    serializer_class = GithubIssueSyncSerializer
-    model = GithubIssueSync
-
-    def perform_create(self, serializer):
-        serializer.save(
-            project_id=self.kwargs.get("project_id"),
-            repository_sync_id=self.kwargs.get("repo_sync_id"),
-        )
-
-
-class BulkCreateGithubIssueSyncEndpoint(BaseAPIView):
-    def post(self, request, slug, project_id, repo_sync_id):
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-
-        github_issue_syncs = request.data.get("github_issue_syncs", [])
-        github_issue_syncs = GithubIssueSync.objects.bulk_create(
-            [
-                GithubIssueSync(
-                    issue_id=github_issue_sync.get("issue"),
-                    repo_issue_id=github_issue_sync.get("repo_issue_id"),
-                    issue_url=github_issue_sync.get("issue_url"),
-                    github_issue_id=github_issue_sync.get("github_issue_id"),
-                    repository_sync_id=repo_sync_id,
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    created_by=request.user,
-                    updated_by=request.user,
-                )
-                for github_issue_sync in github_issue_syncs
-            ],
-            batch_size=100,
-            ignore_conflicts=True,
-        )
-
-        serializer = GithubIssueSyncSerializer(github_issue_syncs, many=True)
-        return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-
-class GithubCommentSyncViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    serializer_class = GithubCommentSyncSerializer
-    model = GithubCommentSync
-
-    def perform_create(self, serializer):
-        serializer.save(
-            project_id=self.kwargs.get("project_id"),
-            issue_sync_id=self.kwargs.get("issue_sync_id"),
-        )
@@ -1,93 +0,0 @@
-# Django import
-from django.db import IntegrityError
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from sentry_sdk import capture_exception
-
-# Module imports
-from plane.app.views import BaseViewSet, BaseAPIView
-from plane.db.models import (
-    SlackProjectSync,
-    WorkspaceIntegration,
-    ProjectMember,
-)
-from plane.app.serializers import SlackProjectSyncSerializer
-from plane.app.permissions import (
-    ProjectBasePermission,
-    ProjectEntityPermission,
-)
-from plane.utils.integrations.slack import slack_oauth
-
-
-class SlackProjectSyncViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectBasePermission,
-    ]
-    serializer_class = SlackProjectSyncSerializer
-    model = SlackProjectSync
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .filter(
-                workspace__slug=self.kwargs.get("slug"),
-                project_id=self.kwargs.get("project_id"),
-            )
-            .filter(project__project_projectmember__member=self.request.user)
-        )
-
-    def create(self, request, slug, project_id, workspace_integration_id):
-        try:
-            code = request.data.get("code", False)
-
-            if not code:
-                return Response(
-                    {"error": "Code is required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            slack_response = slack_oauth(code=code)
-
-            workspace_integration = WorkspaceIntegration.objects.get(
-                workspace__slug=slug, pk=workspace_integration_id
-            )
-
-            workspace_integration = WorkspaceIntegration.objects.get(
-                pk=workspace_integration_id, workspace__slug=slug
-            )
-            slack_project_sync = SlackProjectSync.objects.create(
-                access_token=slack_response.get("access_token"),
-                scopes=slack_response.get("scope"),
-                bot_user_id=slack_response.get("bot_user_id"),
-                webhook_url=slack_response.get("incoming_webhook", {}).get(
-                    "url"
-                ),
-                data=slack_response,
-                team_id=slack_response.get("team", {}).get("id"),
-                team_name=slack_response.get("team", {}).get("name"),
-                workspace_integration=workspace_integration,
-                project_id=project_id,
-            )
-            _ = ProjectMember.objects.get_or_create(
-                member=workspace_integration.actor,
-                role=20,
-                project_id=project_id,
-            )
-            serializer = SlackProjectSyncSerializer(slack_project_sync)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"error": "Slack is already installed for the project"},
-                    status=status.HTTP_410_GONE,
-                )
-            capture_exception(e)
-            return Response(
-                {
-                    "error": "Slack could not be installed. Please try again later"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
@@ -0,0 +1,85 @@
+# Python imports
+from itertools import chain
+
+# Django imports
+from django.db.models import (
+    Prefetch,
+    Q,
+)
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseAPIView
+from plane.app.serializers import (
+    IssueActivitySerializer,
+    IssueCommentSerializer,
+)
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import (
+    IssueActivity,
+    IssueComment,
+    CommentReaction,
+)
+
+
+class IssueActivityEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    @method_decorator(gzip_page)
+    def get(self, request, slug, project_id, issue_id):
+        filters = {}
+        if request.GET.get("created_at__gt", None) is not None:
+            filters = {"created_at__gt": request.GET.get("created_at__gt")}
+
+        issue_activities = (
+            IssueActivity.objects.filter(issue_id=issue_id)
+            .filter(
+                ~Q(field__in=["comment", "vote", "reaction", "draft"]),
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                workspace__slug=slug,
+            )
+            .filter(**filters)
+            .select_related("actor", "workspace", "issue", "project")
+        ).order_by("created_at")
+        issue_comments = (
+            IssueComment.objects.filter(issue_id=issue_id)
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                workspace__slug=slug,
+            )
+            .filter(**filters)
+            .order_by("created_at")
+            .select_related("actor", "issue", "project", "workspace")
+            .prefetch_related(
+                Prefetch(
+                    "comment_reactions",
+                    queryset=CommentReaction.objects.select_related("actor"),
+                )
+            )
+        )
+        issue_activities = IssueActivitySerializer(
+            issue_activities, many=True
+        ).data
+        issue_comments = IssueCommentSerializer(issue_comments, many=True).data
+
+        if request.GET.get("activity_type", None) == "issue-property":
+            return Response(issue_activities, status=status.HTTP_200_OK)
+
+        if request.GET.get("activity_type", None) == "issue-comment":
+            return Response(issue_comments, status=status.HTTP_200_OK)
+
+        result_list = sorted(
+            chain(issue_activities, issue_comments),
+            key=lambda instance: instance["created_at"],
+        )
+
+        return Response(result_list, status=status.HTTP_200_OK)
@@ -0,0 +1,347 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.db.models import (
+    Prefetch,
+    OuterRef,
+    Func,
+    F,
+    Q,
+    Case,
+    Value,
+    CharField,
+    When,
+    Exists,
+    Max,
+    UUIDField,
+)
+from django.core.serializers.json import DjangoJSONEncoder
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models.functions import Coalesce
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import (
+    IssueSerializer,
+    IssueFlatSerializer,
+    IssueDetailSerializer,
+)
+from plane.app.permissions import (
+    ProjectEntityPermission,
+)
+from plane.db.models import (
+    Issue,
+    IssueLink,
+    IssueAttachment,
+    IssueSubscriber,
+    IssueReaction,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from plane.utils.issue_filters import issue_filters
+
+
+class IssueArchiveViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+    serializer_class = IssueFlatSerializer
+    model = Issue
+
+    def get_queryset(self):
+        return (
+            Issue.objects.annotate(
+                sub_issues_count=Issue.objects.filter(parent=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .filter(archived_at__isnull=False)
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module")
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "labels__id",
+                        distinct=True,
+                        filter=~Q(labels__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "assignees__id",
+                        distinct=True,
+                        filter=~Q(assignees__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=~Q(issue_module__module_id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+        )
+
+    @method_decorator(gzip_page)
+    def list(self, request, slug, project_id):
+        filters = issue_filters(request.query_params, "GET")
+        show_sub_issues = request.GET.get("show_sub_issues", "true")
+
+        # Custom ordering for priority and state
+        priority_order = ["urgent", "high", "medium", "low", "none"]
+        state_order = [
+            "backlog",
+            "unstarted",
+            "started",
+            "completed",
+            "cancelled",
+        ]
+
+        order_by_param = request.GET.get("order_by", "-created_at")
+
+        issue_queryset = self.get_queryset().filter(**filters)
+
+        # 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]
+            )
+            issue_queryset = issue_queryset.annotate(
+                priority_order=Case(
+                    *[
+                        When(priority=p, then=Value(i))
+                        for i, p in enumerate(priority_order)
+                    ],
+                    output_field=CharField(),
+                )
+            ).order_by("priority_order")
+
+        # State Ordering
+        elif order_by_param in [
+            "state__name",
+            "state__group",
+            "-state__name",
+            "-state__group",
+        ]:
+            state_order = (
+                state_order
+                if order_by_param in ["state__name", "state__group"]
+                else state_order[::-1]
+            )
+            issue_queryset = issue_queryset.annotate(
+                state_order=Case(
+                    *[
+                        When(state__group=state_group, then=Value(i))
+                        for i, state_group in enumerate(state_order)
+                    ],
+                    default=Value(len(state_order)),
+                    output_field=CharField(),
+                )
+            ).order_by("state_order")
+        # assignee and label ordering
+        elif order_by_param in [
+            "labels__name",
+            "-labels__name",
+            "assignees__first_name",
+            "-assignees__first_name",
+        ]:
+            issue_queryset = issue_queryset.annotate(
+                max_values=Max(
+                    order_by_param[1::]
+                    if order_by_param.startswith("-")
+                    else order_by_param
+                )
+            ).order_by(
+                "-max_values"
+                if order_by_param.startswith("-")
+                else "max_values"
+            )
+        else:
+            issue_queryset = issue_queryset.order_by(order_by_param)
+
+        issue_queryset = (
+            issue_queryset
+            if show_sub_issues == "true"
+            else issue_queryset.filter(parent__isnull=True)
+        )
+        if self.expand or self.fields:
+            issues = IssueSerializer(
+                issue_queryset,
+                many=True,
+                fields=self.fields,
+            ).data
+        else:
+            issues = issue_queryset.values(
+                "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",
+            )
+        return Response(issues, status=status.HTTP_200_OK)
+
+    def retrieve(self, request, slug, project_id, pk=None):
+        issue = (
+            self.get_queryset()
+            .filter(pk=pk)
+            .prefetch_related(
+                Prefetch(
+                    "issue_reactions",
+                    queryset=IssueReaction.objects.select_related(
+                        "issue", "actor"
+                    ),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_attachment",
+                    queryset=IssueAttachment.objects.select_related("issue"),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_link",
+                    queryset=IssueLink.objects.select_related("created_by"),
+                )
+            )
+            .annotate(
+                is_subscribed=Exists(
+                    IssueSubscriber.objects.filter(
+                        workspace__slug=slug,
+                        project_id=project_id,
+                        issue_id=OuterRef("pk"),
+                        subscriber=request.user,
+                    )
+                )
+            )
+        ).first()
+        if not issue:
+            return Response(
+                {"error": "The required object does not exist."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        serializer = IssueDetailSerializer(issue, expand=self.expand)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def archive(self, request, slug, project_id, pk=None):
+        issue = Issue.issue_objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            pk=pk,
+        )
+        if issue.state.group not in ["completed", "cancelled"]:
+            return Response(
+                {
+                    "error": "Can only archive completed or cancelled state group issue"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        issue_activity.delay(
+            type="issue.activity.updated",
+            requested_data=json.dumps(
+                {
+                    "archived_at": str(timezone.now().date()),
+                    "automation": False,
+                }
+            ),
+            actor_id=str(request.user.id),
+            issue_id=str(issue.id),
+            project_id=str(project_id),
+            current_instance=json.dumps(
+                IssueSerializer(issue).data, cls=DjangoJSONEncoder
+            ),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        issue.archived_at = timezone.now().date()
+        issue.save()
+
+        return Response(
+            {"archived_at": str(issue.archived_at)}, status=status.HTTP_200_OK
+        )
+
+    def unarchive(self, request, slug, project_id, pk=None):
+        issue = Issue.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            archived_at__isnull=False,
+            pk=pk,
+        )
+        issue_activity.delay(
+            type="issue.activity.updated",
+            requested_data=json.dumps({"archived_at": None}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue.id),
+            project_id=str(project_id),
+            current_instance=json.dumps(
+                IssueSerializer(issue).data, cls=DjangoJSONEncoder
+            ),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        issue.archived_at = None
+        issue.save()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -0,0 +1,73 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.parsers import MultiPartParser, FormParser
+
+# Module imports
+from .. import BaseAPIView
+from plane.app.serializers import IssueAttachmentSerializer
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import IssueAttachment
+from plane.bgtasks.issue_activites_task import issue_activity
+
+
+class IssueAttachmentEndpoint(BaseAPIView):
+    serializer_class = IssueAttachmentSerializer
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+    model = IssueAttachment
+    parser_classes = (MultiPartParser, FormParser)
+
+    def post(self, request, slug, project_id, issue_id):
+        serializer = IssueAttachmentSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(project_id=project_id, issue_id=issue_id)
+            issue_activity.delay(
+                type="attachment.activity.created",
+                requested_data=None,
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id", None)),
+                project_id=str(self.kwargs.get("project_id", None)),
+                current_instance=json.dumps(
+                    serializer.data,
+                    cls=DjangoJSONEncoder,
+                ),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def delete(self, request, slug, project_id, issue_id, pk):
+        issue_attachment = IssueAttachment.objects.get(pk=pk)
+        issue_attachment.asset.delete(save=False)
+        issue_attachment.delete()
+        issue_activity.delay(
+            type="attachment.activity.deleted",
+            requested_data=None,
+            actor_id=str(self.request.user.id),
+            issue_id=str(self.kwargs.get("issue_id", None)),
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def get(self, request, slug, project_id, issue_id):
+        issue_attachments = IssueAttachment.objects.filter(
+            issue_id=issue_id, workspace__slug=slug, project_id=project_id
+        )
+        serializer = IssueAttachmentSerializer(issue_attachments, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -0,0 +1,686 @@
+# Python imports
+import json
+import random
+from itertools import chain
+
+# Django imports
+from django.utils import timezone
+from django.db.models import (
+    Prefetch,
+    OuterRef,
+    Func,
+    F,
+    Q,
+    Case,
+    Value,
+    CharField,
+    When,
+    Exists,
+    Max,
+)
+from django.core.serializers.json import DjangoJSONEncoder
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+from django.db import IntegrityError
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import Value, UUIDField
+from django.db.models.functions import Coalesce
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.parsers import MultiPartParser, FormParser
+
+# Module imports
+from .. import BaseViewSet, BaseAPIView, WebhookMixin
+from plane.app.serializers import (
+    IssueActivitySerializer,
+    IssueCommentSerializer,
+    IssuePropertySerializer,
+    IssueSerializer,
+    IssueCreateSerializer,
+    LabelSerializer,
+    IssueFlatSerializer,
+    IssueLinkSerializer,
+    IssueLiteSerializer,
+    IssueAttachmentSerializer,
+    IssueSubscriberSerializer,
+    ProjectMemberLiteSerializer,
+    IssueReactionSerializer,
+    CommentReactionSerializer,
+    IssueRelationSerializer,
+    RelatedIssueSerializer,
+    IssueDetailSerializer,
+)
+from plane.app.permissions import (
+    ProjectEntityPermission,
+    WorkSpaceAdminPermission,
+    ProjectMemberPermission,
+    ProjectLitePermission,
+)
+from plane.db.models import (
+    Project,
+    Issue,
+    IssueActivity,
+    IssueComment,
+    IssueProperty,
+    Label,
+    IssueLink,
+    IssueAttachment,
+    IssueSubscriber,
+    ProjectMember,
+    IssueReaction,
+    CommentReaction,
+    IssueRelation,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from plane.utils.grouper import group_results
+from plane.utils.issue_filters import issue_filters
+from collections import defaultdict
+from plane.utils.cache import invalidate_cache
+
+class IssueListEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get(self, request, slug, project_id):
+        issue_ids = request.GET.get("issues", False)
+
+        if not issue_ids:
+            return Response(
+                {"error": "Issues are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        issue_ids = [
+            issue_id for issue_id in issue_ids.split(",") if issue_id != ""
+        ]
+
+        queryset = (
+            Issue.issue_objects.filter(
+                workspace__slug=slug, project_id=project_id, pk__in=issue_ids
+            )
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module")
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "labels__id",
+                        distinct=True,
+                        filter=~Q(labels__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "assignees__id",
+                        distinct=True,
+                        filter=~Q(assignees__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=~Q(issue_module__module_id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+        ).distinct()
+
+        filters = issue_filters(request.query_params, "GET")
+
+        # Custom ordering for priority and state
+        priority_order = ["urgent", "high", "medium", "low", "none"]
+        state_order = [
+            "backlog",
+            "unstarted",
+            "started",
+            "completed",
+            "cancelled",
+        ]
+
+        order_by_param = request.GET.get("order_by", "-created_at")
+
+        issue_queryset = queryset.filter(**filters)
+
+        # 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]
+            )
+            issue_queryset = issue_queryset.annotate(
+                priority_order=Case(
+                    *[
+                        When(priority=p, then=Value(i))
+                        for i, p in enumerate(priority_order)
+                    ],
+                    output_field=CharField(),
+                )
+            ).order_by("priority_order")
+
+        # State Ordering
+        elif order_by_param in [
+            "state__name",
+            "state__group",
+            "-state__name",
+            "-state__group",
+        ]:
+            state_order = (
+                state_order
+                if order_by_param in ["state__name", "state__group"]
+                else state_order[::-1]
+            )
+            issue_queryset = issue_queryset.annotate(
+                state_order=Case(
+                    *[
+                        When(state__group=state_group, then=Value(i))
+                        for i, state_group in enumerate(state_order)
+                    ],
+                    default=Value(len(state_order)),
+                    output_field=CharField(),
+                )
+            ).order_by("state_order")
+        # assignee and label ordering
+        elif order_by_param in [
+            "labels__name",
+            "-labels__name",
+            "assignees__first_name",
+            "-assignees__first_name",
+        ]:
+            issue_queryset = issue_queryset.annotate(
+                max_values=Max(
+                    order_by_param[1::]
+                    if order_by_param.startswith("-")
+                    else order_by_param
+                )
+            ).order_by(
+                "-max_values"
+                if order_by_param.startswith("-")
+                else "max_values"
+            )
+        else:
+            issue_queryset = issue_queryset.order_by(order_by_param)
+
+        if self.fields or self.expand:
+            issues = IssueSerializer(
+                queryset, many=True, fields=self.fields, expand=self.expand
+            ).data
+        else:
+            issues = issue_queryset.values(
+                "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",
+            )
+        return Response(issues, status=status.HTTP_200_OK)
+
+
+class IssueViewSet(WebhookMixin, BaseViewSet):
+    def get_serializer_class(self):
+        return (
+            IssueCreateSerializer
+            if self.action in ["create", "update", "partial_update"]
+            else IssueSerializer
+        )
+
+    model = Issue
+    webhook_event = "issue"
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    search_fields = [
+        "name",
+    ]
+
+    filterset_fields = [
+        "state__name",
+        "assignees__id",
+        "workspace__id",
+    ]
+
+    def get_queryset(self):
+        return (
+            Issue.issue_objects.filter(
+                project_id=self.kwargs.get("project_id")
+            )
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module")
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "labels__id",
+                        distinct=True,
+                        filter=~Q(labels__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "assignees__id",
+                        distinct=True,
+                        filter=~Q(assignees__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=~Q(issue_module__module_id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+        ).distinct()
+
+    @method_decorator(gzip_page)
+    def list(self, request, slug, project_id):
+        filters = issue_filters(request.query_params, "GET")
+        order_by_param = request.GET.get("order_by", "-created_at")
+
+        issue_queryset = self.get_queryset().filter(**filters)
+        # Custom ordering for priority and state
+        priority_order = ["urgent", "high", "medium", "low", "none"]
+        state_order = [
+            "backlog",
+            "unstarted",
+            "started",
+            "completed",
+            "cancelled",
+        ]
+
+        # 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]
+            )
+            issue_queryset = issue_queryset.annotate(
+                priority_order=Case(
+                    *[
+                        When(priority=p, then=Value(i))
+                        for i, p in enumerate(priority_order)
+                    ],
+                    output_field=CharField(),
+                )
+            ).order_by("priority_order")
+
+        # State Ordering
+        elif order_by_param in [
+            "state__name",
+            "state__group",
+            "-state__name",
+            "-state__group",
+        ]:
+            state_order = (
+                state_order
+                if order_by_param in ["state__name", "state__group"]
+                else state_order[::-1]
+            )
+            issue_queryset = issue_queryset.annotate(
+                state_order=Case(
+                    *[
+                        When(state__group=state_group, then=Value(i))
+                        for i, state_group in enumerate(state_order)
+                    ],
+                    default=Value(len(state_order)),
+                    output_field=CharField(),
+                )
+            ).order_by("state_order")
+        # assignee and label ordering
+        elif order_by_param in [
+            "labels__name",
+            "-labels__name",
+            "assignees__first_name",
+            "-assignees__first_name",
+        ]:
+            issue_queryset = issue_queryset.annotate(
+                max_values=Max(
+                    order_by_param[1::]
+                    if order_by_param.startswith("-")
+                    else order_by_param
+                )
+            ).order_by(
+                "-max_values"
+                if order_by_param.startswith("-")
+                else "max_values"
+            )
+        else:
+            issue_queryset = issue_queryset.order_by(order_by_param)
+
+        # Only use serializer when expand or fields else return by values
+        if self.expand or self.fields:
+            issues = IssueSerializer(
+                issue_queryset,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+            ).data
+        else:
+            issues = issue_queryset.values(
+                "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",
+            )
+        return Response(issues, status=status.HTTP_200_OK)
+
+    def create(self, request, slug, project_id):
+        project = Project.objects.get(pk=project_id)
+
+        serializer = IssueCreateSerializer(
+            data=request.data,
+            context={
+                "project_id": project_id,
+                "workspace_id": project.workspace_id,
+                "default_assignee_id": project.default_assignee_id,
+            },
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+
+            # Track the issue
+            issue_activity.delay(
+                type="issue.activity.created",
+                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),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            issue = (
+                self.get_queryset()
+                .filter(pk=serializer.data["id"])
+                .values(
+                    "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",
+                )
+                .first()
+            )
+            return Response(issue, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def retrieve(self, request, slug, project_id, pk=None):
+        issue = (
+            self.get_queryset()
+            .filter(pk=pk)
+            .prefetch_related(
+                Prefetch(
+                    "issue_reactions",
+                    queryset=IssueReaction.objects.select_related(
+                        "issue", "actor"
+                    ),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_attachment",
+                    queryset=IssueAttachment.objects.select_related("issue"),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_link",
+                    queryset=IssueLink.objects.select_related("created_by"),
+                )
+            )
+            .annotate(
+                is_subscribed=Exists(
+                    IssueSubscriber.objects.filter(
+                        workspace__slug=slug,
+                        project_id=project_id,
+                        issue_id=OuterRef("pk"),
+                        subscriber=request.user,
+                    )
+                )
+            )
+        ).first()
+        if not issue:
+            return Response(
+                {"error": "The required object does not exist."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        serializer = IssueDetailSerializer(issue, expand=self.expand)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def partial_update(self, request, slug, project_id, pk=None):
+        issue = self.get_queryset().filter(pk=pk).first()
+
+        if not issue:
+            return Response(
+                {"error": "Issue not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        current_instance = json.dumps(
+            IssueSerializer(issue).data, cls=DjangoJSONEncoder
+        )
+
+        requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
+        serializer = IssueCreateSerializer(
+            issue, data=request.data, partial=True
+        )
+        if serializer.is_valid():
+            serializer.save()
+            issue_activity.delay(
+                type="issue.activity.updated",
+                requested_data=requested_data,
+                actor_id=str(request.user.id),
+                issue_id=str(pk),
+                project_id=str(project_id),
+                current_instance=current_instance,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            issue = self.get_queryset().filter(pk=pk).first()
+            return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def destroy(self, request, slug, project_id, pk=None):
+        issue = Issue.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
+        issue.delete()
+        issue_activity.delay(
+            type="issue.activity.deleted",
+            requested_data=json.dumps({"issue_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(pk),
+            project_id=str(project_id),
+            current_instance={},
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class IssueUserDisplayPropertyEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectLitePermission,
+    ]
+
+    def patch(self, request, slug, project_id):
+        issue_property = IssueProperty.objects.get(
+            user=request.user,
+            project_id=project_id,
+        )
+
+        issue_property.filters = request.data.get(
+            "filters", issue_property.filters
+        )
+        issue_property.display_filters = request.data.get(
+            "display_filters", issue_property.display_filters
+        )
+        issue_property.display_properties = request.data.get(
+            "display_properties", issue_property.display_properties
+        )
+        issue_property.save()
+        serializer = IssuePropertySerializer(issue_property)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    def get(self, request, slug, project_id):
+        issue_property, _ = IssueProperty.objects.get_or_create(
+            user=request.user, project_id=project_id
+        )
+        serializer = IssuePropertySerializer(issue_property)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class BulkDeleteIssuesEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def delete(self, request, slug, project_id):
+        issue_ids = request.data.get("issue_ids", [])
+
+        if not len(issue_ids):
+            return Response(
+                {"error": "Issue IDs are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        issues = Issue.issue_objects.filter(
+            workspace__slug=slug, project_id=project_id, pk__in=issue_ids
+        )
+
+        total_issues = len(issues)
+
+        issues.delete()
+
+        return Response(
+            {"message": f"{total_issues} issues were deleted"},
+            status=status.HTTP_200_OK,
+        )
@@ -0,0 +1,219 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.db.models import Exists
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet, WebhookMixin
+from plane.app.serializers import (
+    IssueCommentSerializer,
+    CommentReactionSerializer,
+)
+from plane.app.permissions import ProjectLitePermission
+from plane.db.models import (
+    IssueComment,
+    ProjectMember,
+    CommentReaction,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+
+
+class IssueCommentViewSet(WebhookMixin, BaseViewSet):
+    serializer_class = IssueCommentSerializer
+    model = IssueComment
+    webhook_event = "issue_comment"
+    permission_classes = [
+        ProjectLitePermission,
+    ]
+
+    filterset_fields = [
+        "issue__id",
+        "workspace__id",
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .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,
+                project__project_projectmember__is_active=True,
+            )
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .annotate(
+                is_member=Exists(
+                    ProjectMember.objects.filter(
+                        workspace__slug=self.kwargs.get("slug"),
+                        project_id=self.kwargs.get("project_id"),
+                        member_id=self.request.user.id,
+                        is_active=True,
+                    )
+                )
+            )
+            .distinct()
+        )
+
+    def create(self, request, slug, project_id, issue_id):
+        serializer = IssueCommentSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(
+                project_id=project_id,
+                issue_id=issue_id,
+                actor=request.user,
+            )
+            issue_activity.delay(
+                type="comment.activity.created",
+                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")),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def partial_update(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,
+        )
+        requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
+        current_instance = json.dumps(
+            IssueCommentSerializer(issue_comment).data,
+            cls=DjangoJSONEncoder,
+        )
+        serializer = IssueCommentSerializer(
+            issue_comment, data=request.data, partial=True
+        )
+        if serializer.is_valid():
+            serializer.save()
+            issue_activity.delay(
+                type="comment.activity.updated",
+                requested_data=requested_data,
+                actor_id=str(request.user.id),
+                issue_id=str(issue_id),
+                project_id=str(project_id),
+                current_instance=current_instance,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def destroy(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,
+        )
+        current_instance = json.dumps(
+            IssueCommentSerializer(issue_comment).data,
+            cls=DjangoJSONEncoder,
+        )
+        issue_comment.delete()
+        issue_activity.delay(
+            type="comment.activity.deleted",
+            requested_data=json.dumps({"comment_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=current_instance,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class CommentReactionViewSet(BaseViewSet):
+    serializer_class = CommentReactionSerializer
+    model = CommentReaction
+    permission_classes = [
+        ProjectLitePermission,
+    ]
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(comment_id=self.kwargs.get("comment_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    def create(self, request, slug, project_id, comment_id):
+        serializer = CommentReactionSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(
+                project_id=project_id,
+                actor_id=request.user.id,
+                comment_id=comment_id,
+            )
+            issue_activity.delay(
+                type="comment_reaction.activity.created",
+                requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+                actor_id=str(request.user.id),
+                issue_id=None,
+                project_id=str(project_id),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def destroy(self, request, slug, project_id, comment_id, reaction_code):
+        comment_reaction = CommentReaction.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            comment_id=comment_id,
+            reaction=reaction_code,
+            actor=request.user,
+        )
+        issue_activity.delay(
+            type="comment_reaction.activity.deleted",
+            requested_data=None,
+            actor_id=str(self.request.user.id),
+            issue_id=None,
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps(
+                {
+                    "reaction": str(reaction_code),
+                    "identifier": str(comment_reaction.id),
+                    "comment_id": str(comment_id),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        comment_reaction.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -0,0 +1,367 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.db.models import (
+    Prefetch,
+    OuterRef,
+    Func,
+    F,
+    Q,
+    Case,
+    Value,
+    CharField,
+    When,
+    Exists,
+    Max,
+    UUIDField,
+)
+from django.core.serializers.json import DjangoJSONEncoder
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models.functions import Coalesce
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import (
+    IssueSerializer,
+    IssueCreateSerializer,
+    IssueFlatSerializer,
+    IssueDetailSerializer,
+)
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import (
+    Project,
+    Issue,
+    IssueLink,
+    IssueAttachment,
+    IssueSubscriber,
+    IssueReaction,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from plane.utils.issue_filters import issue_filters
+
+
+class IssueDraftViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+    serializer_class = IssueFlatSerializer
+    model = Issue
+
+    def get_queryset(self):
+        return (
+            Issue.objects.filter(project_id=self.kwargs.get("project_id"))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(is_draft=True)
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module")
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "labels__id",
+                        distinct=True,
+                        filter=~Q(labels__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "assignees__id",
+                        distinct=True,
+                        filter=~Q(assignees__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=~Q(issue_module__module_id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+        ).distinct()
+
+    @method_decorator(gzip_page)
+    def list(self, request, slug, project_id):
+        filters = issue_filters(request.query_params, "GET")
+        fields = [
+            field
+            for field in request.GET.get("fields", "").split(",")
+            if field
+        ]
+
+        # Custom ordering for priority and state
+        priority_order = ["urgent", "high", "medium", "low", "none"]
+        state_order = [
+            "backlog",
+            "unstarted",
+            "started",
+            "completed",
+            "cancelled",
+        ]
+
+        order_by_param = request.GET.get("order_by", "-created_at")
+
+        issue_queryset = self.get_queryset().filter(**filters)
+
+        # 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]
+            )
+            issue_queryset = issue_queryset.annotate(
+                priority_order=Case(
+                    *[
+                        When(priority=p, then=Value(i))
+                        for i, p in enumerate(priority_order)
+                    ],
+                    output_field=CharField(),
+                )
+            ).order_by("priority_order")
+
+        # State Ordering
+        elif order_by_param in [
+            "state__name",
+            "state__group",
+            "-state__name",
+            "-state__group",
+        ]:
+            state_order = (
+                state_order
+                if order_by_param in ["state__name", "state__group"]
+                else state_order[::-1]
+            )
+            issue_queryset = issue_queryset.annotate(
+                state_order=Case(
+                    *[
+                        When(state__group=state_group, then=Value(i))
+                        for i, state_group in enumerate(state_order)
+                    ],
+                    default=Value(len(state_order)),
+                    output_field=CharField(),
+                )
+            ).order_by("state_order")
+        # assignee and label ordering
+        elif order_by_param in [
+            "labels__name",
+            "-labels__name",
+            "assignees__first_name",
+            "-assignees__first_name",
+        ]:
+            issue_queryset = issue_queryset.annotate(
+                max_values=Max(
+                    order_by_param[1::]
+                    if order_by_param.startswith("-")
+                    else order_by_param
+                )
+            ).order_by(
+                "-max_values"
+                if order_by_param.startswith("-")
+                else "max_values"
+            )
+        else:
+            issue_queryset = issue_queryset.order_by(order_by_param)
+
+        # Only use serializer when expand else return by values
+        if self.expand or self.fields:
+            issues = IssueSerializer(
+                issue_queryset,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+            ).data
+        else:
+            issues = issue_queryset.values(
+                "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",
+            )
+        return Response(issues, status=status.HTTP_200_OK)
+
+    def create(self, request, slug, project_id):
+        project = Project.objects.get(pk=project_id)
+
+        serializer = IssueCreateSerializer(
+            data=request.data,
+            context={
+                "project_id": project_id,
+                "workspace_id": project.workspace_id,
+                "default_assignee_id": project.default_assignee_id,
+            },
+        )
+
+        if serializer.is_valid():
+            serializer.save(is_draft=True)
+
+            # Track the issue
+            issue_activity.delay(
+                type="issue_draft.activity.created",
+                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),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            issue = (
+                self.get_queryset().filter(pk=serializer.data["id"]).first()
+            )
+            return Response(
+                IssueSerializer(issue).data, status=status.HTTP_201_CREATED
+            )
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def partial_update(self, request, slug, project_id, pk):
+        issue = self.get_queryset().filter(pk=pk).first()
+
+        if not issue:
+            return Response(
+                {"error": "Issue does not exist"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        serializer = IssueCreateSerializer(
+            issue, data=request.data, partial=True
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+            issue_activity.delay(
+                type="issue_draft.activity.updated",
+                requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("pk", None)),
+                project_id=str(self.kwargs.get("project_id", None)),
+                current_instance=json.dumps(
+                    IssueSerializer(issue).data,
+                    cls=DjangoJSONEncoder,
+                ),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def retrieve(self, request, slug, project_id, pk=None):
+        issue = (
+            self.get_queryset()
+            .filter(pk=pk)
+            .prefetch_related(
+                Prefetch(
+                    "issue_reactions",
+                    queryset=IssueReaction.objects.select_related(
+                        "issue", "actor"
+                    ),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_attachment",
+                    queryset=IssueAttachment.objects.select_related("issue"),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_link",
+                    queryset=IssueLink.objects.select_related("created_by"),
+                )
+            )
+            .annotate(
+                is_subscribed=Exists(
+                    IssueSubscriber.objects.filter(
+                        workspace__slug=slug,
+                        project_id=project_id,
+                        issue_id=OuterRef("pk"),
+                        subscriber=request.user,
+                    )
+                )
+            )
+        ).first()
+
+        if not issue:
+            return Response(
+                {"error": "The required object does not exist."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        serializer = IssueDetailSerializer(issue, expand=self.expand)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def destroy(self, request, slug, project_id, pk=None):
+        issue = Issue.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
+        issue.delete()
+        issue_activity.delay(
+            type="issue_draft.activity.deleted",
+            requested_data=json.dumps({"issue_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(pk),
+            project_id=str(project_id),
+            current_instance={},
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -0,0 +1,105 @@
+# Python imports
+import random
+
+# Django imports
+from django.db import IntegrityError
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet, BaseAPIView
+from plane.app.serializers import LabelSerializer
+from plane.app.permissions import (
+    ProjectMemberPermission,
+)
+from plane.db.models import (
+    Project,
+    Label,
+)
+from plane.utils.cache import invalidate_cache
+
+
+class LabelViewSet(BaseViewSet):
+    serializer_class = LabelSerializer
+    model = Label
+    permission_classes = [
+        ProjectMemberPermission,
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("parent")
+            .distinct()
+            .order_by("sort_order")
+        )
+
+    @invalidate_cache(
+        path="/api/workspaces/:slug/labels/", url_params=True, user=False
+    )
+    def create(self, request, slug, project_id):
+        try:
+            serializer = LabelSerializer(data=request.data)
+            if serializer.is_valid():
+                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(
+                {
+                    "error": "Label with the same name already exists in the project"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+    @invalidate_cache(
+        path="/api/workspaces/:slug/labels/", url_params=True, user=False
+    )
+    def partial_update(self, request, *args, **kwargs):
+        return super().partial_update(request, *args, **kwargs)
+
+    @invalidate_cache(
+        path="/api/workspaces/:slug/labels/", url_params=True, user=False
+    )
+    def destroy(self, request, *args, **kwargs):
+        return super().destroy(request, *args, **kwargs)
+
+
+class BulkCreateIssueLabelsEndpoint(BaseAPIView):
+    def post(self, request, slug, project_id):
+        label_data = request.data.get("label_data", [])
+        project = Project.objects.get(pk=project_id)
+
+        labels = Label.objects.bulk_create(
+            [
+                Label(
+                    name=label.get("name", "Migrated"),
+                    description=label.get("description", "Migrated Issue"),
+                    color="#" + "%06x" % random.randint(0, 0xFFFFFF),
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for label in label_data
+            ],
+            batch_size=50,
+            ignore_conflicts=True,
+        )
+
+        return Response(
+            {"labels": LabelSerializer(labels, many=True).data},
+            status=status.HTTP_201_CREATED,
+        )
@@ -0,0 +1,120 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import IssueLinkSerializer
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import IssueLink
+from plane.bgtasks.issue_activites_task import issue_activity
+
+
+class IssueLinkViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    model = IssueLink
+    serializer_class = IssueLinkSerializer
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .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,
+                project__project_projectmember__is_active=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    def create(self, request, slug, project_id, issue_id):
+        serializer = IssueLinkSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(
+                project_id=project_id,
+                issue_id=issue_id,
+            )
+            issue_activity.delay(
+                type="link.activity.created",
+                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")),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def partial_update(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,
+        )
+        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
+        )
+        if serializer.is_valid():
+            serializer.save()
+            issue_activity.delay(
+                type="link.activity.updated",
+                requested_data=requested_data,
+                actor_id=str(request.user.id),
+                issue_id=str(issue_id),
+                project_id=str(project_id),
+                current_instance=current_instance,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def destroy(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,
+        )
+        current_instance = json.dumps(
+            IssueLinkSerializer(issue_link).data,
+            cls=DjangoJSONEncoder,
+        )
+        issue_activity.delay(
+            type="link.activity.deleted",
+            requested_data=json.dumps({"link_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=current_instance,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        issue_link.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -0,0 +1,89 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import IssueReactionSerializer
+from plane.app.permissions import ProjectLitePermission
+from plane.db.models import IssueReaction
+from plane.bgtasks.issue_activites_task import issue_activity
+
+
+class IssueReactionViewSet(BaseViewSet):
+    serializer_class = IssueReactionSerializer
+    model = IssueReaction
+    permission_classes = [
+        ProjectLitePermission,
+    ]
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .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,
+                project__project_projectmember__is_active=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    def create(self, request, slug, project_id, issue_id):
+        serializer = IssueReactionSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(
+                issue_id=issue_id,
+                project_id=project_id,
+                actor=request.user,
+            )
+            issue_activity.delay(
+                type="issue_reaction.activity.created",
+                requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+                actor_id=str(request.user.id),
+                issue_id=str(issue_id),
+                project_id=str(project_id),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def destroy(self, request, slug, project_id, issue_id, reaction_code):
+        issue_reaction = IssueReaction.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            issue_id=issue_id,
+            reaction=reaction_code,
+            actor=request.user,
+        )
+        issue_activity.delay(
+            type="issue_reaction.activity.deleted",
+            requested_data=None,
+            actor_id=str(self.request.user.id),
+            issue_id=str(self.kwargs.get("issue_id", None)),
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps(
+                {
+                    "reaction": str(reaction_code),
+                    "identifier": str(issue_reaction.id),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        issue_reaction.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -0,0 +1,204 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.db.models import Q
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import (
+    IssueRelationSerializer,
+    RelatedIssueSerializer,
+)
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import (
+    Project,
+    IssueRelation,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+
+
+class IssueRelationViewSet(BaseViewSet):
+    serializer_class = IssueRelationSerializer
+    model = IssueRelation
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .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,
+                project__project_projectmember__is_active=True,
+            )
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .distinct()
+        )
+
+    def list(self, request, slug, project_id, issue_id):
+        issue_relations = (
+            IssueRelation.objects.filter(
+                Q(issue_id=issue_id) | Q(related_issue=issue_id)
+            )
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .order_by("-created_at")
+            .distinct()
+        )
+
+        blocking_issues = issue_relations.filter(
+            relation_type="blocked_by", related_issue_id=issue_id
+        )
+        blocked_by_issues = issue_relations.filter(
+            relation_type="blocked_by", issue_id=issue_id
+        )
+        duplicate_issues = issue_relations.filter(
+            issue_id=issue_id, relation_type="duplicate"
+        )
+        duplicate_issues_related = issue_relations.filter(
+            related_issue_id=issue_id, relation_type="duplicate"
+        )
+        relates_to_issues = issue_relations.filter(
+            issue_id=issue_id, relation_type="relates_to"
+        )
+        relates_to_issues_related = issue_relations.filter(
+            related_issue_id=issue_id, relation_type="relates_to"
+        )
+
+        blocked_by_issues_serialized = IssueRelationSerializer(
+            blocked_by_issues, many=True
+        ).data
+        duplicate_issues_serialized = IssueRelationSerializer(
+            duplicate_issues, many=True
+        ).data
+        relates_to_issues_serialized = IssueRelationSerializer(
+            relates_to_issues, many=True
+        ).data
+
+        # revere relation for blocked by issues
+        blocking_issues_serialized = RelatedIssueSerializer(
+            blocking_issues, many=True
+        ).data
+        # reverse relation for duplicate issues
+        duplicate_issues_related_serialized = RelatedIssueSerializer(
+            duplicate_issues_related, many=True
+        ).data
+        # reverse relation for related issues
+        relates_to_issues_related_serialized = RelatedIssueSerializer(
+            relates_to_issues_related, many=True
+        ).data
+
+        response_data = {
+            "blocking": blocking_issues_serialized,
+            "blocked_by": blocked_by_issues_serialized,
+            "duplicate": duplicate_issues_serialized
+            + duplicate_issues_related_serialized,
+            "relates_to": relates_to_issues_serialized
+            + relates_to_issues_related_serialized,
+        }
+
+        return Response(response_data, status=status.HTTP_200_OK)
+
+    def create(self, request, slug, project_id, issue_id):
+        relation_type = request.data.get("relation_type", None)
+        issues = request.data.get("issues", [])
+        project = Project.objects.get(pk=project_id)
+
+        issue_relation = IssueRelation.objects.bulk_create(
+            [
+                IssueRelation(
+                    issue_id=(
+                        issue if relation_type == "blocking" else issue_id
+                    ),
+                    related_issue_id=(
+                        issue_id if relation_type == "blocking" else issue
+                    ),
+                    relation_type=(
+                        "blocked_by"
+                        if relation_type == "blocking"
+                        else relation_type
+                    ),
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for issue in issues
+            ],
+            batch_size=10,
+            ignore_conflicts=True,
+        )
+
+        issue_activity.delay(
+            type="issue_relation.activity.created",
+            requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+
+        if relation_type == "blocking":
+            return Response(
+                RelatedIssueSerializer(issue_relation, many=True).data,
+                status=status.HTTP_201_CREATED,
+            )
+        else:
+            return Response(
+                IssueRelationSerializer(issue_relation, many=True).data,
+                status=status.HTTP_201_CREATED,
+            )
+
+    def remove_relation(self, request, slug, project_id, issue_id):
+        relation_type = request.data.get("relation_type", None)
+        related_issue = request.data.get("related_issue", None)
+
+        if relation_type == "blocking":
+            issue_relation = IssueRelation.objects.get(
+                workspace__slug=slug,
+                project_id=project_id,
+                issue_id=related_issue,
+                related_issue_id=issue_id,
+            )
+        else:
+            issue_relation = IssueRelation.objects.get(
+                workspace__slug=slug,
+                project_id=project_id,
+                issue_id=issue_id,
+                related_issue_id=related_issue,
+            )
+        current_instance = json.dumps(
+            IssueRelationSerializer(issue_relation).data,
+            cls=DjangoJSONEncoder,
+        )
+        issue_relation.delete()
+        issue_activity.delay(
+            type="issue_relation.activity.deleted",
+            requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=current_instance,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -0,0 +1,195 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.db.models import (
+    OuterRef,
+    Func,
+    F,
+    Q,
+    Value,
+    UUIDField,
+)
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models.functions import Coalesce
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseAPIView
+from plane.app.serializers import IssueSerializer
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import (
+    Issue,
+    IssueLink,
+    IssueAttachment,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from collections import defaultdict
+
+
+class SubIssuesEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    @method_decorator(gzip_page)
+    def get(self, request, slug, project_id, issue_id):
+        sub_issues = (
+            Issue.issue_objects.filter(
+                parent_id=issue_id, workspace__slug=slug
+            )
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module")
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "labels__id",
+                        distinct=True,
+                        filter=~Q(labels__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "assignees__id",
+                        distinct=True,
+                        filter=~Q(assignees__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=~Q(issue_module__module_id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+            .annotate(state_group=F("state__group"))
+        )
+
+        # create's a dict with state group name with their respective issue id's
+        result = defaultdict(list)
+        for sub_issue in sub_issues:
+            result[sub_issue.state_group].append(str(sub_issue.id))
+
+        sub_issues = sub_issues.values(
+            "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",
+        )
+        return Response(
+            {
+                "sub_issues": sub_issues,
+                "state_distribution": result,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    # Assign multiple sub issues
+    def post(self, request, slug, project_id, issue_id):
+        parent_issue = Issue.issue_objects.get(pk=issue_id)
+        sub_issue_ids = request.data.get("sub_issue_ids", [])
+
+        if not len(sub_issue_ids):
+            return Response(
+                {"error": "Sub Issue IDs are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        sub_issues = Issue.issue_objects.filter(id__in=sub_issue_ids)
+
+        for sub_issue in sub_issues:
+            sub_issue.parent = parent_issue
+
+        _ = Issue.objects.bulk_update(sub_issues, ["parent"], batch_size=10)
+
+        updated_sub_issues = Issue.issue_objects.filter(
+            id__in=sub_issue_ids
+        ).annotate(state_group=F("state__group"))
+
+        # Track the issue
+        _ = [
+            issue_activity.delay(
+                type="issue.activity.updated",
+                requested_data=json.dumps({"parent": str(issue_id)}),
+                actor_id=str(request.user.id),
+                issue_id=str(sub_issue_id),
+                project_id=str(project_id),
+                current_instance=json.dumps({"parent": str(sub_issue_id)}),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            for sub_issue_id in sub_issue_ids
+        ]
+
+        # create's a dict with state group name with their respective issue id's
+        result = defaultdict(list)
+        for sub_issue in updated_sub_issues:
+            result[sub_issue.state_group].append(str(sub_issue.id))
+
+        serializer = IssueSerializer(
+            updated_sub_issues,
+            many=True,
+        )
+        return Response(
+            {
+                "sub_issues": serializer.data,
+                "state_distribution": result,
+            },
+            status=status.HTTP_200_OK,
+        )
@@ -0,0 +1,124 @@
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import (
+    IssueSubscriberSerializer,
+    ProjectMemberLiteSerializer,
+)
+from plane.app.permissions import (
+    ProjectEntityPermission,
+    ProjectLitePermission,
+)
+from plane.db.models import (
+    IssueSubscriber,
+    ProjectMember,
+)
+
+
+class IssueSubscriberViewSet(BaseViewSet):
+    serializer_class = IssueSubscriberSerializer
+    model = IssueSubscriber
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get_permissions(self):
+        if self.action in ["subscribe", "unsubscribe", "subscription_status"]:
+            self.permission_classes = [
+                ProjectLitePermission,
+            ]
+        else:
+            self.permission_classes = [
+                ProjectEntityPermission,
+            ]
+
+        return super(IssueSubscriberViewSet, self).get_permissions()
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"),
+            issue_id=self.kwargs.get("issue_id"),
+        )
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .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,
+                project__project_projectmember__is_active=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    def list(self, request, slug, project_id, issue_id):
+        members = ProjectMember.objects.filter(
+            workspace__slug=slug,
+            project_id=project_id,
+            is_active=True,
+        ).select_related("member")
+        serializer = ProjectMemberLiteSerializer(members, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def destroy(self, request, slug, project_id, issue_id, subscriber_id):
+        issue_subscriber = IssueSubscriber.objects.get(
+            project=project_id,
+            subscriber=subscriber_id,
+            workspace__slug=slug,
+            issue=issue_id,
+        )
+        issue_subscriber.delete()
+        return Response(
+            status=status.HTTP_204_NO_CONTENT,
+        )
+
+    def subscribe(self, request, slug, project_id, issue_id):
+        if IssueSubscriber.objects.filter(
+            issue_id=issue_id,
+            subscriber=request.user,
+            workspace__slug=slug,
+            project=project_id,
+        ).exists():
+            return Response(
+                {"message": "User already subscribed to the issue."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        subscriber = IssueSubscriber.objects.create(
+            issue_id=issue_id,
+            subscriber_id=request.user.id,
+            project_id=project_id,
+        )
+        serializer = IssueSubscriberSerializer(subscriber)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    def unsubscribe(self, request, slug, project_id, issue_id):
+        issue_subscriber = IssueSubscriber.objects.get(
+            project=project_id,
+            subscriber=request.user,
+            workspace__slug=slug,
+            issue=issue_id,
+        )
+        issue_subscriber.delete()
+        return Response(
+            status=status.HTTP_204_NO_CONTENT,
+        )
+
+    def subscription_status(self, request, slug, project_id, issue_id):
+        issue_subscriber = IssueSubscriber.objects.filter(
+            issue=issue_id,
+            subscriber=request.user,
+            workspace__slug=slug,
+            project=project_id,
+        ).exists()
+        return Response(
+            {"subscribed": issue_subscriber}, status=status.HTTP_200_OK
+        )
@@ -3,25 +3,25 @@ import json

 # Django Imports
 from django.utils import timezone
-from django.db.models import Prefetch, F, OuterRef, Func, Exists, Count, Q
-from django.core import serializers
-from django.utils.decorators import method_decorator
-from django.views.decorators.gzip import gzip_page
+from django.db.models import Prefetch, F, OuterRef, Exists, Count, Q
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import Value, UUIDField
+from django.db.models.functions import Coalesce

 # Third party imports
 from rest_framework.response import Response
 from rest_framework import status

 # Module imports
-from . import BaseViewSet, BaseAPIView, WebhookMixin
+from .. import BaseViewSet, BaseAPIView, WebhookMixin
 from plane.app.serializers import (
    ModuleWriteSerializer,
    ModuleSerializer,
-    ModuleIssueSerializer,
    ModuleLinkSerializer,
    ModuleFavoriteSerializer,
-    IssueSerializer,
    ModuleUserPropertiesSerializer,
+    ModuleDetailSerializer,
 )
 from plane.app.permissions import (
    ProjectEntityPermission,
@@ -34,14 +34,9 @@ from plane.db.models import (
    Issue,
    ModuleLink,
    ModuleFavorite,
-    IssueLink,
-    IssueAttachment,
-    IssueSubscriber,
    ModuleUserProperties,
 )
 from plane.bgtasks.issue_activites_task import issue_activity
-from plane.utils.grouper import group_results
-from plane.utils.issue_filters import issue_filters
 from plane.utils.analytics_plot import burndown_plot


@@ -60,7 +55,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
        )

    def get_queryset(self):
-        subquery = ModuleFavorite.objects.filter(
+        favorite_subquery = ModuleFavorite.objects.filter(
            user=self.request.user,
            module_id=OuterRef("pk"),
            project_id=self.kwargs.get("project_id"),
@@ -71,7 +66,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
            .get_queryset()
            .filter(project_id=self.kwargs.get("project_id"))
            .filter(workspace__slug=self.kwargs.get("slug"))
-            .annotate(is_favorite=Exists(subquery))
+            .annotate(is_favorite=Exists(favorite_subquery))
            .select_related("project")
            .select_related("workspace")
            .select_related("lead")
@@ -143,6 +138,16 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
                    ),
                )
            )
+            .annotate(
+                member_ids=Coalesce(
+                    ArrayAgg(
+                        "members__id",
+                        distinct=True,
+                        filter=~Q(members__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                )
+            )
            .order_by("-is_favorite", "-created_at")
        )

@@ -155,25 +160,84 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
        if serializer.is_valid():
            serializer.save()

-            module = Module.objects.get(pk=serializer.data["id"])
-            serializer = ModuleSerializer(module)
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
+            module = (
+                self.get_queryset()
+                .filter(pk=serializer.data["id"])
+                .values(  # 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",
+                )
+            ).first()
+            return Response(module, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def list(self, request, slug, project_id):
        queryset = self.get_queryset()
-        fields = [
-            field
-            for field in request.GET.get("fields", "").split(",")
-            if field
-        ]
-        modules = ModuleSerializer(
-            queryset, many=True, fields=fields if fields else None
-        ).data
+        if self.fields:
+            modules = ModuleSerializer(
+                queryset,
+                many=True,
+                fields=self.fields,
+            ).data
+        else:
+            modules = queryset.values(  # 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",
+            )
        return Response(modules, status=status.HTTP_200_OK)

    def retrieve(self, request, slug, project_id, pk):
-        queryset = self.get_queryset().get(pk=pk)
+        queryset = self.get_queryset().filter(pk=pk)

        assignee_distribution = (
            Issue.objects.filter(
@@ -195,7 +259,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
            )
            .annotate(
                total_issues=Count(
-                    "assignee_id",
+                    "id",
                    filter=Q(
                        archived_at__isnull=True,
                        is_draft=False,
@@ -204,7 +268,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
            )
            .annotate(
                completed_issues=Count(
-                    "assignee_id",
+                    "id",
                    filter=Q(
                        completed_at__isnull=False,
                        archived_at__isnull=True,
@@ -214,7 +278,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
            )
            .annotate(
                pending_issues=Count(
-                    "assignee_id",
+                    "id",
                    filter=Q(
                        completed_at__isnull=True,
                        archived_at__isnull=True,
@@ -237,7 +301,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
            .values("label_name", "color", "label_id")
            .annotate(
                total_issues=Count(
-                    "label_id",
+                    "id",
                    filter=Q(
                        archived_at__isnull=True,
                        is_draft=False,
@@ -246,7 +310,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
            )
            .annotate(
                completed_issues=Count(
-                    "label_id",
+                    "id",
                    filter=Q(
                        completed_at__isnull=False,
                        archived_at__isnull=True,
@@ -256,7 +320,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
            )
            .annotate(
                pending_issues=Count(
-                    "label_id",
+                    "id",
                    filter=Q(
                        completed_at__isnull=True,
                        archived_at__isnull=True,
@@ -267,16 +331,16 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
            .order_by("label_name")
        )

-        data = ModuleSerializer(queryset).data
+        data = ModuleDetailSerializer(queryset.first()).data
        data["distribution"] = {
            "assignees": assignee_distribution,
            "labels": label_distribution,
            "completion_chart": {},
        }

-        if queryset.start_date and queryset.target_date:
+        if queryset.first().start_date and queryset.first().target_date:
            data["distribution"]["completion_chart"] = burndown_plot(
-                queryset=queryset,
+                queryset=queryset.first(),
                slug=slug,
                project_id=project_id,
                module_id=pk,
@@ -287,6 +351,47 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
            status=status.HTTP_200_OK,
        )

+    def partial_update(self, request, slug, project_id, pk):
+        queryset = self.get_queryset().filter(pk=pk)
+        serializer = ModuleWriteSerializer(
+            queryset.first(), data=request.data, partial=True
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+            module = queryset.values(
+                # 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",
+            ).first()
+            return Response(module, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
    def destroy(self, request, slug, project_id, pk):
        module = Module.objects.get(
            workspace__slug=slug, project_id=project_id, pk=pk
@@ -296,237 +401,21 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
                "issue", flat=True
            )
        )
-        issue_activity.delay(
-            type="module.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "module_id": str(pk),
-                    "module_name": str(module.name),
-                    "issues": [str(issue_id) for issue_id in module_issues],
-                }
-            ),
-            actor_id=str(request.user.id),
-            issue_id=str(pk),
-            project_id=str(project_id),
-            current_instance=None,
-            epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-        module.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
-    serializer_class = ModuleIssueSerializer
-    model = ModuleIssue
-    webhook_event = "module_issue"
-    bulk = True
-
-    filterset_fields = [
-        "issue__labels__id",
-        "issue__assignees__id",
-    ]
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("issue")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
+        _ = [
+            issue_activity.delay(
+                type="module.activity.deleted",
+                requested_data=json.dumps({"module_id": str(pk)}),
+                actor_id=str(request.user.id),
+                issue_id=str(issue),
+                project_id=project_id,
+                current_instance=json.dumps({"module_name": str(module.name)}),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
            )
-            .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)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("module")
-            .select_related("issue", "issue__state", "issue__project")
-            .prefetch_related("issue__assignees", "issue__labels")
-            .prefetch_related("module__members")
-            .distinct()
-        )
-
-    @method_decorator(gzip_page)
-    def list(self, request, slug, project_id, module_id):
-        fields = [
-            field
-            for field in request.GET.get("fields", "").split(",")
-            if field
+            for issue in module_issues
        ]
-        order_by = request.GET.get("order_by", "created_at")
-        filters = issue_filters(request.query_params, "GET")
-        issues = (
-            Issue.issue_objects.filter(issue_module__module_id=module_id)
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .filter(project_id=project_id)
-            .filter(workspace__slug=slug)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("state")
-            .select_related("parent")
-            .prefetch_related("assignees")
-            .prefetch_related("labels")
-            .order_by(order_by)
-            .filter(**filters)
-            .annotate(cycle_id=F("issue_cycle__cycle_id"))
-            .annotate(module_id=F("issue_module__module_id"))
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                is_subscribed=Exists(
-                    IssueSubscriber.objects.filter(
-                        subscriber=self.request.user, issue_id=OuterRef("id")
-                    )
-                )
-            )
-        )
-        serializer = IssueSerializer(
-            issues, many=True, fields=fields if fields else None
-        )
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def create(self, request, slug, project_id, module_id):
-        issues = request.data.get("issues", [])
-        if not len(issues):
-            return Response(
-                {"error": "Issues are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        module = Module.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=module_id
-        )
-
-        module_issues = list(ModuleIssue.objects.filter(issue_id__in=issues))
-
-        update_module_issue_activity = []
-        records_to_update = []
-        record_to_create = []
-
-        for issue in issues:
-            module_issue = [
-                module_issue
-                for module_issue in module_issues
-                if str(module_issue.issue_id) in issues
-            ]
-
-            if len(module_issue):
-                if module_issue[0].module_id != module_id:
-                    update_module_issue_activity.append(
-                        {
-                            "old_module_id": str(module_issue[0].module_id),
-                            "new_module_id": str(module_id),
-                            "issue_id": str(module_issue[0].issue_id),
-                        }
-                    )
-                    module_issue[0].module_id = module_id
-                    records_to_update.append(module_issue[0])
-            else:
-                record_to_create.append(
-                    ModuleIssue(
-                        module=module,
-                        issue_id=issue,
-                        project_id=project_id,
-                        workspace=module.workspace,
-                        created_by=request.user,
-                        updated_by=request.user,
-                    )
-                )
-
-        ModuleIssue.objects.bulk_create(
-            record_to_create,
-            batch_size=10,
-            ignore_conflicts=True,
-        )
-
-        ModuleIssue.objects.bulk_update(
-            records_to_update,
-            ["module"],
-            batch_size=10,
-        )
-
-        # Capture Issue Activity
-        issue_activity.delay(
-            type="module.activity.created",
-            requested_data=json.dumps({"modules_list": issues}),
-            actor_id=str(self.request.user.id),
-            issue_id=None,
-            project_id=str(self.kwargs.get("project_id", None)),
-            current_instance=json.dumps(
-                {
-                    "updated_module_issues": update_module_issue_activity,
-                    "created_module_issues": serializers.serialize(
-                        "json", record_to_create
-                    ),
-                }
-            ),
-            epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-
-        issues = self.get_queryset().values_list("issue_id", flat=True)
-
-        return Response(
-            IssueSerializer(
-                Issue.objects.filter(pk__in=issues), many=True
-            ).data,
-            status=status.HTTP_200_OK,
-        )
-
-    def destroy(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,
-        )
-        issue_activity.delay(
-            type="module.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "module_id": str(module_id),
-                    "issues": [str(issue_id)],
-                }
-            ),
-            actor_id=str(request.user.id),
-            issue_id=str(issue_id),
-            project_id=str(project_id),
-            current_instance=None,
-            epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-        module_issue.delete()
+        module.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)


@@ -551,7 +440,10 @@ class ModuleLinkViewSet(BaseViewSet):
            .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,
+            )
            .order_by("-created_at")
            .distinct()
        )
@@ -0,0 +1,259 @@
+# Python imports
+import json
+
+# Django Imports
+from django.utils import timezone
+from django.db.models import F, OuterRef, Func, Q
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import Value, UUIDField
+from django.db.models.functions import Coalesce
+
+# Third party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet, WebhookMixin
+from plane.app.serializers import (
+    ModuleIssueSerializer,
+    IssueSerializer,
+)
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import (
+    ModuleIssue,
+    Project,
+    Issue,
+    IssueLink,
+    IssueAttachment,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from plane.utils.issue_filters import issue_filters
+
+
+class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
+    serializer_class = ModuleIssueSerializer
+    model = ModuleIssue
+    webhook_event = "module_issue"
+    bulk = True
+
+    filterset_fields = [
+        "issue__labels__id",
+        "issue__assignees__id",
+    ]
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get_queryset(self):
+        return (
+            Issue.issue_objects.filter(
+                project_id=self.kwargs.get("project_id"),
+                workspace__slug=self.kwargs.get("slug"),
+                issue_module__module_id=self.kwargs.get("module_id"),
+            )
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module")
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "labels__id",
+                        distinct=True,
+                        filter=~Q(labels__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "assignees__id",
+                        distinct=True,
+                        filter=~Q(assignees__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=~Q(issue_module__module_id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+        ).distinct()
+
+    @method_decorator(gzip_page)
+    def list(self, request, slug, project_id, module_id):
+        fields = [
+            field
+            for field in request.GET.get("fields", "").split(",")
+            if field
+        ]
+        filters = issue_filters(request.query_params, "GET")
+        issue_queryset = self.get_queryset().filter(**filters)
+        if self.fields or self.expand:
+            issues = IssueSerializer(
+                issue_queryset, many=True, fields=fields if fields else None
+            ).data
+        else:
+            issues = issue_queryset.values(
+                "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",
+            )
+        return Response(issues, status=status.HTTP_200_OK)
+
+    # create multiple issues inside a module
+    def create_module_issues(self, request, slug, project_id, module_id):
+        issues = request.data.get("issues", [])
+        if not issues:
+            return Response(
+                {"error": "Issues are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        project = Project.objects.get(pk=project_id)
+        _ = ModuleIssue.objects.bulk_create(
+            [
+                ModuleIssue(
+                    issue_id=str(issue),
+                    module_id=module_id,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for issue in issues
+            ],
+            batch_size=10,
+            ignore_conflicts=True,
+        )
+        # Bulk Update the activity
+        _ = [
+            issue_activity.delay(
+                type="module.activity.created",
+                requested_data=json.dumps({"module_id": str(module_id)}),
+                actor_id=str(request.user.id),
+                issue_id=str(issue),
+                project_id=project_id,
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            for issue in issues
+        ]
+        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
+
+    # create multiple module inside an issue
+    def create_issue_modules(self, request, slug, project_id, issue_id):
+        modules = request.data.get("modules", [])
+        if not modules:
+            return Response(
+                {"error": "Modules are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        project = Project.objects.get(pk=project_id)
+        _ = ModuleIssue.objects.bulk_create(
+            [
+                ModuleIssue(
+                    issue_id=issue_id,
+                    module_id=module,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for module in modules
+            ],
+            batch_size=10,
+            ignore_conflicts=True,
+        )
+        # Bulk Update the activity
+        _ = [
+            issue_activity.delay(
+                type="module.activity.created",
+                requested_data=json.dumps({"module_id": module}),
+                actor_id=str(request.user.id),
+                issue_id=issue_id,
+                project_id=project_id,
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            for module in modules
+        ]
+
+        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
+
+    def destroy(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,
+        )
+        issue_activity.delay(
+            type="module.activity.deleted",
+            requested_data=json.dumps({"module_id": str(module_id)}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=json.dumps(
+                {"module_name": module_issue.module.name}
+            ),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        module_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -8,7 +8,7 @@ from rest_framework.response import Response
 from plane.utils.paginator import BasePaginator

 # Module imports
-from .base import BaseViewSet, BaseAPIView
+from ..base import BaseViewSet, BaseAPIView
 from plane.db.models import (
    Notification,
    IssueAssignee,
@@ -17,7 +17,10 @@ from plane.db.models import (
    WorkspaceMember,
    UserNotificationPreference,
 )
-from plane.app.serializers import NotificationSerializer, UserNotificationPreferenceSerializer
+from plane.app.serializers import (
+    NotificationSerializer,
+    UserNotificationPreferenceSerializer,
+)


 class NotificationViewSet(BaseViewSet, BasePaginator):
@@ -5,7 +5,6 @@ import os

 # Django imports
 from django.utils import timezone
-from django.conf import settings

 # Third Party modules
 from rest_framework.response import Response
@@ -250,9 +249,11 @@ class OauthEndpoint(BaseAPIView):
                [
                    WorkspaceMember(
                        workspace_id=project_member_invite.workspace_id,
-                        role=project_member_invite.role
-                        if project_member_invite.role in [5, 10, 15]
-                        else 15,
+                        role=(
+                            project_member_invite.role
+                            if project_member_invite.role in [5, 10, 15]
+                            else 15
+                        ),
                        member=user,
                        created_by_id=project_member_invite.created_by_id,
                    )
@@ -266,9 +267,11 @@ class OauthEndpoint(BaseAPIView):
                [
                    ProjectMember(
                        workspace_id=project_member_invite.workspace_id,
-                        role=project_member_invite.role
-                        if project_member_invite.role in [5, 10, 15]
-                        else 15,
+                        role=(
+                            project_member_invite.role
+                            if project_member_invite.role in [5, 10, 15]
+                            else 15
+                        ),
                        member=user,
                        created_by_id=project_member_invite.created_by_id,
                    )
@@ -296,7 +299,7 @@ class OauthEndpoint(BaseAPIView):
                email=email,
                user_agent=request.META.get("HTTP_USER_AGENT"),
                ip=request.META.get("REMOTE_ADDR"),
-                event_name="SIGN_IN",
+                event_name="Sign in",
                medium=medium.upper(),
                first_time=False,
            )
@@ -391,9 +394,11 @@ class OauthEndpoint(BaseAPIView):
                [
                    WorkspaceMember(
                        workspace_id=project_member_invite.workspace_id,
-                        role=project_member_invite.role
-                        if project_member_invite.role in [5, 10, 15]
-                        else 15,
+                        role=(
+                            project_member_invite.role
+                            if project_member_invite.role in [5, 10, 15]
+                            else 15
+                        ),
                        member=user,
                        created_by_id=project_member_invite.created_by_id,
                    )
@@ -407,9 +412,11 @@ class OauthEndpoint(BaseAPIView):
                [
                    ProjectMember(
                        workspace_id=project_member_invite.workspace_id,
-                        role=project_member_invite.role
-                        if project_member_invite.role in [5, 10, 15]
-                        else 15,
+                        role=(
+                            project_member_invite.role
+                            if project_member_invite.role in [5, 10, 15]
+                            else 15
+                        ),
                        member=user,
                        created_by_id=project_member_invite.created_by_id,
                    )
@@ -427,7 +434,7 @@ class OauthEndpoint(BaseAPIView):
                email=email,
                user_agent=request.META.get("HTTP_USER_AGENT"),
                ip=request.META.get("REMOTE_ADDR"),
-                event_name="SIGN_IN",
+                event_name="Sign up",
                medium=medium.upper(),
                first_time=True,
            )
@@ -1,25 +1,32 @@
 # Python imports
-from datetime import date, datetime, timedelta
+from datetime import datetime

 # Django imports
 from django.db import connection
 from django.db.models import Exists, OuterRef, Q
-from django.utils import timezone
 from django.utils.decorators import method_decorator
 from django.views.decorators.gzip import gzip_page
+
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response

 from plane.app.permissions import ProjectEntityPermission
-from plane.app.serializers import (IssueLiteSerializer, PageFavoriteSerializer,
-                                   PageLogSerializer, PageSerializer,
-                                   SubPageSerializer)
-from plane.db.models import (Issue, IssueActivity, IssueAssignee, Page,
-                             PageFavorite, PageLog, ProjectMember)
+from plane.app.serializers import (
+    PageFavoriteSerializer,
+    PageLogSerializer,
+    PageSerializer,
+    SubPageSerializer,
+)
+from plane.db.models import (
+    Page,
+    PageFavorite,
+    PageLog,
+    ProjectMember,
+)

 # Module imports
-from .base import BaseAPIView, BaseViewSet
+from ..base import BaseAPIView, BaseViewSet


 def unarchive_archive_page_and_descendants(page_id, archived_at):
@@ -60,7 +67,10 @@ class PageViewSet(BaseViewSet):
            .get_queryset()
            .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(parent__isnull=True)
            .filter(Q(owned_by=self.request.user) | Q(access=0))
            .select_related("project")
@@ -0,0 +1,549 @@
+# Python imports
+import boto3
+
+# Django imports
+from django.db import IntegrityError
+from django.db.models import (
+    Prefetch,
+    Q,
+    Exists,
+    OuterRef,
+    F,
+    Func,
+    Subquery,
+)
+from django.conf import settings
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework import serializers
+from rest_framework.permissions import AllowAny
+
+# Module imports
+from plane.app.views.base import BaseViewSet, BaseAPIView, WebhookMixin
+from plane.app.serializers import (
+    ProjectSerializer,
+    ProjectListSerializer,
+    ProjectFavoriteSerializer,
+    ProjectDeployBoardSerializer,
+)
+
+from plane.app.permissions import (
+    ProjectBasePermission,
+    ProjectMemberPermission,
+)
+
+from plane.db.models import (
+    Project,
+    ProjectMember,
+    Workspace,
+    State,
+    ProjectFavorite,
+    ProjectIdentifier,
+    Module,
+    Cycle,
+    Inbox,
+    ProjectDeployBoard,
+    IssueProperty,
+)
+from plane.utils.cache import cache_response
+
+class ProjectViewSet(WebhookMixin, BaseViewSet):
+    serializer_class = ProjectListSerializer
+    model = Project
+    webhook_event = "project"
+
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    def get_queryset(self):
+        sort_order = ProjectMember.objects.filter(
+            member=self.request.user,
+            project_id=OuterRef("pk"),
+            workspace__slug=self.kwargs.get("slug"),
+            is_active=True,
+        ).values("sort_order")
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(
+                Q(project_projectmember__member=self.request.user)
+                | Q(network=2)
+            )
+            .select_related(
+                "workspace",
+                "workspace__owner",
+                "default_assignee",
+                "project_lead",
+            )
+            .annotate(
+                is_favorite=Exists(
+                    ProjectFavorite.objects.filter(
+                        user=self.request.user,
+                        project_id=OuterRef("pk"),
+                        workspace__slug=self.kwargs.get("slug"),
+                    )
+                )
+            )
+            .annotate(
+                is_member=Exists(
+                    ProjectMember.objects.filter(
+                        member=self.request.user,
+                        project_id=OuterRef("pk"),
+                        workspace__slug=self.kwargs.get("slug"),
+                        is_active=True,
+                    )
+                )
+            )
+            .annotate(
+                total_members=ProjectMember.objects.filter(
+                    project_id=OuterRef("id"),
+                    member__is_bot=False,
+                    is_active=True,
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                total_cycles=Cycle.objects.filter(project_id=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                total_modules=Module.objects.filter(project_id=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                member_role=ProjectMember.objects.filter(
+                    project_id=OuterRef("pk"),
+                    member_id=self.request.user.id,
+                    is_active=True,
+                ).values("role")
+            )
+            .annotate(
+                is_deployed=Exists(
+                    ProjectDeployBoard.objects.filter(
+                        project_id=OuterRef("pk"),
+                        workspace__slug=self.kwargs.get("slug"),
+                    )
+                )
+            )
+            .annotate(sort_order=Subquery(sort_order))
+            .prefetch_related(
+                Prefetch(
+                    "project_projectmember",
+                    queryset=ProjectMember.objects.filter(
+                        workspace__slug=self.kwargs.get("slug"),
+                        is_active=True,
+                    ).select_related("member"),
+                    to_attr="members_list",
+                )
+            )
+            .distinct()
+        )
+
+    def list(self, request, slug):
+        fields = [
+            field
+            for field in request.GET.get("fields", "").split(",")
+            if field
+        ]
+        projects = self.get_queryset().order_by("sort_order", "name")
+        if request.GET.get("per_page", False) and request.GET.get(
+            "cursor", False
+        ):
+            return self.paginate(
+                request=request,
+                queryset=(projects),
+                on_results=lambda projects: ProjectListSerializer(
+                    projects, many=True
+                ).data,
+            )
+        projects = ProjectListSerializer(
+            projects, many=True, fields=fields if fields else None
+        ).data
+        return Response(projects, status=status.HTTP_200_OK)
+
+    def create(self, request, slug):
+        try:
+            workspace = Workspace.objects.get(slug=slug)
+
+            serializer = ProjectSerializer(
+                data={**request.data}, context={"workspace_id": workspace.id}
+            )
+            if serializer.is_valid():
+                serializer.save()
+
+                # Add the user as Administrator to the project
+                _ = ProjectMember.objects.create(
+                    project_id=serializer.data["id"],
+                    member=request.user,
+                    role=20,
+                )
+                # Also create the issue property for the user
+                _ = IssueProperty.objects.create(
+                    project_id=serializer.data["id"],
+                    user=request.user,
+                )
+
+                if serializer.data["project_lead"] is not None and str(
+                    serializer.data["project_lead"]
+                ) != str(request.user.id):
+                    ProjectMember.objects.create(
+                        project_id=serializer.data["id"],
+                        member_id=serializer.data["project_lead"],
+                        role=20,
+                    )
+                    # Also create the issue property for the user
+                    IssueProperty.objects.create(
+                        project_id=serializer.data["id"],
+                        user_id=serializer.data["project_lead"],
+                    )
+
+                # Default states
+                states = [
+                    {
+                        "name": "Backlog",
+                        "color": "#A3A3A3",
+                        "sequence": 15000,
+                        "group": "backlog",
+                        "default": True,
+                    },
+                    {
+                        "name": "Todo",
+                        "color": "#3A3A3A",
+                        "sequence": 25000,
+                        "group": "unstarted",
+                    },
+                    {
+                        "name": "In Progress",
+                        "color": "#F59E0B",
+                        "sequence": 35000,
+                        "group": "started",
+                    },
+                    {
+                        "name": "Done",
+                        "color": "#16A34A",
+                        "sequence": 45000,
+                        "group": "completed",
+                    },
+                    {
+                        "name": "Cancelled",
+                        "color": "#EF4444",
+                        "sequence": 55000,
+                        "group": "cancelled",
+                    },
+                ]
+
+                State.objects.bulk_create(
+                    [
+                        State(
+                            name=state["name"],
+                            color=state["color"],
+                            project=serializer.instance,
+                            sequence=state["sequence"],
+                            workspace=serializer.instance.workspace,
+                            group=state["group"],
+                            default=state.get("default", False),
+                            created_by=request.user,
+                        )
+                        for state in states
+                    ]
+                )
+
+                project = (
+                    self.get_queryset()
+                    .filter(pk=serializer.data["id"])
+                    .first()
+                )
+                serializer = ProjectListSerializer(project)
+                return Response(
+                    serializer.data, status=status.HTTP_201_CREATED
+                )
+            return Response(
+                serializer.errors,
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"name": "The project name is already taken"},
+                    status=status.HTTP_410_GONE,
+                )
+        except Workspace.DoesNotExist as e:
+            return Response(
+                {"error": "Workspace does not exist"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        except serializers.ValidationError as e:
+            return Response(
+                {"identifier": "The project identifier is already taken"},
+                status=status.HTTP_410_GONE,
+            )
+
+    def partial_update(self, request, slug, pk=None):
+        try:
+            workspace = Workspace.objects.get(slug=slug)
+
+            project = Project.objects.get(pk=pk)
+
+            serializer = ProjectSerializer(
+                project,
+                data={**request.data},
+                context={"workspace_id": workspace.id},
+                partial=True,
+            )
+
+            if serializer.is_valid():
+                serializer.save()
+                if serializer.data["inbox_view"]:
+                    Inbox.objects.get_or_create(
+                        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",
+                        description="Default state for managing all Inbox Issues",
+                        project_id=pk,
+                        color="#ff7700",
+                    )
+
+                project = (
+                    self.get_queryset()
+                    .filter(pk=serializer.data["id"])
+                    .first()
+                )
+                serializer = ProjectListSerializer(project)
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(
+                serializer.errors, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"name": "The project name is already taken"},
+                    status=status.HTTP_410_GONE,
+                )
+        except (Project.DoesNotExist, Workspace.DoesNotExist):
+            return Response(
+                {"error": "Project does not exist"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        except serializers.ValidationError as e:
+            return Response(
+                {"identifier": "The project identifier is already taken"},
+                status=status.HTTP_410_GONE,
+            )
+
+
+class ProjectIdentifierEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    def get(self, request, slug):
+        name = request.GET.get("name", "").strip().upper()
+
+        if name == "":
+            return Response(
+                {"error": "Name is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        exists = ProjectIdentifier.objects.filter(
+            name=name, workspace__slug=slug
+        ).values("id", "name", "project")
+
+        return Response(
+            {"exists": len(exists), "identifiers": exists},
+            status=status.HTTP_200_OK,
+        )
+
+    def delete(self, request, slug):
+        name = request.data.get("name", "").strip().upper()
+
+        if name == "":
+            return Response(
+                {"error": "Name is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if Project.objects.filter(
+            identifier=name, workspace__slug=slug
+        ).exists():
+            return Response(
+                {
+                    "error": "Cannot delete an identifier of an existing project"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        ProjectIdentifier.objects.filter(
+            name=name, workspace__slug=slug
+        ).delete()
+
+        return Response(
+            status=status.HTTP_204_NO_CONTENT,
+        )
+
+
+class ProjectUserViewsEndpoint(BaseAPIView):
+    def post(self, request, slug, project_id):
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+
+        project_member = ProjectMember.objects.filter(
+            member=request.user,
+            project=project,
+            is_active=True,
+        ).first()
+
+        if project_member is None:
+            return Response(
+                {"error": "Forbidden"}, status=status.HTTP_403_FORBIDDEN
+            )
+
+        view_props = project_member.view_props
+        default_props = project_member.default_props
+        preferences = project_member.preferences
+        sort_order = project_member.sort_order
+
+        project_member.view_props = request.data.get("view_props", view_props)
+        project_member.default_props = request.data.get(
+            "default_props", default_props
+        )
+        project_member.preferences = request.data.get(
+            "preferences", preferences
+        )
+        project_member.sort_order = request.data.get("sort_order", sort_order)
+
+        project_member.save()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ProjectFavoritesViewSet(BaseViewSet):
+    serializer_class = ProjectFavoriteSerializer
+    model = ProjectFavorite
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(user=self.request.user)
+            .select_related(
+                "project", "project__project_lead", "project__default_assignee"
+            )
+            .select_related("workspace", "workspace__owner")
+        )
+
+    def perform_create(self, serializer):
+        serializer.save(user=self.request.user)
+
+    def create(self, request, slug):
+        serializer = ProjectFavoriteSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(user=request.user)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def destroy(self, request, slug, project_id):
+        project_favorite = ProjectFavorite.objects.get(
+            project=project_id, user=request.user, workspace__slug=slug
+        )
+        project_favorite.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ProjectPublicCoverImagesEndpoint(BaseAPIView):
+    permission_classes = [
+        AllowAny,
+    ]
+    # Cache the below api for 24 hours
+    @cache_response(60 * 60 * 24, user=False)
+    def get(self, request):
+        files = []
+        s3 = boto3.client(
+            "s3",
+            aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
+            aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
+        )
+        params = {
+            "Bucket": settings.AWS_STORAGE_BUCKET_NAME,
+            "Prefix": "static/project-cover/",
+        }
+
+        response = s3.list_objects_v2(**params)
+        # Extracting file keys from the response
+        if "Contents" in response:
+            for content in response["Contents"]:
+                if not content["Key"].endswith(
+                    "/"
+                ):  # This line ensures we're only getting files, not "sub-folders"
+                    files.append(
+                        f"https://{settings.AWS_STORAGE_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
+                    )
+
+        return Response(files, status=status.HTTP_200_OK)
+
+
+class ProjectDeployBoardViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectMemberPermission,
+    ]
+    serializer_class = ProjectDeployBoardSerializer
+    model = ProjectDeployBoard
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(
+                workspace__slug=self.kwargs.get("slug"),
+                project_id=self.kwargs.get("project_id"),
+            )
+            .select_related("project")
+        )
+
+    def create(self, request, slug, project_id):
+        comments = request.data.get("comments", False)
+        reactions = request.data.get("reactions", False)
+        inbox = request.data.get("inbox", None)
+        votes = request.data.get("votes", False)
+        views = request.data.get(
+            "views",
+            {
+                "list": True,
+                "kanban": True,
+                "calendar": True,
+                "gantt": True,
+                "spreadsheet": True,
+            },
+        )
+
+        project_deploy_board, _ = ProjectDeployBoard.objects.get_or_create(
+            anchor=f"{slug}/{project_id}",
+            project_id=project_id,
+        )
+        project_deploy_board.comments = comments
+        project_deploy_board.reactions = reactions
+        project_deploy_board.inbox = inbox
+        project_deploy_board.votes = votes
+        project_deploy_board.views = views
+
+        project_deploy_board.save()
+
+        serializer = ProjectDeployBoardSerializer(project_deploy_board)
+        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -0,0 +1,286 @@
+# Python imports
+import jwt
+from datetime import datetime
+
+# Django imports
+from django.core.exceptions import ValidationError
+from django.core.validators import validate_email
+from django.conf import settings
+from django.utils import timezone
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.permissions import AllowAny
+
+# Module imports
+from .base import BaseViewSet, BaseAPIView
+from plane.app.serializers import ProjectMemberInviteSerializer
+
+from plane.app.permissions import ProjectBasePermission
+
+from plane.db.models import (
+    ProjectMember,
+    Workspace,
+    ProjectMemberInvite,
+    User,
+    WorkspaceMember,
+    IssueProperty,
+)
+
+
+class ProjectInvitationsViewset(BaseViewSet):
+    serializer_class = ProjectMemberInviteSerializer
+    model = ProjectMemberInvite
+
+    search_fields = []
+
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .select_related("project")
+            .select_related("workspace", "workspace__owner")
+        )
+
+    def create(self, request, slug, project_id):
+        emails = request.data.get("emails", [])
+
+        # Check if email is provided
+        if not emails:
+            return Response(
+                {"error": "Emails are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        requesting_user = ProjectMember.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            member_id=request.user.id,
+        )
+
+        # Check if any invited user has an higher role
+        if len(
+            [
+                email
+                for email in emails
+                if int(email.get("role", 10)) > requesting_user.role
+            ]
+        ):
+            return Response(
+                {"error": "You cannot invite a user with higher role"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace = Workspace.objects.get(slug=slug)
+
+        project_invitations = []
+        for email in emails:
+            try:
+                validate_email(email.get("email"))
+                project_invitations.append(
+                    ProjectMemberInvite(
+                        email=email.get("email").strip().lower(),
+                        project_id=project_id,
+                        workspace_id=workspace.id,
+                        token=jwt.encode(
+                            {
+                                "email": email,
+                                "timestamp": datetime.now().timestamp(),
+                            },
+                            settings.SECRET_KEY,
+                            algorithm="HS256",
+                        ),
+                        role=email.get("role", 10),
+                        created_by=request.user,
+                    )
+                )
+            except ValidationError:
+                return Response(
+                    {
+                        "error": f"Invalid email - {email} provided a valid email address is required to send the invite"
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+        # Create workspace member invite
+        project_invitations = ProjectMemberInvite.objects.bulk_create(
+            project_invitations, batch_size=10, ignore_conflicts=True
+        )
+        current_site = request.META.get("HTTP_ORIGIN")
+
+        # Send invitations
+        for invitation in project_invitations:
+            project_invitations.delay(
+                invitation.email,
+                project_id,
+                invitation.token,
+                current_site,
+                request.user.email,
+            )
+
+        return Response(
+            {
+                "message": "Email sent successfully",
+            },
+            status=status.HTTP_200_OK,
+        )
+
+
+class UserProjectInvitationsViewset(BaseViewSet):
+    serializer_class = ProjectMemberInviteSerializer
+    model = ProjectMemberInvite
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(email=self.request.user.email)
+            .select_related("workspace", "workspace__owner", "project")
+        )
+
+    def create(self, request, slug):
+        project_ids = request.data.get("project_ids", [])
+
+        # Get the workspace user role
+        workspace_member = WorkspaceMember.objects.get(
+            member=request.user,
+            workspace__slug=slug,
+            is_active=True,
+        )
+
+        workspace_role = workspace_member.role
+        workspace = workspace_member.workspace
+
+        # If the user was already part of workspace
+        _ = ProjectMember.objects.filter(
+            workspace__slug=slug,
+            project_id__in=project_ids,
+            member=request.user,
+        ).update(is_active=True)
+
+        ProjectMember.objects.bulk_create(
+            [
+                ProjectMember(
+                    project_id=project_id,
+                    member=request.user,
+                    role=15 if workspace_role >= 15 else 10,
+                    workspace=workspace,
+                    created_by=request.user,
+                )
+                for project_id in project_ids
+            ],
+            ignore_conflicts=True,
+        )
+
+        IssueProperty.objects.bulk_create(
+            [
+                IssueProperty(
+                    project_id=project_id,
+                    user=request.user,
+                    workspace=workspace,
+                    created_by=request.user,
+                )
+                for project_id in project_ids
+            ],
+            ignore_conflicts=True,
+        )
+
+        return Response(
+            {"message": "Projects joined successfully"},
+            status=status.HTTP_201_CREATED,
+        )
+
+
+class ProjectJoinEndpoint(BaseAPIView):
+    permission_classes = [
+        AllowAny,
+    ]
+
+    def post(self, request, slug, project_id, pk):
+        project_invite = ProjectMemberInvite.objects.get(
+            pk=pk,
+            project_id=project_id,
+            workspace__slug=slug,
+        )
+
+        email = request.data.get("email", "")
+
+        if email == "" or project_invite.email != email:
+            return Response(
+                {"error": "You do not have permission to join the project"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        if project_invite.responded_at is None:
+            project_invite.accepted = request.data.get("accepted", False)
+            project_invite.responded_at = timezone.now()
+            project_invite.save()
+
+            if project_invite.accepted:
+                # Check if the user account exists
+                user = User.objects.filter(email=email).first()
+
+                # Check if user is a part of workspace
+                workspace_member = WorkspaceMember.objects.filter(
+                    workspace__slug=slug, member=user
+                ).first()
+                # Add him to workspace
+                if workspace_member is None:
+                    _ = WorkspaceMember.objects.create(
+                        workspace_id=project_invite.workspace_id,
+                        member=user,
+                        role=(
+                            15
+                            if project_invite.role >= 15
+                            else project_invite.role
+                        ),
+                    )
+                else:
+                    # Else make him active
+                    workspace_member.is_active = True
+                    workspace_member.save()
+
+                # Check if the user was already a member of project then activate the user
+                project_member = ProjectMember.objects.filter(
+                    workspace_id=project_invite.workspace_id, member=user
+                ).first()
+                if project_member is None:
+                    # Create a Project Member
+                    _ = ProjectMember.objects.create(
+                        workspace_id=project_invite.workspace_id,
+                        member=user,
+                        role=project_invite.role,
+                    )
+                else:
+                    project_member.is_active = True
+                    project_member.role = project_member.role
+                    project_member.save()
+
+                return Response(
+                    {"message": "Project Invitation Accepted"},
+                    status=status.HTTP_200_OK,
+                )
+
+            return Response(
+                {"message": "Project Invitation was not accepted"},
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(
+            {"error": "You have already responded to the invitation request"},
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
+    def get(self, request, slug, project_id, pk):
+        project_invitation = ProjectMemberInvite.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
+        serializer = ProjectMemberInviteSerializer(project_invitation)
+        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -0,0 +1,349 @@
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .base import BaseViewSet, BaseAPIView
+from plane.app.serializers import (
+    ProjectMemberSerializer,
+    ProjectMemberAdminSerializer,
+    ProjectMemberRoleSerializer,
+)
+
+from plane.app.permissions import (
+    ProjectBasePermission,
+    ProjectMemberPermission,
+    ProjectLitePermission,
+    WorkspaceUserPermission,
+)
+
+from plane.db.models import (
+    Project,
+    ProjectMember,
+    Workspace,
+    TeamMember,
+    IssueProperty,
+)
+
+
+class ProjectMemberViewSet(BaseViewSet):
+    serializer_class = ProjectMemberAdminSerializer
+    model = ProjectMember
+    permission_classes = [
+        ProjectMemberPermission,
+    ]
+
+    def get_permissions(self):
+        if self.action == "leave":
+            self.permission_classes = [
+                ProjectLitePermission,
+            ]
+        else:
+            self.permission_classes = [
+                ProjectMemberPermission,
+            ]
+
+        return super(ProjectMemberViewSet, self).get_permissions()
+
+    search_fields = [
+        "member__display_name",
+        "member__first_name",
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(member__is_bot=False)
+            .filter()
+            .select_related("project")
+            .select_related("member")
+            .select_related("workspace", "workspace__owner")
+        )
+
+    def create(self, request, slug, project_id):
+        members = request.data.get("members", [])
+
+        # get the project
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+
+        if not len(members):
+            return Response(
+                {"error": "Atleast one member is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        bulk_project_members = []
+        bulk_issue_props = []
+
+        project_members = (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                member_id__in=[member.get("member_id") for member in members],
+            )
+            .values("member_id", "sort_order")
+            .order_by("sort_order")
+        )
+
+        bulk_project_members = []
+        member_roles = {
+            member.get("member_id"): member.get("role") for member in members
+        }
+        # Update roles in the members array based on the member_roles dictionary
+        for project_member in ProjectMember.objects.filter(
+            project_id=project_id,
+            member_id__in=[member.get("member_id") for member in members],
+        ):
+            project_member.role = member_roles[str(project_member.member_id)]
+            project_member.is_active = True
+            bulk_project_members.append(project_member)
+
+        # Update the roles of the existing members
+        ProjectMember.objects.bulk_update(
+            bulk_project_members, ["is_active", "role"], batch_size=100
+        )
+
+        for member in members:
+            sort_order = [
+                project_member.get("sort_order")
+                for project_member in project_members
+                if str(project_member.get("member_id"))
+                == str(member.get("member_id"))
+            ]
+            bulk_project_members.append(
+                ProjectMember(
+                    member_id=member.get("member_id"),
+                    role=member.get("role", 10),
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    sort_order=(
+                        sort_order[0] - 10000 if len(sort_order) else 65535
+                    ),
+                )
+            )
+            bulk_issue_props.append(
+                IssueProperty(
+                    user_id=member.get("member_id"),
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                )
+            )
+
+        project_members = ProjectMember.objects.bulk_create(
+            bulk_project_members,
+            batch_size=10,
+            ignore_conflicts=True,
+        )
+
+        _ = IssueProperty.objects.bulk_create(
+            bulk_issue_props, batch_size=10, ignore_conflicts=True
+        )
+
+        project_members = ProjectMember.objects.filter(
+            project_id=project_id,
+            member_id__in=[member.get("member_id") for member in members],
+        )
+        serializer = ProjectMemberRoleSerializer(project_members, many=True)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    def list(self, request, slug, project_id):
+        # Get the list of project members for the project
+        project_members = ProjectMember.objects.filter(
+            project_id=project_id,
+            workspace__slug=slug,
+            member__is_bot=False,
+            is_active=True,
+        ).select_related("project", "member", "workspace")
+
+        serializer = ProjectMemberRoleSerializer(
+            project_members, fields=("id", "member", "role"), many=True
+        )
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def partial_update(self, request, slug, project_id, pk):
+        project_member = ProjectMember.objects.get(
+            pk=pk,
+            workspace__slug=slug,
+            project_id=project_id,
+            is_active=True,
+        )
+        if request.user.id == project_member.member_id:
+            return Response(
+                {"error": "You cannot update your own role"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        # Check while updating user roles
+        requested_project_member = ProjectMember.objects.get(
+            project_id=project_id,
+            workspace__slug=slug,
+            member=request.user,
+            is_active=True,
+        )
+        if (
+            "role" in request.data
+            and int(request.data.get("role", project_member.role))
+            > requested_project_member.role
+        ):
+            return Response(
+                {
+                    "error": "You cannot update a role that is higher than your own role"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        serializer = ProjectMemberSerializer(
+            project_member, data=request.data, partial=True
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def destroy(self, request, slug, project_id, pk):
+        project_member = ProjectMember.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            pk=pk,
+            member__is_bot=False,
+            is_active=True,
+        )
+        # check requesting user role
+        requesting_project_member = ProjectMember.objects.get(
+            workspace__slug=slug,
+            member=request.user,
+            project_id=project_id,
+            is_active=True,
+        )
+        # User cannot remove himself
+        if str(project_member.id) == str(requesting_project_member.id):
+            return Response(
+                {
+                    "error": "You cannot remove yourself from the workspace. Please use leave workspace"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        # User cannot deactivate higher role
+        if requesting_project_member.role < project_member.role:
+            return Response(
+                {
+                    "error": "You cannot remove a user having role higher than you"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        project_member.is_active = False
+        project_member.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def leave(self, request, slug, project_id):
+        project_member = ProjectMember.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            member=request.user,
+            is_active=True,
+        )
+
+        # Check if the leaving user is the only admin of the project
+        if (
+            project_member.role == 20
+            and not ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                role=20,
+                is_active=True,
+            ).count()
+            > 1
+        ):
+            return Response(
+                {
+                    "error": "You cannot leave the project as your the only admin of the project you will have to either delete the project or create an another admin",
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        # Deactivate the user
+        project_member.is_active = False
+        project_member.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class AddTeamToProjectEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    def post(self, request, slug, project_id):
+        team_members = TeamMember.objects.filter(
+            workspace__slug=slug, team__in=request.data.get("teams", [])
+        ).values_list("member", flat=True)
+
+        if len(team_members) == 0:
+            return Response(
+                {"error": "No such team exists"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace = Workspace.objects.get(slug=slug)
+
+        project_members = []
+        issue_props = []
+        for member in team_members:
+            project_members.append(
+                ProjectMember(
+                    project_id=project_id,
+                    member_id=member,
+                    workspace=workspace,
+                    created_by=request.user,
+                )
+            )
+            issue_props.append(
+                IssueProperty(
+                    project_id=project_id,
+                    user_id=member,
+                    workspace=workspace,
+                    created_by=request.user,
+                )
+            )
+
+        ProjectMember.objects.bulk_create(
+            project_members, batch_size=10, ignore_conflicts=True
+        )
+
+        _ = IssueProperty.objects.bulk_create(
+            issue_props, batch_size=10, ignore_conflicts=True
+        )
+
+        serializer = ProjectMemberSerializer(project_members, many=True)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+
+class ProjectMemberUserEndpoint(BaseAPIView):
+    def get(self, request, slug, project_id):
+        project_member = ProjectMember.objects.get(
+            project_id=project_id,
+            workspace__slug=slug,
+            member=request.user,
+            is_active=True,
+        )
+        serializer = ProjectMemberSerializer(project_member)
+
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class UserProjectRolesEndpoint(BaseAPIView):
+    permission_classes = [
+        WorkspaceUserPermission,
+    ]
+
+    def get(self, request, slug):
+        project_members = ProjectMember.objects.filter(
+            workspace__slug=slug,
+            member_id=request.user.id,
+        ).values("project_id", "role")
+
+        project_members = {
+            str(member["project_id"]): member["role"]
+            for member in project_members
+        }
+        return Response(project_members, status=status.HTTP_200_OK)
@@ -48,8 +48,8 @@ class GlobalSearchEndpoint(BaseAPIView):
        return (
            Project.objects.filter(
                q,
-                Q(project_projectmember__member=self.request.user)
-                | Q(network=2),
+                project_projectmember__member=self.request.user,
+                project_projectmember__is_active=True,
                workspace__slug=slug,
            )
            .distinct()
@@ -71,6 +71,7 @@ class GlobalSearchEndpoint(BaseAPIView):
        issues = Issue.issue_objects.filter(
            q,
            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
            workspace__slug=slug,
        )

@@ -95,6 +96,7 @@ class GlobalSearchEndpoint(BaseAPIView):
        cycles = Cycle.objects.filter(
            q,
            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
            workspace__slug=slug,
        )

@@ -118,6 +120,7 @@ class GlobalSearchEndpoint(BaseAPIView):
        modules = Module.objects.filter(
            q,
            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
            workspace__slug=slug,
        )

@@ -141,6 +144,7 @@ class GlobalSearchEndpoint(BaseAPIView):
        pages = Page.objects.filter(
            q,
            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
            workspace__slug=slug,
        )

@@ -164,6 +168,7 @@ class GlobalSearchEndpoint(BaseAPIView):
        issue_views = IssueView.objects.filter(
            q,
            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
            workspace__slug=slug,
        )

@@ -228,14 +233,16 @@ class IssueSearchEndpoint(BaseAPIView):
        parent = request.query_params.get("parent", "false")
        issue_relation = request.query_params.get("issue_relation", "false")
        cycle = request.query_params.get("cycle", "false")
-        module = request.query_params.get("module", "false")
+        module = request.query_params.get("module", False)
        sub_issue = request.query_params.get("sub_issue", "false")
+        target_date = request.query_params.get("target_date", True)

        issue_id = request.query_params.get("issue_id", False)

        issues = Issue.issue_objects.filter(
            workspace__slug=slug,
            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
        )

        if workspace_search == "false":
@@ -247,11 +254,7 @@ class IssueSearchEndpoint(BaseAPIView):
        if parent == "true" and issue_id:
            issue = Issue.issue_objects.get(pk=issue_id)
            issues = issues.filter(
-                ~Q(pk=issue_id), ~Q(pk=issue.parent_id), parent__isnull=True
-            ).exclude(
-                pk__in=Issue.issue_objects.filter(
-                    parent__isnull=False
-                ).values_list("parent_id", flat=True)
+                ~Q(pk=issue_id), ~Q(pk=issue.parent_id), ~Q(parent_id=issue_id)
            )
        if issue_relation == "true" and issue_id:
            issue = Issue.issue_objects.get(pk=issue_id)
@@ -269,8 +272,11 @@ class IssueSearchEndpoint(BaseAPIView):
        if cycle == "true":
            issues = issues.exclude(issue_cycle__isnull=False)

-        if module == "true":
-            issues = issues.exclude(issue_module__isnull=False)
+        if module:
+            issues = issues.exclude(issue_module__module=module)
+
+        if target_date == "none":
+            issues = issues.filter(target_date__isnull=True)

        return Response(
            issues.values(
@@ -9,14 +9,13 @@ from rest_framework.response import Response
 from rest_framework import status

 # Module imports
-from . import BaseViewSet, BaseAPIView
+from .. import BaseViewSet
 from plane.app.serializers import StateSerializer
 from plane.app.permissions import (
    ProjectEntityPermission,
-    WorkspaceEntityPermission,
 )
 from plane.db.models import State, Issue
-
+from plane.utils.cache import invalidate_cache

 class StateViewSet(BaseViewSet):
    serializer_class = StateSerializer
@@ -31,13 +30,17 @@ class StateViewSet(BaseViewSet):
            .get_queryset()
            .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(~Q(name="Triage"))
            .select_related("project")
            .select_related("workspace")
            .distinct()
        )

+    @invalidate_cache(path="workspaces/:slug/states/", url_params=True, user=False)
    def create(self, request, slug, project_id):
        serializer = StateSerializer(data=request.data)
        if serializer.is_valid():
@@ -58,6 +61,7 @@ class StateViewSet(BaseViewSet):
            return Response(state_dict, status=status.HTTP_200_OK)
        return Response(states, status=status.HTTP_200_OK)

+    @invalidate_cache(path="workspaces/:slug/states/", url_params=True, user=False)
    def mark_as_default(self, request, slug, project_id, pk):
        # Select all the states which are marked as default
        _ = State.objects.filter(
@@ -68,6 +72,7 @@ class StateViewSet(BaseViewSet):
        ).update(default=True)
        return Response(status=status.HTTP_204_NO_CONTENT)

+    @invalidate_cache(path="workspaces/:slug/states/", url_params=True, user=False)
    def destroy(self, request, slug, project_id, pk):
        state = State.objects.get(
            ~Q(name="Triage"),
@@ -1,25 +1,24 @@
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
+# Django imports
+from django.db.models import Case, Count, IntegerField, Q, When

+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response

 # Module imports
 from plane.app.serializers import (
-    UserSerializer,
    IssueActivitySerializer,
    UserMeSerializer,
    UserMeSettingsSerializer,
+    UserSerializer,
 )
-
-from plane.app.views.base import BaseViewSet, BaseAPIView
-from plane.db.models import User, IssueActivity, WorkspaceMember, ProjectMember
+from plane.app.views.base import BaseAPIView, BaseViewSet
+from plane.db.models import IssueActivity, ProjectMember, User, WorkspaceMember
 from plane.license.models import Instance, InstanceAdmin
+from plane.utils.cache import cache_response, invalidate_cache
 from plane.utils.paginator import BasePaginator


-from django.db.models import Q, F, Count, Case, When, IntegerField
-
-
 class UserEndpoint(BaseViewSet):
    serializer_class = UserSerializer
    model = User
@@ -27,6 +26,7 @@ class UserEndpoint(BaseViewSet):
    def get_object(self):
        return self.request.user

+    @cache_response(60 * 60)
    def retrieve(self, request):
        serialized_data = UserMeSerializer(request.user).data
        return Response(
@@ -34,10 +34,12 @@ class UserEndpoint(BaseViewSet):
            status=status.HTTP_200_OK,
        )

+    @cache_response(60 * 60)
    def retrieve_user_settings(self, request):
        serialized_data = UserMeSettingsSerializer(request.user).data
        return Response(serialized_data, status=status.HTTP_200_OK)

+    @cache_response(60 * 60)
    def retrieve_instance_admin(self, request):
        instance = Instance.objects.first()
        is_admin = InstanceAdmin.objects.filter(
@@ -47,6 +49,11 @@ class UserEndpoint(BaseViewSet):
            {"is_instance_admin": is_admin}, status=status.HTTP_200_OK
        )

+    @invalidate_cache(path="/api/users/me/")
+    def partial_update(self, request, *args, **kwargs):
+        return super().partial_update(request, *args, **kwargs)
+
+    @invalidate_cache(path="/api/users/me/")
    def deactivate(self, request):
        # Check all workspace user is active
        user = self.get_object()
@@ -145,6 +152,8 @@ class UserEndpoint(BaseViewSet):


 class UpdateUserOnBoardedEndpoint(BaseAPIView):
+
+    @invalidate_cache(path="/api/users/me/")
    def patch(self, request):
        user = User.objects.get(pk=request.user.id, is_active=True)
        user.is_onboarded = request.data.get("is_onboarded", False)
@@ -155,6 +164,8 @@ class UpdateUserOnBoardedEndpoint(BaseAPIView):


 class UpdateUserTourCompletedEndpoint(BaseAPIView):
+
+    @invalidate_cache(path="/api/users/me/")
    def patch(self, request):
        user = User.objects.get(pk=request.user.id, is_active=True)
        user.is_tour_completed = request.data.get("is_tour_completed", False)
@@ -165,6 +176,7 @@ class UpdateUserTourCompletedEndpoint(BaseAPIView):


 class UserActivityEndpoint(BaseAPIView, BasePaginator):
+
    def get(self, request):
        queryset = IssueActivity.objects.filter(
            actor=request.user
@@ -1,6 +1,6 @@
 # Django imports
 from django.db.models import (
-    Prefetch,
+    Q,
    OuterRef,
    Func,
    F,
@@ -13,16 +13,18 @@ from django.db.models import (
 )
 from django.utils.decorators import method_decorator
 from django.views.decorators.gzip import gzip_page
-from django.db.models import Prefetch, OuterRef, Exists
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import UUIDField
+from django.db.models.functions import Coalesce

 # Third party imports
 from rest_framework.response import Response
 from rest_framework import status

 # Module imports
-from . import BaseViewSet, BaseAPIView
+from .. import BaseViewSet
 from plane.app.serializers import (
-    GlobalViewSerializer,
    IssueViewSerializer,
    IssueSerializer,
    IssueViewFavoriteSerializer,
@@ -30,22 +32,16 @@ from plane.app.serializers import (
 from plane.app.permissions import (
    WorkspaceEntityPermission,
    ProjectEntityPermission,
-    WorkspaceViewerPermission,
-    ProjectLitePermission,
 )
 from plane.db.models import (
    Workspace,
-    GlobalView,
    IssueView,
    Issue,
    IssueViewFavorite,
-    IssueReaction,
    IssueLink,
    IssueAttachment,
-    IssueSubscriber,
 )
 from plane.utils.issue_filters import issue_filters
-from plane.utils.grouper import group_results


 class GlobalViewViewSet(BaseViewSet):
@@ -87,47 +83,13 @@ class GlobalViewIssuesViewSet(BaseViewSet):
                .values("count")
            )
            .filter(workspace__slug=self.kwargs.get("slug"))
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("state")
-            .select_related("parent")
-            .prefetch_related("assignees")
-            .prefetch_related("labels")
-            .prefetch_related(
-                Prefetch(
-                    "issue_reactions",
-                    queryset=IssueReaction.objects.select_related("actor"),
-                )
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
            )
-        )
-
-    @method_decorator(gzip_page)
-    def list(self, request, slug):
-        filters = issue_filters(request.query_params, "GET")
-        fields = [
-            field
-            for field in request.GET.get("fields", "").split(",")
-            if field
-        ]
-
-        # Custom ordering for priority and state
-        priority_order = ["urgent", "high", "medium", "low", "none"]
-        state_order = [
-            "backlog",
-            "unstarted",
-            "started",
-            "completed",
-            "cancelled",
-        ]
-
-        order_by_param = request.GET.get("order_by", "-created_at")
-
-        issue_queryset = (
-            self.get_queryset()
-            .filter(**filters)
-            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module")
            .annotate(cycle_id=F("issue_cycle__cycle_id"))
-            .annotate(module_id=F("issue_module__module_id"))
            .annotate(
                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
                .order_by()
@@ -151,14 +113,55 @@ class GlobalViewIssuesViewSet(BaseViewSet):
                .values("count")
            )
            .annotate(
-                is_subscribed=Exists(
-                    IssueSubscriber.objects.filter(
-                        subscriber=self.request.user, issue_id=OuterRef("id")
-                    )
-                )
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "labels__id",
+                        distinct=True,
+                        filter=~Q(labels__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "assignees__id",
+                        distinct=True,
+                        filter=~Q(assignees__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=~Q(issue_module__module_id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
            )
        )

+    @method_decorator(gzip_page)
+    def list(self, request, slug):
+        filters = issue_filters(request.query_params, "GET")
+
+        # Custom ordering for priority and state
+        priority_order = ["urgent", "high", "medium", "low", "none"]
+        state_order = [
+            "backlog",
+            "unstarted",
+            "started",
+            "completed",
+            "cancelled",
+        ]
+
+        order_by_param = request.GET.get("order_by", "-created_at")
+
+        issue_queryset = (
+            self.get_queryset()
+            .filter(**filters)
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+        )
+
        # Priority Ordering
        if order_by_param == "priority" or order_by_param == "-priority":
            priority_order = (
@@ -219,10 +222,39 @@ class GlobalViewIssuesViewSet(BaseViewSet):
        else:
            issue_queryset = issue_queryset.order_by(order_by_param)

-        serializer = IssueSerializer(
-            issue_queryset, many=True, fields=fields if fields else None
-        )
-        return Response(serializer.data, status=status.HTTP_200_OK)
+        if self.fields:
+            issues = IssueSerializer(
+                issue_queryset, many=True, fields=self.fields
+            ).data
+        else:
+            issues = issue_queryset.values(
+                "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",
+            )
+        return Response(issues, status=status.HTTP_200_OK)


 class IssueViewViewSet(BaseViewSet):
@@ -247,7 +279,10 @@ class IssueViewViewSet(BaseViewSet):
            .get_queryset()
            .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")
            .annotate(is_favorite=Exists(subquery))
@@ -8,7 +8,7 @@ from rest_framework.response import Response
 # Module imports
 from plane.db.models import Webhook, WebhookLog, Workspace
 from plane.db.models.webhook import generate_token
-from .base import BaseAPIView
+from ..base import BaseAPIView
 from plane.app.permissions import WorkspaceOwnerPermission
 from plane.app.serializers import WebhookSerializer, WebhookLogSerializer

@@ -41,7 +41,7 @@ class WebhookEndpoint(BaseAPIView):
            raise IntegrityError

    def get(self, request, slug, pk=None):
-        if pk == None:
+        if pk is None:
            webhooks = Webhook.objects.filter(workspace__slug=slug)
            serializer = WebhookSerializer(
                webhooks,
@@ -0,0 +1,414 @@
+# Python imports
+from datetime import date
+from dateutil.relativedelta import relativedelta
+import csv
+import io
+
+
+# Django imports
+from django.http import HttpResponse
+from django.db import IntegrityError
+from django.utils import timezone
+from django.db.models import (
+    Prefetch,
+    OuterRef,
+    Func,
+    F,
+    Q,
+    Count,
+)
+from django.db.models.functions import ExtractWeek, Cast, ExtractDay
+from django.db.models.fields import DateField
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.serializers import (
+    WorkSpaceSerializer,
+    WorkspaceThemeSerializer,
+)
+from plane.app.views.base import BaseViewSet, BaseAPIView
+from plane.db.models import (
+    Workspace,
+    IssueActivity,
+    Issue,
+    WorkspaceTheme,
+    WorkspaceMember,
+)
+from plane.app.permissions import (
+    WorkSpaceBasePermission,
+    WorkSpaceAdminPermission,
+    WorkspaceEntityPermission,
+)
+from plane.utils.cache import cache_response, invalidate_cache
+
+class WorkSpaceViewSet(BaseViewSet):
+    model = Workspace
+    serializer_class = WorkSpaceSerializer
+    permission_classes = [
+        WorkSpaceBasePermission,
+    ]
+
+    search_fields = [
+        "name",
+    ]
+    filterset_fields = [
+        "owner",
+    ]
+
+    lookup_field = "slug"
+
+    def get_queryset(self):
+        member_count = (
+            WorkspaceMember.objects.filter(
+                workspace=OuterRef("id"),
+                member__is_bot=False,
+                is_active=True,
+            )
+            .order_by()
+            .annotate(count=Func(F("id"), function="Count"))
+            .values("count")
+        )
+
+        issue_count = (
+            Issue.issue_objects.filter(workspace=OuterRef("id"))
+            .order_by()
+            .annotate(count=Func(F("id"), function="Count"))
+            .values("count")
+        )
+        return (
+            self.filter_queryset(
+                super().get_queryset().select_related("owner")
+            )
+            .order_by("name")
+            .filter(
+                workspace_member__member=self.request.user,
+                workspace_member__is_active=True,
+            )
+            .annotate(total_members=member_count)
+            .annotate(total_issues=issue_count)
+            .select_related("owner")
+        )
+
+    @invalidate_cache(path="/api/workspaces/", user=False)
+    @invalidate_cache(path="/api/users/me/workspaces/")
+    def create(self, request):
+        try:
+            serializer = WorkSpaceSerializer(data=request.data)
+
+            slug = request.data.get("slug", False)
+            name = request.data.get("name", False)
+
+            if not name or not slug:
+                return Response(
+                    {"error": "Both name and slug are required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if len(name) > 80 or len(slug) > 48:
+                return Response(
+                    {
+                        "error": "The maximum length for name is 80 and for slug is 48"
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if serializer.is_valid():
+                serializer.save(owner=request.user)
+                # Create Workspace member
+                _ = WorkspaceMember.objects.create(
+                    workspace_id=serializer.data["id"],
+                    member=request.user,
+                    role=20,
+                    company_role=request.data.get("company_role", ""),
+                )
+                return Response(
+                    serializer.data, status=status.HTTP_201_CREATED
+                )
+            return Response(
+                [serializer.errors[error][0] for error in serializer.errors],
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"slug": "The workspace with the slug already exists"},
+                    status=status.HTTP_410_GONE,
+                )
+    @cache_response(60 * 60 * 2)
+    def list(self, request, *args, **kwargs):
+        return super().list(request, *args, **kwargs)
+
+    @invalidate_cache(path="/api/workspaces/", user=False)
+    @invalidate_cache(path="/api/users/me/workspaces/")
+    def partial_update(self, request, *args, **kwargs):
+        return super().partial_update(request, *args, **kwargs)
+
+    @invalidate_cache(path="/api/workspaces/", user=False)
+    @invalidate_cache(path="/api/users/me/workspaces/")
+    def destroy(self, request, *args, **kwargs):
+        return super().destroy(request, *args, **kwargs)
+
+
+class UserWorkSpacesEndpoint(BaseAPIView):
+    search_fields = [
+        "name",
+    ]
+    filterset_fields = [
+        "owner",
+    ]
+
+    @cache_response(60 * 60 * 2)
+    def get(self, request):
+        fields = [
+            field
+            for field in request.GET.get("fields", "").split(",")
+            if field
+        ]
+        member_count = (
+            WorkspaceMember.objects.filter(
+                workspace=OuterRef("id"),
+                member__is_bot=False,
+                is_active=True,
+            )
+            .order_by()
+            .annotate(count=Func(F("id"), function="Count"))
+            .values("count")
+        )
+
+        issue_count = (
+            Issue.issue_objects.filter(workspace=OuterRef("id"))
+            .order_by()
+            .annotate(count=Func(F("id"), function="Count"))
+            .values("count")
+        )
+
+        workspace = (
+            Workspace.objects.prefetch_related(
+                Prefetch(
+                    "workspace_member",
+                    queryset=WorkspaceMember.objects.filter(
+                        member=request.user, is_active=True
+                    ),
+                )
+            )
+            .select_related("owner")
+            .annotate(total_members=member_count)
+            .annotate(total_issues=issue_count)
+            .filter(
+                workspace_member__member=request.user,
+                workspace_member__is_active=True,
+            )
+            .distinct()
+        )
+        workspaces = WorkSpaceSerializer(
+            self.filter_queryset(workspace),
+            fields=fields if fields else None,
+            many=True,
+        ).data
+        return Response(workspaces, status=status.HTTP_200_OK)
+
+
+class WorkSpaceAvailabilityCheckEndpoint(BaseAPIView):
+    def get(self, request):
+        slug = request.GET.get("slug", False)
+
+        if not slug or slug == "":
+            return Response(
+                {"error": "Workspace Slug is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace = Workspace.objects.filter(slug=slug).exists()
+        return Response({"status": not workspace}, status=status.HTTP_200_OK)
+
+
+class WeekInMonth(Func):
+    function = "FLOOR"
+    template = "(((%(expressions)s - 1) / 7) + 1)::INTEGER"
+
+
+class UserWorkspaceDashboardEndpoint(BaseAPIView):
+    def get(self, request, slug):
+        issue_activities = (
+            IssueActivity.objects.filter(
+                actor=request.user,
+                workspace__slug=slug,
+                created_at__date__gte=date.today() + relativedelta(months=-3),
+            )
+            .annotate(created_date=Cast("created_at", DateField()))
+            .values("created_date")
+            .annotate(activity_count=Count("created_date"))
+            .order_by("created_date")
+        )
+
+        month = request.GET.get("month", 1)
+
+        completed_issues = (
+            Issue.issue_objects.filter(
+                assignees__in=[request.user],
+                workspace__slug=slug,
+                completed_at__month=month,
+                completed_at__isnull=False,
+            )
+            .annotate(day_of_month=ExtractDay("completed_at"))
+            .annotate(week_in_month=WeekInMonth(F("day_of_month")))
+            .values("week_in_month")
+            .annotate(completed_count=Count("id"))
+            .order_by("week_in_month")
+        )
+
+        assigned_issues = Issue.issue_objects.filter(
+            workspace__slug=slug, assignees__in=[request.user]
+        ).count()
+
+        pending_issues_count = Issue.issue_objects.filter(
+            ~Q(state__group__in=["completed", "cancelled"]),
+            workspace__slug=slug,
+            assignees__in=[request.user],
+        ).count()
+
+        completed_issues_count = Issue.issue_objects.filter(
+            workspace__slug=slug,
+            assignees__in=[request.user],
+            state__group="completed",
+        ).count()
+
+        issues_due_week = (
+            Issue.issue_objects.filter(
+                workspace__slug=slug,
+                assignees__in=[request.user],
+            )
+            .annotate(target_week=ExtractWeek("target_date"))
+            .filter(target_week=timezone.now().date().isocalendar()[1])
+            .count()
+        )
+
+        state_distribution = (
+            Issue.issue_objects.filter(
+                workspace__slug=slug, assignees__in=[request.user]
+            )
+            .annotate(state_group=F("state__group"))
+            .values("state_group")
+            .annotate(state_count=Count("state_group"))
+            .order_by("state_group")
+        )
+
+        overdue_issues = Issue.issue_objects.filter(
+            ~Q(state__group__in=["completed", "cancelled"]),
+            workspace__slug=slug,
+            assignees__in=[request.user],
+            target_date__lt=timezone.now(),
+            completed_at__isnull=True,
+        ).values("id", "name", "workspace__slug", "project_id", "target_date")
+
+        upcoming_issues = Issue.issue_objects.filter(
+            ~Q(state__group__in=["completed", "cancelled"]),
+            start_date__gte=timezone.now(),
+            workspace__slug=slug,
+            assignees__in=[request.user],
+            completed_at__isnull=True,
+        ).values("id", "name", "workspace__slug", "project_id", "start_date")
+
+        return Response(
+            {
+                "issue_activities": issue_activities,
+                "completed_issues": completed_issues,
+                "assigned_issues_count": assigned_issues,
+                "pending_issues_count": pending_issues_count,
+                "completed_issues_count": completed_issues_count,
+                "issues_due_week_count": issues_due_week,
+                "state_distribution": state_distribution,
+                "overdue_issues": overdue_issues,
+                "upcoming_issues": upcoming_issues,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+
+class WorkspaceThemeViewSet(BaseViewSet):
+    permission_classes = [
+        WorkSpaceAdminPermission,
+    ]
+    model = WorkspaceTheme
+    serializer_class = WorkspaceThemeSerializer
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+        )
+
+    def create(self, request, slug):
+        workspace = Workspace.objects.get(slug=slug)
+        serializer = WorkspaceThemeSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(workspace=workspace, actor=request.user)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+class ExportWorkspaceUserActivityEndpoint(BaseAPIView):
+    permission_classes = [
+        WorkspaceEntityPermission,
+    ]
+
+    def generate_csv_from_rows(self, rows):
+        """Generate CSV buffer from rows."""
+        csv_buffer = io.StringIO()
+        writer = csv.writer(csv_buffer, delimiter=",", quoting=csv.QUOTE_ALL)
+        [writer.writerow(row) for row in rows]
+        csv_buffer.seek(0)
+        return csv_buffer
+
+    def post(self, request, slug, user_id):
+
+        if not request.data.get("date"):
+            return Response(
+                {"error": "Date is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        user_activities = IssueActivity.objects.filter(
+            ~Q(field__in=["comment", "vote", "reaction", "draft"]),
+            workspace__slug=slug,
+            created_at__date=request.data.get("date"),
+            project__project_projectmember__member=request.user,
+            actor_id=user_id,
+        ).select_related("actor", "workspace", "issue", "project")[:10000]
+
+        header = [
+            "Actor name",
+            "Issue ID",
+            "Project",
+            "Created at",
+            "Updated at",
+            "Action",
+            "Field",
+            "Old value",
+            "New value",
+        ]
+        rows = [
+            (
+                activity.actor.display_name,
+                f"{activity.project.identifier} - {activity.issue.sequence_id if activity.issue else ''}",
+                activity.project.name,
+                activity.created_at,
+                activity.updated_at,
+                activity.verb,
+                activity.field,
+                activity.old_value,
+                activity.new_value,
+            )
+            for activity in user_activities
+        ]
+        csv_buffer = self.generate_csv_from_rows([header] + rows)
+        response = HttpResponse(csv_buffer.getvalue(), content_type="text/csv")
+        response["Content-Disposition"] = (
+            'attachment; filename="workspace-user-activity.csv"'
+        )
+        return response
@@ -0,0 +1,116 @@
+# Django imports
+from django.db.models import (
+    Q,
+    Count,
+    Sum,
+)
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.views.base import BaseAPIView
+from plane.db.models import Cycle
+from plane.app.permissions import WorkspaceViewerPermission
+from plane.app.serializers.cycle import CycleSerializer
+
+
+class WorkspaceCyclesEndpoint(BaseAPIView):
+    permission_classes = [
+        WorkspaceViewerPermission,
+    ]
+
+    def get(self, request, slug):
+        cycles = (
+            Cycle.objects.filter(workspace__slug=slug)
+            .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()
+        )
+        serializer = CycleSerializer(cycles, many=True).data
+        return Response(serializer, status=status.HTTP_200_OK)
@@ -0,0 +1,39 @@
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.serializers import WorkspaceEstimateSerializer
+from plane.app.views.base import BaseAPIView
+from plane.db.models import Project, Estimate
+from plane.app.permissions import WorkspaceEntityPermission
+
+# Django imports
+from django.db.models import (
+    Prefetch,
+)
+from plane.utils.cache import cache_response
+
+
+class WorkspaceEstimatesEndpoint(BaseAPIView):
+    permission_classes = [
+        WorkspaceEntityPermission,
+    ]
+
+    @cache_response(60 * 60 * 2)
+    def get(self, request, slug):
+        estimate_ids = Project.objects.filter(
+            workspace__slug=slug, estimate__isnull=False
+        ).values_list("estimate_id", flat=True)
+        estimates = Estimate.objects.filter(
+            pk__in=estimate_ids
+        ).prefetch_related(
+            Prefetch(
+                "points",
+                queryset=Project.objects.select_related(
+                    "estimate", "workspace", "project"
+                ),
+            )
+        )
+        serializer = WorkspaceEstimateSerializer(estimates, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -0,0 +1,301 @@
+# Python imports
+import jwt
+from datetime import datetime
+
+# Django imports
+from django.conf import settings
+from django.utils import timezone
+from django.db.models import Count
+from django.core.exceptions import ValidationError
+from django.core.validators import validate_email
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+
+# Module imports
+from plane.app.serializers import (
+    WorkSpaceMemberSerializer,
+    WorkSpaceMemberInviteSerializer,
+)
+from plane.app.views.base import BaseAPIView
+from .. import BaseViewSet
+from plane.db.models import (
+    User,
+    Workspace,
+    WorkspaceMemberInvite,
+    WorkspaceMember,
+)
+from plane.app.permissions import WorkSpaceAdminPermission
+from plane.bgtasks.workspace_invitation_task import workspace_invitation
+from plane.bgtasks.event_tracking_task import workspace_invite_event
+from plane.utils.cache import invalidate_cache
+
+class WorkspaceInvitationsViewset(BaseViewSet):
+    """Endpoint for creating, listing and  deleting workspaces"""
+
+    serializer_class = WorkSpaceMemberInviteSerializer
+    model = WorkspaceMemberInvite
+
+    permission_classes = [
+        WorkSpaceAdminPermission,
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace", "workspace__owner", "created_by")
+        )
+
+    def create(self, request, slug):
+        emails = request.data.get("emails", [])
+        # Check if email is provided
+        if not emails:
+            return Response(
+                {"error": "Emails are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # check for role level of the requesting user
+        requesting_user = WorkspaceMember.objects.get(
+            workspace__slug=slug,
+            member=request.user,
+            is_active=True,
+        )
+
+        # Check if any invited user has an higher role
+        if len(
+            [
+                email
+                for email in emails
+                if int(email.get("role", 10)) > requesting_user.role
+            ]
+        ):
+            return Response(
+                {"error": "You cannot invite a user with higher role"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the workspace object
+        workspace = Workspace.objects.get(slug=slug)
+
+        # Check if user is already a member of workspace
+        workspace_members = WorkspaceMember.objects.filter(
+            workspace_id=workspace.id,
+            member__email__in=[email.get("email") for email in emails],
+            is_active=True,
+        ).select_related("member", "workspace", "workspace__owner")
+
+        if workspace_members:
+            return Response(
+                {
+                    "error": "Some users are already member of workspace",
+                    "workspace_users": WorkSpaceMemberSerializer(
+                        workspace_members, many=True
+                    ).data,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace_invitations = []
+        for email in emails:
+            try:
+                validate_email(email.get("email"))
+                workspace_invitations.append(
+                    WorkspaceMemberInvite(
+                        email=email.get("email").strip().lower(),
+                        workspace_id=workspace.id,
+                        token=jwt.encode(
+                            {
+                                "email": email,
+                                "timestamp": datetime.now().timestamp(),
+                            },
+                            settings.SECRET_KEY,
+                            algorithm="HS256",
+                        ),
+                        role=email.get("role", 10),
+                        created_by=request.user,
+                    )
+                )
+            except ValidationError:
+                return Response(
+                    {
+                        "error": f"Invalid email - {email} provided a valid email address is required to send the invite"
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+        # Create workspace member invite
+        workspace_invitations = WorkspaceMemberInvite.objects.bulk_create(
+            workspace_invitations, batch_size=10, ignore_conflicts=True
+        )
+
+        current_site = request.META.get("HTTP_ORIGIN")
+
+        # Send invitations
+        for invitation in workspace_invitations:
+            workspace_invitation.delay(
+                invitation.email,
+                workspace.id,
+                invitation.token,
+                current_site,
+                request.user.email,
+            )
+
+        return Response(
+            {
+                "message": "Emails sent successfully",
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    def destroy(self, request, slug, pk):
+        workspace_member_invite = WorkspaceMemberInvite.objects.get(
+            pk=pk, workspace__slug=slug
+        )
+        workspace_member_invite.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WorkspaceJoinEndpoint(BaseAPIView):
+    permission_classes = [
+        AllowAny,
+    ]
+    """Invitation response endpoint the user can respond to the invitation"""
+
+    @invalidate_cache(path="/api/workspaces/", user=False)
+    @invalidate_cache(path="/api/users/me/workspaces/")
+    def post(self, request, slug, pk):
+        workspace_invite = WorkspaceMemberInvite.objects.get(
+            pk=pk, workspace__slug=slug
+        )
+
+        email = request.data.get("email", "")
+
+        # Check the email
+        if email == "" or workspace_invite.email != email:
+            return Response(
+                {"error": "You do not have permission to join the workspace"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        # If already responded then return error
+        if workspace_invite.responded_at is None:
+            workspace_invite.accepted = request.data.get("accepted", False)
+            workspace_invite.responded_at = timezone.now()
+            workspace_invite.save()
+
+            if workspace_invite.accepted:
+                # Check if the user created account after invitation
+                user = User.objects.filter(email=email).first()
+
+                # If the user is present then create the workspace member
+                if user is not None:
+                    # Check if the user was already a member of workspace then activate the user
+                    workspace_member = WorkspaceMember.objects.filter(
+                        workspace=workspace_invite.workspace, member=user
+                    ).first()
+                    if workspace_member is not None:
+                        workspace_member.is_active = True
+                        workspace_member.role = workspace_invite.role
+                        workspace_member.save()
+                    else:
+                        # Create a Workspace
+                        _ = WorkspaceMember.objects.create(
+                            workspace=workspace_invite.workspace,
+                            member=user,
+                            role=workspace_invite.role,
+                        )
+
+                    # Set the user last_workspace_id to the accepted workspace
+                    user.last_workspace_id = workspace_invite.workspace.id
+                    user.save()
+
+                    # Delete the invitation
+                    workspace_invite.delete()
+
+                # Send event
+                workspace_invite_event.delay(
+                    user=user.id if user is not None else None,
+                    email=email,
+                    user_agent=request.META.get("HTTP_USER_AGENT"),
+                    ip=request.META.get("REMOTE_ADDR"),
+                    event_name="MEMBER_ACCEPTED",
+                    accepted_from="EMAIL",
+                )
+
+                return Response(
+                    {"message": "Workspace Invitation Accepted"},
+                    status=status.HTTP_200_OK,
+                )
+
+            # Workspace invitation rejected
+            return Response(
+                {"message": "Workspace Invitation was not accepted"},
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(
+            {"error": "You have already responded to the invitation request"},
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
+    def get(self, request, slug, pk):
+        workspace_invitation = WorkspaceMemberInvite.objects.get(
+            workspace__slug=slug, pk=pk
+        )
+        serializer = WorkSpaceMemberInviteSerializer(workspace_invitation)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class UserWorkspaceInvitationsViewSet(BaseViewSet):
+    serializer_class = WorkSpaceMemberInviteSerializer
+    model = WorkspaceMemberInvite
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(email=self.request.user.email)
+            .select_related("workspace", "workspace__owner", "created_by")
+            .annotate(total_members=Count("workspace__workspace_member"))
+        )
+
+    @invalidate_cache(path="/api/workspaces/", user=False)
+    @invalidate_cache(path="/api/users/me/workspaces/")
+    @invalidate_cache(
+        path="/api/workspaces/:slug/members/", url_params=True, user=False
+    )
+    def create(self, request):
+        invitations = request.data.get("invitations", [])
+        workspace_invitations = WorkspaceMemberInvite.objects.filter(
+            pk__in=invitations, email=request.user.email
+        ).order_by("-created_at")
+
+        # If the user is already a member of workspace and was deactivated then activate the user
+        for invitation in workspace_invitations:
+            # Update the WorkspaceMember for this specific invitation
+            WorkspaceMember.objects.filter(
+                workspace_id=invitation.workspace_id, member=request.user
+            ).update(is_active=True, role=invitation.role)
+
+        # Bulk create the user for all the workspaces
+        WorkspaceMember.objects.bulk_create(
+            [
+                WorkspaceMember(
+                    workspace=invitation.workspace,
+                    member=request.user,
+                    role=invitation.role,
+                    created_by=request.user,
+                )
+                for invitation in workspace_invitations
+            ],
+            ignore_conflicts=True,
+        )
+
+        # Delete joined workspace invites
+        workspace_invitations.delete()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -0,0 +1,25 @@
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.serializers import LabelSerializer
+from plane.app.views.base import BaseAPIView
+from plane.db.models import Label
+from plane.app.permissions import WorkspaceViewerPermission
+from plane.utils.cache import cache_response
+
+class WorkspaceLabelsEndpoint(BaseAPIView):
+    permission_classes = [
+        WorkspaceViewerPermission,
+    ]
+
+    @cache_response(60 * 60 * 2)
+    def get(self, request, slug):
+        labels = Label.objects.filter(
+            workspace__slug=slug,
+            project__project_projectmember__member=request.user,
+            project__project_projectmember__is_active=True,
+        )
+        serializer = LabelSerializer(labels, many=True).data
+        return Response(serializer, status=status.HTTP_200_OK)
@@ -0,0 +1,396 @@
+# Django imports
+from django.db.models import (
+    Q,
+    Count,
+)
+from django.db.models.functions import Cast
+from django.db.models import CharField
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.serializers import (
+    WorkSpaceMemberSerializer,
+    TeamSerializer,
+    UserLiteSerializer,
+    WorkspaceMemberAdminSerializer,
+    WorkspaceMemberMeSerializer,
+    ProjectMemberRoleSerializer,
+)
+from plane.app.views.base import BaseAPIView
+from .. import BaseViewSet
+from plane.db.models import (
+    User,
+    Workspace,
+    Team,
+    ProjectMember,
+    Project,
+    WorkspaceMember,
+)
+from plane.app.permissions import (
+    WorkSpaceAdminPermission,
+    WorkspaceEntityPermission,
+    WorkspaceUserPermission,
+)
+from plane.utils.cache import cache_response, invalidate_cache
+
+
+class WorkSpaceMemberViewSet(BaseViewSet):
+    serializer_class = WorkspaceMemberAdminSerializer
+    model = WorkspaceMember
+
+    permission_classes = [
+        WorkspaceEntityPermission,
+    ]
+
+    def get_permissions(self):
+        if self.action == "leave":
+            self.permission_classes = [
+                WorkspaceUserPermission,
+            ]
+        else:
+            self.permission_classes = [
+                WorkspaceEntityPermission,
+            ]
+
+        return super(WorkSpaceMemberViewSet, self).get_permissions()
+
+    search_fields = [
+        "member__display_name",
+        "member__first_name",
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(
+                workspace__slug=self.kwargs.get("slug"),
+                is_active=True,
+            )
+            .select_related("workspace", "workspace__owner")
+            .select_related("member")
+        )
+
+    @cache_response(60 * 60 * 2)
+    def list(self, request, slug):
+        workspace_member = WorkspaceMember.objects.get(
+            member=request.user,
+            workspace__slug=slug,
+            is_active=True,
+        )
+
+        # Get all active workspace members
+        workspace_members = self.get_queryset()
+
+        if workspace_member.role > 10:
+            serializer = WorkspaceMemberAdminSerializer(
+                workspace_members,
+                fields=("id", "member", "role"),
+                many=True,
+            )
+        else:
+            serializer = WorkSpaceMemberSerializer(
+                workspace_members,
+                fields=("id", "member", "role"),
+                many=True,
+            )
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @invalidate_cache(
+        path="/api/workspaces/:slug/members/", url_params=True, user=False
+    )
+    def partial_update(self, request, slug, pk):
+        workspace_member = WorkspaceMember.objects.get(
+            pk=pk,
+            workspace__slug=slug,
+            member__is_bot=False,
+            is_active=True,
+        )
+        if request.user.id == workspace_member.member_id:
+            return Response(
+                {"error": "You cannot update your own role"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the requested user role
+        requested_workspace_member = WorkspaceMember.objects.get(
+            workspace__slug=slug,
+            member=request.user,
+            is_active=True,
+        )
+        # Check if role is being updated
+        # One cannot update role higher than his own role
+        if (
+            "role" in request.data
+            and int(request.data.get("role", workspace_member.role))
+            > requested_workspace_member.role
+        ):
+            return Response(
+                {
+                    "error": "You cannot update a role that is higher than your own role"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        serializer = WorkSpaceMemberSerializer(
+            workspace_member, data=request.data, partial=True
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @invalidate_cache(
+        path="/api/workspaces/:slug/members/", url_params=True, user=False
+    )
+    def destroy(self, request, slug, pk):
+        # Check the user role who is deleting the user
+        workspace_member = WorkspaceMember.objects.get(
+            workspace__slug=slug,
+            pk=pk,
+            member__is_bot=False,
+            is_active=True,
+        )
+
+        # check requesting user role
+        requesting_workspace_member = WorkspaceMember.objects.get(
+            workspace__slug=slug,
+            member=request.user,
+            is_active=True,
+        )
+
+        if str(workspace_member.id) == str(requesting_workspace_member.id):
+            return Response(
+                {
+                    "error": "You cannot remove yourself from the workspace. Please use leave workspace"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if requesting_workspace_member.role < workspace_member.role:
+            return Response(
+                {
+                    "error": "You cannot remove a user having role higher than you"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if (
+            Project.objects.annotate(
+                total_members=Count("project_projectmember"),
+                member_with_role=Count(
+                    "project_projectmember",
+                    filter=Q(
+                        project_projectmember__member_id=workspace_member.id,
+                        project_projectmember__role=20,
+                    ),
+                ),
+            )
+            .filter(total_members=1, member_with_role=1, workspace__slug=slug)
+            .exists()
+        ):
+            return Response(
+                {
+                    "error": "User is a part of some projects where they are the only admin, they should either leave that project or promote another user to admin."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Deactivate the users from the projects where the user is part of
+        _ = ProjectMember.objects.filter(
+            workspace__slug=slug,
+            member_id=workspace_member.member_id,
+            is_active=True,
+        ).update(is_active=False)
+
+        workspace_member.is_active = False
+        workspace_member.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @invalidate_cache(
+        path="/api/workspaces/:slug/members/", url_params=True, user=False
+    )
+    def leave(self, request, slug):
+        workspace_member = WorkspaceMember.objects.get(
+            workspace__slug=slug,
+            member=request.user,
+            is_active=True,
+        )
+
+        # Check if the leaving user is the only admin of the workspace
+        if (
+            workspace_member.role == 20
+            and not WorkspaceMember.objects.filter(
+                workspace__slug=slug,
+                role=20,
+                is_active=True,
+            ).count()
+            > 1
+        ):
+            return Response(
+                {
+                    "error": "You cannot leave the workspace as you are the only admin of the workspace you will have to either delete the workspace or promote another user to admin."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if (
+            Project.objects.annotate(
+                total_members=Count("project_projectmember"),
+                member_with_role=Count(
+                    "project_projectmember",
+                    filter=Q(
+                        project_projectmember__member_id=request.user.id,
+                        project_projectmember__role=20,
+                    ),
+                ),
+            )
+            .filter(total_members=1, member_with_role=1, workspace__slug=slug)
+            .exists()
+        ):
+            return Response(
+                {
+                    "error": "You are a part of some projects where you are the only admin, you should either leave the project or promote another user to admin."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # # Deactivate the users from the projects where the user is part of
+        _ = ProjectMember.objects.filter(
+            workspace__slug=slug,
+            member_id=workspace_member.member_id,
+            is_active=True,
+        ).update(is_active=False)
+
+        # # Deactivate the user
+        workspace_member.is_active = False
+        workspace_member.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WorkspaceMemberUserViewsEndpoint(BaseAPIView):
+    def post(self, request, slug):
+        workspace_member = WorkspaceMember.objects.get(
+            workspace__slug=slug,
+            member=request.user,
+            is_active=True,
+        )
+        workspace_member.view_props = request.data.get("view_props", {})
+        workspace_member.save()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WorkspaceMemberUserEndpoint(BaseAPIView):
+    def get(self, request, slug):
+        workspace_member = WorkspaceMember.objects.get(
+            member=request.user,
+            workspace__slug=slug,
+            is_active=True,
+        )
+        serializer = WorkspaceMemberMeSerializer(workspace_member)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class WorkspaceProjectMemberEndpoint(BaseAPIView):
+    serializer_class = ProjectMemberRoleSerializer
+    model = ProjectMember
+
+    permission_classes = [
+        WorkspaceEntityPermission,
+    ]
+
+    def get(self, request, slug):
+        # Fetch all project IDs where the user is involved
+        project_ids = (
+            ProjectMember.objects.filter(
+                member=request.user,
+                is_active=True,
+            )
+            .values_list("project_id", flat=True)
+            .distinct()
+        )
+
+        # Get all the project members in which the user is involved
+        project_members = ProjectMember.objects.filter(
+            workspace__slug=slug,
+            project_id__in=project_ids,
+            is_active=True,
+        ).select_related("project", "member", "workspace")
+        project_members = ProjectMemberRoleSerializer(
+            project_members, many=True
+        ).data
+
+        project_members_dict = dict()
+
+        # Construct a dictionary with project_id as key and project_members as value
+        for project_member in project_members:
+            project_id = project_member.pop("project")
+            if str(project_id) not in project_members_dict:
+                project_members_dict[str(project_id)] = []
+            project_members_dict[str(project_id)].append(project_member)
+
+        return Response(project_members_dict, status=status.HTTP_200_OK)
+
+
+class TeamMemberViewSet(BaseViewSet):
+    serializer_class = TeamSerializer
+    model = Team
+    permission_classes = [
+        WorkSpaceAdminPermission,
+    ]
+
+    search_fields = [
+        "member__display_name",
+        "member__first_name",
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace", "workspace__owner")
+            .prefetch_related("members")
+        )
+
+    def create(self, request, slug):
+        members = list(
+            WorkspaceMember.objects.filter(
+                workspace__slug=slug,
+                member__id__in=request.data.get("members", []),
+                is_active=True,
+            )
+            .annotate(member_str_id=Cast("member", output_field=CharField()))
+            .distinct()
+            .values_list("member_str_id", flat=True)
+        )
+
+        if len(members) != len(request.data.get("members", [])):
+            users = list(
+                set(request.data.get("members", [])).difference(members)
+            )
+            users = User.objects.filter(pk__in=users)
+
+            serializer = UserLiteSerializer(users, many=True)
+            return Response(
+                {
+                    "error": f"{len(users)} of the member(s) are not a part of the workspace",
+                    "members": serializer.data,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace = Workspace.objects.get(slug=slug)
+
+        serializer = TeamSerializer(
+            data=request.data, context={"workspace": workspace}
+        )
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
--- a/Show More
+++ b/Show More