chore: update workspace file

fix: setting up apps folder
chore: updated web docker wip
2025-06-26 14:34:02 +05:30 · 2025-06-20 21:37:49 +05:30 · 2025-06-19 02:34:01 +05:30 · 2025-06-19 01:33:43 +05:30 · 2025-06-18 05:31:43 +05:30 · 2025-06-18 05:30:23 +05:30
5104 changed files with 225613 additions and 151341 deletions
@@ -2,6 +2,7 @@
 *.pyc
 .env
 venv
+.venv
 node_modules/
 **/node_modules/
 npm-debug.log
@@ -14,4 +15,4 @@ build/
 out/
 **/out/
 dist/
-**/dist/
+**/dist/
@@ -38,3 +38,9 @@ USE_MINIO=1

 # Nginx Configuration
 NGINX_PORT=80
+
+# Force HTTPS for handling SSL Termination
+MINIO_ENDPOINT_SSL=0
+
+# API key rate limit
+API_KEY_RATE_LIMIT="60/minute"
@@ -1,126 +0,0 @@
-name: "Build and Push Docker Image"
-description: "Reusable action for building and pushing Docker images"
-inputs:
-  docker-username:
-    description: "The Dockerhub username"
-    required: true
-  docker-token:
-    description: "The Dockerhub Token"
-    required: true
-
-  # Docker Image Options
-  docker-image-owner:
-    description: "The owner of the Docker image"
-    required: true
-  docker-image-name:
-    description: "The name of the Docker image"
-    required: true
-  build-context:
-    description: "The build context"
-    required: true
-    default: "."
-  dockerfile-path:
-    description: "The path to the Dockerfile"
-    required: true
-  build-args:
-    description: "The build arguments"
-    required: false
-    default: ""
-  
-  # Buildx Options
-  buildx-driver:
-    description: "Buildx driver"
-    required: true
-    default: "docker-container"
-  buildx-version:
-    description: "Buildx version"
-    required: true
-    default: "latest"
-  buildx-platforms:
-    description: "Buildx platforms"
-    required: true
-    default: "linux/amd64"
-  buildx-endpoint:
-    description: "Buildx endpoint"
-    required: true
-    default: "default"
-
-  # Release Build Options
-  build-release:
-    description: "Flag to publish release"
-    required: false
-    default: "false"
-  build-prerelease:
-    description: "Flag to publish prerelease"
-    required: false
-    default: "false"
-  release-version:
-    description: "The release version"
-    required: false
-    default: "latest"
-
-runs:
-  using: "composite"
-  steps:
-    - name: Set Docker Tag
-      shell: bash
-      env:
-        IMG_OWNER: ${{ inputs.docker-image-owner }}
-        IMG_NAME: ${{ inputs.docker-image-name }}
-        BUILD_RELEASE: ${{ inputs.build-release }}
-        IS_PRERELEASE: ${{ inputs.build-prerelease }}
-        REL_VERSION: ${{ inputs.release-version }}
-      run: |
-        FLAT_BRANCH_VERSION=$(echo "${{ github.ref_name }}" | sed 's/[^a-zA-Z0-9.-]//g')
-
-        if [ "${{ env.BUILD_RELEASE }}" == "true" ]; then
-          semver_regex="^v([0-9]+)\.([0-9]+)\.([0-9]+)(-[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*)?$"
-          if [[ ! ${{ env.REL_VERSION }} =~ $semver_regex ]]; then
-            echo "Invalid Release Version Format : ${{ env.REL_VERSION }}"
-            echo "Please provide a valid SemVer version"
-            echo "e.g. v1.2.3 or v1.2.3-alpha-1"
-            echo "Exiting the build process"
-            exit 1  # Exit with status 1 to fail the step
-          fi
-
-          TAG=${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:${{ env.REL_VERSION }}
-
-          if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
-            TAG=${TAG},${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:stable
-          fi
-        elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-          TAG=${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:latest
-        else
-          TAG=${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:${FLAT_BRANCH_VERSION}
-        fi
-        
-        echo "DOCKER_TAGS=${TAG}" >> $GITHUB_ENV
-    - name: Login to Docker Hub
-      uses: docker/login-action@v3
-      with:
-        username: ${{ inputs.docker-username }}
-        password: ${{ inputs.docker-token}}
-
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
-      with:
-        driver: ${{ inputs.buildx-driver }}
-        version: ${{ inputs.buildx-version }}
-        endpoint: ${{ inputs.buildx-endpoint }}
-
-    - name: Check out the repo
-      uses: actions/checkout@v4
-
-    - name: Build and Push Docker Image
-      uses: docker/build-push-action@v5.1.0
-      with:
-        context: ${{ inputs.build-context }}
-        file: ${{ inputs.dockerfile-path }}
-        platforms: ${{ inputs.buildx-platforms }}
-        tags: ${{ env.DOCKER_TAGS }}
-        push: true
-        build-args: ${{ inputs.build-args }}
-      env:
-        DOCKER_BUILDKIT: 1
-        DOCKER_USERNAME: ${{ inputs.docker-username }}
-        DOCKER_PASSWORD: ${{ inputs.docker-token }}
@@ -88,7 +88,7 @@ jobs:

  full_build_push:
    if: ${{ needs.branch_build_setup.outputs.do_full_build == 'true' }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    needs: [branch_build_setup]
    env:
      BUILD_TYPE: full
@@ -148,7 +148,7 @@ jobs:

  slim_build_push:
    if: ${{ needs.branch_build_setup.outputs.do_slim_build == 'true' }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    needs: [branch_build_setup]
    env:
      BUILD_TYPE: slim
@@ -25,6 +25,10 @@ on:
        required: false
        default: false
        type: boolean
+  push:
+    branches:
+      - preview
+      - canary

 env:
  TARGET_BRANCH: ${{ github.ref_name }}
@@ -36,19 +40,13 @@ env:
 jobs:
  branch_build_setup:
    name: Build Setup
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    outputs:
      gh_branch_name: ${{ steps.set_env_variables.outputs.TARGET_BRANCH }}
      gh_buildx_driver: ${{ steps.set_env_variables.outputs.BUILDX_DRIVER }}
      gh_buildx_version: ${{ steps.set_env_variables.outputs.BUILDX_VERSION }}
      gh_buildx_platforms: ${{ steps.set_env_variables.outputs.BUILDX_PLATFORMS }}
      gh_buildx_endpoint: ${{ steps.set_env_variables.outputs.BUILDX_ENDPOINT }}
-      build_proxy: ${{ steps.changed_files.outputs.proxy_any_changed }}
-      build_apiserver: ${{ steps.changed_files.outputs.apiserver_any_changed }}
-      build_admin: ${{ steps.changed_files.outputs.admin_any_changed }}
-      build_space: ${{ steps.changed_files.outputs.space_any_changed }}
-      build_web: ${{ steps.changed_files.outputs.web_any_changed }}
-      build_live: ${{ steps.changed_files.outputs.live_any_changed }}

      dh_img_web: ${{ steps.set_env_variables.outputs.DH_IMG_WEB }}
      dh_img_space: ${{ steps.set_env_variables.outputs.DH_IMG_SPACE }}
@@ -119,61 +117,19 @@ jobs:
        name: Checkout Files
        uses: actions/checkout@v4

-      - name: Get changed files
-        id: changed_files
-        uses: tj-actions/changed-files@v42
-        with:
-          files_yaml: |
-            apiserver:
-              - apiserver/**
-            proxy:
-              - nginx/**
-            admin:
-              - admin/**
-              - packages/**
-              - "package.json"
-              - "yarn.lock"
-              - "tsconfig.json"
-              - "turbo.json"
-            space:
-              - space/**
-              - packages/**
-              - "package.json"
-              - "yarn.lock"
-              - "tsconfig.json"
-              - "turbo.json"
-            web:
-              - web/**
-              - packages/**
-              - "package.json"
-              - "yarn.lock"
-              - "tsconfig.json"
-              - "turbo.json"
-            live:
-              - live/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
-
  branch_build_push_admin:
-    if: ${{ needs.branch_build_setup.outputs.build_admin == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
    name: Build-Push Admin Docker Image
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    needs: [branch_build_setup]
    steps:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
      - name: Admin Build and Push
-        uses: ./.github/actions/build-push-ce
+        uses: makeplane/actions/build-push@v1.0.0
        with:
          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
-          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
-          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          docker-image-owner: makeplane
          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_admin }}
          build-context: .
@@ -184,22 +140,18 @@ jobs:
          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}

  branch_build_push_web:
-    if: ${{ needs.branch_build_setup.outputs.build_web == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
    name: Build-Push Web Docker Image
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    needs: [branch_build_setup]
    steps:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
      - name: Web Build and Push
-        uses: ./.github/actions/build-push-ce
+        uses: makeplane/actions/build-push@v1.0.0
        with:
          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
-          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
-          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          docker-image-owner: makeplane
          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_web }}
          build-context: .
@@ -210,22 +162,18 @@ jobs:
          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}

  branch_build_push_space:
-    if: ${{ needs.branch_build_setup.outputs.build_space == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
    name: Build-Push Space Docker Image
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    needs: [branch_build_setup]
    steps:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
      - name: Space Build and Push
-        uses: ./.github/actions/build-push-ce
+        uses: makeplane/actions/build-push@v1.0.0
        with:
          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
-          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
-          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          docker-image-owner: makeplane
          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_space }}
          build-context: .
@@ -236,22 +184,18 @@ jobs:
          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}

  branch_build_push_live:
-    if: ${{ needs.branch_build_setup.outputs.build_live == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
    name: Build-Push Live Collaboration Docker Image
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    needs: [branch_build_setup]
    steps:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
      - name: Live Build and Push
-        uses: ./.github/actions/build-push-ce
+        uses: makeplane/actions/build-push@v1.0.0
        with:
          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
-          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
-          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          docker-image-owner: makeplane
          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_live }}
          build-context: .
@@ -262,22 +206,18 @@ jobs:
          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}

  branch_build_push_apiserver:
-    if: ${{ needs.branch_build_setup.outputs.build_apiserver == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
    name: Build-Push API Server Docker Image
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    needs: [branch_build_setup]
    steps:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
      - name: Backend Build and Push
-        uses: ./.github/actions/build-push-ce
+        uses: makeplane/actions/build-push@v1.0.0
        with:
          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
-          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
-          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          docker-image-owner: makeplane
          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_backend }}
          build-context: ./apiserver
@@ -288,22 +228,18 @@ jobs:
          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}

  branch_build_push_proxy:
-    if: ${{ needs.branch_build_setup.outputs.build_proxy == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
    name: Build-Push Proxy Docker Image
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    needs: [branch_build_setup]
    steps:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
      - name: Proxy Build and Push
-        uses: ./.github/actions/build-push-ce
+        uses: makeplane/actions/build-push@v1.0.0
        with:
          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
-          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
-          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          docker-image-owner: makeplane
          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_proxy }}
          build-context: ./nginx
@@ -313,35 +249,10 @@ jobs:
          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}

-  attach_assets_to_build:
-    if: ${{ needs.branch_build_setup.outputs.build_type == 'Release' }}
-    name: Attach Assets to Release
-    runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Update Assets
-        run: |
-          cp ./deploy/selfhost/install.sh deploy/selfhost/setup.sh
-
-      - name: Attach Assets
-        id: attach_assets
-        uses: actions/upload-artifact@v4
-        with:
-          name: selfhost-assets
-          retention-days: 2
-          path: |
-            ${{ github.workspace }}/deploy/selfhost/setup.sh
-            ${{ github.workspace }}/deploy/selfhost/restore.sh
-            ${{ github.workspace }}/deploy/selfhost/docker-compose.yml
-            ${{ github.workspace }}/deploy/selfhost/variables.env
-
  publish_release:
    if: ${{ needs.branch_build_setup.outputs.build_type == 'Release' }}
    name: Build Release
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    needs:
      [
        branch_build_setup,
@@ -351,7 +262,6 @@ jobs:
        branch_build_push_live,
        branch_build_push_apiserver,
        branch_build_push_proxy,
-        attach_assets_to_build,
      ]
    env:
      REL_VERSION: ${{ needs.branch_build_setup.outputs.release_version }}
@@ -362,6 +272,8 @@ jobs:
      - name: Update Assets
        run: |
          cp ./deploy/selfhost/install.sh deploy/selfhost/setup.sh
+          sed -i 's/${APP_RELEASE:-stable}/${APP_RELEASE:-'${REL_VERSION}'}/g' deploy/selfhost/docker-compose.yml
+          # sed -i 's/APP_RELEASE=stable/APP_RELEASE='${REL_VERSION}'/g' deploy/selfhost/variables.env

      - name: Create Release
        id: create_release
@@ -376,6 +288,8 @@ jobs:
          generate_release_notes: true
          files: |
            ${{ github.workspace }}/deploy/selfhost/setup.sh
+            ${{ github.workspace }}/deploy/selfhost/swarm.sh
            ${{ github.workspace }}/deploy/selfhost/restore.sh
+            ${{ github.workspace }}/deploy/selfhost/restore-airgapped.sh
            ${{ github.workspace }}/deploy/selfhost/docker-compose.yml
            ${{ github.workspace }}/deploy/selfhost/variables.env
@@ -6,49 +6,9 @@ on:
    types: ["opened", "synchronize", "ready_for_review"]

 jobs:
-  get-changed-files:
+  lint-apiserver:
    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
-    outputs:
-      apiserver_changed: ${{ steps.changed-files.outputs.apiserver_any_changed }}
-      admin_changed: ${{ steps.changed-files.outputs.admin_any_changed }}
-      space_changed: ${{ steps.changed-files.outputs.space_any_changed }}
-      web_changed: ${{ steps.changed-files.outputs.web_any_changed }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Get changed files
-        id: changed-files
-        uses: tj-actions/changed-files@v44
-        with:
-          files_yaml: |
-            apiserver:
-              - apiserver/**
-            admin:
-              - admin/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
-            space:
-              - space/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
-            web:
-              - web/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
-
-  lint-apiserver:
-    needs: get-changed-files
-    runs-on: ubuntu-latest
-    if: needs.get-changed-files.outputs.apiserver_changed == 'true'
    steps:
      - uses: actions/checkout@v4
      - name: Set up Python
@@ -63,41 +23,38 @@ jobs:
        run: ruff check --fix apiserver

  lint-admin:
-    needs: get-changed-files
-    if: needs.get-changed-files.outputs.admin_changed == 'true'
+    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 18.x
+          node-version: 20.x
      - run: yarn install
      - run: yarn lint --filter=admin

  lint-space:
-    needs: get-changed-files
-    if: needs.get-changed-files.outputs.space_changed == 'true'
+    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 18.x
+          node-version: 20.x
      - run: yarn install
      - run: yarn lint --filter=space

  lint-web:
-    needs: get-changed-files
-    if: needs.get-changed-files.outputs.web_changed == 'true'
+    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 18.x
+          node-version: 20.x
      - run: yarn install
      - run: yarn lint --filter=web

@@ -109,7 +66,7 @@ jobs:
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 18.x
+          node-version: 20.x
      - run: yarn install
      - run: yarn build --filter=admin

@@ -121,7 +78,7 @@ jobs:
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 18.x
+          node-version: 20.x
      - run: yarn install
      - run: yarn build --filter=space

@@ -133,6 +90,6 @@ jobs:
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 18.x
+          node-version: 20.x
      - run: yarn install
      - run: yarn build --filter=web
@@ -51,7 +51,7 @@ jobs:
        uses: actions/checkout@v4

  full_build_push:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    needs: [branch_build_setup]
    env:
      BUILD_TYPE: full
@@ -11,7 +11,7 @@ env:

 jobs:
  sync_changes:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    permissions:
      pull-requests: write
      contents: read
@@ -1,5 +1,6 @@
 node_modules
 .next
+.yarn

 ### NextJS ###
 # Dependencies
@@ -52,6 +53,8 @@ mediafiles
 .env
 .DS_Store
 logs/
+htmlcov/
+.coverage

 node_modules/
 assets/dist/
@@ -72,16 +75,22 @@ package-lock.json

 # lock files
 package-lock.json
-pnpm-lock.yaml
-pnpm-workspace.yaml
+yarn.lock

 .npmrc
 .secrets
 tmp/
+
 ## packages
 dist
 .temp/
 deploy/selfhost/plane-app/
+
 ## Storybook
 *storybook.log
 output.css
+
+dev-editor
+# Redis
+*.rdb
+*.rdb.gz
@@ -15,14 +15,33 @@ Without said minimal reproduction, we won't be able to investigate all [issues](

 You can open a new issue with this [issue form](https://github.com/makeplane/plane/issues/new).

+### Naming conventions for issues
+
+When opening a new issue, please use a clear and concise title that follows this format:
+
+- For bugs: `🐛 Bug: [short description]`
+- For features: `🚀 Feature: [short description]`
+- For improvements: `🛠️ Improvement: [short description]`
+- For documentation: `📘 Docs: [short description]`
+
+**Examples:**
+- `🐛 Bug: API token expiry time not saving correctly`
+- `📘 Docs: Clarify RAM requirement for local setup`
+- `🚀 Feature: Allow custom time selection for token expiration`
+
+This helps us triage and manage issues more efficiently.
+
 ## Projects setup and Architecture

 ### Requirements

- Node.js version v16.18.0
+- Docker Engine installed and running
+- Node.js version 20+ [LTS version](https://nodejs.org/en/about/previous-releases)
 - Python version 3.8+
 - Postgres version v14
 - Redis version v6.2.7
+- **Memory**: Minimum **12 GB RAM** recommended
+  > ⚠️ Running the project on a system with only 8 GB RAM may lead to setup failures or memory crashes (especially during Docker container build/start or dependency install). Use cloud environments like GitHub Codespaces or upgrade local RAM if possible.

 ### Setup the project

@@ -50,6 +69,17 @@ chmod +x setup.sh
 docker compose -f docker-compose-local.yml up
 ```

+4. Start web apps:
+
+```bash
+pnpm dev
+```
+
+5. Open your browser to http://localhost:3001/god-mode/ and register yourself as instance admin
+6. Open up your browser to http://localhost:3000 then log in using the same credentials from the previous step
+
+That’s it! You’re all set to begin coding. Remember to refresh your browser if changes don’t auto-reload. Happy contributing! 🎉
+
 ## 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.
@@ -62,17 +92,143 @@ To ensure consistency throughout the source code, please keep these rules in min
 - All features or bug fixes must be tested by one or more specs (unit-tests).
 - We use [Eslint default rule guide](https://eslint.org/docs/rules/), with minor changes. An automated formatter is available using prettier.

-## Need help? Questions and suggestions
-
-Questions, suggestions, and thoughts are most welcome. We can also be reached in our [Discord Server](https://discord.com/invite/A92xrEGCge).
-
 ## Ways to contribute

 - Try Plane Cloud and the self hosting platform and give feedback
 - Add new integrations
+- Add or update translations
 - Help with open [issues](https://github.com/makeplane/plane/issues) or [create your own](https://github.com/makeplane/plane/issues/new/choose)
 - Share your thoughts and suggestions with us
 - Help create tutorials and blog posts
 - Request a feature by submitting a proposal
 - Report a bug
 - **Improve documentation** - fix incomplete or missing [docs](https://docs.plane.so/), bad wording, examples or explanations.
+
+## Contributing to language support
+This guide is designed to help contributors understand how to add or update translations in the application.
+
+### Understanding translation structure
+
+#### File organization
+Translations are organized by language in the locales directory. Each language has its own folder containing JSON files for translations. Here's how it looks:
+
+```
+packages/i18n/src/locales/
+    ├── en/
+    │   ├── core.json       # Critical translations
+    │   └── translations.json
+    ├── fr/
+    │   └── translations.json
+    └── [language]/
+        └── translations.json
+```
+#### Nested structure
+To keep translations organized, we use a nested structure for keys. This makes it easier to manage and locate specific translations. For example:
+
+```json
+{
+  "issue": {
+    "label": "Work item",
+    "title": {
+      "label": "Work item title"
+    }
+  }
+}
+```
+
+### Translation formatting guide
+We use [IntlMessageFormat](https://formatjs.github.io/docs/intl-messageformat/) to handle dynamic content, such as variables and pluralization. Here's how to format your translations:
+
+#### Examples
+- **Simple variables**
+    ```json
+    {
+    "greeting": "Hello, {name}!"
+    }
+    ```
+
+- **Pluralization**
+    ```json
+    {
+    "items": "{count, plural, one {Work item} other {Work items}}"
+    }
+    ```
+
+### Contributing guidelines
+
+#### Updating existing translations
+1. Locate the key in `locales/<language>/translations.json`.
+
+2. Update the value while ensuring the key structure remains intact.
+3. Preserve any existing ICU formats (e.g., variables, pluralization).
+
+#### Adding new translation keys
+1. When introducing a new key, ensure it is added to **all** language files, even if translations are not immediately available. Use English as a placeholder if needed.
+
+2. Keep the nesting structure consistent across all languages.
+
+3. If the new key requires dynamic content (e.g., variables or pluralization), ensure the ICU format is applied uniformly across all languages.
+
+### Adding new languages
+Adding a new language involves several steps to ensure it integrates seamlessly with the project. Follow these instructions carefully:
+
+1. **Update type definitions**
+Add the new language to the TLanguage type in the language definitions file:
+
+    ```typescript
+    // types/language.ts
+    export type TLanguage = "en" | "fr" | "your-lang";
+    ```
+
+2. **Add language configuration**
+Include the new language in the list of supported languages:
+
+    ```typescript
+    // constants/language.ts
+    export const SUPPORTED_LANGUAGES: ILanguageOption[] = [
+    { label: "English", value: "en" },
+    { label: "Your Language", value: "your-lang" }
+    ];
+    ```
+
+3. **Create translation files**
+    1.  Create a new folder for your language under locales (e.g., `locales/your-lang/`).
+
+    2. Add a `translations.json` file inside the folder.
+
+    3. Copy the structure from an existing translation file and translate all keys.
+
+4. **Update import logic**
+Modify the language import logic to include your new language:
+
+    ```typescript
+    private importLanguageFile(language: TLanguage): Promise<any> {
+    switch (language) {
+        case "your-lang":
+        return import("../locales/your-lang/translations.json");
+        // ...
+    }
+    }
+    ```
+
+### Quality checklist
+Before submitting your contribution, please ensure the following:
+
+- All translation keys exist in every language file.
+- Nested structures match across all language files.
+- ICU message formats are correctly implemented.
+- All languages load without errors in the application.
+- Dynamic values and pluralization work as expected.
+- There are no missing or untranslated keys.
+
+#### Pro tips
+- When in doubt, refer to the English translations for context.
+- Verify pluralization works with different numbers.
+- Ensure dynamic values (e.g., `{name}`) are correctly interpolated.
+- Double-check that nested key access paths are accurate.
+
+Happy translating! 🌍✨
+
+## Need help? Questions and suggestions
+
+Questions, suggestions, and thoughts are most welcome. We can also be reached in our [Discord Server](https://discord.com/invite/A92xrEGCge).
@@ -43,9 +43,6 @@ NGINX_PORT=80
 # Debug value for api server use it as 0 for production use
 DEBUG=0
 CORS_ALLOWED_ORIGINS="http://localhost"
-# Error logs
-SENTRY_DSN=""
-SENTRY_ENVIRONMENT="development"
 # Database Settings
 POSTGRES_USER="plane"
 POSTGRES_PASSWORD="plane"
@@ -6,6 +6,7 @@
 </a>
 </p>
 <h1 align="center"><b>Plane</b></h1>
+<p align="center"><b>Open-source project management that unlocks customer value</b></p>

 <p align="center">
 <a href="https://discord.com/invite/A92xrEGCge">
@@ -15,10 +16,10 @@
 </p>

 <p align="center">
-    <a href="https://dub.sh/plane-website-readme"><b>Website</b></a> •
-    <a href="https://git.new/releases"><b>Releases</b></a> •
-    <a href="https://dub.sh/planepowershq"><b>Twitter</b></a> •
-    <a href="https://dub.sh/planedocs"><b>Documentation</b></a>
+    <a href="https://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>
@@ -38,7 +39,7 @@
    </a>
 </p>

-Meet [Plane](https://dub.sh/plane-website-readme), an open-source project management tool to track issues, run ~sprints~ cycles, and manage product roadmaps without the chaos of managing the tool itself. 🧘‍♀️
+Meet [Plane](https://plane.so/), an open-source project management tool to track issues, run ~sprints~ cycles, and manage product roadmaps without the chaos of managing the tool itself. 🧘‍♀️

 > Plane is evolving every day. Your suggestions, ideas, and reported bugs help us immensely. Do not hesitate to join in the conversation on [Discord](https://discord.com/invite/A92xrEGCge) or raise a GitHub issue. We read everything and respond to most.

@@ -46,10 +47,10 @@ Meet [Plane](https://dub.sh/plane-website-readme), an open-source project manage

 Getting started with Plane is simple. Choose the setup that works best for you:

- **Plane Cloud**   
+- **Plane Cloud**
 Sign up for a free account on [Plane Cloud](https://app.plane.so)—it's the fastest way to get up and running without worrying about infrastructure.

- **Self-host Plane**  
+- **Self-host Plane**
 Prefer full control over your data and infrastructure? Install and run Plane on your own servers. Follow our detailed [deployment guides](https://developers.plane.so/self-hosting/overview) to get started.

 | Installation methods | Docs link                                                                                                                                          |
@@ -57,26 +58,26 @@ Prefer full control over your data and infrastructure? Install and run Plane on
 | Docker               | [![Docker](https://img.shields.io/badge/docker-%230db7ed.svg?style=for-the-badge&logo=docker&logoColor=white)](https://developers.plane.so/self-hosting/methods/docker-compose)         |
 | Kubernetes           | [![Kubernetes](https://img.shields.io/badge/kubernetes-%23326ce5.svg?style=for-the-badge&logo=kubernetes&logoColor=white)](https://developers.plane.so/self-hosting/methods/kubernetes) |

-`Instance admins` can manage and customize settings using [God mode](https://developers.plane.so/self-hosting/govern/instance-admin).
+`Instance admins` can configure instance settings with [God mode](https://developers.plane.so/self-hosting/govern/instance-admin).

 ## 🌟 Features

- **Issues**  
+- **Issues**
 Efficiently create and manage tasks with a robust rich text editor that supports file uploads. Enhance organization and tracking by adding sub-properties and referencing related issues.

- **Cycles**   
+- **Cycles**
 Maintain your team’s momentum with Cycles. Track progress effortlessly using burn-down charts and other insightful tools.

- **Modules**  
-Simplify complex projects by dividing them into smaller, manageable modules. 
+- **Modules**
+Simplify complex projects by dividing them into smaller, manageable modules.

- **Views**  
+- **Views**
 Customize your workflow by creating filters to display only the most relevant issues. Save and share these views with ease.

- **Pages**  
+- **Pages**
 Capture and organize ideas using Plane Pages, complete with AI capabilities and a rich text editor. Format text, insert images, add hyperlinks, or convert your notes into actionable items.

- **Analytics**  
+- **Analytics**
 Access real-time insights across all your Plane data. Visualize trends, remove blockers, and keep your projects moving forward.

 - **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.
@@ -84,42 +85,11 @@ Access real-time insights across all your Plane data. Visualize trends, remove b

 ## 🛠️ Local development

-### Pre-requisites
- Ensure Docker Engine is installed and running.
+See [CONTRIBUTING](./CONTRIBUTING.md)

-###  Development setup
-Setting up your local environment is simple and straightforward. Follow these steps to get started:
-
-1. Clone the repository:
-   ```
-   git clone https://github.com/makeplane/plane.git
-   ```
-2. Navigate to the project folder:
-   ```
-   cd plane
-   ```
-3. Create a new branch for your feature or fix:
-   ```
-   git checkout -b <feature-branch-name>
-   ```
-4. Run the setup script in the terminal:
-   ```
-   ./setup.sh
-   ```
-5. Open the project in an IDE such as VS Code.
-
-6. Review the `.env` files in the relevant folders. Refer to [Environment Setup](./ENV_SETUP.md) for details on the environment variables used.
-
-7. Start the services using Docker:
-   ```
-   docker compose -f docker-compose-local.yml up -d
-   ```
-
-That’s it! You’re all set to begin coding. Remember to refresh your browser if changes don’t auto-reload. Happy contributing! 🎉
-
-## Built with
-[![Next JS](https://img.shields.io/badge/next.js-000000?style=for-the-badge&logo=nextdotjs&logoColor=white)](https://nextjs.org/)<br/>
-[![Django](https://img.shields.io/badge/Django-092E20?style=for-the-badge&logo=django&logoColor=green)](https://www.djangoproject.com/)<br/>
+## ⚙️ Built with
+[![Next JS](https://img.shields.io/badge/next.js-000000?style=for-the-badge&logo=nextdotjs&logoColor=white)](https://nextjs.org/)
+[![Django](https://img.shields.io/badge/Django-092E20?style=for-the-badge&logo=django&logoColor=green)](https://www.djangoproject.com/)
 [![Node JS](https://img.shields.io/badge/node.js-339933?style=for-the-badge&logo=Node.js&logoColor=white)](https://nodejs.org/en)

 ## 📸 Screenshots
@@ -193,7 +163,7 @@ Feel free to ask questions, report bugs, participate in discussions, share ideas

 If you discover a security vulnerability in Plane, please report it responsibly instead of opening a public issue. We take all legitimate reports seriously and will investigate them promptly. See [Security policy](https://github.com/makeplane/plane/blob/master/SECURITY.md) for more info.

-To disclose any security issues, please email us at security@plane.so. 
+To disclose any security issues, please email us at security@plane.so.

 ## 🤝 Contributing

@@ -218,4 +188,4 @@ Please read [CONTRIBUTING.md](https://github.com/makeplane/plane/blob/master/CON


 ## License
-This project is licensed under the [GNU Affero General Public License v3.0](https://github.com/makeplane/plane/blob/master/LICENSE.txt).
+This project is licensed under the [GNU Affero General Public License v3.0](https://github.com/makeplane/plane/blob/master/LICENSE.txt).
@@ -1,3 +0,0 @@
-NEXT_PUBLIC_API_BASE_URL=""
-NEXT_PUBLIC_ADMIN_BASE_PATH="/god-mode"
-NEXT_PUBLIC_WEB_BASE_URL=""
@@ -1,8 +0,0 @@
-module.exports = {
-  root: true,
-  extends: ["@plane/eslint-config/next.js"],
-  parser: "@typescript-eslint/parser",
-  parserOptions: {
-    project: true,
-  },
-};
@@ -1,17 +0,0 @@
-FROM node:18-alpine
-RUN apk add --no-cache libc6-compat
-# Set working directory
-WORKDIR /app
-
-COPY . .
-
-RUN yarn global add turbo
-RUN yarn install
-
-ENV NEXT_PUBLIC_ADMIN_BASE_PATH="/god-mode"
-
-EXPOSE 3000
-
-VOLUME [ "/app/node_modules", "/app/admin/node_modules" ]
-
-CMD ["yarn", "dev", "--filter=admin"]
@@ -1,134 +0,0 @@
-"use client";
-import { FC } from "react";
-import { useForm } from "react-hook-form";
-import { Lightbulb } from "lucide-react";
-import { IFormattedInstanceConfiguration, TInstanceAIConfigurationKeys } from "@plane/types";
-import { Button, TOAST_TYPE, setToast } from "@plane/ui";
-// components
-import { ControllerInput, TControllerInputFormField } from "@/components/common";
-// hooks
-import { useInstance } from "@/hooks/store";
-
-type IInstanceAIForm = {
-  config: IFormattedInstanceConfiguration;
-};
-
-type AIFormValues = Record<TInstanceAIConfigurationKeys, string>;
-
-export const InstanceAIForm: FC<IInstanceAIForm> = (props) => {
-  const { config } = props;
-  // store
-  const { updateInstanceConfigurations } = useInstance();
-  // form data
-  const {
-    handleSubmit,
-    control,
-    formState: { errors, isSubmitting },
-  } = useForm<AIFormValues>({
-    defaultValues: {
-      OPENAI_API_KEY: config["OPENAI_API_KEY"],
-      GPT_ENGINE: config["GPT_ENGINE"],
-    },
-  });
-
-  const aiFormFields: TControllerInputFormField[] = [
-    {
-      key: "GPT_ENGINE",
-      type: "text",
-      label: "GPT_ENGINE",
-      description: (
-        <>
-          Choose an OpenAI engine.{" "}
-          <a
-            href="https://platform.openai.com/docs/models/overview"
-            target="_blank"
-            className="text-custom-primary-100 hover:underline"
-            rel="noreferrer"
-          >
-            Learn more
-          </a>
-        </>
-      ),
-      placeholder: "gpt-3.5-turbo",
-      error: Boolean(errors.GPT_ENGINE),
-      required: false,
-    },
-    {
-      key: "OPENAI_API_KEY",
-      type: "password",
-      label: "API key",
-      description: (
-        <>
-          You will find your API key{" "}
-          <a
-            href="https://platform.openai.com/api-keys"
-            target="_blank"
-            className="text-custom-primary-100 hover:underline"
-            rel="noreferrer"
-          >
-            here.
-          </a>
-        </>
-      ),
-      placeholder: "sk-asddassdfasdefqsdfasd23das3dasdcasd",
-      error: Boolean(errors.OPENAI_API_KEY),
-      required: false,
-    },
-  ];
-
-  const onSubmit = async (formData: AIFormValues) => {
-    const payload: Partial<AIFormValues> = { ...formData };
-
-    await updateInstanceConfigurations(payload)
-      .then(() =>
-        setToast({
-          type: TOAST_TYPE.SUCCESS,
-          title: "Success",
-          message: "AI Settings updated successfully",
-        })
-      )
-      .catch((err) => console.error(err));
-  };
-
-  return (
-    <div className="space-y-8">
-      <div className="space-y-3">
-        <div>
-          <div className="pb-1 text-xl font-medium text-custom-text-100">OpenAI</div>
-          <div className="text-sm font-normal text-custom-text-300">If you use ChatGPT, this is for you.</div>
-        </div>
-        <div className="grid-col grid w-full grid-cols-1 items-center justify-between gap-x-12 gap-y-8 lg:grid-cols-3">
-          {aiFormFields.map((field) => (
-            <ControllerInput
-              key={field.key}
-              control={control}
-              type={field.type}
-              name={field.key}
-              label={field.label}
-              description={field.description}
-              placeholder={field.placeholder}
-              error={field.error}
-              required={field.required}
-            />
-          ))}
-        </div>
-      </div>
-
-      <div className="space-y-4">
-        <Button variant="primary" onClick={handleSubmit(onSubmit)} loading={isSubmitting}>
-          {isSubmitting ? "Saving..." : "Save changes"}
-        </Button>
-
-        <div className="relative inline-flex items-center gap-2 rounded border border-custom-primary-100/20 bg-custom-primary-100/10 px-4 py-2 text-xs text-custom-primary-200">
-          <Lightbulb height="14" width="14" />
-          <div>
-            If you have a preferred AI models vendor, please get in{" "}
-            <a className="underline font-medium" href="https://plane.so/contact">
-              touch with us.
-            </a>
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-};
@@ -1,216 +0,0 @@
-"use client";
-
-import { FC, useState } from "react";
-import isEmpty from "lodash/isEmpty";
-import Link from "next/link";
-import { useForm } from "react-hook-form";
-// plane internal packages
-import { API_BASE_URL } from "@plane/constants";
-import { IFormattedInstanceConfiguration, TInstanceGithubAuthenticationConfigurationKeys } from "@plane/types";
-import { Button, TOAST_TYPE, getButtonStyling, setToast } from "@plane/ui";
-import { cn } from "@plane/utils";
-// components
-import {
-  CodeBlock,
-  ConfirmDiscardModal,
-  ControllerInput,
-  CopyField,
-  TControllerInputFormField,
-  TCopyField,
-} from "@/components/common";
-// hooks
-import { useInstance } from "@/hooks/store";
-
-type Props = {
-  config: IFormattedInstanceConfiguration;
-};
-
-type GithubConfigFormValues = Record<TInstanceGithubAuthenticationConfigurationKeys, string>;
-
-export const InstanceGithubConfigForm: FC<Props> = (props) => {
-  const { config } = props;
-  // states
-  const [isDiscardChangesModalOpen, setIsDiscardChangesModalOpen] = useState(false);
-  // store hooks
-  const { updateInstanceConfigurations } = useInstance();
-  // form data
-  const {
-    handleSubmit,
-    control,
-    reset,
-    formState: { errors, isDirty, isSubmitting },
-  } = useForm<GithubConfigFormValues>({
-    defaultValues: {
-      GITHUB_CLIENT_ID: config["GITHUB_CLIENT_ID"],
-      GITHUB_CLIENT_SECRET: config["GITHUB_CLIENT_SECRET"],
-    },
-  });
-
-  const originURL = !isEmpty(API_BASE_URL) ? API_BASE_URL : typeof window !== "undefined" ? window.location.origin : "";
-
-  const GITHUB_FORM_FIELDS: TControllerInputFormField[] = [
-    {
-      key: "GITHUB_CLIENT_ID",
-      type: "text",
-      label: "Client ID",
-      description: (
-        <>
-          You will get this from your{" "}
-          <a
-            tabIndex={-1}
-            href="https://github.com/settings/applications/new"
-            target="_blank"
-            className="text-custom-primary-100 hover:underline"
-            rel="noreferrer"
-          >
-            GitHub OAuth application settings.
-          </a>
-        </>
-      ),
-      placeholder: "70a44354520df8bd9bcd",
-      error: Boolean(errors.GITHUB_CLIENT_ID),
-      required: true,
-    },
-    {
-      key: "GITHUB_CLIENT_SECRET",
-      type: "password",
-      label: "Client secret",
-      description: (
-        <>
-          Your client secret is also found in your{" "}
-          <a
-            tabIndex={-1}
-            href="https://github.com/settings/applications/new"
-            target="_blank"
-            className="text-custom-primary-100 hover:underline"
-            rel="noreferrer"
-          >
-            GitHub OAuth application settings.
-          </a>
-        </>
-      ),
-      placeholder: "9b0050f94ec1b744e32ce79ea4ffacd40d4119cb",
-      error: Boolean(errors.GITHUB_CLIENT_SECRET),
-      required: true,
-    },
-  ];
-
-  const GITHUB_SERVICE_FIELD: TCopyField[] = [
-    {
-      key: "Origin_URL",
-      label: "Origin URL",
-      url: originURL,
-      description: (
-        <>
-          We will auto-generate this. Paste this into the <CodeBlock darkerShade>Authorized origin URL</CodeBlock> field{" "}
-          <a
-            tabIndex={-1}
-            href="https://github.com/settings/applications/new"
-            target="_blank"
-            className="text-custom-primary-100 hover:underline"
-            rel="noreferrer"
-          >
-            here.
-          </a>
-        </>
-      ),
-    },
-    {
-      key: "Callback_URI",
-      label: "Callback URI",
-      url: `${originURL}/auth/github/callback/`,
-      description: (
-        <>
-          We will auto-generate this. Paste this into your <CodeBlock darkerShade>Authorized Callback URI</CodeBlock>{" "}
-          field{" "}
-          <a
-            tabIndex={-1}
-            href="https://github.com/settings/applications/new"
-            target="_blank"
-            className="text-custom-primary-100 hover:underline"
-            rel="noreferrer"
-          >
-            here.
-          </a>
-        </>
-      ),
-    },
-  ];
-
-  const onSubmit = async (formData: GithubConfigFormValues) => {
-    const payload: Partial<GithubConfigFormValues> = { ...formData };
-
-    await updateInstanceConfigurations(payload)
-      .then((response = []) => {
-        setToast({
-          type: TOAST_TYPE.SUCCESS,
-          title: "Done!",
-          message: "Your GitHub authentication is configured. You should test it now.",
-        });
-        reset({
-          GITHUB_CLIENT_ID: response.find((item) => item.key === "GITHUB_CLIENT_ID")?.value,
-          GITHUB_CLIENT_SECRET: response.find((item) => item.key === "GITHUB_CLIENT_SECRET")?.value,
-        });
-      })
-      .catch((err) => console.error(err));
-  };
-
-  const handleGoBack = (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => {
-    if (isDirty) {
-      e.preventDefault();
-      setIsDiscardChangesModalOpen(true);
-    }
-  };
-
-  return (
-    <>
-      <ConfirmDiscardModal
-        isOpen={isDiscardChangesModalOpen}
-        onDiscardHref="/authentication"
-        handleClose={() => setIsDiscardChangesModalOpen(false)}
-      />
-      <div className="flex flex-col gap-8">
-        <div className="grid grid-cols-2 gap-x-12 gap-y-8 w-full">
-          <div className="flex flex-col gap-y-4 col-span-2 md:col-span-1 pt-1">
-            <div className="pt-2.5 text-xl font-medium">GitHub-provided details for Plane</div>
-            {GITHUB_FORM_FIELDS.map((field) => (
-              <ControllerInput
-                key={field.key}
-                control={control}
-                type={field.type}
-                name={field.key}
-                label={field.label}
-                description={field.description}
-                placeholder={field.placeholder}
-                error={field.error}
-                required={field.required}
-              />
-            ))}
-            <div className="flex flex-col gap-1 pt-4">
-              <div className="flex items-center gap-4">
-                <Button variant="primary" onClick={handleSubmit(onSubmit)} loading={isSubmitting} disabled={!isDirty}>
-                  {isSubmitting ? "Saving..." : "Save changes"}
-                </Button>
-                <Link
-                  href="/authentication"
-                  className={cn(getButtonStyling("neutral-primary", "md"), "font-medium")}
-                  onClick={handleGoBack}
-                >
-                  Go back
-                </Link>
-              </div>
-            </div>
-          </div>
-          <div className="col-span-2 md:col-span-1">
-            <div className="flex flex-col gap-y-4 px-6 pt-1.5 pb-4 bg-custom-background-80/60 rounded-lg">
-              <div className="pt-2 text-xl font-medium">Plane-provided details for GitHub</div>
-              {GITHUB_SERVICE_FIELD.map((field) => (
-                <CopyField key={field.key} label={field.label} url={field.url} description={field.description} />
-              ))}
-            </div>
-          </div>
-        </div>
-      </div>
-    </>
-  );
-};
@@ -1,155 +0,0 @@
-"use client";
-import { FC } from "react";
-import { observer } from "mobx-react";
-import { Controller, useForm } from "react-hook-form";
-import { Telescope } from "lucide-react";
-// types
-import { IInstance, IInstanceAdmin } from "@plane/types";
-// ui
-import { Button, Input, TOAST_TYPE, ToggleSwitch, setToast } from "@plane/ui";
-// components
-import { ControllerInput } from "@/components/common";
-import { useInstance } from "@/hooks/store";
-import { IntercomConfig } from "./intercom";
-// hooks
-
-export interface IGeneralConfigurationForm {
-  instance: IInstance;
-  instanceAdmins: IInstanceAdmin[];
-}
-
-export const GeneralConfigurationForm: FC<IGeneralConfigurationForm> = observer((props) => {
-  const { instance, instanceAdmins } = props;
-  // hooks
-  const { instanceConfigurations, updateInstanceInfo, updateInstanceConfigurations } = useInstance();
-
-  // form data
-  const {
-    handleSubmit,
-    control,
-    watch,
-    formState: { errors, isSubmitting },
-  } = useForm<Partial<IInstance>>({
-    defaultValues: {
-      instance_name: instance?.instance_name,
-      is_telemetry_enabled: instance?.is_telemetry_enabled,
-    },
-  });
-
-  const onSubmit = async (formData: Partial<IInstance>) => {
-    const payload: Partial<IInstance> = { ...formData };
-
-    // update the intercom configuration
-    const isIntercomEnabled =
-      instanceConfigurations?.find((config) => config.key === "IS_INTERCOM_ENABLED")?.value === "1";
-    if (!payload.is_telemetry_enabled && isIntercomEnabled) {
-      try {
-        await updateInstanceConfigurations({ IS_INTERCOM_ENABLED: "0" });
-      } catch (error) {
-        console.error(error);
-      }
-    }
-
-    await updateInstanceInfo(payload)
-      .then(() =>
-        setToast({
-          type: TOAST_TYPE.SUCCESS,
-          title: "Success",
-          message: "Settings updated successfully",
-        })
-      )
-      .catch((err) => console.error(err));
-  };
-
-  return (
-    <div className="space-y-8">
-      <div className="space-y-3">
-        <div className="text-lg font-medium">Instance details</div>
-        <div className="grid-col grid w-full grid-cols-1 items-center justify-between gap-8 md:grid-cols-2 lg:grid-cols-3">
-          <ControllerInput
-            key="instance_name"
-            name="instance_name"
-            control={control}
-            type="text"
-            label="Name of instance"
-            placeholder="Instance name"
-            error={Boolean(errors.instance_name)}
-            required
-          />
-
-          <div className="flex flex-col gap-1">
-            <h4 className="text-sm text-custom-text-300">Email</h4>
-            <Input
-              id="email"
-              name="email"
-              type="email"
-              value={instanceAdmins[0]?.user_detail?.email ?? ""}
-              placeholder="Admin email"
-              className="w-full cursor-not-allowed !text-custom-text-400"
-              autoComplete="on"
-              disabled
-            />
-          </div>
-
-          <div className="flex flex-col gap-1">
-            <h4 className="text-sm text-custom-text-300">Instance ID</h4>
-            <Input
-              id="instance_id"
-              name="instance_id"
-              type="text"
-              value={instance.instance_id}
-              className="w-full cursor-not-allowed rounded-md font-medium !text-custom-text-400"
-              disabled
-            />
-          </div>
-        </div>
-      </div>
-
-      <div className="space-y-3">
-        <div className="text-lg font-medium">Chat + telemetry</div>
-        <IntercomConfig isTelemetryEnabled={watch("is_telemetry_enabled") ?? false} />
-        <div className="flex items-center gap-14 px-4 py-3 border border-custom-border-200 rounded">
-          <div className="grow flex items-center gap-4">
-            <div className="shrink-0">
-              <div className="flex items-center justify-center w-10 h-10 bg-custom-background-80 rounded-full">
-                <Telescope className="w-6 h-6 text-custom-text-300/80 p-0.5" />
-              </div>
-            </div>
-            <div className="grow">
-              <div className="text-sm font-medium text-custom-text-100 leading-5">
-                Let Plane collect anonymous usage data
-              </div>
-              <div className="text-xs font-normal text-custom-text-300 leading-5">
-                No PII is collected.This anonymized data is used to understand how you use Plane and build new features
-                in line with{" "}
-                <a
-                  href="https://docs.plane.so/self-hosting/telemetry"
-                  target="_blank"
-                  className="text-custom-primary-100 hover:underline"
-                  rel="noreferrer"
-                >
-                  our Telemetry Policy.
-                </a>
-              </div>
-            </div>
-          </div>
-          <div className={`shrink-0 ${isSubmitting && "opacity-70"}`}>
-            <Controller
-              control={control}
-              name="is_telemetry_enabled"
-              render={({ field: { value, onChange } }) => (
-                <ToggleSwitch value={value ?? false} onChange={onChange} size="sm" disabled={isSubmitting} />
-              )}
-            />
-          </div>
-        </div>
-      </div>
-
-      <div>
-        <Button variant="primary" onClick={handleSubmit(onSubmit)} loading={isSubmitting}>
-          {isSubmitting ? "Saving..." : "Save changes"}
-        </Button>
-      </div>
-    </div>
-  );
-});
@@ -1,432 +0,0 @@
-@import url("https://fonts.googleapis.com/css2?family=Inter:wght@200;300;400;500;600;700;800&display=swap");
-@import url("https://fonts.googleapis.com/css2?family=Material+Symbols+Rounded:opsz,wght,FILL,GRAD@48,400,0,0&display=swap");
-
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
-
-@layer components {
-  .text-1\.5xl {
-    font-size: 1.375rem;
-    line-height: 1.875rem;
-  }
-
-  .text-2\.5xl {
-    font-size: 1.75rem;
-    line-height: 2.25rem;
-  }
-}
-
-@layer base {
-  html {
-    font-family: "Inter", sans-serif;
-  }
-
-  :root {
-    color-scheme: light !important;
-
-    --color-primary-10: 236, 241, 255;
-    --color-primary-20: 217, 228, 255;
-    --color-primary-30: 197, 214, 255;
-    --color-primary-40: 178, 200, 255;
-    --color-primary-50: 159, 187, 255;
-    --color-primary-60: 140, 173, 255;
-    --color-primary-70: 121, 159, 255;
-    --color-primary-80: 101, 145, 255;
-    --color-primary-90: 82, 132, 255;
-    --color-primary-100: 63, 118, 255;
-    --color-primary-200: 57, 106, 230;
-    --color-primary-300: 50, 94, 204;
-    --color-primary-400: 44, 83, 179;
-    --color-primary-500: 38, 71, 153;
-    --color-primary-600: 32, 59, 128;
-    --color-primary-700: 25, 47, 102;
-    --color-primary-800: 19, 35, 76;
-    --color-primary-900: 13, 24, 51;
-
-    --color-background-100: 255, 255, 255; /* primary bg */
-    --color-background-90: 247, 247, 247; /* secondary bg */
-    --color-background-80: 232, 232, 232; /* tertiary bg */
-
-    --color-text-100: 23, 23, 23; /* primary text */
-    --color-text-200: 58, 58, 58; /* secondary text */
-    --color-text-300: 82, 82, 82; /* tertiary text */
-    --color-text-400: 163, 163, 163; /* placeholder text */
-
-    --color-scrollbar: 163, 163, 163; /* scrollbar thumb */
-
-    --color-border-100: 245, 245, 245; /* subtle border= 1 */
-    --color-border-200: 229, 229, 229; /* subtle border- 2 */
-    --color-border-300: 212, 212, 212; /* strong border- 1 */
-    --color-border-400: 185, 185, 185; /* strong border- 2 */
-
-    --color-shadow-2xs: 0px 0px 1px 0px rgba(23, 23, 23, 0.06), 0px 1px 2px 0px rgba(23, 23, 23, 0.06),
-      0px 1px 2px 0px rgba(23, 23, 23, 0.14);
-    --color-shadow-xs: 0px 1px 2px 0px rgba(0, 0, 0, 0.16), 0px 2px 4px 0px rgba(16, 24, 40, 0.12),
-      0px 1px 8px -1px rgba(16, 24, 40, 0.1);
-    --color-shadow-sm: 0px 1px 4px 0px rgba(0, 0, 0, 0.01), 0px 4px 8px 0px rgba(0, 0, 0, 0.02),
-      0px 1px 12px 0px rgba(0, 0, 0, 0.12);
-    --color-shadow-rg: 0px 3px 6px 0px rgba(0, 0, 0, 0.1), 0px 4px 4px 0px rgba(16, 24, 40, 0.08),
-      0px 1px 12px 0px rgba(16, 24, 40, 0.04);
-    --color-shadow-md: 0px 4px 8px 0px rgba(0, 0, 0, 0.12), 0px 6px 12px 0px rgba(16, 24, 40, 0.12),
-      0px 1px 16px 0px rgba(16, 24, 40, 0.12);
-    --color-shadow-lg: 0px 6px 12px 0px rgba(0, 0, 0, 0.12), 0px 8px 16px 0px rgba(0, 0, 0, 0.12),
-      0px 1px 24px 0px rgba(16, 24, 40, 0.12);
-    --color-shadow-xl: 0px 0px 18px 0px rgba(0, 0, 0, 0.16), 0px 0px 24px 0px rgba(16, 24, 40, 0.16),
-      0px 0px 52px 0px rgba(16, 24, 40, 0.16);
-    --color-shadow-2xl: 0px 8px 16px 0px rgba(0, 0, 0, 0.12), 0px 12px 24px 0px rgba(16, 24, 40, 0.12),
-      0px 1px 32px 0px rgba(16, 24, 40, 0.12);
-    --color-shadow-3xl: 0px 12px 24px 0px rgba(0, 0, 0, 0.12), 0px 16px 32px 0px rgba(0, 0, 0, 0.12),
-      0px 1px 48px 0px rgba(16, 24, 40, 0.12);
-    --color-shadow-4xl: 0px 8px 40px 0px rgba(0, 0, 61, 0.05), 0px 12px 32px -16px rgba(0, 0, 0, 0.05);
-
-    --color-sidebar-background-100: var(--color-background-100); /* primary sidebar bg */
-    --color-sidebar-background-90: var(--color-background-90); /* secondary sidebar bg */
-    --color-sidebar-background-80: var(--color-background-80); /* tertiary sidebar bg */
-
-    --color-sidebar-text-100: var(--color-text-100); /* primary sidebar text */
-    --color-sidebar-text-200: var(--color-text-200); /* secondary sidebar text */
-    --color-sidebar-text-300: var(--color-text-300); /* tertiary sidebar text */
-    --color-sidebar-text-400: var(--color-text-400); /* sidebar placeholder text */
-
-    --color-sidebar-border-100: var(--color-border-100); /* subtle sidebar border= 1 */
-    --color-sidebar-border-200: var(--color-border-100); /* subtle sidebar border- 2 */
-    --color-sidebar-border-300: var(--color-border-100); /* strong sidebar border- 1 */
-    --color-sidebar-border-400: var(--color-border-100); /* strong sidebar border- 2 */
-
-    --color-sidebar-shadow-2xs: var(--color-shadow-2xs);
-    --color-sidebar-shadow-xs: var(--color-shadow-xs);
-    --color-sidebar-shadow-sm: var(--color-shadow-sm);
-    --color-sidebar-shadow-rg: var(--color-shadow-rg);
-    --color-sidebar-shadow-md: var(--color-shadow-md);
-    --color-sidebar-shadow-lg: var(--color-shadow-lg);
-    --color-sidebar-shadow-xl: var(--color-shadow-xl);
-    --color-sidebar-shadow-2xl: var(--color-shadow-2xl);
-    --color-sidebar-shadow-3xl: var(--color-shadow-3xl);
-    --color-sidebar-shadow-4xl: var(--color-shadow-4xl);
-  }
-
-  [data-theme="light"],
-  [data-theme="light-contrast"] {
-    color-scheme: light !important;
-
-    --color-background-100: 255, 255, 255; /* primary bg */
-    --color-background-90: 247, 247, 247; /* secondary bg */
-    --color-background-80: 232, 232, 232; /* tertiary bg */
-  }
-
-  [data-theme="light"] {
-    --color-text-100: 23, 23, 23; /* primary text */
-    --color-text-200: 58, 58, 58; /* secondary text */
-    --color-text-300: 82, 82, 82; /* tertiary text */
-    --color-text-400: 163, 163, 163; /* placeholder text */
-
-    --color-scrollbar: 163, 163, 163; /* scrollbar thumb */
-
-    --color-border-100: 245, 245, 245; /* subtle border= 1 */
-    --color-border-200: 229, 229, 229; /* subtle border- 2 */
-    --color-border-300: 212, 212, 212; /* strong border- 1 */
-    --color-border-400: 185, 185, 185; /* strong border- 2 */
-
-    /* onboarding colors */
-    --gradient-onboarding-100: linear-gradient(106deg, #f2f6ff 29.8%, #e1eaff 99.34%);
-    --gradient-onboarding-200: linear-gradient(129deg, rgba(255, 255, 255, 0) -22.23%, rgba(255, 255, 255, 0.8) 62.98%);
-    --gradient-onboarding-300: linear-gradient(164deg, #fff 4.25%, rgba(255, 255, 255, 0.06) 93.5%);
-    --gradient-onboarding-400: linear-gradient(129deg, rgba(255, 255, 255, 0) -22.23%, rgba(255, 255, 255, 0.8) 62.98%);
-
-    --color-onboarding-text-100: 23, 23, 23;
-    --color-onboarding-text-200: 58, 58, 58;
-    --color-onboarding-text-300: 82, 82, 82;
-    --color-onboarding-text-400: 163, 163, 163;
-
-    --color-onboarding-background-100: 236, 241, 255;
-    --color-onboarding-background-200: 255, 255, 255;
-    --color-onboarding-background-300: 236, 241, 255;
-    --color-onboarding-background-400: 177, 206, 250;
-
-    --color-onboarding-border-100: 229, 229, 229;
-    --color-onboarding-border-200: 217, 228, 255;
-    --color-onboarding-border-300: 229, 229, 229, 0.5;
-
-    --color-onboarding-shadow-sm: 0px 4px 20px 0px rgba(126, 139, 171, 0.1);
-
-    /* toast theme */
-    --color-toast-success-text: 62, 155, 79;
-    --color-toast-error-text: 220, 62, 66;
-    --color-toast-warning-text: 255, 186, 24;
-    --color-toast-info-text: 51, 88, 212;
-    --color-toast-loading-text: 28, 32, 36;
-    --color-toast-secondary-text: 128, 131, 141;
-    --color-toast-tertiary-text: 96, 100, 108;
-
-    --color-toast-success-background: 253, 253, 254;
-    --color-toast-error-background: 255, 252, 252;
-    --color-toast-warning-background: 254, 253, 251;
-    --color-toast-info-background: 253, 253, 254;
-    --color-toast-loading-background: 253, 253, 254;
-
-    --color-toast-success-border: 218, 241, 219;
-    --color-toast-error-border: 255, 219, 220;
-    --color-toast-warning-border: 255, 247, 194;
-    --color-toast-info-border: 210, 222, 255;
-    --color-toast-loading-border: 224, 225, 230;
-  }
-
-  [data-theme="light-contrast"] {
-    --color-text-100: 11, 11, 11; /* primary text */
-    --color-text-200: 38, 38, 38; /* secondary text */
-    --color-text-300: 58, 58, 58; /* tertiary text */
-    --color-text-400: 115, 115, 115; /* placeholder text */
-
-    --color-scrollbar: 115, 115, 115; /* scrollbar thumb */
-
-    --color-border-100: 34, 34, 34; /* subtle border= 1 */
-    --color-border-200: 38, 38, 38; /* subtle border- 2 */
-    --color-border-300: 46, 46, 46; /* strong border- 1 */
-    --color-border-400: 58, 58, 58; /* strong border- 2 */
-  }
-
-  [data-theme="dark"],
-  [data-theme="dark-contrast"] {
-    color-scheme: dark !important;
-
-    --color-background-100: 25, 25, 25; /* primary bg */
-    --color-background-90: 32, 32, 32; /* secondary bg */
-    --color-background-80: 44, 44, 44; /* tertiary bg */
-
-    --color-shadow-2xs: 0px 0px 1px 0px rgba(0, 0, 0, 0.15), 0px 1px 3px 0px rgba(0, 0, 0, 0.5);
-    --color-shadow-xs: 0px 0px 2px 0px rgba(0, 0, 0, 0.2), 0px 2px 4px 0px rgba(0, 0, 0, 0.5);
-    --color-shadow-sm: 0px 0px 4px 0px rgba(0, 0, 0, 0.2), 0px 2px 6px 0px rgba(0, 0, 0, 0.5);
-    --color-shadow-rg: 0px 0px 6px 0px rgba(0, 0, 0, 0.2), 0px 4px 6px 0px rgba(0, 0, 0, 0.5);
-    --color-shadow-md: 0px 2px 8px 0px rgba(0, 0, 0, 0.2), 0px 4px 8px 0px rgba(0, 0, 0, 0.5);
-    --color-shadow-lg: 0px 4px 12px 0px rgba(0, 0, 0, 0.25), 0px 4px 10px 0px rgba(0, 0, 0, 0.55);
-    --color-shadow-xl: 0px 0px 14px 0px rgba(0, 0, 0, 0.25), 0px 6px 10px 0px rgba(0, 0, 0, 0.55);
-    --color-shadow-2xl: 0px 0px 18px 0px rgba(0, 0, 0, 0.25), 0px 8px 12px 0px rgba(0, 0, 0, 0.6);
-    --color-shadow-3xl: 0px 4px 24px 0px rgba(0, 0, 0, 0.3), 0px 12px 40px 0px rgba(0, 0, 0, 0.65);
-  }
-
-  [data-theme="dark"] {
-    --color-text-100: 229, 229, 229; /* primary text */
-    --color-text-200: 163, 163, 163; /* secondary text */
-    --color-text-300: 115, 115, 115; /* tertiary text */
-    --color-text-400: 82, 82, 82; /* placeholder text */
-
-    --color-scrollbar: 82, 82, 82; /* scrollbar thumb */
-
-    --color-border-100: 34, 34, 34; /* subtle border= 1 */
-    --color-border-200: 38, 38, 38; /* subtle border- 2 */
-    --color-border-300: 46, 46, 46; /* strong border- 1 */
-    --color-border-400: 58, 58, 58; /* strong border- 2 */
-
-    /* onboarding colors */
-    --gradient-onboarding-100: linear-gradient(106deg, #18191b 25.17%, #18191b 99.34%);
-    --gradient-onboarding-200: linear-gradient(129deg, rgba(47, 49, 53, 0.8) -22.23%, rgba(33, 34, 37, 0.8) 62.98%);
-    --gradient-onboarding-300: linear-gradient(167deg, rgba(47, 49, 53, 0.45) 19.22%, #212225 98.48%);
-
-    --color-onboarding-text-100: 237, 238, 240;
-    --color-onboarding-text-200: 176, 180, 187;
-    --color-onboarding-text-300: 118, 123, 132;
-    --color-onboarding-text-400: 105, 110, 119;
-
-    --color-onboarding-background-100: 54, 58, 64;
-    --color-onboarding-background-200: 40, 42, 45;
-    --color-onboarding-background-300: 40, 42, 45;
-    --color-onboarding-background-400: 67, 72, 79;
-
-    --color-onboarding-border-100: 54, 58, 64;
-    --color-onboarding-border-200: 54, 58, 64;
-    --color-onboarding-border-300: 34, 35, 38, 0.5;
-
-    --color-onboarding-shadow-sm: 0px 4px 20px 0px rgba(39, 44, 56, 0.1);
-
-    /* toast theme */
-    --color-toast-success-text: 178, 221, 181;
-    --color-toast-error-text: 206, 44, 49;
-    --color-toast-warning-text: 255, 186, 24;
-    --color-toast-info-text: 141, 164, 239;
-    --color-toast-loading-text: 255, 255, 255;
-    --color-toast-secondary-text: 185, 187, 198;
-    --color-toast-tertiary-text: 139, 141, 152;
-
-    --color-toast-success-background: 46, 46, 46;
-    --color-toast-error-background: 46, 46, 46;
-    --color-toast-warning-background: 46, 46, 46;
-    --color-toast-info-background: 46, 46, 46;
-    --color-toast-loading-background: 46, 46, 46;
-
-    --color-toast-success-border: 42, 126, 59;
-    --color-toast-error-border: 100, 23, 35;
-    --color-toast-warning-border: 79, 52, 34;
-    --color-toast-info-border: 58, 91, 199;
-    --color-toast-loading-border: 96, 100, 108;
-  }
-
-  [data-theme="dark-contrast"] {
-    --color-text-100: 250, 250, 250; /* primary text */
-    --color-text-200: 241, 241, 241; /* secondary text */
-    --color-text-300: 212, 212, 212; /* tertiary text */
-    --color-text-400: 115, 115, 115; /* placeholder text */
-
-    --color-scrollbar: 115, 115, 115; /* scrollbar thumb */
-
-    --color-border-100: 245, 245, 245; /* subtle border= 1 */
-    --color-border-200: 229, 229, 229; /* subtle border- 2 */
-    --color-border-300: 212, 212, 212; /* strong border- 1 */
-    --color-border-400: 185, 185, 185; /* strong border- 2 */
-  }
-
-  [data-theme="light"],
-  [data-theme="dark"],
-  [data-theme="light-contrast"],
-  [data-theme="dark-contrast"] {
-    --color-primary-10: 236, 241, 255;
-    --color-primary-20: 217, 228, 255;
-    --color-primary-30: 197, 214, 255;
-    --color-primary-40: 178, 200, 255;
-    --color-primary-50: 159, 187, 255;
-    --color-primary-60: 140, 173, 255;
-    --color-primary-70: 121, 159, 255;
-    --color-primary-80: 101, 145, 255;
-    --color-primary-90: 82, 132, 255;
-    --color-primary-100: 63, 118, 255;
-    --color-primary-200: 57, 106, 230;
-    --color-primary-300: 50, 94, 204;
-    --color-primary-400: 44, 83, 179;
-    --color-primary-500: 38, 71, 153;
-    --color-primary-600: 32, 59, 128;
-    --color-primary-700: 25, 47, 102;
-    --color-primary-800: 19, 35, 76;
-    --color-primary-900: 13, 24, 51;
-
-    --color-sidebar-background-100: var(--color-background-100); /* primary sidebar bg */
-    --color-sidebar-background-90: var(--color-background-90); /* secondary sidebar bg */
-    --color-sidebar-background-80: var(--color-background-80); /* tertiary sidebar bg */
-
-    --color-sidebar-text-100: var(--color-text-100); /* primary sidebar text */
-    --color-sidebar-text-200: var(--color-text-200); /* secondary sidebar text */
-    --color-sidebar-text-300: var(--color-text-300); /* tertiary sidebar text */
-    --color-sidebar-text-400: var(--color-text-400); /* sidebar placeholder text */
-
-    --color-sidebar-border-100: var(--color-border-100); /* subtle sidebar border= 1 */
-    --color-sidebar-border-200: var(--color-border-200); /* subtle sidebar border- 2 */
-    --color-sidebar-border-300: var(--color-border-300); /* strong sidebar border- 1 */
-    --color-sidebar-border-400: var(--color-border-400); /* strong sidebar border- 2 */
-  }
-}
-
-* {
-  margin: 0;
-  padding: 0;
-  box-sizing: border-box;
-  -webkit-text-size-adjust: 100%;
-  -ms-text-size-adjust: 100%;
-  font-variant-ligatures: none;
-  -webkit-font-variant-ligatures: none;
-  text-rendering: optimizeLegibility;
-  -moz-osx-font-smoothing: grayscale;
-  -webkit-font-smoothing: antialiased;
-}
-
-body {
-  color: rgba(var(--color-text-100));
-}
-
-/* scrollbar style */
-@-moz-document url-prefix() {
-  * {
-    scrollbar-width: none;
-  }
-  .vertical-scrollbar,
-  .horizontal-scrollbar {
-    scrollbar-width: initial;
-    scrollbar-color: rgba(96, 100, 108, 0.1) transparent;
-  }
-  .vertical-scrollbar:hover,
-  .horizontal-scrollbar:hover {
-    scrollbar-color: rgba(96, 100, 108, 0.25) transparent;
-  }
-  .vertical-scrollbar:active,
-  .horizontal-scrollbar:active {
-    scrollbar-color: rgba(96, 100, 108, 0.7) transparent;
-  }
-}
-
-.vertical-scrollbar {
-  overflow-y: auto;
-}
-.horizontal-scrollbar {
-  overflow-x: auto;
-}
-.vertical-scrollbar::-webkit-scrollbar,
-.horizontal-scrollbar::-webkit-scrollbar {
-  display: block;
-}
-.vertical-scrollbar::-webkit-scrollbar-track,
-.horizontal-scrollbar::-webkit-scrollbar-track {
-  background-color: transparent;
-  border-radius: 9999px;
-}
-.vertical-scrollbar::-webkit-scrollbar-thumb,
-.horizontal-scrollbar::-webkit-scrollbar-thumb {
-  background-clip: padding-box;
-  background-color: rgba(96, 100, 108, 0.1);
-  border-radius: 9999px;
-}
-.vertical-scrollbar:hover::-webkit-scrollbar-thumb,
-.horizontal-scrollbar:hover::-webkit-scrollbar-thumb {
-  background-color: rgba(96, 100, 108, 0.25);
-}
-.vertical-scrollbar::-webkit-scrollbar-thumb:hover,
-.horizontal-scrollbar::-webkit-scrollbar-thumb:hover {
-  background-color: rgba(96, 100, 108, 0.5);
-}
-.vertical-scrollbar::-webkit-scrollbar-thumb:active,
-.horizontal-scrollbar::-webkit-scrollbar-thumb:active {
-  background-color: rgba(96, 100, 108, 0.7);
-}
-.vertical-scrollbar::-webkit-scrollbar-corner,
-.horizontal-scrollbar::-webkit-scrollbar-corner {
-  background-color: transparent;
-}
-.vertical-scrollbar-margin-top-md::-webkit-scrollbar-track {
-  margin-top: 44px;
-}
-
-/* scrollbar sm size */
-.scrollbar-sm::-webkit-scrollbar {
-  height: 12px;
-  width: 12px;
-}
-.scrollbar-sm::-webkit-scrollbar-thumb {
-  border: 3px solid rgba(0, 0, 0, 0);
-}
-/* scrollbar md size */
-.scrollbar-md::-webkit-scrollbar {
-  height: 14px;
-  width: 14px;
-}
-.scrollbar-md::-webkit-scrollbar-thumb {
-  border: 3px solid rgba(0, 0, 0, 0);
-}
-/* scrollbar lg size */
-
-.scrollbar-lg::-webkit-scrollbar {
-  height: 16px;
-  width: 16px;
-}
-.scrollbar-lg::-webkit-scrollbar-thumb {
-  border: 4px solid rgba(0, 0, 0, 0);
-}
-/* end scrollbar style */
-
-/* progress bar */
-.progress-bar {
-  fill: currentColor;
-  color: rgba(var(--color-sidebar-background-100));
-}
-
-::-webkit-input-placeholder,
-::placeholder,
-:-ms-input-placeholder {
-  color: rgb(var(--color-text-400));
-}
@@ -1,49 +0,0 @@
-"use client";
-
-import { ReactNode } from "react";
-import { ThemeProvider, useTheme } from "next-themes";
-import { SWRConfig } from "swr";
-// ui
-import { ADMIN_BASE_PATH, DEFAULT_SWR_CONFIG } from "@plane/constants";
-import { Toast } from "@plane/ui";
-import { resolveGeneralTheme } from "@plane/utils";
-// constants
-// helpers
-// lib
-import { InstanceProvider } from "@/lib/instance-provider";
-import { StoreProvider } from "@/lib/store-provider";
-import { UserProvider } from "@/lib/user-provider";
-// styles
-import "./globals.css";
-
-const ToastWithTheme = () => {
-  const { resolvedTheme } = useTheme();
-  return <Toast theme={resolveGeneralTheme(resolvedTheme)} />;
-};
-
-export default function RootLayout({ children }: { children: ReactNode }) {
-  const ASSET_PREFIX = ADMIN_BASE_PATH;
-  return (
-    <html lang="en">
-      <head>
-        <link rel="apple-touch-icon" sizes="180x180" href={`${ASSET_PREFIX}/favicon/apple-touch-icon.png`} />
-        <link rel="icon" type="image/png" sizes="32x32" href={`${ASSET_PREFIX}/favicon/favicon-32x32.png`} />
-        <link rel="icon" type="image/png" sizes="16x16" href={`${ASSET_PREFIX}/favicon/favicon-16x16.png`} />
-        <link rel="manifest" href={`${ASSET_PREFIX}/site.webmanifest.json`} />
-        <link rel="shortcut icon" href={`${ASSET_PREFIX}/favicon/favicon.ico`} />
-      </head>
-      <body className={`antialiased`}>
-        <ThemeProvider themes={["light", "dark"]} defaultTheme="system" enableSystem>
-          <ToastWithTheme />
-          <SWRConfig value={DEFAULT_SWR_CONFIG}>
-            <StoreProvider>
-              <InstanceProvider>
-                <UserProvider>{children}</UserProvider>
-              </InstanceProvider>
-            </StoreProvider>
-          </SWRConfig>
-        </ThemeProvider>
-      </body>
-    </html>
-  );
-}
@@ -1,30 +0,0 @@
-import { Metadata } from "next";
-// components
-import { InstanceSignInForm } from "@/components/login";
-// layouts
-import { DefaultLayout } from "@/layouts/default-layout";
-
-export const metadata: Metadata = {
-  title: "Plane | Simple, extensible, open-source project management tool.",
-  description:
-    "Open-source project management tool to manage issues, sprints, and product roadmaps with peace of mind.",
-  openGraph: {
-    title: "Plane | Simple, extensible, open-source project management tool.",
-    description:
-      "Open-source project management tool to manage issues, sprints, and product roadmaps with peace of mind.",
-    url: "https://plane.so/",
-  },
-  keywords:
-    "software development, customer feedback, software, accelerate, code management, release management, project management, issue tracking, agile, scrum, kanban, collaboration",
-  twitter: {
-    site: "@planepowers",
-  },
-};
-
-export default async function LoginPage() {
-  return (
-    <DefaultLayout>
-      <InstanceSignInForm />
-    </DefaultLayout>
-  );
-}
@@ -1,212 +0,0 @@
-import { useState, useEffect } from "react";
-import Link from "next/link";
-import { useRouter } from "next/navigation";
-import { Controller, useForm } from "react-hook-form";
-// constants
-import { WEB_BASE_URL, ORGANIZATION_SIZE, RESTRICTED_URLS } from "@plane/constants";
-// types
-import { IWorkspace } from "@plane/types";
-// components
-import { Button, CustomSelect, getButtonStyling, Input, setToast, TOAST_TYPE } from "@plane/ui";
-// hooks
-import { useWorkspace } from "@/hooks/store";
-// services
-import { WorkspaceService } from "@/services/workspace.service";
-
-const workspaceService = new WorkspaceService();
-
-export const WorkspaceCreateForm = () => {
-  // router
-  const router = useRouter();
-  // states
-  const [slugError, setSlugError] = useState(false);
-  const [invalidSlug, setInvalidSlug] = useState(false);
-  const [defaultValues, setDefaultValues] = useState<Partial<IWorkspace>>({
-    name: "",
-    slug: "",
-    organization_size: "",
-  });
-  // store hooks
-  const { createWorkspace } = useWorkspace();
-  // form info
-  const {
-    handleSubmit,
-    control,
-    setValue,
-    getValues,
-    formState: { errors, isSubmitting, isValid },
-  } = useForm<IWorkspace>({ defaultValues, mode: "onChange" });
-  // derived values
-  const workspaceBaseURL = encodeURI(WEB_BASE_URL || window.location.origin + "/");
-
-  const handleCreateWorkspace = async (formData: IWorkspace) => {
-    await workspaceService
-      .workspaceSlugCheck(formData.slug)
-      .then(async (res) => {
-        if (res.status === true && !RESTRICTED_URLS.includes(formData.slug)) {
-          setSlugError(false);
-          await createWorkspace(formData)
-            .then(async () => {
-              setToast({
-                type: TOAST_TYPE.SUCCESS,
-                title: "Success!",
-                message: "Workspace created successfully.",
-              });
-              router.push(`/workspace`);
-            })
-            .catch(() => {
-              setToast({
-                type: TOAST_TYPE.ERROR,
-                title: "Error!",
-                message: "Workspace could not be created. Please try again.",
-              });
-            });
-        } else setSlugError(true);
-      })
-      .catch(() => {
-        setToast({
-          type: TOAST_TYPE.ERROR,
-          title: "Error!",
-          message: "Some error occurred while creating workspace. Please try again.",
-        });
-      });
-  };
-
-  useEffect(
-    () => () => {
-      // when the component unmounts set the default values to whatever user typed in
-      setDefaultValues(getValues());
-    },
-    [getValues, setDefaultValues]
-  );
-
-  return (
-    <div className="space-y-8">
-      <div className="grid-col grid w-full max-w-4xl grid-cols-1 items-start justify-between gap-x-10 gap-y-6 lg:grid-cols-2">
-        <div className="flex flex-col gap-1">
-          <h4 className="text-sm text-custom-text-300">Name your workspace</h4>
-          <div className="flex flex-col gap-1">
-            <Controller
-              control={control}
-              name="name"
-              rules={{
-                required: "This is a required field.",
-                validate: (value) =>
-                  /^[\w\s-]*$/.test(value) ||
-                  `Workspaces names can contain only (" "), ( - ), ( _ ) and alphanumeric characters.`,
-                maxLength: {
-                  value: 80,
-                  message: "Limit your name to 80 characters.",
-                },
-              }}
-              render={({ field: { value, ref, onChange } }) => (
-                <Input
-                  id="workspaceName"
-                  type="text"
-                  value={value}
-                  onChange={(e) => {
-                    onChange(e.target.value);
-                    setValue("name", e.target.value);
-                    setValue("slug", e.target.value.toLocaleLowerCase().trim().replace(/ /g, "-"), {
-                      shouldValidate: true,
-                    });
-                  }}
-                  ref={ref}
-                  hasError={Boolean(errors.name)}
-                  placeholder="Something familiar and recognizable is always best."
-                  className="w-full"
-                />
-              )}
-            />
-            <span className="text-xs text-red-500">{errors?.name?.message}</span>
-          </div>
-        </div>
-        <div className="flex flex-col gap-1">
-          <h4 className="text-sm text-custom-text-300">Set your workspace&apos;s URL</h4>
-          <div className="flex gap-0.5 w-full items-center rounded-md border-[0.5px] border-custom-border-200 px-3">
-            <span className="whitespace-nowrap text-sm text-custom-text-200">{workspaceBaseURL}</span>
-            <Controller
-              control={control}
-              name="slug"
-              rules={{
-                required: "The URL is a required field.",
-                maxLength: {
-                  value: 48,
-                  message: "Limit your URL to 48 characters.",
-                },
-              }}
-              render={({ field: { onChange, value, ref } }) => (
-                <Input
-                  id="workspaceUrl"
-                  type="text"
-                  value={value.toLocaleLowerCase().trim().replace(/ /g, "-")}
-                  onChange={(e) => {
-                    if (/^[a-zA-Z0-9_-]+$/.test(e.target.value)) setInvalidSlug(false);
-                    else setInvalidSlug(true);
-                    onChange(e.target.value.toLowerCase());
-                  }}
-                  ref={ref}
-                  hasError={Boolean(errors.slug)}
-                  placeholder="workspace-name"
-                  className="block w-full rounded-md border-none bg-transparent !px-0 py-2 text-sm"
-                />
-              )}
-            />
-          </div>
-          {slugError && <p className="text-sm text-red-500">This URL is taken. Try something else.</p>}
-          {invalidSlug && (
-            <p className="text-sm text-red-500">{`URLs can contain only ( - ), ( _ ) and alphanumeric characters.`}</p>
-          )}
-          {errors.slug && <span className="text-xs text-red-500">{errors.slug.message}</span>}
-        </div>
-        <div className="flex flex-col gap-1">
-          <h4 className="text-sm text-custom-text-300">How many people will use this workspace?</h4>
-          <div className="w-full">
-            <Controller
-              name="organization_size"
-              control={control}
-              rules={{ required: "This is a required field." }}
-              render={({ field: { value, onChange } }) => (
-                <CustomSelect
-                  value={value}
-                  onChange={onChange}
-                  label={
-                    ORGANIZATION_SIZE.find((c) => c === value) ?? (
-                      <span className="text-custom-text-400">Select a range</span>
-                    )
-                  }
-                  buttonClassName="!border-[0.5px] !border-custom-border-200 !shadow-none"
-                  input
-                  optionsClassName="w-full"
-                >
-                  {ORGANIZATION_SIZE.map((item) => (
-                    <CustomSelect.Option key={item} value={item}>
-                      {item}
-                    </CustomSelect.Option>
-                  ))}
-                </CustomSelect>
-              )}
-            />
-            {errors.organization_size && (
-              <span className="text-sm text-red-500">{errors.organization_size.message}</span>
-            )}
-          </div>
-        </div>
-      </div>
-      <div className="flex max-w-4xl items-center py-1 gap-4">
-        <Button
-          variant="primary"
-          size="sm"
-          onClick={handleSubmit(handleCreateWorkspace)}
-          disabled={!isValid}
-          loading={isSubmitting}
-        >
-          {isSubmitting ? "Creating workspace" : "Create workspace"}
-        </Button>
-        <Link className={getButtonStyling("neutral-primary", "sm")} href="/workspace">
-          Go back
-        </Link>
-      </div>
-    </div>
-  );
-};
@@ -1,29 +0,0 @@
-import { FC } from "react";
-import { Info, X } from "lucide-react";
-// plane constants
-import { TAuthErrorInfo } from "@plane/constants";
-
-type TAuthBanner = {
-  bannerData: TAuthErrorInfo | undefined;
-  handleBannerData?: (bannerData: TAuthErrorInfo | undefined) => void;
-};
-
-export const AuthBanner: FC<TAuthBanner> = (props) => {
-  const { bannerData, handleBannerData } = props;
-
-  if (!bannerData) return <></>;
-  return (
-    <div className="relative flex items-center p-2 rounded-md gap-2 border border-custom-primary-100/50 bg-custom-primary-100/10">
-      <div className="w-4 h-4 flex-shrink-0 relative flex justify-center items-center">
-        <Info size={16} className="text-custom-primary-100" />
-      </div>
-      <div className="w-full text-sm font-medium text-custom-primary-100">{bannerData?.message}</div>
-      <div
-        className="relative ml-auto w-6 h-6 rounded-sm flex justify-center items-center transition-all cursor-pointer hover:bg-custom-primary-100/20 text-custom-primary-100/80"
-        onClick={() => handleBannerData && handleBannerData(undefined)}
-      >
-        <X className="w-4 h-4 flex-shrink-0" />
-      </div>
-    </div>
-  );
-};
@@ -1,53 +0,0 @@
-import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
-// store
-// import { rootStore } from "@/lib/store-context";
-
-export abstract class APIService {
-  protected baseURL: string;
-  private axiosInstance: AxiosInstance;
-
-  constructor(baseURL: string) {
-    this.baseURL = baseURL;
-    this.axiosInstance = axios.create({
-      baseURL,
-      withCredentials: true,
-    });
-
-    this.setupInterceptors();
-  }
-
-  private setupInterceptors() {
-    // this.axiosInstance.interceptors.response.use(
-    //   (response) => response,
-    //   (error) => {
-    //     const store = rootStore;
-    //     if (error.response && error.response.status === 401 && store.user.currentUser) store.user.reset();
-    //     return Promise.reject(error);
-    //   }
-    // );
-  }
-
-  get<ResponseType>(url: string, params = {}): Promise<AxiosResponse<ResponseType>> {
-    return this.axiosInstance.get(url, { params });
-  }
-
-  post<RequestType, ResponseType>(url: string, data: RequestType, config = {}): Promise<AxiosResponse<ResponseType>> {
-    return this.axiosInstance.post(url, data, config);
-  }
-
-  put<RequestType, ResponseType>(url: string, data: RequestType, config = {}): Promise<AxiosResponse<ResponseType>> {
-    return this.axiosInstance.put(url, data, config);
-  }
-
-  patch<RequestType, ResponseType>(url: string, data: RequestType, config = {}): Promise<AxiosResponse<ResponseType>> {
-    return this.axiosInstance.patch(url, data, config);
-  }
-
-  delete<RequestType>(url: string, data?: RequestType, config = {}) {
-    return this.axiosInstance.delete(url, { data, ...config });
-  }
-
-  request<T>(config: AxiosRequestConfig = {}): Promise<AxiosResponse<T>> {
-    return this.axiosInstance(config);
-  }
-}
@@ -1,21 +0,0 @@
-import { API_BASE_URL } from "@plane/constants";
-// services
-import { APIService } from "@/services/api.service";
-
-type TCsrfTokenResponse = {
-  csrf_token: string;
-};
-
-export class AuthService extends APIService {
-  constructor() {
-    super(API_BASE_URL);
-  }
-
-  async requestCSRFToken(): Promise<TCsrfTokenResponse> {
-    return this.get<TCsrfTokenResponse>("/auth/get-csrf-token/")
-      .then((response) => response.data)
-      .catch((error) => {
-        throw error;
-      });
-  }
-}
@@ -1,72 +0,0 @@
-// plane internal packages
-import { API_BASE_URL } from "@plane/constants";
-import type {
-  IFormattedInstanceConfiguration,
-  IInstance,
-  IInstanceAdmin,
-  IInstanceConfiguration,
-  IInstanceInfo,
-} from "@plane/types";
-// helpers
-import { APIService } from "@/services/api.service";
-
-export class InstanceService extends APIService {
-  constructor() {
-    super(API_BASE_URL);
-  }
-
-  async getInstanceInfo(): Promise<IInstanceInfo> {
-    return this.get<IInstanceInfo>("/api/instances/")
-      .then((response) => response.data)
-      .catch((error) => {
-        throw error?.response?.data;
-      });
-  }
-
-  async getInstanceAdmins(): Promise<IInstanceAdmin[]> {
-    return this.get<IInstanceAdmin[]>("/api/instances/admins/")
-      .then((response) => response.data)
-      .catch((error) => {
-        throw error;
-      });
-  }
-
-  async updateInstanceInfo(data: Partial<IInstance>): Promise<IInstance> {
-    return this.patch<Partial<IInstance>, IInstance>("/api/instances/", data)
-      .then((response) => response?.data)
-      .catch((error) => {
-        throw error?.response?.data;
-      });
-  }
-
-  async getInstanceConfigurations() {
-    return this.get<IInstanceConfiguration[]>("/api/instances/configurations/")
-      .then((response) => response.data)
-      .catch((error) => {
-        throw error;
-      });
-  }
-
-  async updateInstanceConfigurations(
-    data: Partial<IFormattedInstanceConfiguration>
-  ): Promise<IInstanceConfiguration[]> {
-    return this.patch<Partial<IFormattedInstanceConfiguration>, IInstanceConfiguration[]>(
-      "/api/instances/configurations/",
-      data
-    )
-      .then((response) => response?.data)
-      .catch((error) => {
-        throw error?.response?.data;
-      });
-  }
-
-  async sendTestEmail(receiverEmail: string): Promise<undefined> {
-    return this.post<{ receiver_email: string }, undefined>("/api/instances/email-credentials-check/", {
-      receiver_email: receiverEmail,
-    })
-      .then((response) => response?.data)
-      .catch((error) => {
-        throw error?.response?.data;
-      });
-  }
-}
@@ -1,29 +0,0 @@
-// plane internal packages
-import { API_BASE_URL } from "@plane/constants";
-import type { IUser } from "@plane/types";
-// services
-import { APIService } from "@/services/api.service";
-
-interface IUserSession extends IUser {
-  isAuthenticated: boolean;
-}
-
-export class UserService extends APIService {
-  constructor() {
-    super(API_BASE_URL);
-  }
-
-  async authCheck(): Promise<IUserSession> {
-    return this.get<any>("/api/instances/admins/me/")
-      .then((response) => ({ ...response?.data, isAuthenticated: true }))
-      .catch(() => ({ isAuthenticated: false }));
-  }
-
-  async currentUser(): Promise<IUser> {
-    return this.get<IUser>("/api/instances/admins/me/")
-      .then((response) => response?.data)
-      .catch((error) => {
-        throw error?.response;
-      });
-  }
-}
@@ -1,52 +0,0 @@
-// plane internal packages
-import { API_BASE_URL } from "@plane/constants";
-import type { IWorkspace, TWorkspacePaginationInfo } from "@plane/types";
-// services
-import { APIService } from "@/services/api.service";
-
-export class WorkspaceService extends APIService {
-  constructor() {
-    super(API_BASE_URL);
-  }
-
-  /**
-   * @description Fetches all workspaces
-   * @returns Promise<TWorkspacePaginationInfo>
-   */
-  async getWorkspaces(nextPageCursor?: string): Promise<TWorkspacePaginationInfo> {
-    return this.get<TWorkspacePaginationInfo>("/api/instances/workspaces/", {
-      cursor: nextPageCursor,
-    })
-      .then((response) => response.data)
-      .catch((error) => {
-        throw error?.response?.data;
-      });
-  }
-
-  /**
-   * @description Checks if a slug is available
-   * @param slug - string
-   * @returns Promise<any>
-   */
-  async workspaceSlugCheck(slug: string): Promise<any> {
-    const params = new URLSearchParams({ slug });
-    return this.get(`/api/instances/workspace-slug-check/?${params.toString()}`)
-      .then((response) => response?.data)
-      .catch((error) => {
-        throw error?.response?.data;
-      });
-  }
-
-  /**
-   * @description Creates a new workspace
-   * @param data - IWorkspace
-   * @returns Promise<IWorkspace>
-   */
-  async createWorkspace(data: IWorkspace): Promise<IWorkspace> {
-    return this.post<IWorkspace, IWorkspace>("/api/instances/workspaces/", data)
-      .then((response) => response.data)
-      .catch((error) => {
-        throw error?.response?.data;
-      });
-  }
-}
@@ -1,191 +0,0 @@
-import set from "lodash/set";
-import { observable, action, computed, makeObservable, runInAction } from "mobx";
-// plane internal packages
-import { EInstanceStatus, TInstanceStatus } from "@plane/constants";
-import {
-  IInstance,
-  IInstanceAdmin,
-  IInstanceConfiguration,
-  IFormattedInstanceConfiguration,
-  IInstanceInfo,
-  IInstanceConfig,
-} from "@plane/types";
-// services
-import { InstanceService } from "@/services/instance.service";
-// root store
-import { CoreRootStore } from "@/store/root.store";
-
-export interface IInstanceStore {
-  // issues
-  isLoading: boolean;
-  error: any;
-  instanceStatus: TInstanceStatus | undefined;
-  instance: IInstance | undefined;
-  config: IInstanceConfig | undefined;
-  instanceAdmins: IInstanceAdmin[] | undefined;
-  instanceConfigurations: IInstanceConfiguration[] | undefined;
-  // computed
-  formattedConfig: IFormattedInstanceConfiguration | undefined;
-  // action
-  hydrate: (data: IInstanceInfo) => void;
-  fetchInstanceInfo: () => Promise<IInstanceInfo | undefined>;
-  updateInstanceInfo: (data: Partial<IInstance>) => Promise<IInstance | undefined>;
-  fetchInstanceAdmins: () => Promise<IInstanceAdmin[] | undefined>;
-  fetchInstanceConfigurations: () => Promise<IInstanceConfiguration[] | undefined>;
-  updateInstanceConfigurations: (data: Partial<IFormattedInstanceConfiguration>) => Promise<IInstanceConfiguration[]>;
-}
-
-export class InstanceStore implements IInstanceStore {
-  isLoading: boolean = true;
-  error: any = undefined;
-  instanceStatus: TInstanceStatus | undefined = undefined;
-  instance: IInstance | undefined = undefined;
-  config: IInstanceConfig | undefined = undefined;
-  instanceAdmins: IInstanceAdmin[] | undefined = undefined;
-  instanceConfigurations: IInstanceConfiguration[] | undefined = undefined;
-  // service
-  instanceService;
-
-  constructor(private store: CoreRootStore) {
-    makeObservable(this, {
-      // observable
-      isLoading: observable.ref,
-      error: observable.ref,
-      instanceStatus: observable,
-      instance: observable,
-      instanceAdmins: observable,
-      instanceConfigurations: observable,
-      // computed
-      formattedConfig: computed,
-      // actions
-      hydrate: action,
-      fetchInstanceInfo: action,
-      fetchInstanceAdmins: action,
-      updateInstanceInfo: action,
-      fetchInstanceConfigurations: action,
-      updateInstanceConfigurations: action,
-    });
-
-    this.instanceService = new InstanceService();
-  }
-
-  hydrate = (data: IInstanceInfo) => {
-    if (data) {
-      this.instance = data.instance;
-      this.config = data.config;
-    }
-  };
-
-  /**
-   * computed value for instance configurations data for forms.
-   * @returns configurations in the form of {key, value} pair.
-   */
-  get formattedConfig() {
-    if (!this.instanceConfigurations) return undefined;
-    return this.instanceConfigurations?.reduce((formData: IFormattedInstanceConfiguration, config) => {
-      formData[config.key] = config.value;
-      return formData;
-    }, {} as IFormattedInstanceConfiguration);
-  }
-
-  /**
-   * @description fetching instance configuration
-   * @returns {IInstance} instance
-   */
-  fetchInstanceInfo = async () => {
-    try {
-      if (this.instance === undefined) this.isLoading = true;
-      this.error = undefined;
-      const instanceInfo = await this.instanceService.getInstanceInfo();
-      // handling the new user popup toggle
-      if (this.instance === undefined && !instanceInfo?.instance?.workspaces_exist)
-        this.store.theme.toggleNewUserPopup();
-      runInAction(() => {
-        console.log("instanceInfo: ", instanceInfo);
-        this.isLoading = false;
-        this.instance = instanceInfo.instance;
-        this.config = instanceInfo.config;
-      });
-      return instanceInfo;
-    } catch (error) {
-      console.error("Error fetching the instance info");
-      this.isLoading = false;
-      this.error = { message: "Failed to fetch the instance info" };
-      this.instanceStatus = {
-        status: EInstanceStatus.ERROR,
-      };
-      throw error;
-    }
-  };
-
-  /**
-   * @description updating instance information
-   * @param {Partial<IInstance>} data
-   * @returns void
-   */
-  updateInstanceInfo = async (data: Partial<IInstance>) => {
-    try {
-      const instanceResponse = await this.instanceService.updateInstanceInfo(data);
-      if (instanceResponse) {
-        runInAction(() => {
-          if (this.instance) set(this.instance, "instance", instanceResponse);
-        });
-      }
-      return instanceResponse;
-    } catch (error) {
-      console.error("Error updating the instance info");
-      throw error;
-    }
-  };
-
-  /**
-   * @description fetching instance admins
-   * @return {IInstanceAdmin[]} instanceAdmins
-   */
-  fetchInstanceAdmins = async () => {
-    try {
-      const instanceAdmins = await this.instanceService.getInstanceAdmins();
-      if (instanceAdmins) runInAction(() => (this.instanceAdmins = instanceAdmins));
-      return instanceAdmins;
-    } catch (error) {
-      console.error("Error fetching the instance admins");
-      throw error;
-    }
-  };
-
-  /**
-   * @description fetching instance configurations
-   * @return {IInstanceAdmin[]} instanceConfigurations
-   */
-  fetchInstanceConfigurations = async () => {
-    try {
-      const instanceConfigurations = await this.instanceService.getInstanceConfigurations();
-      if (instanceConfigurations) runInAction(() => (this.instanceConfigurations = instanceConfigurations));
-      return instanceConfigurations;
-    } catch (error) {
-      console.error("Error fetching the instance configurations");
-      throw error;
-    }
-  };
-
-  /**
-   * @description updating instance configurations
-   * @param data
-   */
-  updateInstanceConfigurations = async (data: Partial<IFormattedInstanceConfiguration>) => {
-    try {
-      const response = await this.instanceService.updateInstanceConfigurations(data);
-      runInAction(() => {
-        this.instanceConfigurations = this.instanceConfigurations?.map((config) => {
-          const item = response.find((item) => item.key === config.key);
-          if (item) return item;
-          return config;
-        });
-      });
-      return response;
-    } catch (error) {
-      console.error("Error updating the instance configurations");
-      throw error;
-    }
-  };
-}
@@ -1,104 +0,0 @@
-import { action, observable, runInAction, makeObservable } from "mobx";
-// plane internal packages
-import { EUserStatus, TUserStatus } from "@plane/constants";
-import { IUser } from "@plane/types";
-// services
-import { AuthService } from "@/services/auth.service";
-import { UserService } from "@/services/user.service";
-// root store
-import { CoreRootStore } from "@/store/root.store";
-
-export interface IUserStore {
-  // observables
-  isLoading: boolean;
-  userStatus: TUserStatus | undefined;
-  isUserLoggedIn: boolean | undefined;
-  currentUser: IUser | undefined;
-  // fetch actions
-  hydrate: (data: any) => void;
-  fetchCurrentUser: () => Promise<IUser>;
-  reset: () => void;
-  signOut: () => void;
-}
-
-export class UserStore implements IUserStore {
-  // observables
-  isLoading: boolean = true;
-  userStatus: TUserStatus | undefined = undefined;
-  isUserLoggedIn: boolean | undefined = undefined;
-  currentUser: IUser | undefined = undefined;
-  // services
-  userService;
-  authService;
-
-  constructor(private store: CoreRootStore) {
-    makeObservable(this, {
-      // observables
-      isLoading: observable.ref,
-      userStatus: observable,
-      isUserLoggedIn: observable.ref,
-      currentUser: observable,
-      // action
-      fetchCurrentUser: action,
-      reset: action,
-      signOut: action,
-    });
-    this.userService = new UserService();
-    this.authService = new AuthService();
-  }
-
-  hydrate = (data: any) => {
-    if (data) this.currentUser = data;
-  };
-
-  /**
-   * @description Fetches the current user
-   * @returns Promise<IUser>
-   */
-  fetchCurrentUser = async () => {
-    try {
-      if (this.currentUser === undefined) this.isLoading = true;
-      const currentUser = await this.userService.currentUser();
-      if (currentUser) {
-        await this.store.instance.fetchInstanceAdmins();
-        runInAction(() => {
-          this.isUserLoggedIn = true;
-          this.currentUser = currentUser;
-          this.isLoading = false;
-        });
-      } else {
-        runInAction(() => {
-          this.isUserLoggedIn = false;
-          this.currentUser = undefined;
-          this.isLoading = false;
-        });
-      }
-      return currentUser;
-    } catch (error: any) {
-      this.isLoading = false;
-      this.isUserLoggedIn = false;
-      if (error.status === 403)
-        this.userStatus = {
-          status: EUserStatus.AUTHENTICATION_NOT_DONE,
-          message: error?.message || "",
-        };
-      else
-        this.userStatus = {
-          status: EUserStatus.ERROR,
-          message: error?.message || "",
-        };
-      throw error;
-    }
-  };
-
-  reset = async () => {
-    this.isUserLoggedIn = false;
-    this.currentUser = undefined;
-    this.isLoading = false;
-    this.userStatus = undefined;
-  };
-
-  signOut = async () => {
-    this.store.resetOnSignOut();
-  };
-}
@@ -1,150 +0,0 @@
-import set from "lodash/set";
-import { action, observable, runInAction, makeObservable, computed } from "mobx";
-import { IWorkspace, TLoader, TPaginationInfo } from "@plane/types";
-// services
-import { WorkspaceService } from "@/services/workspace.service";
-// root store
-import { CoreRootStore } from "@/store/root.store";
-
-export interface IWorkspaceStore {
-  // observables
-  loader: TLoader;
-  workspaces: Record<string, IWorkspace>;
-  paginationInfo: TPaginationInfo | undefined;
-  // computed
-  workspaceIds: string[];
-  // helper actions
-  hydrate: (data: Record<string, IWorkspace>) => void;
-  getWorkspaceById: (workspaceId: string) => IWorkspace | undefined;
-  // fetch actions
-  fetchWorkspaces: () => Promise<IWorkspace[]>;
-  fetchNextWorkspaces: () => Promise<IWorkspace[]>;
-  // curd actions
-  createWorkspace: (data: IWorkspace) => Promise<IWorkspace>;
-}
-
-export class WorkspaceStore implements IWorkspaceStore {
-  // observables
-  loader: TLoader = "init-loader";
-  workspaces: Record<string, IWorkspace> = {};
-  paginationInfo: TPaginationInfo | undefined = undefined;
-  // services
-  workspaceService;
-
-  constructor(private store: CoreRootStore) {
-    makeObservable(this, {
-      // observables
-      loader: observable,
-      workspaces: observable,
-      paginationInfo: observable,
-      // computed
-      workspaceIds: computed,
-      // helper actions
-      hydrate: action,
-      getWorkspaceById: action,
-      // fetch actions
-      fetchWorkspaces: action,
-      fetchNextWorkspaces: action,
-      // curd actions
-      createWorkspace: action,
-    });
-    this.workspaceService = new WorkspaceService();
-  }
-
-  // computed
-  get workspaceIds() {
-    return Object.keys(this.workspaces);
-  }
-
-  // helper actions
-  /**
-   * @description Hydrates the workspaces
-   * @param data - Record<string, IWorkspace>
-   */
-  hydrate = (data: Record<string, IWorkspace>) => {
-    if (data) this.workspaces = data;
-  };
-
-  /**
-   * @description Gets a workspace by id
-   * @param workspaceId - string
-   * @returns IWorkspace | undefined
-   */
-  getWorkspaceById = (workspaceId: string) => this.workspaces[workspaceId];
-
-  // fetch actions
-  /**
-   * @description Fetches all workspaces
-   * @returns Promise<>
-   */
-  fetchWorkspaces = async (): Promise<IWorkspace[]> => {
-    try {
-      if (this.workspaceIds.length > 0) {
-        this.loader = "mutation";
-      } else {
-        this.loader = "init-loader";
-      }
-      const paginatedWorkspaceData = await this.workspaceService.getWorkspaces();
-      runInAction(() => {
-        const { results, ...paginationInfo } = paginatedWorkspaceData;
-        results.forEach((workspace: IWorkspace) => {
-          set(this.workspaces, [workspace.id], workspace);
-        });
-        set(this, "paginationInfo", paginationInfo);
-      });
-      return paginatedWorkspaceData.results;
-    } catch (error) {
-      console.error("Error fetching workspaces", error);
-      throw error;
-    } finally {
-      this.loader = "loaded";
-    }
-  };
-
-  /**
-   * @description Fetches the next page of workspaces
-   * @returns Promise<IWorkspace[]>
-   */
-  fetchNextWorkspaces = async (): Promise<IWorkspace[]> => {
-    if (!this.paginationInfo || this.paginationInfo.next_page_results === false) return [];
-    try {
-      this.loader = "pagination";
-      const paginatedWorkspaceData = await this.workspaceService.getWorkspaces(this.paginationInfo.next_cursor);
-      runInAction(() => {
-        const { results, ...paginationInfo } = paginatedWorkspaceData;
-        results.forEach((workspace: IWorkspace) => {
-          set(this.workspaces, [workspace.id], workspace);
-        });
-        set(this, "paginationInfo", paginationInfo);
-      });
-      return paginatedWorkspaceData.results;
-    } catch (error) {
-      console.error("Error fetching next workspaces", error);
-      throw error;
-    } finally {
-      this.loader = "loaded";
-    }
-  };
-
-  // curd actions
-  /**
-   * @description Creates a new workspace
-   * @param data - IWorkspace
-   * @returns Promise<IWorkspace>
-   */
-  createWorkspace = async (data: IWorkspace): Promise<IWorkspace> => {
-    try {
-      this.loader = "mutation";
-      const workspace = await this.workspaceService.createWorkspace(data);
-      runInAction(() => {
-        set(this.workspaces, [workspace.id], workspace);
-      });
-      return workspace;
-    } catch (error) {
-      console.error("Error creating workspace", error);
-      throw error;
-    } finally {
-      this.loader = "loaded";
-    }
-  };
-}
@@ -1,14 +0,0 @@
-/** @type {import('next').NextConfig} */
-
-const nextConfig = {
-  trailingSlash: true,
-  reactStrictMode: false,
-  swcMinify: true,
-  output: "standalone",
-  images: {
-    unoptimized: true,
-  },
-  basePath: process.env.NEXT_PUBLIC_ADMIN_BASE_PATH || "",
-};
-
-module.exports = nextConfig;
@@ -1,52 +0,0 @@
-{
-  "name": "admin",
-  "version": "0.24.1",
-  "private": true,
-  "scripts": {
-    "dev": "turbo run develop",
-    "develop": "next dev --port 3001",
-    "build": "next build",
-    "preview": "next build && next start",
-    "start": "next start",
-    "lint": "eslint . --ext .ts,.tsx",
-    "lint:errors": "eslint . --ext .ts,.tsx --quiet"
-  },
-  "dependencies": {
-    "@headlessui/react": "^1.7.19",
-    "@plane/constants": "*",
-    "@plane/hooks": "*",
-    "@plane/types": "*",
-    "@plane/ui": "*",
-    "@plane/utils": "*",
-    "@sentry/nextjs": "^8.32.0",
-    "@tailwindcss/typography": "^0.5.9",
-    "@types/lodash": "^4.17.0",
-    "autoprefixer": "10.4.14",
-    "axios": "^1.7.4",
-    "lodash": "^4.17.21",
-    "lucide-react": "^0.356.0",
-    "mobx": "^6.12.0",
-    "mobx-react": "^9.1.1",
-    "next": "^14.2.20",
-    "next-themes": "^0.2.1",
-    "postcss": "^8.4.38",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-hook-form": "7.51.5",
-    "swr": "^2.2.4",
-    "tailwindcss": "3.3.2",
-    "uuid": "^9.0.1",
-    "zxcvbn": "^4.4.2"
-  },
-  "devDependencies": {
-    "@plane/eslint-config": "*",
-    "@plane/typescript-config": "*",
-    "@types/node": "18.16.1",
-    "@types/react": "^18.3.11",
-    "@types/react-dom": "^18.2.18",
-    "@types/uuid": "^9.0.8",
-    "@types/zxcvbn": "^4.4.4",
-    "tailwind-config-custom": "*",
-    "typescript": "5.3.3"
-  }
-}
@@ -1,8 +0,0 @@
-module.exports = {
-  plugins: {
-    "postcss-import": {},
-    "tailwindcss/nesting": {},
-    tailwindcss: {},
-    autoprefixer: {},
-  },
-};
@@ -1,5 +0,0 @@
-const sharedConfig = require("tailwind-config-custom/tailwind.config.js");
-
-module.exports = {
-  presets: [sharedConfig],
-};
@@ -1,14 +0,0 @@
-{
-  "extends": "@plane/typescript-config/nextjs.json",
-  "compilerOptions": {
-    "plugins": [{ "name": "next" }],
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["core/*"],
-      "@/public/*": ["public/*"],
-      "@/plane-admin/*": ["ce/*"]
-    }
-  },
-  "include": ["next-env.d.ts", "next.config.js", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
-  "exclude": ["node_modules"]
-}
@@ -145,11 +145,8 @@ RUN chmod +x /app/pg-setup.sh
 #  APPLICATION ENVIRONMENT SETTINGS
 # *****************************************************************************
 ENV APP_DOMAIN=localhost
-
 ENV WEB_URL=http://${APP_DOMAIN}
 ENV DEBUG=0
-ENV SENTRY_DSN=
-ENV SENTRY_ENVIRONMENT=production
 ENV CORS_ALLOWED_ORIGINS=http://${APP_DOMAIN},https://${APP_DOMAIN}
 # Secret Key
 ENV SECRET_KEY=60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5
@@ -1,62 +0,0 @@
-# Backend
-# Debug value for api server use it as 0 for production use
-DEBUG=0
-CORS_ALLOWED_ORIGINS="http://localhost"
-
-# Error logs
-SENTRY_DSN=""
-SENTRY_ENVIRONMENT="development"
-
-# Database Settings
-POSTGRES_USER="plane"
-POSTGRES_PASSWORD="plane"
-POSTGRES_HOST="plane-db"
-POSTGRES_DB="plane"
-POSTGRES_PORT=5432
-DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
-
-# Redis Settings
-REDIS_HOST="plane-redis"
-REDIS_PORT="6379"
-REDIS_URL="redis://${REDIS_HOST}:6379/"
-
-# RabbitMQ Settings
-RABBITMQ_HOST="plane-mq"
-RABBITMQ_PORT="5672"
-RABBITMQ_USER="plane"
-RABBITMQ_PASSWORD="plane"
-RABBITMQ_VHOST="plane"
-
-# AWS Settings
-AWS_REGION=""
-AWS_ACCESS_KEY_ID="access-key"
-AWS_SECRET_ACCESS_KEY="secret-key"
-AWS_S3_ENDPOINT_URL="http://plane-minio:9000"
-# Changing this requires change in the nginx.conf for uploads if using minio setup
-AWS_S3_BUCKET_NAME="uploads"
-# Maximum file upload limit
-FILE_SIZE_LIMIT=5242880
-
-# Settings related to Docker
-DOCKERIZED=1 # deprecated
-
-# set to 1 If using the pre-configured minio setup
-USE_MINIO=1
-
-# Nginx Configuration
-NGINX_PORT=80
-
-# Email redirections and minio domain settings
-WEB_URL="http://localhost"
-
-# Gunicorn Workers
-GUNICORN_WORKERS=2
-
-# Base URLs
-ADMIN_BASE_URL=
-SPACE_BASE_URL=
-APP_BASE_URL=
-
-
-# Hard delete files after days
-HARD_DELETE_AFTER_DAYS=60
@@ -1,4 +0,0 @@
-{
-  "name": "plane-api",
-  "version": "0.24.1"
-}
@@ -1,17 +0,0 @@
-from .user import UserLiteSerializer
-from .workspace import WorkspaceLiteSerializer
-from .project import ProjectSerializer, ProjectLiteSerializer
-from .issue import (
-    IssueSerializer,
-    LabelSerializer,
-    IssueLinkSerializer,
-    IssueCommentSerializer,
-    IssueAttachmentSerializer,
-    IssueActivitySerializer,
-    IssueExpandSerializer,
-    IssueLiteSerializer,
-)
-from .state import StateLiteSerializer, StateSerializer
-from .cycle import CycleSerializer, CycleIssueSerializer, CycleLiteSerializer
-from .module import ModuleSerializer, ModuleIssueSerializer, ModuleLiteSerializer
-from .intake import IntakeIssueSerializer
@@ -1,107 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-
-class BaseSerializer(serializers.ModelSerializer):
-    id = serializers.PrimaryKeyRelatedField(read_only=True)
-
-    def __init__(self, *args, **kwargs):
-        # If 'fields' is provided in the arguments, remove it and store it separately.
-        # This is done so as not to pass this custom argument up to the superclass.
-        fields = kwargs.pop("fields", [])
-        self.expand = kwargs.pop("expand", []) or []
-
-        # Call the initialization of the superclass.
-        super().__init__(*args, **kwargs)
-
-        # If 'fields' was provided, filter the fields of the serializer accordingly.
-        if fields:
-            self.fields = self._filter_fields(fields=fields)
-
-    def _filter_fields(self, fields):
-        """
-        Adjust the serializer's fields based on the provided 'fields' list.
-
-        :param fields: List or dictionary specifying which fields to include in the serializer.
-        :return: The updated fields for the serializer.
-        """
-        # Check each field_name in the provided fields.
-        for field_name in fields:
-            # If the field is a dictionary (indicating nested fields),
-            # loop through its keys and values.
-            if isinstance(field_name, dict):
-                for key, value in field_name.items():
-                    # If the value of this nested field is a list,
-                    # perform a recursive filter on it.
-                    if isinstance(value, list):
-                        self._filter_fields(self.fields[key], value)
-
-        # Create a list to store allowed fields.
-        allowed = []
-        for item in fields:
-            # If the item is a string, it directly represents a field's name.
-            if isinstance(item, str):
-                allowed.append(item)
-            # If the item is a dictionary, it represents a nested field.
-            # Add the key of this dictionary to the allowed list.
-            elif isinstance(item, dict):
-                allowed.append(list(item.keys())[0])
-
-        # Convert the current serializer's fields and the allowed fields to sets.
-        existing = set(self.fields)
-        allowed = set(allowed)
-
-        # Remove fields from the serializer that aren't in the 'allowed' list.
-        for field_name in existing - allowed:
-            self.fields.pop(field_name)
-
-        return self.fields
-
-    def to_representation(self, instance):
-        response = super().to_representation(instance)
-
-        # Ensure 'expand' is iterable before processing
-        if self.expand:
-            for expand in self.expand:
-                if expand in self.fields:
-                    # Import all the expandable serializers
-                    from . import (
-                        IssueSerializer,
-                        IssueLiteSerializer,
-                        ProjectLiteSerializer,
-                        StateLiteSerializer,
-                        UserLiteSerializer,
-                        WorkspaceLiteSerializer,
-                    )
-
-                    # Expansion mapper
-                    expansion = {
-                        "user": UserLiteSerializer,
-                        "workspace": WorkspaceLiteSerializer,
-                        "project": ProjectLiteSerializer,
-                        "default_assignee": UserLiteSerializer,
-                        "project_lead": UserLiteSerializer,
-                        "state": StateLiteSerializer,
-                        "created_by": UserLiteSerializer,
-                        "issue": IssueSerializer,
-                        "actor": UserLiteSerializer,
-                        "owned_by": UserLiteSerializer,
-                        "members": UserLiteSerializer,
-                        "parent": IssueLiteSerializer,
-                    }
-                    # Check if field in expansion  then expand the field
-                    if expand in expansion:
-                        if isinstance(response.get(expand), list):
-                            exp_serializer = expansion[expand](
-                                getattr(instance, expand), many=True
-                            )
-                        else:
-                            exp_serializer = expansion[expand](
-                                getattr(instance, expand)
-                            )
-                        response[expand] = exp_serializer.data
-                    else:
-                        # You might need to handle this case differently
-                        response[expand] = getattr(instance, f"{expand}_id", None)
-
-        return response
@@ -1,69 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from .base import BaseSerializer
-from plane.db.models import Cycle, CycleIssue
-from plane.utils.timezone_converter import convert_to_utc
-
-class CycleSerializer(BaseSerializer):
-    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)
-    total_estimates = serializers.FloatField(read_only=True)
-    completed_estimates = serializers.FloatField(read_only=True)
-    started_estimates = serializers.FloatField(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")
-
-        if (
-            data.get("start_date", None) is not None
-            and data.get("end_date", None) is not None
-        ):
-            project_id = self.initial_data.get("project_id") or self.instance.project_id
-            data["start_date"] = convert_to_utc(
-                str(data.get("start_date").date()), project_id, is_start_date=True
-            )
-            data["end_date"] = convert_to_utc(
-                str(data.get("end_date", None).date()), project_id
-            )
-        return data
-
-    class Meta:
-        model = Cycle
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-            "workspace",
-            "project",
-            "owned_by",
-            "deleted_at",
-        ]
-
-
-class CycleIssueSerializer(BaseSerializer):
-    sub_issues_count = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = CycleIssue
-        fields = "__all__"
-        read_only_fields = ["workspace", "project", "cycle"]
-
-
-class CycleLiteSerializer(BaseSerializer):
-    class Meta:
-        model = Cycle
-        fields = "__all__"
@@ -1,439 +0,0 @@
-# Django imports
-from django.utils import timezone
-from lxml import html
-
-#  Third party imports
-from rest_framework import serializers
-
-# Module imports
-from plane.db.models import (
-    Issue,
-    IssueType,
-    IssueActivity,
-    IssueAssignee,
-    FileAsset,
-    IssueComment,
-    IssueLabel,
-    IssueLink,
-    Label,
-    ProjectMember,
-    State,
-    User,
-)
-
-from .base import BaseSerializer
-from .cycle import CycleLiteSerializer, CycleSerializer
-from .module import ModuleLiteSerializer, ModuleSerializer
-from .state import StateLiteSerializer
-from .user import UserLiteSerializer
-
-# Django imports
-from django.core.exceptions import ValidationError
-from django.core.validators import URLValidator
-
-
-class IssueSerializer(BaseSerializer):
-    assignees = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(
-            queryset=User.objects.values_list("id", flat=True)
-        ),
-        write_only=True,
-        required=False,
-    )
-
-    labels = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(
-            queryset=Label.objects.values_list("id", flat=True)
-        ),
-        write_only=True,
-        required=False,
-    )
-    type_id = serializers.PrimaryKeyRelatedField(
-        source="type", queryset=IssueType.objects.all(), required=False, allow_null=True
-    )
-
-    class Meta:
-        model = Issue
-        read_only_fields = ["id", "workspace", "project", "updated_by", "updated_at"]
-        exclude = ["description", "description_stripped"]
-
-    def validate(self, data):
-        if (
-            data.get("start_date", None) is not None
-            and data.get("target_date", None) is not None
-            and data.get("start_date", None) > data.get("target_date", None)
-        ):
-            raise serializers.ValidationError("Start date cannot exceed target date")
-
-        try:
-            if data.get("description_html", None) is not None:
-                parsed = html.fromstring(data["description_html"])
-                parsed_str = html.tostring(parsed, encoding="unicode")
-                data["description_html"] = parsed_str
-
-        except Exception:
-            raise serializers.ValidationError("Invalid HTML passed")
-
-        # Validate assignees are from project
-        if data.get("assignees", []):
-            data["assignees"] = ProjectMember.objects.filter(
-                project_id=self.context.get("project_id"),
-                is_active=True,
-                member_id__in=data["assignees"],
-            ).values_list("member_id", flat=True)
-
-        # Validate labels are from project
-        if data.get("labels", []):
-            data["labels"] = Label.objects.filter(
-                project_id=self.context.get("project_id"), id__in=data["labels"]
-            ).values_list("id", flat=True)
-
-        # Check state is from the project only else raise validation error
-        if (
-            data.get("state")
-            and not State.objects.filter(
-                project_id=self.context.get("project_id"), pk=data.get("state").id
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "State is not valid please pass a valid state_id"
-            )
-
-        # Check parent issue is from workspace as it can be cross workspace
-        if (
-            data.get("parent")
-            and not Issue.objects.filter(
-                workspace_id=self.context.get("workspace_id"), pk=data.get("parent").id
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "Parent is not valid issue_id please pass a valid issue_id"
-            )
-
-        return data
-
-    def create(self, validated_data):
-        assignees = validated_data.pop("assignees", None)
-        labels = validated_data.pop("labels", None)
-
-        project_id = self.context["project_id"]
-        workspace_id = self.context["workspace_id"]
-        default_assignee_id = self.context["default_assignee_id"]
-
-        issue_type = validated_data.pop("type", None)
-
-        if not issue_type:
-            # Get default issue type
-            issue_type = IssueType.objects.filter(
-                project_issue_types__project_id=project_id, is_default=True
-            ).first()
-            issue_type = issue_type
-
-        issue = Issue.objects.create(
-            **validated_data, project_id=project_id, type=issue_type
-        )
-
-        # Issue Audit Users
-        created_by_id = issue.created_by_id
-        updated_by_id = issue.updated_by_id
-
-        if assignees is not None and len(assignees):
-            IssueAssignee.objects.bulk_create(
-                [
-                    IssueAssignee(
-                        assignee_id=assignee_id,
-                        issue=issue,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for assignee_id in assignees
-                ],
-                batch_size=10,
-            )
-        else:
-            # Then assign it to default assignee
-            if default_assignee_id is not None:
-                IssueAssignee.objects.create(
-                    assignee_id=default_assignee_id,
-                    issue=issue,
-                    project_id=project_id,
-                    workspace_id=workspace_id,
-                    created_by_id=created_by_id,
-                    updated_by_id=updated_by_id,
-                )
-
-        if labels is not None and len(labels):
-            IssueLabel.objects.bulk_create(
-                [
-                    IssueLabel(
-                        label_id=label_id,
-                        issue=issue,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for label_id in labels
-                ],
-                batch_size=10,
-            )
-
-        return issue
-
-    def update(self, instance, validated_data):
-        assignees = validated_data.pop("assignees", None)
-        labels = validated_data.pop("labels", None)
-
-        # Related models
-        project_id = instance.project_id
-        workspace_id = instance.workspace_id
-        created_by_id = instance.created_by_id
-        updated_by_id = instance.updated_by_id
-
-        if assignees is not None:
-            IssueAssignee.objects.filter(issue=instance).delete()
-            IssueAssignee.objects.bulk_create(
-                [
-                    IssueAssignee(
-                        assignee_id=assignee_id,
-                        issue=instance,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for assignee_id in assignees
-                ],
-                batch_size=10,
-            )
-
-        if labels is not None:
-            IssueLabel.objects.filter(issue=instance).delete()
-            IssueLabel.objects.bulk_create(
-                [
-                    IssueLabel(
-                        label_id=label_id,
-                        issue=instance,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for label_id in labels
-                ],
-                batch_size=10,
-            )
-
-        # Time updation occues even when other related models are updated
-        instance.updated_at = timezone.now()
-        return super().update(instance, validated_data)
-
-    def to_representation(self, instance):
-        data = super().to_representation(instance)
-        if "assignees" in self.fields:
-            if "assignees" in self.expand:
-                from .user import UserLiteSerializer
-
-                data["assignees"] = UserLiteSerializer(
-                    User.objects.filter(
-                        pk__in=IssueAssignee.objects.filter(issue=instance).values_list(
-                            "assignee_id", flat=True
-                        )
-                    ),
-                    many=True,
-                ).data
-            else:
-                data["assignees"] = [
-                    str(assignee)
-                    for assignee in IssueAssignee.objects.filter(
-                        issue=instance
-                    ).values_list("assignee_id", flat=True)
-                ]
-        if "labels" in self.fields:
-            if "labels" in self.expand:
-                data["labels"] = LabelSerializer(
-                    Label.objects.filter(
-                        pk__in=IssueLabel.objects.filter(issue=instance).values_list(
-                            "label_id", flat=True
-                        )
-                    ),
-                    many=True,
-                ).data
-            else:
-                data["labels"] = [
-                    str(label)
-                    for label in IssueLabel.objects.filter(issue=instance).values_list(
-                        "label_id", flat=True
-                    )
-                ]
-
-        return data
-
-
-class IssueLiteSerializer(BaseSerializer):
-    class Meta:
-        model = Issue
-        fields = ["id", "sequence_id", "project_id"]
-        read_only_fields = fields
-
-
-class LabelSerializer(BaseSerializer):
-    class Meta:
-        model = Label
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-            "deleted_at",
-        ]
-
-
-class IssueLinkSerializer(BaseSerializer):
-    class Meta:
-        model = IssueLink
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-    def validate_url(self, value):
-        # Check URL format
-        validate_url = URLValidator()
-        try:
-            validate_url(value)
-        except ValidationError:
-            raise serializers.ValidationError("Invalid URL format.")
-
-        # Check URL scheme
-        if not value.startswith(("http://", "https://")):
-            raise serializers.ValidationError("Invalid URL scheme.")
-
-        return value
-
-    # Validation if url already exists
-    def create(self, validated_data):
-        if IssueLink.objects.filter(
-            url=validated_data.get("url"), issue_id=validated_data.get("issue_id")
-        ).exists():
-            raise serializers.ValidationError(
-                {"error": "URL already exists for this Issue"}
-            )
-        return IssueLink.objects.create(**validated_data)
-
-    def update(self, instance, validated_data):
-        if (
-            IssueLink.objects.filter(
-                url=validated_data.get("url"), issue_id=instance.issue_id
-            )
-            .exclude(pk=instance.id)
-            .exists()
-        ):
-            raise serializers.ValidationError(
-                {"error": "URL already exists for this Issue"}
-            )
-
-        return super().update(instance, validated_data)
-
-
-class IssueAttachmentSerializer(BaseSerializer):
-    class Meta:
-        model = FileAsset
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "issue",
-            "updated_by",
-            "updated_at",
-        ]
-
-
-class IssueCommentSerializer(BaseSerializer):
-    is_member = serializers.BooleanField(read_only=True)
-
-    class Meta:
-        model = IssueComment
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-        exclude = ["comment_stripped", "comment_json"]
-
-    def validate(self, data):
-        try:
-            if data.get("comment_html", None) is not None:
-                parsed = html.fromstring(data["comment_html"])
-                parsed_str = html.tostring(parsed, encoding="unicode")
-                data["comment_html"] = parsed_str
-
-        except Exception:
-            raise serializers.ValidationError("Invalid HTML passed")
-        return data
-
-
-class IssueActivitySerializer(BaseSerializer):
-    class Meta:
-        model = IssueActivity
-        exclude = ["created_by", "updated_by"]
-
-
-class CycleIssueSerializer(BaseSerializer):
-    cycle = CycleSerializer(read_only=True)
-
-    class Meta:
-        fields = ["cycle"]
-
-
-class ModuleIssueSerializer(BaseSerializer):
-    module = ModuleSerializer(read_only=True)
-
-    class Meta:
-        fields = ["module"]
-
-
-class LabelLiteSerializer(BaseSerializer):
-    class Meta:
-        model = Label
-        fields = ["id", "name", "color"]
-
-
-class IssueExpandSerializer(BaseSerializer):
-    cycle = CycleLiteSerializer(source="issue_cycle.cycle", read_only=True)
-    module = ModuleLiteSerializer(source="issue_module.module", read_only=True)
-    labels = LabelLiteSerializer(read_only=True, many=True)
-    assignees = UserLiteSerializer(read_only=True, many=True)
-    state = StateLiteSerializer(read_only=True)
-
-    class Meta:
-        model = Issue
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
@@ -1,99 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from plane.db.models import Project, ProjectIdentifier, WorkspaceMember
-
-from .base import BaseSerializer
-
-
-class ProjectSerializer(BaseSerializer):
-    total_members = serializers.IntegerField(read_only=True)
-    total_cycles = serializers.IntegerField(read_only=True)
-    total_modules = serializers.IntegerField(read_only=True)
-    is_member = serializers.BooleanField(read_only=True)
-    sort_order = serializers.FloatField(read_only=True)
-    member_role = serializers.IntegerField(read_only=True)
-    is_deployed = serializers.BooleanField(read_only=True)
-    cover_image_url = serializers.CharField(read_only=True)
-    inbox_view = serializers.BooleanField(read_only=True, source="intake_view")
-
-    class Meta:
-        model = Project
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "emoji",
-            "workspace",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-            "deleted_at",
-            "cover_image_url",
-        ]
-
-    def validate(self, data):
-        # Check project lead should be a member of the workspace
-        if (
-            data.get("project_lead", None) is not None
-            and not WorkspaceMember.objects.filter(
-                workspace_id=self.context["workspace_id"],
-                member_id=data.get("project_lead"),
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "Project lead should be a user in the workspace"
-            )
-
-        # Check default assignee should be a member of the workspace
-        if (
-            data.get("default_assignee", None) is not None
-            and not WorkspaceMember.objects.filter(
-                workspace_id=self.context["workspace_id"],
-                member_id=data.get("default_assignee"),
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "Default assignee should be a user in the workspace"
-            )
-
-        return data
-
-    def create(self, validated_data):
-        identifier = validated_data.get("identifier", "").strip().upper()
-        if identifier == "":
-            raise serializers.ValidationError(detail="Project Identifier is required")
-
-        if ProjectIdentifier.objects.filter(
-            name=identifier, workspace_id=self.context["workspace_id"]
-        ).exists():
-            raise serializers.ValidationError(detail="Project Identifier is taken")
-
-        project = Project.objects.create(
-            **validated_data, workspace_id=self.context["workspace_id"]
-        )
-        _ = ProjectIdentifier.objects.create(
-            name=project.identifier,
-            project=project,
-            workspace_id=self.context["workspace_id"],
-        )
-        return project
-
-
-class ProjectLiteSerializer(BaseSerializer):
-    cover_image_url = serializers.CharField(read_only=True)
-
-    class Meta:
-        model = Project
-        fields = [
-            "id",
-            "identifier",
-            "name",
-            "cover_image",
-            "icon_prop",
-            "emoji",
-            "description",
-            "cover_image_url",
-        ]
-        read_only_fields = fields
@@ -1,27 +0,0 @@
-from django.urls import path
-
-from plane.api.views import IntakeIssueAPIEndpoint
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:issue_id>/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="intake-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/<uuid:issue_id>/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="intake-issue",
-    ),
-]
@@ -1,74 +0,0 @@
-from django.urls import path
-
-from plane.api.views import (
-    IssueAPIEndpoint,
-    LabelAPIEndpoint,
-    IssueLinkAPIEndpoint,
-    IssueCommentAPIEndpoint,
-    IssueActivityAPIEndpoint,
-    WorkspaceIssueAPIEndpoint,
-    IssueAttachmentEndpoint,
-)
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/issues/<str:project__identifier>-<str:issue__identifier>/",
-        WorkspaceIssueAPIEndpoint.as_view(),
-        name="issue-by-identifier",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/",
-        IssueAPIEndpoint.as_view(),
-        name="issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/",
-        IssueAPIEndpoint.as_view(),
-        name="issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/labels/",
-        LabelAPIEndpoint.as_view(),
-        name="label",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/labels/<uuid:pk>/",
-        LabelAPIEndpoint.as_view(),
-        name="label",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/links/",
-        IssueLinkAPIEndpoint.as_view(),
-        name="link",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/links/<uuid:pk>/",
-        IssueLinkAPIEndpoint.as_view(),
-        name="link",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/",
-        IssueCommentAPIEndpoint.as_view(),
-        name="comment",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/<uuid:pk>/",
-        IssueCommentAPIEndpoint.as_view(),
-        name="comment",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/activities/",
-        IssueActivityAPIEndpoint.as_view(),
-        name="activity",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/activities/<uuid:pk>/",
-        IssueActivityAPIEndpoint.as_view(),
-        name="activity",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-attachments/",
-        IssueAttachmentEndpoint.as_view(),
-        name="attachment",
-    ),
-]
@@ -1,357 +0,0 @@
-# Python imports
-import json
-
-# Django imports
-from django.core.serializers.json import DjangoJSONEncoder
-from django.utils import timezone
-from django.db.models import Q, Value, UUIDField
-from django.db.models.functions import Coalesce
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from plane.api.serializers import IntakeIssueSerializer, IssueSerializer
-from plane.app.permissions import ProjectLitePermission
-from plane.bgtasks.issue_activities_task import issue_activity
-from plane.db.models import Intake, IntakeIssue, Issue, Project, ProjectMember, State
-
-from .base import BaseAPIView
-
-
-class IntakeIssueAPIEndpoint(BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to intake issues.
-
-    """
-
-    permission_classes = [ProjectLitePermission]
-
-    serializer_class = IntakeIssueSerializer
-    model = IntakeIssue
-
-    filterset_fields = ["status"]
-
-    def get_queryset(self):
-        intake = Intake.objects.filter(
-            workspace__slug=self.kwargs.get("slug"),
-            project_id=self.kwargs.get("project_id"),
-        ).first()
-
-        project = Project.objects.get(
-            workspace__slug=self.kwargs.get("slug"), pk=self.kwargs.get("project_id")
-        )
-
-        if intake is None and not project.intake_view:
-            return IntakeIssue.objects.none()
-
-        return (
-            IntakeIssue.objects.filter(
-                Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
-                workspace__slug=self.kwargs.get("slug"),
-                project_id=self.kwargs.get("project_id"),
-                intake_id=intake.id,
-            )
-            .select_related("issue", "workspace", "project")
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-        )
-
-    def get(self, request, slug, project_id, issue_id=None):
-        if issue_id:
-            intake_issue_queryset = self.get_queryset().get(issue_id=issue_id)
-            intake_issue_data = IntakeIssueSerializer(
-                intake_issue_queryset, fields=self.fields, expand=self.expand
-            ).data
-            return Response(intake_issue_data, status=status.HTTP_200_OK)
-        issue_queryset = self.get_queryset()
-        return self.paginate(
-            request=request,
-            queryset=(issue_queryset),
-            on_results=lambda intake_issues: IntakeIssueSerializer(
-                intake_issues, many=True, fields=self.fields, expand=self.expand
-            ).data,
-        )
-
-    def post(self, request, slug, project_id):
-        if not request.data.get("issue", {}).get("name", False):
-            return Response(
-                {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        intake = Intake.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-
-        project = Project.objects.get(workspace__slug=slug, pk=project_id)
-
-        # Intake view
-        if intake is None and not project.intake_view:
-            return Response(
-                {
-                    "error": "Intake is not enabled for this project enable it through the project's api"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Check for valid priority
-        if request.data.get("issue", {}).get("priority", "none") not in [
-            "low",
-            "medium",
-            "high",
-            "urgent",
-            "none",
-        ]:
-            return Response(
-                {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        # create an issue
-        issue = Issue.objects.create(
-            name=request.data.get("issue", {}).get("name"),
-            description=request.data.get("issue", {}).get("description", {}),
-            description_html=request.data.get("issue", {}).get(
-                "description_html", "<p></p>"
-            ),
-            priority=request.data.get("issue", {}).get("priority", "none"),
-            project_id=project_id,
-        )
-
-        # create an intake issue
-        intake_issue = IntakeIssue.objects.create(
-            intake_id=intake.id,
-            project_id=project_id,
-            issue=issue,
-            source=request.data.get("source", "IN-APP"),
-        )
-        # Create an Issue Activity
-        issue_activity.delay(
-            type="issue.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()),
-            intake=str(intake_issue.id),
-        )
-
-        serializer = IntakeIssueSerializer(intake_issue)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def patch(self, request, slug, project_id, issue_id):
-        intake = Intake.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-
-        project = Project.objects.get(workspace__slug=slug, pk=project_id)
-
-        # Intake view
-        if intake is None and not project.intake_view:
-            return Response(
-                {
-                    "error": "Intake is not enabled for this project enable it through the project's api"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get the intake issue
-        intake_issue = IntakeIssue.objects.get(
-            issue_id=issue_id,
-            workspace__slug=slug,
-            project_id=project_id,
-            intake_id=intake.id,
-        )
-
-        # Get the project member
-        project_member = ProjectMember.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            member=request.user,
-            is_active=True,
-        )
-
-        # Only project members admins and created_by users can access this endpoint
-        if project_member.role <= 5 and str(intake_issue.created_by_id) != str(
-            request.user.id
-        ):
-            return Response(
-                {"error": "You cannot edit intake issues"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get issue data
-        issue_data = request.data.pop("issue", False)
-
-        if bool(issue_data):
-            issue = Issue.objects.annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=Q(
-                            ~Q(labels__id__isnull=True)
-                            & Q(label_issue__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=Q(
-                            ~Q(assignees__id__isnull=True)
-                            & Q(assignees__member_project__is_active=True)
-                            & Q(issue_assignee__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            ).get(pk=issue_id, workspace__slug=slug, project_id=project_id)
-            # Only allow guests to edit name and description
-            if project_member.role <= 5:
-                issue_data = {
-                    "name": issue_data.get("name", issue.name),
-                    "description_html": issue_data.get(
-                        "description_html", issue.description_html
-                    ),
-                    "description": issue_data.get("description", issue.description),
-                }
-
-            issue_serializer = IssueSerializer(issue, data=issue_data, partial=True)
-
-            if issue_serializer.is_valid():
-                current_instance = issue
-                # Log all the updates
-                requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
-                if issue is not None:
-                    issue_activity.delay(
-                        type="issue.activity.updated",
-                        requested_data=requested_data,
-                        actor_id=str(request.user.id),
-                        issue_id=str(issue_id),
-                        project_id=str(project_id),
-                        current_instance=json.dumps(
-                            IssueSerializer(current_instance).data,
-                            cls=DjangoJSONEncoder,
-                        ),
-                        epoch=int(timezone.now().timestamp()),
-                        intake=(intake_issue.id),
-                    )
-                issue_serializer.save()
-            else:
-                return Response(
-                    issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
-                )
-
-        # Only project admins and members can edit intake issue attributes
-        if project_member.role > 15:
-            serializer = IntakeIssueSerializer(
-                intake_issue, data=request.data, partial=True
-            )
-            current_instance = json.dumps(
-                IntakeIssueSerializer(intake_issue).data, cls=DjangoJSONEncoder
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                # Update the issue state if the issue is rejected or marked as duplicate
-                if serializer.data["status"] in [-1, 2]:
-                    issue = Issue.objects.get(
-                        pk=issue_id, workspace__slug=slug, project_id=project_id
-                    )
-                    state = State.objects.filter(
-                        group="cancelled", workspace__slug=slug, project_id=project_id
-                    ).first()
-                    if state is not None:
-                        issue.state = state
-                        issue.save()
-
-                # Update the issue state if it is accepted
-                if serializer.data["status"] in [1]:
-                    issue = Issue.objects.get(
-                        pk=issue_id, workspace__slug=slug, project_id=project_id
-                    )
-
-                    # Update the issue state only if it is in triage state
-                    if issue.state.is_triage:
-                        # Move to default state
-                        state = State.objects.filter(
-                            workspace__slug=slug, project_id=project_id, default=True
-                        ).first()
-                        if state is not None:
-                            issue.state = state
-                            issue.save()
-
-                # create a activity for status change
-                issue_activity.delay(
-                    type="intake.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=current_instance,
-                    epoch=int(timezone.now().timestamp()),
-                    notification=False,
-                    origin=request.META.get("HTTP_ORIGIN"),
-                    intake=str(intake_issue.id),
-                )
-
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        else:
-            return Response(
-                IntakeIssueSerializer(intake_issue).data, status=status.HTTP_200_OK
-            )
-
-    def delete(self, request, slug, project_id, issue_id):
-        intake = Intake.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-
-        project = Project.objects.get(workspace__slug=slug, pk=project_id)
-
-        # Intake view
-        if intake is None and not project.intake_view:
-            return Response(
-                {
-                    "error": "Intake is not enabled for this project enable it through the project's api"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get the intake issue
-        intake_issue = IntakeIssue.objects.get(
-            issue_id=issue_id,
-            workspace__slug=slug,
-            project_id=project_id,
-            intake_id=intake.id,
-        )
-
-        # Check the issue status
-        if intake_issue.status in [-2, -1, 0, 2]:
-            # Delete the issue also
-            issue = Issue.objects.filter(
-                workspace__slug=slug, project_id=project_id, pk=issue_id
-            ).first()
-            if issue.created_by_id != request.user.id and (
-                not ProjectMember.objects.filter(
-                    workspace__slug=slug,
-                    member=request.user,
-                    role=20,
-                    project_id=project_id,
-                    is_active=True,
-                ).exists()
-            ):
-                return Response(
-                    {"error": "Only admin or creator can delete the issue"},
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-            issue.delete()
-
-        intake_issue.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,356 +0,0 @@
-# Python imports
-import json
-
-# Django imports
-from django.db import IntegrityError
-from django.db.models import Exists, F, Func, OuterRef, Prefetch, Q, Subquery
-from django.utils import timezone
-from django.core.serializers.json import DjangoJSONEncoder
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.serializers import ValidationError
-
-from plane.api.serializers import ProjectSerializer
-from plane.app.permissions import ProjectBasePermission
-
-# Module imports
-from plane.db.models import (
-    Cycle,
-    Intake,
-    IssueUserProperty,
-    Module,
-    Project,
-    DeployBoard,
-    ProjectMember,
-    State,
-    Workspace,
-    UserFavorite,
-)
-from plane.bgtasks.webhook_task import model_activity
-from .base import BaseAPIView
-
-
-class ProjectAPIEndpoint(BaseAPIView):
-    """Project Endpoints to create, update, list, retrieve and delete endpoint"""
-
-    serializer_class = ProjectSerializer
-    model = Project
-    webhook_event = "project"
-
-    permission_classes = [ProjectBasePermission]
-
-    def get_queryset(self):
-        return (
-            Project.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(
-                Q(
-                    project_projectmember__member=self.request.user,
-                    project_projectmember__is_active=True,
-                )
-                | Q(network=2)
-            )
-            .select_related(
-                "workspace", "workspace__owner", "default_assignee", "project_lead"
-            )
-            .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(
-                    DeployBoard.objects.filter(
-                        project_id=OuterRef("pk"),
-                        workspace__slug=self.kwargs.get("slug"),
-                    )
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, pk=None):
-        if pk is None:
-            sort_order_query = ProjectMember.objects.filter(
-                member=request.user,
-                project_id=OuterRef("pk"),
-                workspace__slug=self.kwargs.get("slug"),
-                is_active=True,
-            ).values("sort_order")
-            projects = (
-                self.get_queryset()
-                .annotate(sort_order=Subquery(sort_order_query))
-                .prefetch_related(
-                    Prefetch(
-                        "project_projectmember",
-                        queryset=ProjectMember.objects.filter(
-                            workspace__slug=slug, is_active=True
-                        ).select_related("member"),
-                    )
-                )
-                .order_by(request.GET.get("order_by", "sort_order"))
-            )
-            return self.paginate(
-                request=request,
-                queryset=(projects),
-                on_results=lambda projects: ProjectSerializer(
-                    projects, many=True, fields=self.fields, expand=self.expand
-                ).data,
-            )
-        project = self.get_queryset().get(workspace__slug=slug, pk=pk)
-        serializer = ProjectSerializer(project, fields=self.fields, expand=self.expand)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def post(self, request, slug):
-        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
-                _ = IssueUserProperty.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
-                    IssueUserProperty.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()
-
-                # Model activity
-                model_activity.delay(
-                    model_name="project",
-                    model_id=str(project.id),
-                    requested_data=request.data,
-                    current_instance=None,
-                    actor_id=request.user.id,
-                    slug=slug,
-                    origin=request.META.get("HTTP_ORIGIN"),
-                )
-
-                serializer = ProjectSerializer(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:
-            return Response(
-                {"error": "Workspace does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except ValidationError:
-            return Response(
-                {"identifier": "The project identifier is already taken"},
-                status=status.HTTP_410_GONE,
-            )
-
-    def patch(self, request, slug, pk):
-        try:
-            workspace = Workspace.objects.get(slug=slug)
-            project = Project.objects.get(pk=pk)
-            current_instance = json.dumps(
-                ProjectSerializer(project).data, cls=DjangoJSONEncoder
-            )
-
-            intake_view = request.data.get(
-                "inbox_view", request.data.get("intake_view", project.intake_view)
-            )
-
-            if project.archived_at:
-                return Response(
-                    {"error": "Archived project cannot be updated"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            serializer = ProjectSerializer(
-                project,
-                data={**request.data, "intake_view": intake_view},
-                context={"workspace_id": workspace.id},
-                partial=True,
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                if serializer.data["intake_view"]:
-                    intake = Intake.objects.filter(
-                        project=project, is_default=True
-                    ).first()
-                    if not intake:
-                        Intake.objects.create(
-                            name=f"{project.name} Intake",
-                            project=project,
-                            is_default=True,
-                        )
-
-                    # Create the triage state in Backlog group
-                    State.objects.get_or_create(
-                        name="Triage",
-                        group="triage",
-                        description="Default state for managing all Intake Issues",
-                        project_id=pk,
-                        color="#ff7700",
-                        is_triage=True,
-                    )
-
-                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
-
-                model_activity.delay(
-                    model_name="project",
-                    model_id=str(project.id),
-                    requested_data=request.data,
-                    current_instance=current_instance,
-                    actor_id=request.user.id,
-                    slug=slug,
-                    origin=request.META.get("HTTP_ORIGIN"),
-                )
-
-                serializer = ProjectSerializer(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 ValidationError:
-            return Response(
-                {"identifier": "The project identifier is already taken"},
-                status=status.HTTP_410_GONE,
-            )
-
-    def delete(self, request, slug, pk):
-        project = Project.objects.get(pk=pk, workspace__slug=slug)
-        # Delete the user favorite cycle
-        UserFavorite.objects.filter(
-            entity_type="project", entity_identifier=pk, project_id=pk
-        ).delete()
-        project.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class ProjectArchiveUnarchiveAPIEndpoint(BaseAPIView):
-    permission_classes = [ProjectBasePermission]
-
-    def post(self, request, slug, project_id):
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-        project.archived_at = timezone.now()
-        project.save()
-        UserFavorite.objects.filter(workspace__slug=slug, project=project_id).delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    def delete(self, request, slug, project_id):
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-        project.archived_at = None
-        project.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,126 +0,0 @@
-from .base import BaseSerializer
-from .user import (
-    UserSerializer,
-    UserLiteSerializer,
-    ChangePasswordSerializer,
-    ResetPasswordSerializer,
-    UserAdminLiteSerializer,
-    UserMeSerializer,
-    UserMeSettingsSerializer,
-    ProfileSerializer,
-    AccountSerializer,
-)
-from .workspace import (
-    WorkSpaceSerializer,
-    WorkSpaceMemberSerializer,
-    WorkSpaceMemberInviteSerializer,
-    WorkspaceLiteSerializer,
-    WorkspaceThemeSerializer,
-    WorkspaceMemberAdminSerializer,
-    WorkspaceMemberMeSerializer,
-    WorkspaceUserPropertiesSerializer,
-)
-from .project import (
-    ProjectSerializer,
-    ProjectListSerializer,
-    ProjectDetailSerializer,
-    ProjectMemberSerializer,
-    ProjectMemberInviteSerializer,
-    ProjectIdentifierSerializer,
-    ProjectLiteSerializer,
-    ProjectMemberLiteSerializer,
-    DeployBoardSerializer,
-    ProjectMemberAdminSerializer,
-    ProjectPublicMemberSerializer,
-    ProjectMemberRoleSerializer,
-)
-from .state import StateSerializer, StateLiteSerializer
-from .view import IssueViewSerializer
-from .cycle import (
-    CycleSerializer,
-    CycleIssueSerializer,
-    CycleWriteSerializer,
-    CycleUserPropertiesSerializer,
-)
-from .asset import FileAssetSerializer
-from .issue import (
-    IssueCreateSerializer,
-    IssueActivitySerializer,
-    IssueCommentSerializer,
-    IssueUserPropertySerializer,
-    IssueAssigneeSerializer,
-    LabelSerializer,
-    IssueSerializer,
-    IssueFlatSerializer,
-    IssueStateSerializer,
-    IssueLinkSerializer,
-    IssueIntakeSerializer,
-    IssueLiteSerializer,
-    IssueAttachmentSerializer,
-    IssueSubscriberSerializer,
-    IssueReactionSerializer,
-    CommentReactionSerializer,
-    IssueVoteSerializer,
-    IssueRelationSerializer,
-    RelatedIssueSerializer,
-    IssuePublicSerializer,
-    IssueDetailSerializer,
-    IssueReactionLiteSerializer,
-    IssueAttachmentLiteSerializer,
-    IssueLinkLiteSerializer,
-)
-
-from .module import (
-    ModuleDetailSerializer,
-    ModuleWriteSerializer,
-    ModuleSerializer,
-    ModuleIssueSerializer,
-    ModuleLinkSerializer,
-    ModuleUserPropertiesSerializer,
-)
-
-from .api import APITokenSerializer, APITokenReadSerializer
-
-from .importer import ImporterSerializer
-
-from .page import (
-    PageSerializer,
-    PageLogSerializer,
-    SubPageSerializer,
-    PageDetailSerializer,
-    PageVersionSerializer,
-    PageVersionDetailSerializer,
-)
-
-from .estimate import (
-    EstimateSerializer,
-    EstimatePointSerializer,
-    EstimateReadSerializer,
-    WorkspaceEstimateSerializer,
-)
-
-from .intake import (
-    IntakeSerializer,
-    IntakeIssueSerializer,
-    IssueStateIntakeSerializer,
-    IntakeIssueLiteSerializer,
-    IntakeIssueDetailSerializer,
-)
-
-from .analytic import AnalyticViewSerializer
-
-from .notification import NotificationSerializer, UserNotificationPreferenceSerializer
-
-from .exporter import ExporterHistorySerializer
-
-from .webhook import WebhookSerializer, WebhookLogSerializer
-
-from .dashboard import DashboardSerializer, WidgetSerializer
-
-from .favorite import UserFavoriteSerializer
-
-from .draft import (
-    DraftIssueCreateSerializer,
-    DraftIssueSerializer,
-    DraftIssueDetailSerializer,
-)
@@ -1,28 +0,0 @@
-from .base import BaseSerializer
-from plane.db.models import APIToken, APIActivityLog
-
-
-class APITokenSerializer(BaseSerializer):
-    class Meta:
-        model = APIToken
-        fields = "__all__"
-        read_only_fields = [
-            "token",
-            "expired_at",
-            "created_at",
-            "updated_at",
-            "workspace",
-            "user",
-        ]
-
-
-class APITokenReadSerializer(BaseSerializer):
-    class Meta:
-        model = APIToken
-        exclude = ("token",)
-
-
-class APIActivityLogSerializer(BaseSerializer):
-    class Meta:
-        model = APIActivityLog
-        fields = "__all__"
@@ -1,98 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from .base import BaseSerializer
-from .issue import IssueStateSerializer
-from plane.db.models import Cycle, CycleIssue, CycleUserProperties
-from plane.utils.timezone_converter import convert_to_utc
-
-
-class CycleWriteSerializer(BaseSerializer):
-    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")
-        if (
-            data.get("start_date", None) is not None
-            and data.get("end_date", None) is not None
-        ):
-            project_id = self.initial_data.get("project_id") or self.instance.project_id
-            data["start_date"] = convert_to_utc(
-                str(data.get("start_date").date()), project_id, is_start_date=True
-            )
-            data["end_date"] = convert_to_utc(
-                str(data.get("end_date", None).date()), project_id
-            )
-        return data
-
-    class Meta:
-        model = Cycle
-        fields = "__all__"
-        read_only_fields = ["workspace", "project", "owned_by", "archived_at"]
-
-
-class CycleSerializer(BaseSerializer):
-    # favorite
-    is_favorite = serializers.BooleanField(read_only=True)
-    total_issues = serializers.IntegerField(read_only=True)
-    # state group wise distribution
-    cancelled_issues = serializers.IntegerField(read_only=True)
-    completed_issues = serializers.IntegerField(read_only=True)
-    started_issues = serializers.IntegerField(read_only=True)
-    unstarted_issues = serializers.IntegerField(read_only=True)
-    backlog_issues = serializers.IntegerField(read_only=True)
-
-    # active | draft | upcoming | completed
-    status = serializers.CharField(read_only=True)
-
-    class Meta:
-        model = Cycle
-        fields = [
-            # necessary fields
-            "id",
-            "workspace_id",
-            "project_id",
-            # model fields
-            "name",
-            "description",
-            "start_date",
-            "end_date",
-            "owned_by_id",
-            "view_props",
-            "sort_order",
-            "external_source",
-            "external_id",
-            "progress_snapshot",
-            "logo_props",
-            # 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)
-
-    class Meta:
-        model = CycleIssue
-        fields = "__all__"
-        read_only_fields = ["workspace", "project", "cycle"]
-
-
-class CycleUserPropertiesSerializer(BaseSerializer):
-    class Meta:
-        model = CycleUserProperties
-        fields = "__all__"
-        read_only_fields = ["workspace", "project", "cycle" "user"]
@@ -1,21 +0,0 @@
-# Module imports
-from .base import BaseSerializer
-from plane.db.models import Dashboard, Widget
-
-# Third party frameworks
-from rest_framework import serializers
-
-
-class DashboardSerializer(BaseSerializer):
-    class Meta:
-        model = Dashboard
-        fields = "__all__"
-
-
-class WidgetSerializer(BaseSerializer):
-    is_visible = serializers.BooleanField(read_only=True)
-    widget_filters = serializers.JSONField(read_only=True)
-
-    class Meta:
-        model = Widget
-        fields = ["id", "key", "is_visible", "widget_filters"]
@@ -1,669 +0,0 @@
-# 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
-
-# Module imports
-from .base import BaseSerializer, DynamicBaseSerializer
-from .user import UserLiteSerializer
-from .state import StateLiteSerializer
-from .project import ProjectLiteSerializer
-from .workspace import WorkspaceLiteSerializer
-from plane.db.models import (
-    User,
-    Issue,
-    IssueActivity,
-    IssueComment,
-    IssueUserProperty,
-    IssueAssignee,
-    IssueSubscriber,
-    IssueLabel,
-    Label,
-    CycleIssue,
-    Cycle,
-    Module,
-    ModuleIssue,
-    IssueLink,
-    FileAsset,
-    IssueReaction,
-    CommentReaction,
-    IssueVote,
-    IssueRelation,
-    State,
-)
-
-
-class IssueFlatSerializer(BaseSerializer):
-    ## Contain only flat fields
-
-    class Meta:
-        model = Issue
-        fields = [
-            "id",
-            "name",
-            "description",
-            "description_html",
-            "priority",
-            "start_date",
-            "target_date",
-            "sequence_id",
-            "sort_order",
-            "is_draft",
-        ]
-
-
-class IssueProjectLiteSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
-
-    class Meta:
-        model = Issue
-        fields = ["id", "project_detail", "name", "sequence_id"]
-        read_only_fields = fields
-
-
-##TODO: Find a better way to write this serializer
-## Find a better approach to save manytomany?
-class IssueCreateSerializer(BaseSerializer):
-    # ids
-    state_id = serializers.PrimaryKeyRelatedField(
-        source="state", queryset=State.objects.all(), required=False, allow_null=True
-    )
-    parent_id = serializers.PrimaryKeyRelatedField(
-        source="parent", queryset=Issue.objects.all(), required=False, allow_null=True
-    )
-    label_ids = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
-        write_only=True,
-        required=False,
-    )
-    assignee_ids = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
-        write_only=True,
-        required=False,
-    )
-    project_id = serializers.UUIDField(source="project.id", read_only=True)
-    workspace_id = serializers.UUIDField(source="workspace.id", read_only=True)
-
-    class Meta:
-        model = Issue
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-    def to_representation(self, instance):
-        data = super().to_representation(instance)
-        assignee_ids = self.initial_data.get("assignee_ids")
-        data["assignee_ids"] = assignee_ids if assignee_ids else []
-        label_ids = self.initial_data.get("label_ids")
-        data["label_ids"] = label_ids if label_ids else []
-        return data
-
-    def validate(self, data):
-        if (
-            data.get("start_date", None) is not None
-            and data.get("target_date", None) is not None
-            and data.get("start_date", None) > data.get("target_date", None)
-        ):
-            raise serializers.ValidationError("Start date cannot exceed target date")
-        return data
-
-    def create(self, validated_data):
-        assignees = validated_data.pop("assignee_ids", None)
-        labels = validated_data.pop("label_ids", None)
-
-        project_id = self.context["project_id"]
-        workspace_id = self.context["workspace_id"]
-        default_assignee_id = self.context["default_assignee_id"]
-
-        # Create Issue
-        issue = Issue.objects.create(**validated_data, project_id=project_id)
-
-        # Issue Audit Users
-        created_by_id = issue.created_by_id
-        updated_by_id = issue.updated_by_id
-
-        if assignees is not None and len(assignees):
-            IssueAssignee.objects.bulk_create(
-                [
-                    IssueAssignee(
-                        assignee=user,
-                        issue=issue,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for user in assignees
-                ],
-                batch_size=10,
-            )
-        else:
-            # Then assign it to default assignee
-            if default_assignee_id is not None:
-                IssueAssignee.objects.create(
-                    assignee_id=default_assignee_id,
-                    issue=issue,
-                    project_id=project_id,
-                    workspace_id=workspace_id,
-                    created_by_id=created_by_id,
-                    updated_by_id=updated_by_id,
-                )
-
-        if labels is not None and len(labels):
-            IssueLabel.objects.bulk_create(
-                [
-                    IssueLabel(
-                        label=label,
-                        issue=issue,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for label in labels
-                ],
-                batch_size=10,
-            )
-
-        return issue
-
-    def update(self, instance, validated_data):
-        assignees = validated_data.pop("assignee_ids", None)
-        labels = validated_data.pop("label_ids", None)
-
-        # Related models
-        project_id = instance.project_id
-        workspace_id = instance.workspace_id
-        created_by_id = instance.created_by_id
-        updated_by_id = instance.updated_by_id
-
-        if assignees is not None:
-            IssueAssignee.objects.filter(issue=instance).delete()
-            IssueAssignee.objects.bulk_create(
-                [
-                    IssueAssignee(
-                        assignee=user,
-                        issue=instance,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for user in assignees
-                ],
-                batch_size=10,
-            )
-
-        if labels is not None:
-            IssueLabel.objects.filter(issue=instance).delete()
-            IssueLabel.objects.bulk_create(
-                [
-                    IssueLabel(
-                        label=label,
-                        issue=instance,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for label in labels
-                ],
-                batch_size=10,
-            )
-
-        # Time updation occues even when other related models are updated
-        instance.updated_at = timezone.now()
-        return super().update(instance, validated_data)
-
-
-class IssueActivitySerializer(BaseSerializer):
-    actor_detail = UserLiteSerializer(read_only=True, source="actor")
-    issue_detail = IssueFlatSerializer(read_only=True, source="issue")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-
-    class Meta:
-        model = IssueActivity
-        fields = "__all__"
-
-
-class IssueUserPropertySerializer(BaseSerializer):
-    class Meta:
-        model = IssueUserProperty
-        fields = "__all__"
-        read_only_fields = ["user", "workspace", "project"]
-
-
-class LabelSerializer(BaseSerializer):
-    class Meta:
-        model = Label
-        fields = [
-            "parent",
-            "name",
-            "color",
-            "id",
-            "project_id",
-            "workspace_id",
-            "sort_order",
-        ]
-        read_only_fields = ["workspace", "project"]
-
-
-class LabelLiteSerializer(BaseSerializer):
-    class Meta:
-        model = Label
-        fields = ["id", "name", "color"]
-
-
-class IssueLabelSerializer(BaseSerializer):
-    class Meta:
-        model = IssueLabel
-        fields = "__all__"
-        read_only_fields = ["workspace", "project"]
-
-
-class IssueRelationSerializer(BaseSerializer):
-    id = serializers.UUIDField(source="related_issue.id", read_only=True)
-    project_id = serializers.PrimaryKeyRelatedField(
-        source="related_issue.project_id", read_only=True
-    )
-    sequence_id = serializers.IntegerField(
-        source="related_issue.sequence_id", read_only=True
-    )
-    name = serializers.CharField(source="related_issue.name", read_only=True)
-    relation_type = serializers.CharField(read_only=True)
-
-    class Meta:
-        model = IssueRelation
-        fields = ["id", "project_id", "sequence_id", "relation_type", "name"]
-        read_only_fields = ["workspace", "project"]
-
-
-class RelatedIssueSerializer(BaseSerializer):
-    id = serializers.UUIDField(source="issue.id", read_only=True)
-    project_id = serializers.PrimaryKeyRelatedField(
-        source="issue.project_id", read_only=True
-    )
-    sequence_id = serializers.IntegerField(source="issue.sequence_id", read_only=True)
-    name = serializers.CharField(source="issue.name", read_only=True)
-    relation_type = serializers.CharField(read_only=True)
-
-    class Meta:
-        model = IssueRelation
-        fields = ["id", "project_id", "sequence_id", "relation_type", "name"]
-        read_only_fields = ["workspace", "project"]
-
-
-class IssueAssigneeSerializer(BaseSerializer):
-    assignee_details = UserLiteSerializer(read_only=True, source="assignee")
-
-    class Meta:
-        model = IssueAssignee
-        fields = "__all__"
-
-
-class CycleBaseSerializer(BaseSerializer):
-    class Meta:
-        model = Cycle
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueCycleDetailSerializer(BaseSerializer):
-    cycle_detail = CycleBaseSerializer(read_only=True, source="cycle")
-
-    class Meta:
-        model = CycleIssue
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class ModuleBaseSerializer(BaseSerializer):
-    class Meta:
-        model = Module
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueModuleDetailSerializer(BaseSerializer):
-    module_detail = ModuleBaseSerializer(read_only=True, source="module")
-
-    class Meta:
-        model = ModuleIssue
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueLinkSerializer(BaseSerializer):
-    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
-
-    class Meta:
-        model = IssueLink
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-            "issue",
-        ]
-
-    def to_internal_value(self, data):
-        # Modify the URL before validation by appending http:// if missing
-        url = data.get("url", "")
-        if url and not url.startswith(("http://", "https://")):
-            data["url"] = "http://" + url
-
-        return super().to_internal_value(data)
-
-    def validate_url(self, value):
-        # Use Django's built-in URLValidator for validation
-        url_validator = URLValidator()
-        try:
-            url_validator(value)
-        except ValidationError:
-            raise serializers.ValidationError({"error": "Invalid URL format."})
-
-        return value
-
-    # Validation if url already exists
-    def create(self, validated_data):
-        if IssueLink.objects.filter(
-            url=validated_data.get("url"), issue_id=validated_data.get("issue_id")
-        ).exists():
-            raise serializers.ValidationError(
-                {"error": "URL already exists for this Issue"}
-            )
-        return IssueLink.objects.create(**validated_data)
-
-    def update(self, instance, validated_data):
-        if (
-            IssueLink.objects.filter(
-                url=validated_data.get("url"), issue_id=instance.issue_id
-            )
-            .exclude(pk=instance.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):
-    asset_url = serializers.CharField(read_only=True)
-
-    class Meta:
-        model = FileAsset
-        fields = "__all__"
-        read_only_fields = [
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-            "workspace",
-            "project",
-            "issue",
-        ]
-
-
-class IssueAttachmentLiteSerializer(DynamicBaseSerializer):
-    class Meta:
-        model = FileAsset
-        fields = [
-            "id",
-            "asset",
-            "attributes",
-            # "issue_id",
-            "updated_at",
-            "updated_by",
-            "asset_url",
-        ]
-        read_only_fields = fields
-
-
-class IssueReactionSerializer(BaseSerializer):
-    actor_detail = UserLiteSerializer(read_only=True, source="actor")
-
-    class Meta:
-        model = IssueReaction
-        fields = "__all__"
-        read_only_fields = ["workspace", "project", "issue", "actor", "deleted_at"]
-
-
-class IssueReactionLiteSerializer(DynamicBaseSerializer):
-    class Meta:
-        model = IssueReaction
-        fields = ["id", "actor", "issue", "reaction"]
-
-
-class CommentReactionSerializer(BaseSerializer):
-    class Meta:
-        model = CommentReaction
-        fields = "__all__"
-        read_only_fields = ["workspace", "project", "comment", "actor", "deleted_at"]
-
-
-class IssueVoteSerializer(BaseSerializer):
-    actor_detail = UserLiteSerializer(read_only=True, source="actor")
-
-    class Meta:
-        model = IssueVote
-        fields = ["issue", "vote", "workspace", "project", "actor", "actor_detail"]
-        read_only_fields = fields
-
-
-class IssueCommentSerializer(BaseSerializer):
-    actor_detail = UserLiteSerializer(read_only=True, source="actor")
-    issue_detail = IssueFlatSerializer(read_only=True, source="issue")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-    comment_reactions = CommentReactionSerializer(read_only=True, many=True)
-    is_member = serializers.BooleanField(read_only=True)
-
-    class Meta:
-        model = IssueComment
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueStateFlatSerializer(BaseSerializer):
-    state_detail = StateLiteSerializer(read_only=True, source="state")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-
-    class Meta:
-        model = Issue
-        fields = ["id", "sequence_id", "name", "state_detail", "project_detail"]
-
-
-# Issue Serializer with state details
-class IssueStateSerializer(DynamicBaseSerializer):
-    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
-    state_detail = StateLiteSerializer(read_only=True, source="state")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
-    sub_issues_count = serializers.IntegerField(read_only=True)
-    attachment_count = serializers.IntegerField(read_only=True)
-    link_count = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = Issue
-        fields = "__all__"
-
-
-class IssueIntakeSerializer(DynamicBaseSerializer):
-    label_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
-
-    class Meta:
-        model = Issue
-        fields = [
-            "id",
-            "name",
-            "priority",
-            "sequence_id",
-            "project_id",
-            "created_at",
-            "label_ids",
-            "created_by",
-        ]
-        read_only_fields = fields
-
-
-class IssueSerializer(DynamicBaseSerializer):
-    # ids
-    cycle_id = serializers.PrimaryKeyRelatedField(read_only=True)
-    module_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
-
-    # Many to many
-    label_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
-    assignee_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
-
-    # Count items
-    sub_issues_count = serializers.IntegerField(read_only=True)
-    attachment_count = serializers.IntegerField(read_only=True)
-    link_count = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = Issue
-        fields = [
-            "id",
-            "name",
-            "state_id",
-            "sort_order",
-            "completed_at",
-            "estimate_point",
-            "priority",
-            "start_date",
-            "target_date",
-            "sequence_id",
-            "project_id",
-            "parent_id",
-            "cycle_id",
-            "module_ids",
-            "label_ids",
-            "assignee_ids",
-            "sub_issues_count",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-            "attachment_count",
-            "link_count",
-            "is_draft",
-            "archived_at",
-        ]
-        read_only_fields = fields
-
-
-class IssueLiteSerializer(DynamicBaseSerializer):
-    class Meta:
-        model = Issue
-        fields = ["id", "sequence_id", "project_id"]
-        read_only_fields = fields
-
-
-class IssueDetailSerializer(IssueSerializer):
-    description_html = serializers.CharField()
-    is_subscribed = serializers.BooleanField(read_only=True)
-
-    class Meta(IssueSerializer.Meta):
-        fields = IssueSerializer.Meta.fields + ["description_html", "is_subscribed"]
-        read_only_fields = fields
-
-
-class IssuePublicSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    state_detail = StateLiteSerializer(read_only=True, source="state")
-    reactions = IssueReactionSerializer(
-        read_only=True, many=True, source="issue_reactions"
-    )
-    votes = IssueVoteSerializer(read_only=True, many=True)
-
-    class Meta:
-        model = Issue
-        fields = [
-            "id",
-            "name",
-            "description_html",
-            "sequence_id",
-            "state",
-            "state_detail",
-            "project",
-            "project_detail",
-            "workspace",
-            "priority",
-            "target_date",
-            "reactions",
-            "votes",
-        ]
-        read_only_fields = fields
-
-
-class IssueSubscriberSerializer(BaseSerializer):
-    class Meta:
-        model = IssueSubscriber
-        fields = "__all__"
-        read_only_fields = ["workspace", "project", "issue"]
@@ -1,184 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from .base import BaseSerializer
-from plane.db.models import (
-    Page,
-    PageLog,
-    PageLabel,
-    Label,
-    ProjectPage,
-    Project,
-    PageVersion,
-)
-
-
-class PageSerializer(BaseSerializer):
-    is_favorite = serializers.BooleanField(read_only=True)
-    labels = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
-        write_only=True,
-        required=False,
-    )
-    # Many to many
-    label_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
-    project_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
-
-    class Meta:
-        model = Page
-        fields = [
-            "id",
-            "name",
-            "owned_by",
-            "access",
-            "color",
-            "labels",
-            "parent",
-            "is_favorite",
-            "is_locked",
-            "archived_at",
-            "workspace",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-            "view_props",
-            "logo_props",
-            "label_ids",
-            "project_ids",
-        ]
-        read_only_fields = ["workspace", "owned_by"]
-
-    def create(self, validated_data):
-        labels = validated_data.pop("labels", None)
-        project_id = self.context["project_id"]
-        owned_by_id = self.context["owned_by_id"]
-        description_html = self.context["description_html"]
-
-        # Get the workspace id from the project
-        project = Project.objects.get(pk=project_id)
-
-        # Create the page
-        page = Page.objects.create(
-            **validated_data,
-            description_html=description_html,
-            owned_by_id=owned_by_id,
-            workspace_id=project.workspace_id,
-        )
-
-        # Create the project page
-        ProjectPage.objects.create(
-            workspace_id=page.workspace_id,
-            project_id=project_id,
-            page_id=page.id,
-            created_by_id=page.created_by_id,
-            updated_by_id=page.updated_by_id,
-        )
-
-        # Create page labels
-        if labels is not None:
-            PageLabel.objects.bulk_create(
-                [
-                    PageLabel(
-                        label=label,
-                        page=page,
-                        workspace_id=page.workspace_id,
-                        created_by_id=page.created_by_id,
-                        updated_by_id=page.updated_by_id,
-                    )
-                    for label in labels
-                ],
-                batch_size=10,
-            )
-        return page
-
-    def update(self, instance, validated_data):
-        labels = validated_data.pop("labels", None)
-        if labels is not None:
-            PageLabel.objects.filter(page=instance).delete()
-            PageLabel.objects.bulk_create(
-                [
-                    PageLabel(
-                        label=label,
-                        page=instance,
-                        workspace_id=instance.workspace_id,
-                        created_by_id=instance.created_by_id,
-                        updated_by_id=instance.updated_by_id,
-                    )
-                    for label in labels
-                ],
-                batch_size=10,
-            )
-
-        return super().update(instance, validated_data)
-
-
-class PageDetailSerializer(PageSerializer):
-    description_html = serializers.CharField()
-
-    class Meta(PageSerializer.Meta):
-        fields = PageSerializer.Meta.fields + ["description_html"]
-
-
-class SubPageSerializer(BaseSerializer):
-    entity_details = serializers.SerializerMethodField()
-
-    class Meta:
-        model = PageLog
-        fields = "__all__"
-        read_only_fields = ["workspace", "page"]
-
-    def get_entity_details(self, obj):
-        entity_name = obj.entity_name
-        if entity_name == "forward_link" or entity_name == "back_link":
-            try:
-                page = Page.objects.get(pk=obj.entity_identifier)
-                return PageSerializer(page).data
-            except Page.DoesNotExist:
-                return None
-        return None
-
-
-class PageLogSerializer(BaseSerializer):
-    class Meta:
-        model = PageLog
-        fields = "__all__"
-        read_only_fields = ["workspace", "page"]
-
-
-class PageVersionSerializer(BaseSerializer):
-    class Meta:
-        model = PageVersion
-        fields = [
-            "id",
-            "workspace",
-            "page",
-            "last_saved_at",
-            "owned_by",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-        ]
-        read_only_fields = ["workspace", "page"]
-
-
-class PageVersionDetailSerializer(BaseSerializer):
-    class Meta:
-        model = PageVersion
-        fields = [
-            "id",
-            "workspace",
-            "page",
-            "last_saved_at",
-            "description_binary",
-            "description_html",
-            "description_json",
-            "owned_by",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-        ]
-        read_only_fields = ["workspace", "page"]
@@ -1,215 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from .base import BaseSerializer, DynamicBaseSerializer
-from plane.app.serializers.workspace import WorkspaceLiteSerializer
-from plane.app.serializers.user import UserLiteSerializer, UserAdminLiteSerializer
-from plane.db.models import (
-    Project,
-    ProjectMember,
-    ProjectMemberInvite,
-    ProjectIdentifier,
-    DeployBoard,
-    ProjectPublicMember,
-)
-
-
-class ProjectSerializer(BaseSerializer):
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
-    inbox_view = serializers.BooleanField(read_only=True, source="intake_view")
-
-    class Meta:
-        model = Project
-        fields = "__all__"
-        read_only_fields = ["workspace", "deleted_at"]
-
-    def create(self, validated_data):
-        identifier = validated_data.get("identifier", "").strip().upper()
-        if identifier == "":
-            raise serializers.ValidationError(detail="Project Identifier is required")
-
-        if ProjectIdentifier.objects.filter(
-            name=identifier, workspace_id=self.context["workspace_id"]
-        ).exists():
-            raise serializers.ValidationError(detail="Project Identifier is taken")
-        project = Project.objects.create(
-            **validated_data, workspace_id=self.context["workspace_id"]
-        )
-        _ = ProjectIdentifier.objects.create(
-            name=project.identifier,
-            project=project,
-            workspace_id=self.context["workspace_id"],
-        )
-        return project
-
-    def update(self, instance, validated_data):
-        identifier = validated_data.get("identifier", "").strip().upper()
-
-        # If identifier is not passed update the project and return
-        if identifier == "":
-            project = super().update(instance, validated_data)
-            return project
-
-        # If no Project Identifier is found create it
-        project_identifier = ProjectIdentifier.objects.filter(
-            name=identifier, workspace_id=instance.workspace_id
-        ).first()
-        if project_identifier is None:
-            project = super().update(instance, validated_data)
-            project_identifier = ProjectIdentifier.objects.filter(
-                project=project
-            ).first()
-            if project_identifier is not None:
-                project_identifier.name = identifier
-                project_identifier.save()
-            return project
-        # If found check if the project_id to be updated and identifier project id is same
-        if project_identifier.project_id == instance.id:
-            # If same pass update
-            project = super().update(instance, validated_data)
-            return project
-
-        # If not same fail update
-        raise serializers.ValidationError(detail="Project Identifier is already taken")
-
-
-class ProjectLiteSerializer(BaseSerializer):
-    class Meta:
-        model = Project
-        fields = [
-            "id",
-            "identifier",
-            "name",
-            "cover_image",
-            "cover_image_url",
-            "logo_props",
-            "description",
-        ]
-        read_only_fields = fields
-
-
-class ProjectListSerializer(DynamicBaseSerializer):
-    total_issues = serializers.IntegerField(read_only=True)
-    archived_issues = serializers.IntegerField(read_only=True)
-    archived_sub_issues = serializers.IntegerField(read_only=True)
-    draft_issues = serializers.IntegerField(read_only=True)
-    draft_sub_issues = serializers.IntegerField(read_only=True)
-    sub_issues = serializers.IntegerField(read_only=True)
-    is_favorite = serializers.BooleanField(read_only=True)
-    total_members = serializers.IntegerField(read_only=True)
-    total_cycles = serializers.IntegerField(read_only=True)
-    total_modules = serializers.IntegerField(read_only=True)
-    is_member = serializers.BooleanField(read_only=True)
-    sort_order = serializers.FloatField(read_only=True)
-    member_role = serializers.IntegerField(read_only=True)
-    anchor = serializers.CharField(read_only=True)
-    members = serializers.SerializerMethodField()
-    cover_image_url = serializers.CharField(read_only=True)
-    inbox_view = serializers.BooleanField(read_only=True, source="intake_view")
-
-    def get_members(self, obj):
-        project_members = getattr(obj, "members_list", None)
-        if project_members is not None:
-            # Filter members by the project ID
-            return [
-                {
-                    "id": member.id,
-                    "member_id": member.member_id,
-                    "member__display_name": member.member.display_name,
-                    "member__avatar": member.member.avatar,
-                    "member__avatar_url": member.member.avatar_url,
-                }
-                for member in project_members
-            ]
-        return []
-
-    class Meta:
-        model = Project
-        fields = "__all__"
-
-
-class ProjectDetailSerializer(BaseSerializer):
-    # workspace = WorkSpaceSerializer(read_only=True)
-    default_assignee = UserLiteSerializer(read_only=True)
-    project_lead = UserLiteSerializer(read_only=True)
-    is_favorite = serializers.BooleanField(read_only=True)
-    total_members = serializers.IntegerField(read_only=True)
-    total_cycles = serializers.IntegerField(read_only=True)
-    total_modules = serializers.IntegerField(read_only=True)
-    is_member = serializers.BooleanField(read_only=True)
-    sort_order = serializers.FloatField(read_only=True)
-    member_role = serializers.IntegerField(read_only=True)
-    anchor = serializers.CharField(read_only=True)
-
-    class Meta:
-        model = Project
-        fields = "__all__"
-
-
-class ProjectMemberSerializer(BaseSerializer):
-    workspace = WorkspaceLiteSerializer(read_only=True)
-    project = ProjectLiteSerializer(read_only=True)
-    member = UserLiteSerializer(read_only=True)
-
-    class Meta:
-        model = ProjectMember
-        fields = "__all__"
-
-
-class ProjectMemberAdminSerializer(BaseSerializer):
-    workspace = WorkspaceLiteSerializer(read_only=True)
-    project = ProjectLiteSerializer(read_only=True)
-    member = UserAdminLiteSerializer(read_only=True)
-
-    class Meta:
-        model = ProjectMember
-        fields = "__all__"
-
-
-class ProjectMemberRoleSerializer(DynamicBaseSerializer):
-    class Meta:
-        model = ProjectMember
-        fields = ("id", "role", "member", "project")
-
-
-class ProjectMemberInviteSerializer(BaseSerializer):
-    project = ProjectLiteSerializer(read_only=True)
-    workspace = WorkspaceLiteSerializer(read_only=True)
-
-    class Meta:
-        model = ProjectMemberInvite
-        fields = "__all__"
-
-
-class ProjectIdentifierSerializer(BaseSerializer):
-    class Meta:
-        model = ProjectIdentifier
-        fields = "__all__"
-
-
-class ProjectMemberLiteSerializer(BaseSerializer):
-    member = UserLiteSerializer(read_only=True)
-    is_subscribed = serializers.BooleanField(read_only=True)
-
-    class Meta:
-        model = ProjectMember
-        fields = ["member", "id", "is_subscribed"]
-        read_only_fields = fields
-
-
-class DeployBoardSerializer(BaseSerializer):
-    project_details = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-
-    class Meta:
-        model = DeployBoard
-        fields = "__all__"
-        read_only_fields = ["workspace", "project", "anchor"]
-
-
-class ProjectPublicMemberSerializer(BaseSerializer):
-    class Meta:
-        model = ProjectPublicMember
-        fields = "__all__"
-        read_only_fields = ["workspace", "project", "member"]
@@ -1,29 +0,0 @@
-# Module imports
-from .base import BaseSerializer
-
-
-from plane.db.models import State
-
-
-class StateSerializer(BaseSerializer):
-    class Meta:
-        model = State
-        fields = [
-            "id",
-            "project_id",
-            "workspace_id",
-            "name",
-            "color",
-            "group",
-            "default",
-            "description",
-            "sequence",
-        ]
-        read_only_fields = ["workspace", "project"]
-
-
-class StateLiteSerializer(BaseSerializer):
-    class Meta:
-        model = State
-        fields = ["id", "name", "color", "group"]
-        read_only_fields = fields
@@ -1,209 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module import
-from plane.db.models import Account, Profile, User, Workspace, WorkspaceMemberInvite
-
-from .base import BaseSerializer
-
-
-class UserSerializer(BaseSerializer):
-    class Meta:
-        model = User
-        # Exclude password field from the serializer
-        fields = [field.name for field in User._meta.fields if field.name != "password"]
-        # Make all system fields and email read only
-        read_only_fields = [
-            "id",
-            "username",
-            "mobile_number",
-            "email",
-            "token",
-            "created_at",
-            "updated_at",
-            "is_superuser",
-            "is_staff",
-            "is_managed",
-            "last_active",
-            "last_login_time",
-            "last_logout_time",
-            "last_login_ip",
-            "last_logout_ip",
-            "last_login_uagent",
-            "last_location",
-            "last_login_medium",
-            "created_location",
-            "is_bot",
-            "is_password_autoset",
-            "is_email_verified",
-            "is_active",
-            "token_updated_at",
-        ]
-
-        # If the user has already filled first name or last name then he is onboarded
-        def get_is_onboarded(self, obj):
-            return bool(obj.first_name) or bool(obj.last_name)
-
-
-class UserMeSerializer(BaseSerializer):
-    class Meta:
-        model = User
-        fields = [
-            "id",
-            "avatar",
-            "cover_image",
-            "avatar_url",
-            "cover_image_url",
-            "date_joined",
-            "display_name",
-            "email",
-            "first_name",
-            "last_name",
-            "is_active",
-            "is_bot",
-            "is_email_verified",
-            "user_timezone",
-            "username",
-            "is_password_autoset",
-            "is_email_verified",
-            "last_login_medium",
-        ]
-        read_only_fields = fields
-
-
-class UserMeSettingsSerializer(BaseSerializer):
-    workspace = serializers.SerializerMethodField()
-
-    class Meta:
-        model = User
-        fields = ["id", "email", "workspace"]
-        read_only_fields = fields
-
-    def get_workspace(self, obj):
-        workspace_invites = WorkspaceMemberInvite.objects.filter(
-            email=obj.email
-        ).count()
-
-        # profile
-        profile = Profile.objects.get(user=obj)
-        if (
-            profile.last_workspace_id is not None
-            and Workspace.objects.filter(
-                pk=profile.last_workspace_id,
-                workspace_member__member=obj.id,
-                workspace_member__is_active=True,
-            ).exists()
-        ):
-            workspace = Workspace.objects.filter(
-                pk=profile.last_workspace_id,
-                workspace_member__member=obj.id,
-                workspace_member__is_active=True,
-            ).first()
-            return {
-                "last_workspace_id": profile.last_workspace_id,
-                "last_workspace_slug": (
-                    workspace.slug if workspace is not None else ""
-                ),
-                "fallback_workspace_id": profile.last_workspace_id,
-                "fallback_workspace_slug": (
-                    workspace.slug if workspace is not None else ""
-                ),
-                "invites": workspace_invites,
-            }
-        else:
-            fallback_workspace = (
-                Workspace.objects.filter(
-                    workspace_member__member_id=obj.id, workspace_member__is_active=True
-                )
-                .order_by("created_at")
-                .first()
-            )
-            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
-                ),
-                "invites": workspace_invites,
-            }
-
-
-class UserLiteSerializer(BaseSerializer):
-    class Meta:
-        model = User
-        fields = [
-            "id",
-            "first_name",
-            "last_name",
-            "avatar",
-            "avatar_url",
-            "is_bot",
-            "display_name",
-        ]
-        read_only_fields = ["id", "is_bot"]
-
-
-class UserAdminLiteSerializer(BaseSerializer):
-    class Meta:
-        model = User
-        fields = [
-            "id",
-            "first_name",
-            "last_name",
-            "avatar",
-            "avatar_url",
-            "is_bot",
-            "display_name",
-            "email",
-            "last_login_medium",
-        ]
-        read_only_fields = ["id", "is_bot"]
-
-
-class ChangePasswordSerializer(serializers.Serializer):
-    model = User
-
-    """
-    Serializer for password change endpoint.
-    """
-    old_password = serializers.CharField(required=True)
-    new_password = serializers.CharField(required=True, min_length=8)
-    confirm_password = serializers.CharField(required=True, min_length=8)
-
-    def validate(self, data):
-        if data.get("old_password") == data.get("new_password"):
-            raise serializers.ValidationError(
-                {"error": "New password cannot be same as old password."}
-            )
-
-        if data.get("new_password") != data.get("confirm_password"):
-            raise serializers.ValidationError(
-                {"error": "Confirm password should be same as the new password."}
-            )
-
-        return data
-
-
-class ResetPasswordSerializer(serializers.Serializer):
-    """
-    Serializer for password change endpoint.
-    """
-
-    new_password = serializers.CharField(required=True, min_length=8)
-
-
-class ProfileSerializer(BaseSerializer):
-    class Meta:
-        model = Profile
-        fields = "__all__"
-        read_only_fields = ["user"]
-
-
-class AccountSerializer(BaseSerializer):
-    class Meta:
-        model = Account
-        fields = "__all__"
-        read_only_fields = ["user"]
@@ -1,108 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from .base import BaseSerializer, DynamicBaseSerializer
-from .user import UserLiteSerializer, UserAdminLiteSerializer
-
-from plane.db.models import (
-    Workspace,
-    WorkspaceMember,
-    WorkspaceMemberInvite,
-    WorkspaceTheme,
-    WorkspaceUserProperties,
-)
-from plane.utils.constants import RESTRICTED_WORKSPACE_SLUGS
-
-
-class WorkSpaceSerializer(DynamicBaseSerializer):
-    owner = UserLiteSerializer(read_only=True)
-    total_members = serializers.IntegerField(read_only=True)
-    total_issues = serializers.IntegerField(read_only=True)
-    logo_url = serializers.CharField(read_only=True)
-
-    def validate_slug(self, value):
-        # Check if the slug is restricted
-        if value in RESTRICTED_WORKSPACE_SLUGS:
-            raise serializers.ValidationError("Slug is not valid")
-        return value
-
-    class Meta:
-        model = Workspace
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-            "owner",
-            "logo_url",
-        ]
-
-
-class WorkspaceLiteSerializer(BaseSerializer):
-    class Meta:
-        model = Workspace
-        fields = ["name", "slug", "id"]
-        read_only_fields = fields
-
-
-class WorkSpaceMemberSerializer(DynamicBaseSerializer):
-    member = UserLiteSerializer(read_only=True)
-    workspace = WorkspaceLiteSerializer(read_only=True)
-
-    class Meta:
-        model = WorkspaceMember
-        fields = "__all__"
-
-
-class WorkspaceMemberMeSerializer(BaseSerializer):
-    draft_issue_count = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = WorkspaceMember
-        fields = "__all__"
-
-
-class WorkspaceMemberAdminSerializer(DynamicBaseSerializer):
-    member = UserAdminLiteSerializer(read_only=True)
-    workspace = WorkspaceLiteSerializer(read_only=True)
-
-    class Meta:
-        model = WorkspaceMember
-        fields = "__all__"
-
-
-class WorkSpaceMemberInviteSerializer(BaseSerializer):
-    workspace = WorkSpaceSerializer(read_only=True)
-    total_members = serializers.IntegerField(read_only=True)
-    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
-
-    class Meta:
-        model = WorkspaceMemberInvite
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "email",
-            "token",
-            "workspace",
-            "message",
-            "responded_at",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class WorkspaceThemeSerializer(BaseSerializer):
-    class Meta:
-        model = WorkspaceTheme
-        fields = "__all__"
-        read_only_fields = ["workspace", "actor"]
-
-
-class WorkspaceUserPropertiesSerializer(BaseSerializer):
-    class Meta:
-        model = WorkspaceUserProperties
-        fields = "__all__"
-        read_only_fields = ["workspace", "user"]
@@ -1,43 +0,0 @@
-from .analytic import urlpatterns as analytic_urls
-from .api import urlpatterns as api_urls
-from .asset import urlpatterns as asset_urls
-from .cycle import urlpatterns as cycle_urls
-from .dashboard import urlpatterns as dashboard_urls
-from .estimate import urlpatterns as estimate_urls
-from .external import urlpatterns as external_urls
-from .intake import urlpatterns as intake_urls
-from .issue import urlpatterns as issue_urls
-from .module import urlpatterns as module_urls
-from .notification import urlpatterns as notification_urls
-from .page import urlpatterns as page_urls
-from .project import urlpatterns as project_urls
-from .search import urlpatterns as search_urls
-from .state import urlpatterns as state_urls
-from .user import urlpatterns as user_urls
-from .views import urlpatterns as view_urls
-from .webhook import urlpatterns as webhook_urls
-from .workspace import urlpatterns as workspace_urls
-from .timezone import urlpatterns as timezone_urls
-
-urlpatterns = [
-    *analytic_urls,
-    *asset_urls,
-    *cycle_urls,
-    *dashboard_urls,
-    *estimate_urls,
-    *external_urls,
-    *intake_urls,
-    *issue_urls,
-    *module_urls,
-    *notification_urls,
-    *page_urls,
-    *project_urls,
-    *search_urls,
-    *state_urls,
-    *user_urls,
-    *view_urls,
-    *workspace_urls,
-    *api_urls,
-    *webhook_urls,
-    *timezone_urls,
-]
@@ -1,46 +0,0 @@
-from django.urls import path
-
-
-from plane.app.views import (
-    AnalyticsEndpoint,
-    AnalyticViewViewset,
-    SavedAnalyticEndpoint,
-    ExportAnalyticsEndpoint,
-    DefaultAnalyticsEndpoint,
-)
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/analytics/",
-        AnalyticsEndpoint.as_view(),
-        name="plane-analytics",
-    ),
-    path(
-        "workspaces/<str:slug>/analytic-view/",
-        AnalyticViewViewset.as_view({"get": "list", "post": "create"}),
-        name="analytic-view",
-    ),
-    path(
-        "workspaces/<str:slug>/analytic-view/<uuid:pk>/",
-        AnalyticViewViewset.as_view(
-            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
-        ),
-        name="analytic-view",
-    ),
-    path(
-        "workspaces/<str:slug>/saved-analytic-view/<uuid:analytic_id>/",
-        SavedAnalyticEndpoint.as_view(),
-        name="saved-analytic-view",
-    ),
-    path(
-        "workspaces/<str:slug>/export-analytics/",
-        ExportAnalyticsEndpoint.as_view(),
-        name="export-analytics",
-    ),
-    path(
-        "workspaces/<str:slug>/default-analytics/",
-        DefaultAnalyticsEndpoint.as_view(),
-        name="default-analytics",
-    ),
-]
@@ -1,85 +0,0 @@
-from django.urls import path
-
-
-from plane.app.views import (
-    FileAssetEndpoint,
-    UserAssetsEndpoint,
-    FileAssetViewSet,
-    # V2 Endpoints
-    WorkspaceFileAssetEndpoint,
-    UserAssetsV2Endpoint,
-    StaticFileAssetEndpoint,
-    AssetRestoreEndpoint,
-    ProjectAssetEndpoint,
-    ProjectBulkAssetEndpoint,
-)
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/file-assets/",
-        FileAssetEndpoint.as_view(),
-        name="file-assets",
-    ),
-    path(
-        "workspaces/file-assets/<uuid:workspace_id>/<str:asset_key>/",
-        FileAssetEndpoint.as_view(),
-        name="file-assets",
-    ),
-    path("users/file-assets/", UserAssetsEndpoint.as_view(), name="user-file-assets"),
-    path(
-        "users/file-assets/<str:asset_key>/",
-        UserAssetsEndpoint.as_view(),
-        name="user-file-assets",
-    ),
-    path(
-        "workspaces/file-assets/<uuid:workspace_id>/<str:asset_key>/restore/",
-        FileAssetViewSet.as_view({"post": "restore"}),
-        name="file-assets-restore",
-    ),
-    # V2 Endpoints
-    path(
-        "assets/v2/workspaces/<str:slug>/",
-        WorkspaceFileAssetEndpoint.as_view(),
-        name="workspace-file-assets",
-    ),
-    path(
-        "assets/v2/workspaces/<str:slug>/<uuid:asset_id>/",
-        WorkspaceFileAssetEndpoint.as_view(),
-        name="workspace-file-assets",
-    ),
-    path(
-        "assets/v2/user-assets/",
-        UserAssetsV2Endpoint.as_view(),
-        name="user-file-assets",
-    ),
-    path(
-        "assets/v2/user-assets/<uuid:asset_id>/",
-        UserAssetsV2Endpoint.as_view(),
-        name="user-file-assets",
-    ),
-    path(
-        "assets/v2/workspaces/<str:slug>/restore/<uuid:asset_id>/",
-        AssetRestoreEndpoint.as_view(),
-        name="asset-restore",
-    ),
-    path(
-        "assets/v2/static/<uuid:asset_id>/",
-        StaticFileAssetEndpoint.as_view(),
-        name="static-file-asset",
-    ),
-    path(
-        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/",
-        ProjectAssetEndpoint.as_view(),
-        name="bulk-asset-update",
-    ),
-    path(
-        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/<uuid:pk>/",
-        ProjectAssetEndpoint.as_view(),
-        name="bulk-asset-update",
-    ),
-    path(
-        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/<uuid:entity_id>/bulk/",
-        ProjectBulkAssetEndpoint.as_view(),
-    ),
-]
@@ -1,23 +0,0 @@
-from django.urls import path
-
-
-from plane.app.views import DashboardEndpoint, WidgetsEndpoint
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/dashboard/",
-        DashboardEndpoint.as_view(),
-        name="dashboard",
-    ),
-    path(
-        "workspaces/<str:slug>/dashboard/<uuid:dashboard_id>/",
-        DashboardEndpoint.as_view(),
-        name="dashboard",
-    ),
-    path(
-        "dashboard/<uuid:dashboard_id>/widgets/<uuid:widget_id>/",
-        WidgetsEndpoint.as_view(),
-        name="widgets",
-    ),
-]
@@ -1,56 +0,0 @@
-from django.urls import path
-
-
-from plane.app.views import IntakeViewSet, IntakeIssueViewSet
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intakes/",
-        IntakeViewSet.as_view({"get": "list", "post": "create"}),
-        name="intake",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intakes/<uuid:pk>/",
-        IntakeViewSet.as_view(
-            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
-        ),
-        name="intake",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/",
-        IntakeIssueViewSet.as_view({"get": "list", "post": "create"}),
-        name="intake-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/<uuid:pk>/",
-        IntakeIssueViewSet.as_view(
-            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
-        ),
-        name="intake-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/",
-        IntakeViewSet.as_view({"get": "list", "post": "create"}),
-        name="inbox",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:pk>/",
-        IntakeViewSet.as_view(
-            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
-        ),
-        name="inbox",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
-        IntakeIssueViewSet.as_view({"get": "list", "post": "create"}),
-        name="inbox-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:pk>/",
-        IntakeIssueViewSet.as_view(
-            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
-        ),
-        name="inbox-issue",
-    ),
-]
@@ -1,259 +0,0 @@
-from django.urls import path
-
-from plane.app.views import (
-    BulkCreateIssueLabelsEndpoint,
-    BulkDeleteIssuesEndpoint,
-    SubIssuesEndpoint,
-    IssueLinkViewSet,
-    IssueAttachmentEndpoint,
-    CommentReactionViewSet,
-    ExportIssuesEndpoint,
-    IssueActivityEndpoint,
-    IssueArchiveViewSet,
-    IssueCommentViewSet,
-    IssueListEndpoint,
-    IssueReactionViewSet,
-    IssueRelationViewSet,
-    IssueSubscriberViewSet,
-    IssueUserDisplayPropertyEndpoint,
-    IssueViewSet,
-    LabelViewSet,
-    BulkArchiveIssuesEndpoint,
-    DeletedIssuesListViewSet,
-    IssuePaginatedViewSet,
-    IssueDetailEndpoint,
-    IssueAttachmentV2Endpoint,
-    IssueBulkUpdateDateEndpoint,
-)
-
-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({"get": "list", "post": "create"}),
-        name="project-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues-detail/",
-        IssueDetailEndpoint.as_view(),
-        name="project-issue-detail",
-    ),
-    # updated v1 paginated issues
-    # updated v2 paginated issues
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/v2/issues/",
-        IssuePaginatedViewSet.as_view({"get": "list"}),
-        name="project-issues-paginated",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/",
-        IssueViewSet.as_view(
-            {
-                "get": "retrieve",
-                "put": "update",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="project-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/",
-        LabelViewSet.as_view({"get": "list", "post": "create"}),
-        name="project-issue-labels",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/<uuid:pk>/",
-        LabelViewSet.as_view(
-            {
-                "get": "retrieve",
-                "put": "update",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="project-issue-labels",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-create-labels/",
-        BulkCreateIssueLabelsEndpoint.as_view(),
-        name="project-bulk-labels",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-delete-issues/",
-        BulkDeleteIssuesEndpoint.as_view(),
-        name="project-issues-bulk",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-archive-issues/",
-        BulkArchiveIssuesEndpoint.as_view(),
-        name="bulk-archive-issues",
-    ),
-    ##
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/sub-issues/",
-        SubIssuesEndpoint.as_view(),
-        name="sub-issues",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-links/",
-        IssueLinkViewSet.as_view({"get": "list", "post": "create"}),
-        name="project-issue-links",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-links/<uuid:pk>/",
-        IssueLinkViewSet.as_view(
-            {
-                "get": "retrieve",
-                "put": "update",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="project-issue-links",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-attachments/",
-        IssueAttachmentEndpoint.as_view(),
-        name="project-issue-attachments",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-attachments/<uuid:pk>/",
-        IssueAttachmentEndpoint.as_view(),
-        name="project-issue-attachments",
-    ),
-    # V2 Attachments
-    path(
-        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/attachments/",
-        IssueAttachmentV2Endpoint.as_view(),
-        name="project-issue-attachments",
-    ),
-    path(
-        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/attachments/<uuid:pk>/",
-        IssueAttachmentV2Endpoint.as_view(),
-        name="project-issue-attachments",
-    ),
-    ## Export Issues
-    path(
-        "workspaces/<str:slug>/export-issues/",
-        ExportIssuesEndpoint.as_view(),
-        name="export-issues",
-    ),
-    ## End Issues
-    ## Issue Activity
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/history/",
-        IssueActivityEndpoint.as_view(),
-        name="project-issue-history",
-    ),
-    ## Issue Activity
-    ## IssueComments
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/",
-        IssueCommentViewSet.as_view({"get": "list", "post": "create"}),
-        name="project-issue-comment",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/<uuid:pk>/",
-        IssueCommentViewSet.as_view(
-            {
-                "get": "retrieve",
-                "put": "update",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="project-issue-comment",
-    ),
-    ## End IssueComments
-    # Issue Subscribers
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-subscribers/",
-        IssueSubscriberViewSet.as_view({"get": "list", "post": "create"}),
-        name="project-issue-subscribers",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-subscribers/<uuid:subscriber_id>/",
-        IssueSubscriberViewSet.as_view({"delete": "destroy"}),
-        name="project-issue-subscribers",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/subscribe/",
-        IssueSubscriberViewSet.as_view(
-            {"get": "subscription_status", "post": "subscribe", "delete": "unsubscribe"}
-        ),
-        name="project-issue-subscribers",
-    ),
-    ## End Issue Subscribers
-    # Issue Reactions
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/reactions/",
-        IssueReactionViewSet.as_view({"get": "list", "post": "create"}),
-        name="project-issue-reactions",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/reactions/<str:reaction_code>/",
-        IssueReactionViewSet.as_view({"delete": "destroy"}),
-        name="project-issue-reactions",
-    ),
-    ## End Issue Reactions
-    # Comment Reactions
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/comments/<uuid:comment_id>/reactions/",
-        CommentReactionViewSet.as_view({"get": "list", "post": "create"}),
-        name="project-issue-comment-reactions",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/comments/<uuid:comment_id>/reactions/<str:reaction_code>/",
-        CommentReactionViewSet.as_view({"delete": "destroy"}),
-        name="project-issue-comment-reactions",
-    ),
-    ## End Comment Reactions
-    ## IssueUserProperty
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/user-properties/",
-        IssueUserDisplayPropertyEndpoint.as_view(),
-        name="project-issue-display-properties",
-    ),
-    ## IssueUserProperty End
-    ## Issue Archives
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-issues/",
-        IssueArchiveViewSet.as_view({"get": "list"}),
-        name="project-issue-archive",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/archive/",
-        IssueArchiveViewSet.as_view(
-            {"get": "retrieve", "post": "archive", "delete": "unarchive"}
-        ),
-        name="project-issue-archive-unarchive",
-    ),
-    ## End Issue Archives
-    ## Issue Relation
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-relation/",
-        IssueRelationViewSet.as_view({"get": "list", "post": "create"}),
-        name="issue-relation",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/remove-relation/",
-        IssueRelationViewSet.as_view({"post": "remove_relation"}),
-        name="issue-relation",
-    ),
-    ## End Issue Relation
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/deleted-issues/",
-        DeletedIssuesListViewSet.as_view(),
-        name="deleted-issues",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-dates/",
-        IssueBulkUpdateDateEndpoint.as_view(),
-        name="project-issue-dates",
-    ),
-]
@@ -1,81 +0,0 @@
-from django.urls import path
-
-
-from plane.app.views import (
-    PageViewSet,
-    PageFavoriteViewSet,
-    PageLogEndpoint,
-    SubPagesEndpoint,
-    PagesDescriptionViewSet,
-    PageVersionEndpoint,
-)
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/",
-        PageViewSet.as_view({"get": "list", "post": "create"}),
-        name="project-pages",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/",
-        PageViewSet.as_view(
-            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
-        ),
-        name="project-pages",
-    ),
-    # favorite pages
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/favorite-pages/<uuid:pk>/",
-        PageFavoriteViewSet.as_view({"post": "create", "delete": "destroy"}),
-        name="user-favorite-pages",
-    ),
-    # archived pages
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/archive/",
-        PageViewSet.as_view({"post": "archive", "delete": "unarchive"}),
-        name="project-page-archive-unarchive",
-    ),
-    # lock and unlock
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/lock/",
-        PageViewSet.as_view({"post": "lock", "delete": "unlock"}),
-        name="project-pages-lock-unlock",
-    ),
-    # private and public page
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/access/",
-        PageViewSet.as_view({"post": "access"}),
-        name="project-pages-access",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/transactions/",
-        PageLogEndpoint.as_view(),
-        name="page-transactions",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/transactions/<uuid:transaction>/",
-        PageLogEndpoint.as_view(),
-        name="page-transactions",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/sub-pages/",
-        SubPagesEndpoint.as_view(),
-        name="sub-page",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/description/",
-        PagesDescriptionViewSet.as_view({"get": "retrieve", "patch": "partial_update"}),
-        name="page-description",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/versions/",
-        PageVersionEndpoint.as_view(),
-        name="page-versions",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/versions/<uuid:pk>/",
-        PageVersionEndpoint.as_view(),
-        name="page-versions",
-    ),
-]
@@ -1,127 +0,0 @@
-from django.urls import path
-
-from plane.app.views import (
-    ProjectViewSet,
-    DeployBoardViewSet,
-    ProjectInvitationsViewset,
-    ProjectMemberViewSet,
-    ProjectMemberUserEndpoint,
-    ProjectJoinEndpoint,
-    ProjectUserViewsEndpoint,
-    ProjectIdentifierEndpoint,
-    ProjectFavoritesViewSet,
-    UserProjectInvitationsViewset,
-    ProjectPublicCoverImagesEndpoint,
-    UserProjectRolesEndpoint,
-    ProjectArchiveUnarchiveEndpoint,
-)
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/",
-        ProjectViewSet.as_view({"get": "list", "post": "create"}),
-        name="project",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:pk>/",
-        ProjectViewSet.as_view(
-            {
-                "get": "retrieve",
-                "put": "update",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="project",
-    ),
-    path(
-        "workspaces/<str:slug>/project-identifiers/",
-        ProjectIdentifierEndpoint.as_view(),
-        name="project-identifiers",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/invitations/",
-        ProjectInvitationsViewset.as_view({"get": "list", "post": "create"}),
-        name="project-member-invite",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/invitations/<uuid:pk>/",
-        ProjectInvitationsViewset.as_view({"get": "retrieve", "delete": "destroy"}),
-        name="project-member-invite",
-    ),
-    path(
-        "users/me/workspaces/<str:slug>/projects/invitations/",
-        UserProjectInvitationsViewset.as_view({"get": "list", "post": "create"}),
-        name="user-project-invitations",
-    ),
-    path(
-        "users/me/workspaces/<str:slug>/project-roles/",
-        UserProjectRolesEndpoint.as_view(),
-        name="user-project-roles",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/join/<uuid:pk>/",
-        ProjectJoinEndpoint.as_view(),
-        name="project-join",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/members/",
-        ProjectMemberViewSet.as_view({"get": "list", "post": "create"}),
-        name="project-member",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/members/<uuid:pk>/",
-        ProjectMemberViewSet.as_view(
-            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
-        ),
-        name="project-member",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/members/leave/",
-        ProjectMemberViewSet.as_view({"post": "leave"}),
-        name="project-member",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/project-views/",
-        ProjectUserViewsEndpoint.as_view(),
-        name="project-view",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/project-members/me/",
-        ProjectMemberUserEndpoint.as_view(),
-        name="project-member-view",
-    ),
-    path(
-        "workspaces/<str:slug>/user-favorite-projects/",
-        ProjectFavoritesViewSet.as_view({"get": "list", "post": "create"}),
-        name="project-favorite",
-    ),
-    path(
-        "workspaces/<str:slug>/user-favorite-projects/<uuid:project_id>/",
-        ProjectFavoritesViewSet.as_view({"delete": "destroy"}),
-        name="project-favorite",
-    ),
-    path(
-        "project-covers/",
-        ProjectPublicCoverImagesEndpoint.as_view(),
-        name="project-covers",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/project-deploy-boards/",
-        DeployBoardViewSet.as_view({"get": "list", "post": "create"}),
-        name="project-deploy-board",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/project-deploy-boards/<uuid:pk>/",
-        DeployBoardViewSet.as_view(
-            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
-        ),
-        name="project-deploy-board",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/archive/",
-        ProjectArchiveUnarchiveEndpoint.as_view(),
-        name="project-archive-unarchive",
-    ),
-]
@@ -1,216 +0,0 @@
-from django.urls import path
-
-
-from plane.app.views import (
-    UserWorkspaceInvitationsViewSet,
-    WorkSpaceViewSet,
-    WorkspaceJoinEndpoint,
-    WorkSpaceMemberViewSet,
-    WorkspaceInvitationsViewset,
-    WorkspaceMemberUserEndpoint,
-    WorkspaceMemberUserViewsEndpoint,
-    WorkSpaceAvailabilityCheckEndpoint,
-    UserLastProjectWithWorkspaceEndpoint,
-    WorkspaceThemeViewSet,
-    WorkspaceUserProfileStatsEndpoint,
-    WorkspaceUserActivityEndpoint,
-    WorkspaceUserProfileEndpoint,
-    WorkspaceUserProfileIssuesEndpoint,
-    WorkspaceLabelsEndpoint,
-    WorkspaceProjectMemberEndpoint,
-    WorkspaceUserPropertiesEndpoint,
-    WorkspaceStatesEndpoint,
-    WorkspaceEstimatesEndpoint,
-    ExportWorkspaceUserActivityEndpoint,
-    WorkspaceModulesEndpoint,
-    WorkspaceCyclesEndpoint,
-    WorkspaceFavoriteEndpoint,
-    WorkspaceFavoriteGroupEndpoint,
-    WorkspaceDraftIssueViewSet,
-)
-
-
-urlpatterns = [
-    path(
-        "workspace-slug-check/",
-        WorkSpaceAvailabilityCheckEndpoint.as_view(),
-        name="workspace-availability",
-    ),
-    path(
-        "workspaces/",
-        WorkSpaceViewSet.as_view({"get": "list", "post": "create"}),
-        name="workspace",
-    ),
-    path(
-        "workspaces/<str:slug>/",
-        WorkSpaceViewSet.as_view(
-            {
-                "get": "retrieve",
-                "put": "update",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="workspace",
-    ),
-    path(
-        "workspaces/<str:slug>/invitations/",
-        WorkspaceInvitationsViewset.as_view({"get": "list", "post": "create"}),
-        name="workspace-invitations",
-    ),
-    path(
-        "workspaces/<str:slug>/invitations/<uuid:pk>/",
-        WorkspaceInvitationsViewset.as_view(
-            {"delete": "destroy", "get": "retrieve", "patch": "partial_update"}
-        ),
-        name="workspace-invitations",
-    ),
-    # user workspace invitations
-    path(
-        "users/me/workspaces/invitations/",
-        UserWorkspaceInvitationsViewSet.as_view({"get": "list", "post": "create"}),
-        name="user-workspace-invitations",
-    ),
-    path(
-        "workspaces/<str:slug>/invitations/<uuid:pk>/join/",
-        WorkspaceJoinEndpoint.as_view(),
-        name="workspace-join",
-    ),
-    # user join workspace
-    path(
-        "workspaces/<str:slug>/members/",
-        WorkSpaceMemberViewSet.as_view({"get": "list"}),
-        name="workspace-member",
-    ),
-    path(
-        "workspaces/<str:slug>/project-members/",
-        WorkspaceProjectMemberEndpoint.as_view(),
-        name="workspace-member-roles",
-    ),
-    path(
-        "workspaces/<str:slug>/members/<uuid:pk>/",
-        WorkSpaceMemberViewSet.as_view(
-            {"patch": "partial_update", "delete": "destroy", "get": "retrieve"}
-        ),
-        name="workspace-member",
-    ),
-    path(
-        "workspaces/<str:slug>/members/leave/",
-        WorkSpaceMemberViewSet.as_view({"post": "leave"}),
-        name="leave-workspace-members",
-    ),
-    path(
-        "users/last-visited-workspace/",
-        UserLastProjectWithWorkspaceEndpoint.as_view(),
-        name="workspace-project-details",
-    ),
-    path(
-        "workspaces/<str:slug>/workspace-members/me/",
-        WorkspaceMemberUserEndpoint.as_view(),
-        name="workspace-member-details",
-    ),
-    path(
-        "workspaces/<str:slug>/workspace-views/",
-        WorkspaceMemberUserViewsEndpoint.as_view(),
-        name="workspace-member-views-details",
-    ),
-    path(
-        "workspaces/<str:slug>/workspace-themes/",
-        WorkspaceThemeViewSet.as_view({"get": "list", "post": "create"}),
-        name="workspace-themes",
-    ),
-    path(
-        "workspaces/<str:slug>/workspace-themes/<uuid:pk>/",
-        WorkspaceThemeViewSet.as_view(
-            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
-        ),
-        name="workspace-themes",
-    ),
-    path(
-        "workspaces/<str:slug>/user-stats/<uuid:user_id>/",
-        WorkspaceUserProfileStatsEndpoint.as_view(),
-        name="workspace-user-stats",
-    ),
-    path(
-        "workspaces/<str:slug>/user-activity/<uuid:user_id>/",
-        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(),
-        name="workspace-user-profile-page",
-    ),
-    path(
-        "workspaces/<str:slug>/user-issues/<uuid:user_id>/",
-        WorkspaceUserProfileIssuesEndpoint.as_view(),
-        name="workspace-user-profile-issues",
-    ),
-    path(
-        "workspaces/<str:slug>/labels/",
-        WorkspaceLabelsEndpoint.as_view(),
-        name="workspace-labels",
-    ),
-    path(
-        "workspaces/<str:slug>/user-properties/",
-        WorkspaceUserPropertiesEndpoint.as_view(),
-        name="workspace-user-filters",
-    ),
-    path(
-        "workspaces/<str:slug>/states/",
-        WorkspaceStatesEndpoint.as_view(),
-        name="workspace-state",
-    ),
-    path(
-        "workspaces/<str:slug>/estimates/",
-        WorkspaceEstimatesEndpoint.as_view(),
-        name="workspace-estimate",
-    ),
-    path(
-        "workspaces/<str:slug>/modules/",
-        WorkspaceModulesEndpoint.as_view(),
-        name="workspace-modules",
-    ),
-    path(
-        "workspaces/<str:slug>/cycles/",
-        WorkspaceCyclesEndpoint.as_view(),
-        name="workspace-cycles",
-    ),
-    path(
-        "workspaces/<str:slug>/user-favorites/",
-        WorkspaceFavoriteEndpoint.as_view(),
-        name="workspace-user-favorites",
-    ),
-    path(
-        "workspaces/<str:slug>/user-favorites/<uuid:favorite_id>/",
-        WorkspaceFavoriteEndpoint.as_view(),
-        name="workspace-user-favorites",
-    ),
-    path(
-        "workspaces/<str:slug>/user-favorites/<uuid:favorite_id>/group/",
-        WorkspaceFavoriteGroupEndpoint.as_view(),
-        name="workspace-user-favorites-groups",
-    ),
-    path(
-        "workspaces/<str:slug>/draft-issues/",
-        WorkspaceDraftIssueViewSet.as_view({"get": "list", "post": "create"}),
-        name="workspace-draft-issues",
-    ),
-    path(
-        "workspaces/<str:slug>/draft-issues/<uuid:pk>/",
-        WorkspaceDraftIssueViewSet.as_view(
-            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
-        ),
-        name="workspace-drafts-issues",
-    ),
-    path(
-        "workspaces/<str:slug>/draft-to-issue/<uuid:draft_id>/",
-        WorkspaceDraftIssueViewSet.as_view({"post": "create_draft_to_issue"}),
-        name="workspace-drafts-issues",
-    ),
-]
@@ -1,208 +0,0 @@
-from .project.base import (
-    ProjectViewSet,
-    ProjectIdentifierEndpoint,
-    ProjectUserViewsEndpoint,
-    ProjectFavoritesViewSet,
-    ProjectPublicCoverImagesEndpoint,
-    DeployBoardViewSet,
-    ProjectArchiveUnarchiveEndpoint,
-)
-
-from .project.invite import (
-    UserProjectInvitationsViewset,
-    ProjectInvitationsViewset,
-    ProjectJoinEndpoint,
-)
-
-from .project.member import (
-    ProjectMemberViewSet,
-    ProjectMemberUserEndpoint,
-    UserProjectRolesEndpoint,
-)
-
-from .user.base import (
-    UserEndpoint,
-    UpdateUserOnBoardedEndpoint,
-    UpdateUserTourCompletedEndpoint,
-    UserActivityEndpoint,
-)
-
-
-from .base import BaseAPIView, BaseViewSet
-
-from .workspace.base import (
-    WorkSpaceViewSet,
-    UserWorkSpacesEndpoint,
-    WorkSpaceAvailabilityCheckEndpoint,
-    UserWorkspaceDashboardEndpoint,
-    WorkspaceThemeViewSet,
-    ExportWorkspaceUserActivityEndpoint,
-)
-
-from .workspace.draft import WorkspaceDraftIssueViewSet
-
-from .workspace.favorite import (
-    WorkspaceFavoriteEndpoint,
-    WorkspaceFavoriteGroupEndpoint,
-)
-
-from .workspace.member import (
-    WorkSpaceMemberViewSet,
-    WorkspaceMemberUserEndpoint,
-    WorkspaceProjectMemberEndpoint,
-    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 .workspace.module import WorkspaceModulesEndpoint
-from .workspace.cycle import WorkspaceCyclesEndpoint
-
-from .state.base import StateViewSet
-from .view.base import (
-    WorkspaceViewViewSet,
-    WorkspaceViewIssuesViewSet,
-    IssueViewViewSet,
-    IssueViewFavoriteViewSet,
-)
-from .cycle.base import (
-    CycleViewSet,
-    CycleDateCheckEndpoint,
-    CycleFavoriteViewSet,
-    TransferCycleIssueEndpoint,
-    CycleUserPropertiesEndpoint,
-    CycleAnalyticsEndpoint,
-    CycleProgressEndpoint,
-)
-from .cycle.issue import CycleIssueViewSet
-from .cycle.archive import CycleArchiveUnarchiveEndpoint
-
-from .asset.base import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
-from .asset.v2 import (
-    WorkspaceFileAssetEndpoint,
-    UserAssetsV2Endpoint,
-    StaticFileAssetEndpoint,
-    AssetRestoreEndpoint,
-    ProjectAssetEndpoint,
-    ProjectBulkAssetEndpoint,
-)
-from .issue.base import (
-    IssueListEndpoint,
-    IssueViewSet,
-    IssueUserDisplayPropertyEndpoint,
-    BulkDeleteIssuesEndpoint,
-    DeletedIssuesListViewSet,
-    IssuePaginatedViewSet,
-    IssueDetailEndpoint,
-    IssueBulkUpdateDateEndpoint,
-)
-
-from .issue.activity import IssueActivityEndpoint
-
-from .issue.archive import IssueArchiveViewSet, BulkArchiveIssuesEndpoint
-
-from .issue.attachment import (
-    IssueAttachmentEndpoint,
-    # V2
-    IssueAttachmentV2Endpoint,
-)
-
-from .issue.comment import IssueCommentViewSet, CommentReactionViewSet
-
-from .issue.label import LabelViewSet, BulkCreateIssueLabelsEndpoint
-
-from .issue.link import IssueLinkViewSet
-
-from .issue.relation import IssueRelationViewSet
-
-from .issue.reaction import IssueReactionViewSet
-
-from .issue.sub_issue import SubIssuesEndpoint
-
-from .issue.subscriber import IssueSubscriberViewSet
-
-from .module.base import (
-    ModuleViewSet,
-    ModuleLinkViewSet,
-    ModuleFavoriteViewSet,
-    ModuleUserPropertiesEndpoint,
-)
-
-from .module.issue import ModuleIssueViewSet
-
-from .module.archive import ModuleArchiveUnarchiveEndpoint
-
-from .api import ApiTokenEndpoint, ServiceApiTokenEndpoint
-
-from .page.base import (
-    PageViewSet,
-    PageFavoriteViewSet,
-    PageLogEndpoint,
-    SubPagesEndpoint,
-    PagesDescriptionViewSet,
-)
-from .page.version import PageVersionEndpoint
-
-from .search.base import GlobalSearchEndpoint, SearchEndpoint
-from .search.issue import IssueSearchEndpoint
-
-
-from .external.base import (
-    GPTIntegrationEndpoint,
-    UnsplashEndpoint,
-    WorkspaceGPTIntegrationEndpoint,
-)
-from .estimate.base import (
-    ProjectEstimatePointEndpoint,
-    BulkEstimatePointEndpoint,
-    EstimatePointEndpoint,
-)
-
-from .intake.base import IntakeViewSet, IntakeIssueViewSet
-
-from .analytic.base import (
-    AnalyticsEndpoint,
-    AnalyticViewViewset,
-    SavedAnalyticEndpoint,
-    ExportAnalyticsEndpoint,
-    DefaultAnalyticsEndpoint,
-)
-
-from .notification.base import (
-    NotificationViewSet,
-    UnreadNotificationEndpoint,
-    UserNotificationPreferenceEndpoint,
-)
-
-from .exporter.base import ExportIssuesEndpoint
-
-
-from .webhook.base import (
-    WebhookEndpoint,
-    WebhookLogsEndpoint,
-    WebhookSecretRegenerateEndpoint,
-)
-
-from .dashboard.base import DashboardEndpoint, WidgetsEndpoint
-
-from .error_404 import custom_404_view
-
-from .notification.base import MarkAllReadNotificationViewSet
-from .user.base import AccountEndpoint, ProfileEndpoint, UserSessionEndpoint
-
-from .timezone.base import TimezoneEndpoint
@@ -1,443 +0,0 @@
-# Django imports
-from django.db.models import Count, F, Sum, Q
-from django.db.models.functions import ExtractMonth
-from django.utils import timezone
-from django.db.models.functions import Concat
-from django.db.models import Case, When, Value
-from django.db import models
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from plane.app.permissions import WorkSpaceAdminPermission
-from plane.app.serializers import AnalyticViewSerializer
-from plane.app.views.base import BaseAPIView, BaseViewSet
-from plane.bgtasks.analytic_plot_export import analytic_export_task
-from plane.db.models import AnalyticView, Issue, Workspace
-from plane.utils.analytics_plot import build_graph_plot
-from plane.utils.issue_filters import issue_filters
-from plane.app.permissions import allow_permission, ROLE
-
-
-class AnalyticsEndpoint(BaseAPIView):
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    def get(self, request, slug):
-        x_axis = request.GET.get("x_axis", False)
-        y_axis = request.GET.get("y_axis", False)
-        segment = request.GET.get("segment", False)
-
-        valid_xaxis_segment = [
-            "state_id",
-            "state__group",
-            "labels__id",
-            "assignees__id",
-            "estimate_point__value",
-            "issue_cycle__cycle_id",
-            "issue_module__module_id",
-            "priority",
-            "start_date",
-            "target_date",
-            "created_at",
-            "completed_at",
-        ]
-
-        valid_yaxis = ["issue_count", "estimate"]
-
-        # Check for x-axis and y-axis as thery are required parameters
-        if (
-            not x_axis
-            or not y_axis
-            or x_axis not in valid_xaxis_segment
-            or y_axis not in valid_yaxis
-        ):
-            return Response(
-                {
-                    "error": "x-axis and y-axis dimensions are required and the values should be valid"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # If segment is present it cannot be same as x-axis
-        if segment and (segment not in valid_xaxis_segment or x_axis == segment):
-            return Response(
-                {
-                    "error": "Both segment and x axis cannot be same and segment should be valid"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Additional filters that need to be applied
-        filters = issue_filters(request.GET, "GET")
-
-        # Get the issues for the workspace with the additional filters applied
-        queryset = Issue.issue_objects.filter(workspace__slug=slug, **filters)
-
-        # Get the total issue count
-        total_issues = queryset.count()
-
-        # Build the graph payload
-        distribution = build_graph_plot(
-            queryset=queryset, x_axis=x_axis, y_axis=y_axis, segment=segment
-        )
-
-        state_details = {}
-        if x_axis in ["state_id"] or segment in ["state_id"]:
-            state_details = (
-                Issue.issue_objects.filter(workspace__slug=slug, **filters)
-                .distinct("state_id")
-                .order_by("state_id")
-                .values("state_id", "state__name", "state__color")
-            )
-
-        label_details = {}
-        if x_axis in ["labels__id"] or segment in ["labels__id"]:
-            label_details = (
-                Issue.objects.filter(
-                    workspace__slug=slug,
-                    **filters,
-                    labels__id__isnull=False,
-                    label_issue__deleted_at__isnull=True,
-                )
-                .distinct("labels__id")
-                .order_by("labels__id")
-                .values("labels__id", "labels__color", "labels__name")
-            )
-
-        assignee_details = {}
-        if x_axis in ["assignees__id"] or segment in ["assignees__id"]:
-            assignee_details = (
-                Issue.issue_objects.filter(
-                    Q(
-                        Q(assignees__avatar__isnull=False)
-                        | Q(assignees__avatar_asset__isnull=False)
-                    ),
-                    workspace__slug=slug,
-                    **filters,
-                )
-                .annotate(
-                    assignees__avatar_url=Case(
-                        # If `avatar_asset` exists, use it to generate the asset URL
-                        When(
-                            assignees__avatar_asset__isnull=False,
-                            then=Concat(
-                                Value("/api/assets/v2/static/"),
-                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                                Value("/"),
-                            ),
-                        ),
-                        # If `avatar_asset` is None, fall back to using `avatar` field directly
-                        When(
-                            assignees__avatar_asset__isnull=True,
-                            then="assignees__avatar",
-                        ),
-                        default=Value(None),
-                        output_field=models.CharField(),
-                    )
-                )
-                .order_by("assignees__id")
-                .distinct("assignees__id")
-                .values(
-                    "assignees__avatar_url",
-                    "assignees__display_name",
-                    "assignees__first_name",
-                    "assignees__last_name",
-                    "assignees__id",
-                )
-            )
-
-        cycle_details = {}
-        if x_axis in ["issue_cycle__cycle_id"] or segment in ["issue_cycle__cycle_id"]:
-            cycle_details = (
-                Issue.issue_objects.filter(
-                    workspace__slug=slug,
-                    **filters,
-                    issue_cycle__cycle_id__isnull=False,
-                    issue_cycle__deleted_at__isnull=True,
-                )
-                .distinct("issue_cycle__cycle_id")
-                .order_by("issue_cycle__cycle_id")
-                .values("issue_cycle__cycle_id", "issue_cycle__cycle__name")
-            )
-
-        module_details = {}
-        if x_axis in ["issue_module__module_id"] or segment in [
-            "issue_module__module_id"
-        ]:
-            module_details = (
-                Issue.issue_objects.filter(
-                    workspace__slug=slug,
-                    **filters,
-                    issue_module__module_id__isnull=False,
-                    issue_module__deleted_at__isnull=True,
-                )
-                .distinct("issue_module__module_id")
-                .order_by("issue_module__module_id")
-                .values("issue_module__module_id", "issue_module__module__name")
-            )
-
-        return Response(
-            {
-                "total": total_issues,
-                "distribution": distribution,
-                "extras": {
-                    "state_details": state_details,
-                    "assignee_details": assignee_details,
-                    "label_details": label_details,
-                    "cycle_details": cycle_details,
-                    "module_details": module_details,
-                },
-            },
-            status=status.HTTP_200_OK,
-        )
-
-
-class AnalyticViewViewset(BaseViewSet):
-    permission_classes = [WorkSpaceAdminPermission]
-    model = AnalyticView
-    serializer_class = AnalyticViewSerializer
-
-    def perform_create(self, serializer):
-        workspace = Workspace.objects.get(slug=self.kwargs.get("slug"))
-        serializer.save(workspace_id=workspace.id)
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super().get_queryset().filter(workspace__slug=self.kwargs.get("slug"))
-        )
-
-
-class SavedAnalyticEndpoint(BaseAPIView):
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    def get(self, request, slug, analytic_id):
-        analytic_view = AnalyticView.objects.get(pk=analytic_id, workspace__slug=slug)
-
-        filter = analytic_view.query
-        queryset = Issue.issue_objects.filter(**filter)
-
-        x_axis = analytic_view.query_dict.get("x_axis", False)
-        y_axis = analytic_view.query_dict.get("y_axis", False)
-
-        if not x_axis or not y_axis:
-            return Response(
-                {"error": "x-axis and y-axis dimensions are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        segment = request.GET.get("segment", False)
-        distribution = build_graph_plot(
-            queryset=queryset, x_axis=x_axis, y_axis=y_axis, segment=segment
-        )
-        total_issues = queryset.count()
-        return Response(
-            {"total": total_issues, "distribution": distribution},
-            status=status.HTTP_200_OK,
-        )
-
-
-class ExportAnalyticsEndpoint(BaseAPIView):
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    def post(self, request, slug):
-        x_axis = request.data.get("x_axis", False)
-        y_axis = request.data.get("y_axis", False)
-        segment = request.data.get("segment", False)
-
-        valid_xaxis_segment = [
-            "state_id",
-            "state__group",
-            "labels__id",
-            "assignees__id",
-            "estimate_point",
-            "issue_cycle__cycle_id",
-            "issue_module__module_id",
-            "priority",
-            "start_date",
-            "target_date",
-            "created_at",
-            "completed_at",
-        ]
-
-        valid_yaxis = ["issue_count", "estimate"]
-
-        # Check for x-axis and y-axis as thery are required parameters
-        if (
-            not x_axis
-            or not y_axis
-            or x_axis not in valid_xaxis_segment
-            or y_axis not in valid_yaxis
-        ):
-            return Response(
-                {
-                    "error": "x-axis and y-axis dimensions are required and the values should be valid"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # If segment is present it cannot be same as x-axis
-        if segment and (segment not in valid_xaxis_segment or x_axis == segment):
-            return Response(
-                {
-                    "error": "Both segment and x axis cannot be same and segment should be valid"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        analytic_export_task.delay(
-            email=request.user.email, data=request.data, slug=slug
-        )
-
-        return Response(
-            {
-                "message": f"Once the export is ready it will be emailed to you at {str(request.user.email)}"
-            },
-            status=status.HTTP_200_OK,
-        )
-
-
-class DefaultAnalyticsEndpoint(BaseAPIView):
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
-    def get(self, request, slug):
-        filters = issue_filters(request.GET, "GET")
-        base_issues = Issue.issue_objects.filter(workspace__slug=slug, **filters)
-
-        total_issues = base_issues.count()
-
-        state_groups = base_issues.annotate(state_group=F("state__group"))
-
-        total_issues_classified = (
-            state_groups.values("state_group")
-            .annotate(state_count=Count("state_group"))
-            .order_by("state_group")
-        )
-
-        open_issues_groups = ["backlog", "unstarted", "started"]
-        open_issues_queryset = state_groups.filter(state__group__in=open_issues_groups)
-
-        open_issues = open_issues_queryset.count()
-        open_issues_classified = (
-            open_issues_queryset.values("state_group")
-            .annotate(state_count=Count("state_group"))
-            .order_by("state_group")
-        )
-
-        current_year = timezone.now().year
-        issue_completed_month_wise = (
-            base_issues.filter(completed_at__year=current_year)
-            .annotate(month=ExtractMonth("completed_at"))
-            .values("month")
-            .annotate(count=Count("*"))
-            .order_by("month")
-        )
-
-        user_details = [
-            "created_by__first_name",
-            "created_by__last_name",
-            "created_by__display_name",
-            "created_by__id",
-        ]
-
-        most_issue_created_user = (
-            base_issues.exclude(created_by=None)
-            .values(*user_details)
-            .annotate(count=Count("id"))
-            .annotate(
-                created_by__avatar_url=Case(
-                    # If `avatar_asset` exists, use it to generate the asset URL
-                    When(
-                        created_by__avatar_asset__isnull=False,
-                        then=Concat(
-                            Value("/api/assets/v2/static/"),
-                            "created_by__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                            Value("/"),
-                        ),
-                    ),
-                    # If `avatar_asset` is None, fall back to using `avatar` field directly
-                    When(
-                        created_by__avatar_asset__isnull=True, then="created_by__avatar"
-                    ),
-                    default=Value(None),
-                    output_field=models.CharField(),
-                )
-            )
-            .order_by("-count")[:5]
-        )
-
-        user_assignee_details = [
-            "assignees__first_name",
-            "assignees__last_name",
-            "assignees__display_name",
-            "assignees__id",
-        ]
-
-        most_issue_closed_user = (
-            base_issues.filter(completed_at__isnull=False)
-            .exclude(assignees=None)
-            .values(*user_assignee_details)
-            .annotate(
-                assignees__avatar_url=Case(
-                    # If `avatar_asset` exists, use it to generate the asset URL
-                    When(
-                        assignees__avatar_asset__isnull=False,
-                        then=Concat(
-                            Value("/api/assets/v2/static/"),
-                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                            Value("/"),
-                        ),
-                    ),
-                    # If `avatar_asset` is None, fall back to using `avatar` field directly
-                    When(
-                        assignees__avatar_asset__isnull=True, then="assignees__avatar"
-                    ),
-                    default=Value(None),
-                    output_field=models.CharField(),
-                )
-            )
-            .annotate(count=Count("id"))
-            .order_by("-count")[:5]
-        )
-
-        pending_issue_user = (
-            base_issues.filter(completed_at__isnull=True)
-            .values(*user_assignee_details)
-            .annotate(count=Count("id"))
-            .annotate(
-                assignees__avatar_url=Case(
-                    # If `avatar_asset` exists, use it to generate the asset URL
-                    When(
-                        assignees__avatar_asset__isnull=False,
-                        then=Concat(
-                            Value("/api/assets/v2/static/"),
-                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                            Value("/"),
-                        ),
-                    ),
-                    # If `avatar_asset` is None, fall back to using `avatar` field directly
-                    When(
-                        assignees__avatar_asset__isnull=True, then="assignees__avatar"
-                    ),
-                    default=Value(None),
-                    output_field=models.CharField(),
-                )
-            )
-            .order_by("-count")
-        )
-
-        open_estimate_sum = open_issues_queryset.aggregate(sum=Sum("point"))["sum"]
-        total_estimate_sum = base_issues.aggregate(sum=Sum("point"))["sum"]
-
-        return Response(
-            {
-                "total_issues": total_issues,
-                "total_issues_classified": total_issues_classified,
-                "open_issues": open_issues,
-                "open_issues_classified": open_issues_classified,
-                "issue_completed_month_wise": issue_completed_month_wise,
-                "most_issue_created_user": most_issue_created_user,
-                "most_issue_closed_user": most_issue_closed_user,
-                "pending_issue_user": pending_issue_user,
-                "open_estimate_sum": open_estimate_sum,
-                "total_estimate_sum": total_estimate_sum,
-            },
-            status=status.HTTP_200_OK,
-        )
@@ -1,96 +0,0 @@
-# Python import
-from uuid import uuid4
-
-# Third party
-from rest_framework.response import Response
-from rest_framework import status
-
-# Module import
-from .base import BaseAPIView
-from plane.db.models import APIToken, Workspace
-from plane.app.serializers import APITokenSerializer, APITokenReadSerializer
-from plane.app.permissions import WorkspaceOwnerPermission
-
-
-class ApiTokenEndpoint(BaseAPIView):
-    permission_classes = [WorkspaceOwnerPermission]
-
-    def post(self, request, slug):
-        label = request.data.get("label", str(uuid4().hex))
-        description = request.data.get("description", "")
-        workspace = Workspace.objects.get(slug=slug)
-        expired_at = request.data.get("expired_at", None)
-
-        # Check the user type
-        user_type = 1 if request.user.is_bot else 0
-
-        api_token = APIToken.objects.create(
-            label=label,
-            description=description,
-            user=request.user,
-            workspace=workspace,
-            user_type=user_type,
-            expired_at=expired_at,
-        )
-
-        serializer = APITokenSerializer(api_token)
-        # Token will be only visible while creating
-        return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-    def get(self, request, slug, pk=None):
-        if pk is None:
-            api_tokens = APIToken.objects.filter(
-                user=request.user, workspace__slug=slug, is_service=False
-            )
-            serializer = APITokenReadSerializer(api_tokens, many=True)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        else:
-            api_tokens = APIToken.objects.get(
-                user=request.user, workspace__slug=slug, pk=pk
-            )
-            serializer = APITokenReadSerializer(api_tokens)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def delete(self, request, slug, pk):
-        api_token = APIToken.objects.get(
-            workspace__slug=slug, user=request.user, pk=pk, is_service=False
-        )
-        api_token.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    def patch(self, request, slug, pk):
-        api_token = APIToken.objects.get(workspace__slug=slug, user=request.user, pk=pk)
-        serializer = APITokenSerializer(api_token, 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 ServiceApiTokenEndpoint(BaseAPIView):
-    permission_classes = [WorkspaceOwnerPermission]
-
-    def post(self, request, slug):
-        workspace = Workspace.objects.get(slug=slug)
-
-        api_token = APIToken.objects.filter(
-            workspace=workspace, is_service=True
-        ).first()
-
-        if api_token:
-            return Response({"token": str(api_token.token)}, status=status.HTTP_200_OK)
-        else:
-            # Check the user type
-            user_type = 1 if request.user.is_bot else 0
-
-            api_token = APIToken.objects.create(
-                label=str(uuid4().hex),
-                description="Service Token",
-                user=request.user,
-                workspace=workspace,
-                user_type=user_type,
-                is_service=True,
-            )
-            return Response(
-                {"token": str(api_token.token)}, status=status.HTTP_201_CREATED
-            )
@@ -1,323 +0,0 @@
-# Python imports
-import json
-
-# Django imports
-from django.core import serializers
-from django.db.models import F, Func, OuterRef, Q, Subquery
-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
-
-
-# Module imports
-from .. import BaseViewSet
-from plane.app.serializers import CycleIssueSerializer
-from plane.bgtasks.issue_activities_task import issue_activity
-from plane.db.models import Cycle, CycleIssue, Issue, FileAsset, IssueLink
-from plane.utils.grouper import (
-    issue_group_values,
-    issue_on_results,
-    issue_queryset_grouper,
-)
-from plane.utils.issue_filters import issue_filters
-from plane.utils.order_queryset import order_issue_queryset
-from plane.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPaginator
-from plane.app.permissions import allow_permission, ROLE
-
-
-class CycleIssueViewSet(BaseViewSet):
-    serializer_class = CycleIssueSerializer
-    model = CycleIssue
-
-    webhook_event = "cycle_issue"
-    bulk = True
-
-    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(project__archived_at__isnull=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)
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def list(self, request, slug, project_id, cycle_id):
-        order_by_param = request.GET.get("order_by", "created_at")
-        filters = issue_filters(request.query_params, "GET")
-        issue_queryset = (
-            Issue.issue_objects.filter(
-                issue_cycle__cycle_id=cycle_id, issue_cycle__deleted_at__isnull=True
-            )
-            .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"
-            )
-            .filter(**filters)
-            .annotate(
-                cycle_id=Subquery(
-                    CycleIssue.objects.filter(
-                        issue=OuterRef("id"), deleted_at__isnull=True
-                    ).values("cycle_id")[:1]
-                )
-            )
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
-                )
-                .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")
-            )
-        )
-        filters = issue_filters(request.query_params, "GET")
-
-        order_by_param = request.GET.get("order_by", "-created_at")
-        issue_queryset = issue_queryset.filter(**filters)
-        # Issue queryset
-        issue_queryset, order_by_param = order_issue_queryset(
-            issue_queryset=issue_queryset, order_by_param=order_by_param
-        )
-
-        # Group by
-        group_by = request.GET.get("group_by", False)
-        sub_group_by = request.GET.get("sub_group_by", False)
-
-        # issue queryset
-        issue_queryset = issue_queryset_grouper(
-            queryset=issue_queryset, group_by=group_by, sub_group_by=sub_group_by
-        )
-
-        if group_by:
-            # Check group and sub group value paginate
-            if sub_group_by:
-                if group_by == sub_group_by:
-                    return Response(
-                        {
-                            "error": "Group by and sub group by cannot have same parameters"
-                        },
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                else:
-                    # group and sub group pagination
-                    return self.paginate(
-                        request=request,
-                        order_by=order_by_param,
-                        queryset=issue_queryset,
-                        on_results=lambda issues: issue_on_results(
-                            group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                        ),
-                        paginator_cls=SubGroupedOffsetPaginator,
-                        group_by_fields=issue_group_values(
-                            field=group_by,
-                            slug=slug,
-                            project_id=project_id,
-                            filters=filters,
-                        ),
-                        sub_group_by_fields=issue_group_values(
-                            field=sub_group_by,
-                            slug=slug,
-                            project_id=project_id,
-                            filters=filters,
-                        ),
-                        group_by_field_name=group_by,
-                        sub_group_by_field_name=sub_group_by,
-                        count_filter=Q(
-                            Q(issue_intake__status=1)
-                            | Q(issue_intake__status=-1)
-                            | Q(issue_intake__status=2)
-                            | Q(issue_intake__isnull=True),
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-            # Group Paginate
-            else:
-                # Group paginate
-                return self.paginate(
-                    request=request,
-                    order_by=order_by_param,
-                    queryset=issue_queryset,
-                    on_results=lambda issues: issue_on_results(
-                        group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                    ),
-                    paginator_cls=GroupedOffsetPaginator,
-                    group_by_fields=issue_group_values(
-                        field=group_by,
-                        slug=slug,
-                        project_id=project_id,
-                        filters=filters,
-                    ),
-                    group_by_field_name=group_by,
-                    count_filter=Q(
-                        Q(issue_intake__status=1)
-                        | Q(issue_intake__status=-1)
-                        | Q(issue_intake__status=2)
-                        | Q(issue_intake__isnull=True),
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                )
-        else:
-            # List Paginate
-            return self.paginate(
-                order_by=order_by_param,
-                request=request,
-                queryset=issue_queryset,
-                on_results=lambda issues: issue_on_results(
-                    group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                ),
-            )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    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():
-            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:
-            old_cycle_id = cycle_issue.cycle_id
-            # 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(old_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)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def destroy(self, request, slug, project_id, cycle_id, issue_id):
-        cycle_issue = CycleIssue.objects.filter(
-            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)
@@ -1,806 +0,0 @@
-# Django imports
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models import (
-    Case,
-    CharField,
-    Count,
-    Exists,
-    F,
-    Func,
-    IntegerField,
-    JSONField,
-    OuterRef,
-    Prefetch,
-    Q,
-    Subquery,
-    UUIDField,
-    Value,
-    When,
-)
-from django.db.models.functions import Coalesce
-from django.utils import timezone
-from rest_framework import status
-
-# Third Party imports
-from rest_framework.response import Response
-
-from plane.app.serializers import (
-    DashboardSerializer,
-    IssueActivitySerializer,
-    IssueSerializer,
-    WidgetSerializer,
-)
-from plane.db.models import (
-    Dashboard,
-    DashboardWidget,
-    Issue,
-    IssueActivity,
-    FileAsset,
-    IssueLink,
-    IssueRelation,
-    Project,
-    Widget,
-    WorkspaceMember,
-    CycleIssue,
-)
-from plane.utils.issue_filters import issue_filters
-
-# Module imports
-from .. import BaseAPIView
-
-
-def dashboard_overview_stats(self, request, slug):
-    assigned_issues = (
-        Issue.issue_objects.filter(
-            project__project_projectmember__is_active=True,
-            project__project_projectmember__member=request.user,
-            workspace__slug=slug,
-            assignees__in=[request.user],
-        )
-        .filter(
-            Q(
-                project__project_projectmember__role=5,
-                project__guest_view_all_features=True,
-            )
-            | Q(
-                project__project_projectmember__role=5,
-                project__guest_view_all_features=False,
-                created_by=self.request.user,
-            )
-            |
-            # For other roles (role < 5), show all issues
-            Q(project__project_projectmember__role__gt=5),
-            project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
-        )
-        .count()
-    )
-
-    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,
-            assignees__in=[request.user],
-        )
-        .filter(
-            Q(
-                project__project_projectmember__role=5,
-                project__guest_view_all_features=True,
-            )
-            | Q(
-                project__project_projectmember__role=5,
-                project__guest_view_all_features=False,
-                created_by=self.request.user,
-            )
-            |
-            # For other roles (role < 5), show all issues
-            Q(project__project_projectmember__role__gt=5),
-            project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
-        )
-        .count()
-    )
-
-    created_issues_count = (
-        Issue.issue_objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__is_active=True,
-            project__project_projectmember__member=request.user,
-            created_by_id=request.user.id,
-        )
-        .filter(
-            Q(
-                project__project_projectmember__role=5,
-                project__guest_view_all_features=True,
-            )
-            | Q(
-                project__project_projectmember__role=5,
-                project__guest_view_all_features=False,
-                created_by=self.request.user,
-            )
-            |
-            # For other roles (role < 5), show all issues
-            Q(project__project_projectmember__role__gt=5),
-            project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
-        )
-        .count()
-    )
-
-    completed_issues_count = (
-        Issue.issue_objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__is_active=True,
-            project__project_projectmember__member=request.user,
-            assignees__in=[request.user],
-            state__group="completed",
-        )
-        .filter(
-            Q(
-                project__project_projectmember__role=5,
-                project__guest_view_all_features=True,
-            )
-            | Q(
-                project__project_projectmember__role=5,
-                project__guest_view_all_features=False,
-                created_by=self.request.user,
-            )
-            |
-            # For other roles (role < 5), show all issues
-            Q(project__project_projectmember__role__gt=5),
-            project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
-        )
-        .count()
-    )
-
-    return Response(
-        {
-            "assigned_issues_count": assigned_issues,
-            "pending_issues_count": pending_issues_count,
-            "completed_issues_count": completed_issues_count,
-            "created_issues_count": created_issues_count,
-        },
-        status=status.HTTP_200_OK,
-    )
-
-
-def dashboard_assigned_issues(self, request, slug):
-    filters = issue_filters(request.query_params, "GET")
-    issue_type = request.GET.get("issue_type", None)
-
-    # get all the assigned issues
-    assigned_issues = (
-        Issue.issue_objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True,
-            assignees__in=[request.user],
-        )
-        .filter(**filters)
-        .select_related("workspace", "project", "state", "parent")
-        .prefetch_related("assignees", "labels", "issue_module__module")
-        .prefetch_related(
-            Prefetch(
-                "issue_relation",
-                queryset=IssueRelation.objects.select_related(
-                    "related_issue"
-                ).select_related("issue"),
-            )
-        )
-        .annotate(
-            cycle_id=Subquery(
-                CycleIssue.objects.filter(
-                    issue=OuterRef("id"), deleted_at__isnull=True
-                ).values("cycle_id")[:1]
-            )
-        )
-        .annotate(
-            link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-            .order_by()
-            .annotate(count=Func(F("id"), function="Count"))
-            .values("count")
-        )
-        .annotate(
-            attachment_count=FileAsset.objects.filter(
-                issue_id=OuterRef("id"),
-                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
-            )
-            .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(
-                        ~Q(labels__id__isnull=True)
-                        & Q(label_issue__deleted_at__isnull=True)
-                    ),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            assignee_ids=Coalesce(
-                ArrayAgg(
-                    "assignees__id",
-                    distinct=True,
-                    filter=Q(
-                        ~Q(assignees__id__isnull=True)
-                        & Q(assignees__member_project__is_active=True)
-                        & Q(issue_assignee__deleted_at__isnull=True)
-                    ),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            module_ids=Coalesce(
-                ArrayAgg(
-                    "issue_module__module_id",
-                    distinct=True,
-                    filter=Q(
-                        ~Q(issue_module__module_id__isnull=True)
-                        & Q(issue_module__module__archived_at__isnull=True)
-                        & Q(issue_module__deleted_at__isnull=True)
-                    ),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-        )
-    )
-
-    if WorkspaceMember.objects.filter(
-        workspace__slug=slug, member=request.user, role=5, is_active=True
-    ).exists():
-        assigned_issues = assigned_issues.filter(created_by=request.user)
-
-    # Priority Ordering
-    priority_order = ["urgent", "high", "medium", "low", "none"]
-    assigned_issues = assigned_issues.annotate(
-        priority_order=Case(
-            *[When(priority=p, then=Value(i)) for i, p in enumerate(priority_order)],
-            output_field=CharField(),
-        )
-    ).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"]
-        ).count()
-        completed_issues = assigned_issues.filter(state__group__in=["completed"])[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(
-                    completed_issues, many=True, expand=self.expand
-                ).data,
-                "count": completed_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    if issue_type == "overdue":
-        overdue_issues_count = assigned_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now(),
-        ).count()
-        overdue_issues = assigned_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now(),
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(
-                    overdue_issues, many=True, expand=self.expand
-                ).data,
-                "count": overdue_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    if issue_type == "upcoming":
-        upcoming_issues_count = assigned_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now(),
-        ).count()
-        upcoming_issues = assigned_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now(),
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(
-                    upcoming_issues, many=True, expand=self.expand
-                ).data,
-                "count": upcoming_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    return Response(
-        {"error": "Please specify a valid issue type"},
-        status=status.HTTP_400_BAD_REQUEST,
-    )
-
-
-def dashboard_created_issues(self, request, slug):
-    filters = issue_filters(request.query_params, "GET")
-    issue_type = request.GET.get("issue_type", None)
-
-    # get all the assigned issues
-    created_issues = (
-        Issue.issue_objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True,
-            created_by=request.user,
-        )
-        .filter(**filters)
-        .select_related("workspace", "project", "state", "parent")
-        .prefetch_related("assignees", "labels", "issue_module__module")
-        .annotate(
-            cycle_id=Subquery(
-                CycleIssue.objects.filter(
-                    issue=OuterRef("id"), deleted_at__isnull=True
-                ).values("cycle_id")[:1]
-            )
-        )
-        .annotate(
-            link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-            .order_by()
-            .annotate(count=Func(F("id"), function="Count"))
-            .values("count")
-        )
-        .annotate(
-            attachment_count=FileAsset.objects.filter(
-                issue_id=OuterRef("id"),
-                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
-            )
-            .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(
-                        ~Q(labels__id__isnull=True)
-                        & Q(label_issue__deleted_at__isnull=True)
-                    ),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            assignee_ids=Coalesce(
-                ArrayAgg(
-                    "assignees__id",
-                    distinct=True,
-                    filter=Q(
-                        ~Q(assignees__id__isnull=True)
-                        & Q(assignees__member_project__is_active=True)
-                        & Q(issue_assignee__deleted_at__isnull=True)
-                    ),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            module_ids=Coalesce(
-                ArrayAgg(
-                    "issue_module__module_id",
-                    distinct=True,
-                    filter=Q(
-                        ~Q(issue_module__module_id__isnull=True)
-                        & Q(issue_module__module__archived_at__isnull=True)
-                        & Q(issue_module__deleted_at__isnull=True)
-                    ),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-        )
-        .order_by("created_at")
-    )
-
-    # Priority Ordering
-    priority_order = ["urgent", "high", "medium", "low", "none"]
-    created_issues = created_issues.annotate(
-        priority_order=Case(
-            *[When(priority=p, then=Value(i)) for i, p in enumerate(priority_order)],
-            output_field=CharField(),
-        )
-    ).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"]
-        ).count()
-        completed_issues = created_issues.filter(state__group__in=["completed"])[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(completed_issues, many=True).data,
-                "count": completed_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    if issue_type == "overdue":
-        overdue_issues_count = created_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now(),
-        ).count()
-        overdue_issues = created_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now(),
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(overdue_issues, many=True).data,
-                "count": overdue_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    if issue_type == "upcoming":
-        upcoming_issues_count = created_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now(),
-        ).count()
-        upcoming_issues = created_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now(),
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(upcoming_issues, many=True).data,
-                "count": upcoming_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    return Response(
-        {"error": "Please specify a valid issue type"},
-        status=status.HTTP_400_BAD_REQUEST,
-    )
-
-
-def dashboard_issues_by_state_groups(self, request, slug):
-    filters = issue_filters(request.query_params, "GET")
-    state_order = ["backlog", "unstarted", "started", "completed", "cancelled"]
-    extra_filters = {}
-
-    if WorkspaceMember.objects.filter(
-        workspace__slug=slug, member=request.user, role=5, is_active=True
-    ).exists():
-        extra_filters = {"created_by": request.user}
-
-    issues_by_state_groups = (
-        Issue.issue_objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__is_active=True,
-            project__project_projectmember__member=request.user,
-            assignees__in=[request.user],
-        )
-        .filter(**filters, **extra_filters)
-        .values("state__group")
-        .annotate(count=Count("id"))
-    )
-
-    # default state
-    all_groups = {state: 0 for state in state_order}
-
-    # Update counts for existing groups
-    for entry in issues_by_state_groups:
-        all_groups[entry["state__group"]] = entry["count"]
-
-    # Prepare output including all groups with their counts
-    output_data = [
-        {"state": group, "count": count} for group, count in all_groups.items()
-    ]
-
-    return Response(output_data, status=status.HTTP_200_OK)
-
-
-def dashboard_issues_by_priority(self, request, slug):
-    filters = issue_filters(request.query_params, "GET")
-    priority_order = ["urgent", "high", "medium", "low", "none"]
-    extra_filters = {}
-
-    if WorkspaceMember.objects.filter(
-        workspace__slug=slug, member=request.user, role=5, is_active=True
-    ).exists():
-        extra_filters = {"created_by": request.user}
-
-    issues_by_priority = (
-        Issue.issue_objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__is_active=True,
-            project__project_projectmember__member=request.user,
-            assignees__in=[request.user],
-        )
-        .filter(**filters, **extra_filters)
-        .values("priority")
-        .annotate(count=Count("id"))
-    )
-
-    # default priority
-    all_groups = {priority: 0 for priority in priority_order}
-
-    # Update counts for existing groups
-    for entry in issues_by_priority:
-        all_groups[entry["priority"]] = entry["count"]
-
-    # Prepare output including all groups with their counts
-    output_data = [
-        {"priority": group, "count": count} for group, count in all_groups.items()
-    ]
-
-    return Response(output_data, status=status.HTTP_200_OK)
-
-
-def dashboard_recent_activity(self, request, slug):
-    queryset = IssueActivity.objects.filter(
-        ~Q(field__in=["comment", "vote", "reaction", "draft"]),
-        workspace__slug=slug,
-        project__project_projectmember__member=request.user,
-        project__project_projectmember__is_active=True,
-        project__archived_at__isnull=True,
-        actor=request.user,
-    ).select_related("actor", "workspace", "issue", "project")[:8]
-
-    return Response(
-        IssueActivitySerializer(queryset, many=True).data, status=status.HTTP_200_OK
-    )
-
-
-def dashboard_recent_projects(self, request, slug):
-    project_ids = (
-        IssueActivity.objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True,
-            project__archived_at__isnull=True,
-            actor=request.user,
-        )
-        .values_list("project_id", flat=True)
-        .distinct()
-    )
-
-    # Extract project IDs from the recent projects
-    unique_project_ids = set(project_id for project_id in project_ids)
-
-    # Fetch additional projects only if needed
-    if len(unique_project_ids) < 4:
-        additional_projects = Project.objects.filter(
-            project_projectmember__member=request.user,
-            project_projectmember__is_active=True,
-            archived_at__isnull=True,
-            workspace__slug=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))
-
-    return Response(list(unique_project_ids)[:4], status=status.HTTP_200_OK)
-
-
-def dashboard_recent_collaborators(self, request, slug):
-    project_members_with_activities = (
-        WorkspaceMember.objects.filter(workspace__slug=slug, is_active=True)
-        .annotate(
-            active_issue_count=Count(
-                Case(
-                    When(
-                        member__issue_assignee__issue__state__group__in=[
-                            "unstarted",
-                            "started",
-                        ],
-                        member__issue_assignee__issue__workspace__slug=slug,
-                        member__issue_assignee__issue__project__project_projectmember__member=request.user,
-                        member__issue_assignee__issue__project__project_projectmember__is_active=True,
-                        then=F("member__issue_assignee__issue__id"),
-                    ),
-                    distinct=True,
-                    output_field=IntegerField(),
-                ),
-                distinct=True,
-            ),
-            user_id=F("member_id"),
-        )
-        .values("user_id", "active_issue_count")
-        .order_by("-active_issue_count")
-        .distinct()
-    )
-    return Response((project_members_with_activities), status=status.HTTP_200_OK)
-
-
-class DashboardEndpoint(BaseAPIView):
-    def create(self, request, slug):
-        serializer = DashboardSerializer(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 patch(self, request, slug, pk):
-        serializer = DashboardSerializer(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 delete(self, request, slug, pk):
-        serializer = DashboardSerializer(data=request.data, partial=True)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_204_NO_CONTENT)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def get(self, request, slug, dashboard_id=None):
-        if not dashboard_id:
-            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,
-                )
-
-                if created:
-                    widgets_to_fetch = [
-                        "overview_stats",
-                        "assigned_issues",
-                        "created_issues",
-                        "issues_by_state_groups",
-                        "issues_by_priority",
-                        "recent_activity",
-                        "recent_projects",
-                        "recent_collaborators",
-                    ]
-
-                    updated_dashboard_widgets = []
-                    for widget_key in widgets_to_fetch:
-                        widget = Widget.objects.filter(key=widget_key).values_list(
-                            "id", flat=True
-                        )
-                        if widget:
-                            updated_dashboard_widgets.append(
-                                DashboardWidget(
-                                    widget_id=widget, dashboard_id=dashboard.id
-                                )
-                            )
-
-                    DashboardWidget.objects.bulk_create(
-                        updated_dashboard_widgets, batch_size=100
-                    )
-
-                widgets = (
-                    Widget.objects.annotate(
-                        is_visible=Exists(
-                            DashboardWidget.objects.filter(
-                                widget_id=OuterRef("pk"),
-                                dashboard_id=dashboard.id,
-                                is_visible=True,
-                            )
-                        )
-                    )
-                    .annotate(
-                        dashboard_filters=Subquery(
-                            DashboardWidget.objects.filter(
-                                widget_id=OuterRef("pk"),
-                                dashboard_id=dashboard.id,
-                                filters__isnull=False,
-                            )
-                            .exclude(filters={})
-                            .values("filters")[:1]
-                        )
-                    )
-                    .annotate(
-                        widget_filters=Case(
-                            When(
-                                dashboard_filters__isnull=False,
-                                then=F("dashboard_filters"),
-                            ),
-                            default=F("filters"),
-                            output_field=JSONField(),
-                        )
-                    )
-                )
-                return Response(
-                    {
-                        "dashboard": DashboardSerializer(dashboard).data,
-                        "widgets": WidgetSerializer(widgets, many=True).data,
-                    },
-                    status=status.HTTP_200_OK,
-                )
-            return Response(
-                {"error": "Please specify a valid dashboard type"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        widget_key = request.GET.get("widget_key", "overview_stats")
-
-        WIDGETS_MAPPER = {
-            "overview_stats": dashboard_overview_stats,
-            "assigned_issues": dashboard_assigned_issues,
-            "created_issues": dashboard_created_issues,
-            "issues_by_state_groups": dashboard_issues_by_state_groups,
-            "issues_by_priority": dashboard_issues_by_priority,
-            "recent_activity": dashboard_recent_activity,
-            "recent_projects": dashboard_recent_projects,
-            "recent_collaborators": dashboard_recent_collaborators,
-        }
-
-        func = WIDGETS_MAPPER.get(widget_key)
-        if func is not None:
-            response = func(self, request=request, slug=slug)
-            if isinstance(response, Response):
-                return response
-
-        return Response(
-            {"error": "Please specify a valid widget key"},
-            status=status.HTTP_400_BAD_REQUEST,
-        )
-
-
-class WidgetsEndpoint(BaseAPIView):
-    def patch(self, request, dashboard_id, widget_id):
-        dashboard_widget = DashboardWidget.objects.filter(
-            widget_id=widget_id, dashboard_id=dashboard_id
-        ).first()
-        dashboard_widget.is_visible = request.data.get(
-            "is_visible", dashboard_widget.is_visible
-        )
-        dashboard_widget.sort_order = request.data.get(
-            "sort_order", dashboard_widget.sort_order
-        )
-        dashboard_widget.filters = request.data.get("filters", dashboard_widget.filters)
-        dashboard_widget.save()
-        return Response({"message": "successfully updated"}, status=status.HTTP_200_OK)
@@ -1,151 +0,0 @@
-# Python imports
-import requests
-import os
-
-# Third party imports
-from openai import OpenAI
-from rest_framework.response import Response
-from rest_framework import status
-
-# Django imports
-
-# Module imports
-from ..base import BaseAPIView
-from plane.app.permissions import allow_permission, ROLE
-from plane.db.models import Workspace, Project
-from plane.app.serializers import ProjectLiteSerializer, WorkspaceLiteSerializer
-from plane.license.utils.instance_value import get_configuration_value
-
-
-class GPTIntegrationEndpoint(BaseAPIView):
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def post(self, request, slug, project_id):
-        OPENAI_API_KEY, GPT_ENGINE = get_configuration_value(
-            [
-                {
-                    "key": "OPENAI_API_KEY",
-                    "default": os.environ.get("OPENAI_API_KEY", None),
-                },
-                {
-                    "key": "GPT_ENGINE",
-                    "default": os.environ.get("GPT_ENGINE", "gpt-3.5-turbo"),
-                },
-            ]
-        )
-
-        # Get the configuration value
-        # Check the keys
-        if not OPENAI_API_KEY or not GPT_ENGINE:
-            return Response(
-                {"error": "OpenAI API key and engine is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        prompt = request.data.get("prompt", False)
-        task = request.data.get("task", False)
-
-        if not task:
-            return Response(
-                {"error": "Task is required"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        final_text = task + "\n" + prompt
-
-        client = OpenAI(api_key=OPENAI_API_KEY)
-
-        response = client.chat.completions.create(
-            model=GPT_ENGINE, messages=[{"role": "user", "content": final_text}]
-        )
-
-        workspace = Workspace.objects.get(slug=slug)
-        project = Project.objects.get(pk=project_id)
-
-        text = response.choices[0].message.content.strip()
-        text_html = text.replace("\n", "<br/>")
-        return Response(
-            {
-                "response": text,
-                "response_html": text_html,
-                "project_detail": ProjectLiteSerializer(project).data,
-                "workspace_detail": WorkspaceLiteSerializer(workspace).data,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-
-class WorkspaceGPTIntegrationEndpoint(BaseAPIView):
-    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    def post(self, request, slug):
-        OPENAI_API_KEY, GPT_ENGINE = get_configuration_value(
-            [
-                {
-                    "key": "OPENAI_API_KEY",
-                    "default": os.environ.get("OPENAI_API_KEY", None),
-                },
-                {
-                    "key": "GPT_ENGINE",
-                    "default": os.environ.get("GPT_ENGINE", "gpt-3.5-turbo"),
-                },
-            ]
-        )
-
-        # Get the configuration value
-        # Check the keys
-        if not OPENAI_API_KEY or not GPT_ENGINE:
-            return Response(
-                {"error": "OpenAI API key and engine is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        prompt = request.data.get("prompt", False)
-        task = request.data.get("task", False)
-
-        if not task:
-            return Response(
-                {"error": "Task is required"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        final_text = task + "\n" + prompt
-
-        client = OpenAI(api_key=OPENAI_API_KEY)
-
-        response = client.chat.completions.create(
-            model=GPT_ENGINE, messages=[{"role": "user", "content": final_text}]
-        )
-
-        text = response.choices[0].message.content.strip()
-        text_html = text.replace("\n", "<br/>")
-        return Response(
-            {"response": text, "response_html": text_html}, status=status.HTTP_200_OK
-        )
-
-
-class UnsplashEndpoint(BaseAPIView):
-    def get(self, request):
-        (UNSPLASH_ACCESS_KEY,) = get_configuration_value(
-            [
-                {
-                    "key": "UNSPLASH_ACCESS_KEY",
-                    "default": os.environ.get("UNSPLASH_ACCESS_KEY"),
-                }
-            ]
-        )
-        # Check unsplash access key
-        if not UNSPLASH_ACCESS_KEY:
-            return Response([], status=status.HTTP_200_OK)
-
-        # Query parameters
-        query = request.GET.get("query", False)
-        page = request.GET.get("page", 1)
-        per_page = request.GET.get("per_page", 20)
-
-        url = (
-            f"https://api.unsplash.com/search/photos/?client_id={UNSPLASH_ACCESS_KEY}&query={query}&page=${page}&per_page={per_page}"
-            if query
-            else f"https://api.unsplash.com/photos/?client_id={UNSPLASH_ACCESS_KEY}&page={page}&per_page={per_page}"
-        )
-
-        headers = {"Content-Type": "application/json"}
-
-        resp = requests.get(url=url, headers=headers)
-        return Response(resp.json(), status=resp.status_code)
@@ -1,581 +0,0 @@
-# Python imports
-import json
-
-# Django import
-from django.utils import timezone
-from django.db.models import Q, Count, OuterRef, Func, F, Prefetch, Subquery
-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 plane.app.permissions import allow_permission, ROLE
-from plane.db.models import (
-    Intake,
-    IntakeIssue,
-    Issue,
-    State,
-    IssueLink,
-    FileAsset,
-    Project,
-    ProjectMember,
-    CycleIssue,
-)
-from plane.app.serializers import (
-    IssueCreateSerializer,
-    IssueSerializer,
-    IntakeSerializer,
-    IntakeIssueSerializer,
-    IntakeIssueDetailSerializer,
-)
-from plane.utils.issue_filters import issue_filters
-from plane.bgtasks.issue_activities_task import issue_activity
-
-
-class IntakeViewSet(BaseViewSet):
-    serializer_class = IntakeSerializer
-    model = Intake
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .filter(
-                workspace__slug=self.kwargs.get("slug"),
-                project_id=self.kwargs.get("project_id"),
-            )
-            .annotate(
-                pending_issue_count=Count(
-                    "issue_intake", filter=Q(issue_intake__status=-2)
-                )
-            )
-            .select_related("workspace", "project")
-        )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def list(self, request, slug, project_id):
-        intake = self.get_queryset().first()
-        return Response(IntakeSerializer(intake).data, status=status.HTTP_200_OK)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def perform_create(self, serializer):
-        serializer.save(project_id=self.kwargs.get("project_id"))
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def destroy(self, request, slug, project_id, pk):
-        intake = Intake.objects.filter(
-            workspace__slug=slug, project_id=project_id, pk=pk
-        ).first()
-        # Handle default intake delete
-        if intake.is_default:
-            return Response(
-                {"error": "You cannot delete the default intake"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        intake.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class IntakeIssueViewSet(BaseViewSet):
-    serializer_class = IntakeIssueSerializer
-    model = IntakeIssue
-
-    filterset_fields = ["statulls"]
-
-    def get_queryset(self):
-        return (
-            Issue.objects.filter(
-                project_id=self.kwargs.get("project_id"),
-                workspace__slug=self.kwargs.get("slug"),
-            )
-            .select_related("workspace", "project", "state", "parent")
-            .prefetch_related("assignees", "labels", "issue_module__module")
-            .prefetch_related(
-                Prefetch(
-                    "issue_intake",
-                    queryset=IntakeIssue.objects.only(
-                        "status", "duplicate_to", "snoozed_till", "source"
-                    ),
-                )
-            )
-            .annotate(
-                cycle_id=Subquery(
-                    CycleIssue.objects.filter(
-                        issue=OuterRef("id"), deleted_at__isnull=True
-                    ).values("cycle_id")[:1]
-                )
-            )
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
-                )
-                .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(
-                            ~Q(labels__id__isnull=True)
-                            & Q(label_issue__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=Q(
-                            ~Q(assignees__id__isnull=True)
-                            & Q(assignees__member_project__is_active=True)
-                            & Q(issue_assignee__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "issue_module__module_id",
-                        distinct=True,
-                        filter=Q(
-                            ~Q(issue_module__module_id__isnull=True)
-                            & Q(issue_module__module__archived_at__isnull=True)
-                            & Q(issue_module__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-        ).distinct()
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def list(self, request, slug, project_id):
-        intake_id = Intake.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-        project = Project.objects.get(pk=project_id)
-        filters = issue_filters(request.GET, "GET", "issue__")
-        intake_issue = (
-            IntakeIssue.objects.filter(
-                intake_id=intake_id.id, project_id=project_id, **filters
-            )
-            .select_related("issue")
-            .prefetch_related("issue__labels")
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "issue__labels__id",
-                        distinct=True,
-                        filter=Q(
-                            ~Q(issue__labels__id__isnull=True)
-                            & Q(issue__label_issue__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                )
-            )
-        ).order_by(request.GET.get("order_by", "-issue__created_at"))
-        # Intake status filter
-        intake_status = [
-            item
-            for item in request.GET.get("status", "-2").split(",")
-            if item != "null"
-        ]
-        if intake_status:
-            intake_issue = intake_issue.filter(status__in=intake_status)
-
-        if (
-            ProjectMember.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                member=request.user,
-                role=5,
-                is_active=True,
-            ).exists()
-            and not project.guest_view_all_features
-        ):
-            intake_issue = intake_issue.filter(created_by=request.user)
-        return self.paginate(
-            request=request,
-            queryset=(intake_issue),
-            on_results=lambda intake_issues: IntakeIssueSerializer(
-                intake_issues, many=True
-            ).data,
-        )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def create(self, request, slug, project_id):
-        if not request.data.get("issue", {}).get("name", False):
-            return Response(
-                {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        # Check for valid priority
-        if request.data.get("issue", {}).get("priority", "none") not in [
-            "low",
-            "medium",
-            "high",
-            "urgent",
-            "none",
-        ]:
-            return Response(
-                {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        # create an issue
-        project = Project.objects.get(pk=project_id)
-        serializer = IssueCreateSerializer(
-            data=request.data.get("issue"),
-            context={
-                "project_id": project_id,
-                "workspace_id": project.workspace_id,
-                "default_assignee_id": project.default_assignee_id,
-            },
-        )
-        if serializer.is_valid():
-            serializer.save()
-            intake_id = Intake.objects.filter(
-                workspace__slug=slug, project_id=project_id
-            ).first()
-            # create an intake issue
-            intake_issue = IntakeIssue.objects.create(
-                intake_id=intake_id.id,
-                project_id=project_id,
-                issue_id=serializer.data["id"],
-                source=request.data.get("source", "IN-APP"),
-            )
-            # Create an Issue Activity
-            issue_activity.delay(
-                type="issue.activity.created",
-                requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
-                actor_id=str(request.user.id),
-                issue_id=str(serializer.data["id"]),
-                project_id=str(project_id),
-                current_instance=None,
-                epoch=int(timezone.now().timestamp()),
-                notification=True,
-                origin=request.META.get("HTTP_ORIGIN"),
-                intake=str(intake_issue.id),
-            )
-            intake_issue = (
-                IntakeIssue.objects.select_related("issue")
-                .prefetch_related("issue__labels", "issue__assignees")
-                .annotate(
-                    label_ids=Coalesce(
-                        ArrayAgg(
-                            "issue__labels__id",
-                            distinct=True,
-                            filter=Q(
-                                ~Q(issue__labels__id__isnull=True)
-                                & Q(issue__label_issue__deleted_at__isnull=True)
-                            ),
-                        ),
-                        Value([], output_field=ArrayField(UUIDField())),
-                    ),
-                    assignee_ids=Coalesce(
-                        ArrayAgg(
-                            "issue__assignees__id",
-                            distinct=True,
-                            filter=~Q(issue__assignees__id__isnull=True)
-                            & Q(issue__assignees__member_project__is_active=True),
-                        ),
-                        Value([], output_field=ArrayField(UUIDField())),
-                    ),
-                )
-                .get(
-                    intake_id=intake_id.id,
-                    issue_id=serializer.data["id"],
-                    project_id=project_id,
-                )
-            )
-            serializer = IntakeIssueDetailSerializer(intake_issue)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        else:
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=Issue)
-    def partial_update(self, request, slug, project_id, pk):
-        intake_id = Intake.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-        intake_issue = IntakeIssue.objects.get(
-            issue_id=pk,
-            workspace__slug=slug,
-            project_id=project_id,
-            intake_id=intake_id,
-        )
-        # Get the project member
-        project_member = ProjectMember.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            member=request.user,
-            is_active=True,
-        )
-        # Only project members admins and created_by users can access this endpoint
-        if project_member.role <= 5 and str(intake_issue.created_by_id) != str(
-            request.user.id
-        ):
-            return Response(
-                {"error": "You cannot edit intake issues"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get issue data
-        issue_data = request.data.pop("issue", False)
-        if bool(issue_data):
-            issue = Issue.objects.annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=Q(
-                            ~Q(labels__id__isnull=True)
-                            & Q(label_issue__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=Q(
-                            ~Q(assignees__id__isnull=True)
-                            & Q(issue_assignee__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            ).get(pk=intake_issue.issue_id, workspace__slug=slug, project_id=project_id)
-            # Only allow guests to edit name and description
-            if project_member.role <= 5:
-                issue_data = {
-                    "name": issue_data.get("name", issue.name),
-                    "description_html": issue_data.get(
-                        "description_html", issue.description_html
-                    ),
-                    "description": issue_data.get("description", issue.description),
-                }
-
-            issue_serializer = IssueCreateSerializer(
-                issue, data=issue_data, partial=True
-            )
-
-            if issue_serializer.is_valid():
-                current_instance = issue
-                # Log all the updates
-                requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
-                if issue is not None:
-                    issue_activity.delay(
-                        type="issue.activity.updated",
-                        requested_data=requested_data,
-                        actor_id=str(request.user.id),
-                        issue_id=str(issue.id),
-                        project_id=str(project_id),
-                        current_instance=json.dumps(
-                            IssueSerializer(current_instance).data,
-                            cls=DjangoJSONEncoder,
-                        ),
-                        epoch=int(timezone.now().timestamp()),
-                        notification=True,
-                        origin=request.META.get("HTTP_ORIGIN"),
-                        intake=str(intake_issue.id),
-                    )
-                issue_serializer.save()
-            else:
-                return Response(
-                    issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
-                )
-
-        # Only project admins and members can edit intake issue attributes
-        if project_member.role > 15:
-            serializer = IntakeIssueSerializer(
-                intake_issue, data=request.data, partial=True
-            )
-            current_instance = json.dumps(
-                IntakeIssueSerializer(intake_issue).data, cls=DjangoJSONEncoder
-            )
-            if serializer.is_valid():
-                serializer.save()
-                # Update the issue state if the issue is rejected or marked as duplicate
-                if serializer.data["status"] in [-1, 2]:
-                    issue = Issue.objects.get(
-                        pk=intake_issue.issue_id,
-                        workspace__slug=slug,
-                        project_id=project_id,
-                    )
-                    state = State.objects.filter(
-                        group="cancelled", workspace__slug=slug, project_id=project_id
-                    ).first()
-                    if state is not None:
-                        issue.state = state
-                        issue.save()
-
-                # Update the issue state if it is accepted
-                if serializer.data["status"] in [1]:
-                    issue = Issue.objects.get(
-                        pk=intake_issue.issue_id,
-                        workspace__slug=slug,
-                        project_id=project_id,
-                    )
-
-                    # Update the issue state only if it is in triage state
-                    if issue.state.is_triage:
-                        # Move to default state
-                        state = State.objects.filter(
-                            workspace__slug=slug, project_id=project_id, default=True
-                        ).first()
-                        if state is not None:
-                            issue.state = state
-                            issue.save()
-                # create a activity for status change
-                issue_activity.delay(
-                    type="intake.activity.created",
-                    requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
-                    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=False,
-                    origin=request.META.get("HTTP_ORIGIN"),
-                    intake=(intake_issue.id),
-                )
-
-                intake_issue = (
-                    IntakeIssue.objects.select_related("issue")
-                    .prefetch_related("issue__labels", "issue__assignees")
-                    .annotate(
-                        label_ids=Coalesce(
-                            ArrayAgg(
-                                "issue__labels__id",
-                                distinct=True,
-                                filter=Q(
-                                    ~Q(issue__labels__id__isnull=True)
-                                    & Q(issue__label_issue__deleted_at__isnull=True)
-                                ),
-                            ),
-                            Value([], output_field=ArrayField(UUIDField())),
-                        ),
-                        assignee_ids=Coalesce(
-                            ArrayAgg(
-                                "issue__assignees__id",
-                                distinct=True,
-                                filter=Q(
-                                    ~Q(issue__assignees__id__isnull=True)
-                                    & Q(issue__issue_assignee__deleted_at__isnull=True)
-                                ),
-                            ),
-                            Value([], output_field=ArrayField(UUIDField())),
-                        ),
-                    )
-                    .get(intake_id=intake_id.id, issue_id=pk, project_id=project_id)
-                )
-                serializer = IntakeIssueDetailSerializer(intake_issue).data
-                return Response(serializer, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        else:
-            serializer = IntakeIssueDetailSerializer(intake_issue).data
-            return Response(serializer, status=status.HTTP_200_OK)
-
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], creator=True, model=Issue
-    )
-    def retrieve(self, request, slug, project_id, pk):
-        intake_id = Intake.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-        project = Project.objects.get(pk=project_id)
-        intake_issue = (
-            IntakeIssue.objects.select_related("issue")
-            .prefetch_related("issue__labels", "issue__assignees")
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "issue__labels__id",
-                        distinct=True,
-                        filter=Q(
-                            ~Q(issue__labels__id__isnull=True)
-                            & Q(issue__label_issue__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "issue__assignees__id",
-                        distinct=True,
-                        filter=Q(
-                            ~Q(issue__assignees__id__isnull=True)
-                            & Q(issue__issue_assignee__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-            .get(intake_id=intake_id.id, issue_id=pk, project_id=project_id)
-        )
-        if (
-            ProjectMember.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                member=request.user,
-                role=5,
-                is_active=True,
-            ).exists()
-            and not project.guest_view_all_features
-            and not intake_issue.created_by == request.user
-        ):
-            return Response(
-                {"error": "You are not allowed to view this issue"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        issue = IntakeIssueDetailSerializer(intake_issue).data
-        return Response(issue, status=status.HTTP_200_OK)
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=Issue)
-    def destroy(self, request, slug, project_id, pk):
-        intake_id = Intake.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-        intake_issue = IntakeIssue.objects.get(
-            issue_id=pk,
-            workspace__slug=slug,
-            project_id=project_id,
-            intake_id=intake_id,
-        )
-
-        # Check the issue status
-        if intake_issue.status in [-2, -1, 0, 2]:
-            # Delete the issue also
-            issue = Issue.objects.filter(
-                workspace__slug=slug, project_id=project_id, pk=pk
-            ).first()
-            issue.delete()
-
-        intake_issue.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,910 +0,0 @@
-# Python imports
-import json
-
-# Django Imports
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models import (
-    Count,
-    Exists,
-    F,
-    Func,
-    IntegerField,
-    OuterRef,
-    Prefetch,
-    Q,
-    Subquery,
-    UUIDField,
-    Value,
-    Sum,
-    FloatField,
-    Case,
-    When,
-)
-from django.db import models
-from django.db.models.functions import Coalesce, Cast, Concat
-from django.core.serializers.json import DjangoJSONEncoder
-from django.utils import timezone
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from plane.app.permissions import (
-    ProjectEntityPermission,
-    ProjectLitePermission,
-    allow_permission,
-    ROLE,
-)
-
-from plane.app.serializers import (
-    ModuleDetailSerializer,
-    ModuleLinkSerializer,
-    ModuleSerializer,
-    ModuleUserPropertiesSerializer,
-    ModuleWriteSerializer,
-)
-from plane.bgtasks.issue_activities_task import issue_activity
-from plane.db.models import (
-    Issue,
-    Module,
-    UserFavorite,
-    ModuleIssue,
-    ModuleLink,
-    ModuleUserProperties,
-    Project,
-)
-from plane.utils.analytics_plot import burndown_plot
-from plane.utils.timezone_converter import user_timezone_converter
-from plane.bgtasks.webhook_task import model_activity
-from .. import BaseAPIView, BaseViewSet
-from plane.bgtasks.recent_visited_task import recent_visited_task
-
-
-class ModuleViewSet(BaseViewSet):
-    model = Module
-    webhook_event = "module"
-
-    def get_serializer_class(self):
-        return (
-            ModuleWriteSerializer
-            if self.action in ["create", "update", "partial_update"]
-            else ModuleSerializer
-        )
-
-    def get_queryset(self):
-        favorite_subquery = UserFavorite.objects.filter(
-            user=self.request.user,
-            entity_type="module",
-            entity_identifier=OuterRef("pk"),
-            project_id=self.kwargs.get("project_id"),
-            workspace__slug=self.kwargs.get("slug"),
-        )
-        cancelled_issues = (
-            Issue.issue_objects.filter(
-                state__group="cancelled",
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(cnt=Count("pk"))
-            .values("cnt")
-        )
-        completed_issues = (
-            Issue.issue_objects.filter(
-                state__group="completed",
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(cnt=Count("pk"))
-            .values("cnt")
-        )
-        started_issues = (
-            Issue.issue_objects.filter(
-                state__group="started",
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(cnt=Count("pk"))
-            .values("cnt")
-        )
-        unstarted_issues = (
-            Issue.issue_objects.filter(
-                state__group="unstarted",
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(cnt=Count("pk"))
-            .values("cnt")
-        )
-        backlog_issues = (
-            Issue.issue_objects.filter(
-                state__group="backlog",
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(cnt=Count("pk"))
-            .values("cnt")
-        )
-        total_issues = (
-            Issue.issue_objects.filter(
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(cnt=Count("pk"))
-            .values("cnt")
-        )
-        completed_estimate_point = (
-            Issue.issue_objects.filter(
-                estimate_point__estimate__type="points",
-                state__group="completed",
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(
-                completed_estimate_points=Sum(
-                    Cast("estimate_point__value", FloatField())
-                )
-            )
-            .values("completed_estimate_points")[:1]
-        )
-
-        total_estimate_point = (
-            Issue.issue_objects.filter(
-                estimate_point__estimate__type="points",
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(
-                total_estimate_points=Sum(Cast("estimate_point__value", FloatField()))
-            )
-            .values("total_estimate_points")[:1]
-        )
-        backlog_estimate_point = (
-            Issue.issue_objects.filter(
-                estimate_point__estimate__type="points",
-                state__group="backlog",
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(
-                backlog_estimate_point=Sum(Cast("estimate_point__value", FloatField()))
-            )
-            .values("backlog_estimate_point")[:1]
-        )
-        unstarted_estimate_point = (
-            Issue.issue_objects.filter(
-                estimate_point__estimate__type="points",
-                state__group="unstarted",
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(
-                unstarted_estimate_point=Sum(
-                    Cast("estimate_point__value", FloatField())
-                )
-            )
-            .values("unstarted_estimate_point")[:1]
-        )
-        started_estimate_point = (
-            Issue.issue_objects.filter(
-                estimate_point__estimate__type="points",
-                state__group="started",
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(
-                started_estimate_point=Sum(Cast("estimate_point__value", FloatField()))
-            )
-            .values("started_estimate_point")[:1]
-        )
-        cancelled_estimate_point = (
-            Issue.issue_objects.filter(
-                estimate_point__estimate__type="points",
-                state__group="cancelled",
-                issue_module__module_id=OuterRef("pk"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .values("issue_module__module_id")
-            .annotate(
-                cancelled_estimate_point=Sum(
-                    Cast("estimate_point__value", FloatField())
-                )
-            )
-            .values("cancelled_estimate_point")[:1]
-        )
-        return (
-            super()
-            .get_queryset()
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .annotate(is_favorite=Exists(favorite_subquery))
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("lead")
-            .prefetch_related("members")
-            .prefetch_related(
-                Prefetch(
-                    "link_module",
-                    queryset=ModuleLink.objects.select_related("module", "created_by"),
-                )
-            )
-            .annotate(
-                completed_issues=Coalesce(
-                    Subquery(completed_issues[:1]),
-                    Value(0, output_field=IntegerField()),
-                )
-            )
-            .annotate(
-                cancelled_issues=Coalesce(
-                    Subquery(cancelled_issues[:1]),
-                    Value(0, output_field=IntegerField()),
-                )
-            )
-            .annotate(
-                started_issues=Coalesce(
-                    Subquery(started_issues[:1]), Value(0, output_field=IntegerField())
-                )
-            )
-            .annotate(
-                unstarted_issues=Coalesce(
-                    Subquery(unstarted_issues[:1]),
-                    Value(0, output_field=IntegerField()),
-                )
-            )
-            .annotate(
-                backlog_issues=Coalesce(
-                    Subquery(backlog_issues[:1]), Value(0, output_field=IntegerField())
-                )
-            )
-            .annotate(
-                total_issues=Coalesce(
-                    Subquery(total_issues[:1]), Value(0, output_field=IntegerField())
-                )
-            )
-            .annotate(
-                backlog_estimate_points=Coalesce(
-                    Subquery(backlog_estimate_point),
-                    Value(0, output_field=FloatField()),
-                )
-            )
-            .annotate(
-                unstarted_estimate_points=Coalesce(
-                    Subquery(unstarted_estimate_point),
-                    Value(0, output_field=FloatField()),
-                )
-            )
-            .annotate(
-                started_estimate_points=Coalesce(
-                    Subquery(started_estimate_point),
-                    Value(0, output_field=FloatField()),
-                )
-            )
-            .annotate(
-                cancelled_estimate_points=Coalesce(
-                    Subquery(cancelled_estimate_point),
-                    Value(0, output_field=FloatField()),
-                )
-            )
-            .annotate(
-                completed_estimate_points=Coalesce(
-                    Subquery(completed_estimate_point),
-                    Value(0, output_field=FloatField()),
-                )
-            )
-            .annotate(
-                total_estimate_points=Coalesce(
-                    Subquery(total_estimate_point), Value(0, output_field=FloatField())
-                )
-            )
-            .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")
-        )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def create(self, request, slug, project_id):
-        project = Project.objects.get(workspace__slug=slug, pk=project_id)
-        serializer = ModuleWriteSerializer(
-            data=request.data, context={"project": project}
-        )
-
-        if serializer.is_valid():
-            serializer.save()
-
-            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",
-                    "logo_props",
-                    # computed fields
-                    "is_favorite",
-                    "cancelled_issues",
-                    "completed_issues",
-                    "total_issues",
-                    "started_issues",
-                    "unstarted_issues",
-                    "completed_estimate_points",
-                    "total_estimate_points",
-                    "backlog_issues",
-                    "created_at",
-                    "updated_at",
-                )
-            ).first()
-            # Send the model activity
-            model_activity.delay(
-                model_name="module",
-                model_id=str(module["id"]),
-                requested_data=request.data,
-                current_instance=None,
-                actor_id=request.user.id,
-                slug=slug,
-                origin=request.META.get("HTTP_ORIGIN"),
-            )
-            datetime_fields = ["created_at", "updated_at"]
-            module = user_timezone_converter(
-                module, datetime_fields, request.user.user_timezone
-            )
-            return Response(module, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def list(self, request, slug, project_id):
-        queryset = self.get_queryset().filter(archived_at__isnull=True)
-        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",
-                "logo_props",
-                # computed fields
-                "completed_estimate_points",
-                "total_estimate_points",
-                "total_issues",
-                "is_favorite",
-                "cancelled_issues",
-                "completed_issues",
-                "started_issues",
-                "unstarted_issues",
-                "backlog_issues",
-                "created_at",
-                "updated_at",
-            )
-            datetime_fields = ["created_at", "updated_at"]
-            modules = user_timezone_converter(
-                modules, datetime_fields, request.user.user_timezone
-            )
-        return Response(modules, status=status.HTTP_200_OK)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def retrieve(self, request, slug, project_id, pk):
-        queryset = (
-            self.get_queryset()
-            .filter(archived_at__isnull=True)
-            .filter(pk=pk)
-            .annotate(
-                sub_issues=Issue.issue_objects.filter(
-                    project_id=self.kwargs.get("project_id"),
-                    parent__isnull=False,
-                    issue_module__module_id=pk,
-                    issue_module__deleted_at__isnull=True,
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-        )
-
-        if not queryset.exists():
-            return Response(
-                {"error": "Module not found"}, status=status.HTTP_404_NOT_FOUND
-            )
-
-        estimate_type = Project.objects.filter(
-            workspace__slug=slug,
-            pk=project_id,
-            estimate__isnull=False,
-            estimate__type="points",
-        ).exists()
-
-        data = ModuleDetailSerializer(queryset.first()).data
-        modules = queryset.first()
-
-        data["estimate_distribution"] = {}
-
-        if estimate_type:
-            assignee_distribution = (
-                Issue.issue_objects.filter(
-                    issue_module__module_id=pk,
-                    issue_module__deleted_at__isnull=True,
-                    workspace__slug=slug,
-                    project_id=project_id,
-                )
-                .annotate(first_name=F("assignees__first_name"))
-                .annotate(last_name=F("assignees__last_name"))
-                .annotate(assignee_id=F("assignees__id"))
-                .annotate(display_name=F("assignees__display_name"))
-                .annotate(
-                    avatar_url=Case(
-                        # If `avatar_asset` exists, use it to generate the asset URL
-                        When(
-                            assignees__avatar_asset__isnull=False,
-                            then=Concat(
-                                Value("/api/assets/v2/static/"),
-                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                                Value("/"),
-                            ),
-                        ),
-                        # If `avatar_asset` is None, fall back to using `avatar` field directly
-                        When(
-                            assignees__avatar_asset__isnull=True,
-                            then="assignees__avatar",
-                        ),
-                        default=Value(None),
-                        output_field=models.CharField(),
-                    )
-                )
-                .values(
-                    "first_name",
-                    "last_name",
-                    "assignee_id",
-                    "avatar_url",
-                    "display_name",
-                )
-                .annotate(
-                    total_estimates=Sum(Cast("estimate_point__value", FloatField()))
-                )
-                .annotate(
-                    completed_estimates=Sum(
-                        Cast("estimate_point__value", FloatField()),
-                        filter=Q(
-                            completed_at__isnull=False,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    pending_estimates=Sum(
-                        Cast("estimate_point__value", FloatField()),
-                        filter=Q(
-                            completed_at__isnull=True,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .order_by("first_name", "last_name")
-            )
-
-            label_distribution = (
-                Issue.issue_objects.filter(
-                    issue_module__module_id=pk,
-                    issue_module__deleted_at__isnull=True,
-                    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_estimates=Sum(Cast("estimate_point__value", FloatField()))
-                )
-                .annotate(
-                    completed_estimates=Sum(
-                        Cast("estimate_point__value", FloatField()),
-                        filter=Q(
-                            completed_at__isnull=False,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    pending_estimates=Sum(
-                        Cast("estimate_point__value", FloatField()),
-                        filter=Q(
-                            completed_at__isnull=True,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .order_by("label_name")
-            )
-            data["estimate_distribution"]["assignees"] = assignee_distribution
-            data["estimate_distribution"]["labels"] = label_distribution
-
-            if modules and modules.start_date and modules.target_date:
-                data["estimate_distribution"]["completion_chart"] = burndown_plot(
-                    queryset=modules,
-                    slug=slug,
-                    project_id=project_id,
-                    plot_type="points",
-                    module_id=pk,
-                )
-
-        assignee_distribution = (
-            Issue.issue_objects.filter(
-                issue_module__module_id=pk,
-                issue_module__deleted_at__isnull=True,
-                workspace__slug=slug,
-                project_id=project_id,
-            )
-            .annotate(first_name=F("assignees__first_name"))
-            .annotate(last_name=F("assignees__last_name"))
-            .annotate(assignee_id=F("assignees__id"))
-            .annotate(display_name=F("assignees__display_name"))
-            .annotate(
-                avatar_url=Case(
-                    # If `avatar_asset` exists, use it to generate the asset URL
-                    When(
-                        assignees__avatar_asset__isnull=False,
-                        then=Concat(
-                            Value("/api/assets/v2/static/"),
-                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                            Value("/"),
-                        ),
-                    ),
-                    # If `avatar_asset` is None, fall back to using `avatar` field directly
-                    When(
-                        assignees__avatar_asset__isnull=True, then="assignees__avatar"
-                    ),
-                    default=Value(None),
-                    output_field=models.CharField(),
-                )
-            )
-            .values(
-                "first_name", "last_name", "assignee_id", "avatar_url", "display_name"
-            )
-            .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("first_name", "last_name")
-        )
-
-        label_distribution = (
-            Issue.issue_objects.filter(
-                issue_module__module_id=pk,
-                issue_module__deleted_at__isnull=True,
-                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")
-        )
-
-        data["distribution"] = {
-            "assignees": assignee_distribution,
-            "labels": label_distribution,
-            "completion_chart": {},
-        }
-
-        if (
-            modules
-            and modules.start_date
-            and modules.target_date
-            and modules.total_issues > 0
-        ):
-            data["distribution"]["completion_chart"] = burndown_plot(
-                queryset=modules,
-                slug=slug,
-                project_id=project_id,
-                plot_type="issues",
-                module_id=pk,
-            )
-
-        recent_visited_task.delay(
-            slug=slug,
-            entity_name="module",
-            entity_identifier=pk,
-            user_id=request.user.id,
-            project_id=project_id,
-        )
-
-        return Response(data, status=status.HTTP_200_OK)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def partial_update(self, request, slug, project_id, pk):
-        module = self.get_queryset().filter(pk=pk)
-
-        if module.first().archived_at:
-            return Response(
-                {"error": "Archived module cannot be updated"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        current_instance = json.dumps(
-            ModuleSerializer(module.first()).data, cls=DjangoJSONEncoder
-        )
-        serializer = ModuleWriteSerializer(
-            module.first(), data=request.data, partial=True
-        )
-
-        if serializer.is_valid():
-            serializer.save()
-            module = module.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",
-                "logo_props",
-                # computed fields
-                "completed_estimate_points",
-                "total_estimate_points",
-                "is_favorite",
-                "cancelled_issues",
-                "completed_issues",
-                "started_issues",
-                "total_issues",
-                "unstarted_issues",
-                "backlog_issues",
-                "created_at",
-                "updated_at",
-            ).first()
-
-            # Send the model activity
-            model_activity.delay(
-                model_name="module",
-                model_id=str(module["id"]),
-                requested_data=request.data,
-                current_instance=current_instance,
-                actor_id=request.user.id,
-                slug=slug,
-                origin=request.META.get("HTTP_ORIGIN"),
-            )
-
-            datetime_fields = ["created_at", "updated_at"]
-            module = user_timezone_converter(
-                module, datetime_fields, request.user.user_timezone
-            )
-            return Response(module, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    @allow_permission([ROLE.ADMIN], creator=True, model=Module)
-    def destroy(self, request, slug, project_id, pk):
-        module = Module.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
-
-        module_issues = list(
-            ModuleIssue.objects.filter(module_id=pk).values_list("issue", flat=True)
-        )
-        _ = [
-            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"),
-            )
-            for issue in module_issues
-        ]
-        module.delete()
-        # Delete the module issues
-        ModuleIssue.objects.filter(module=pk, project_id=project_id).delete()
-        # Delete the user favorite module
-        UserFavorite.objects.filter(
-            user=request.user,
-            entity_type="module",
-            entity_identifier=pk,
-            project_id=project_id,
-        ).delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class ModuleLinkViewSet(BaseViewSet):
-    permission_classes = [ProjectEntityPermission]
-
-    model = ModuleLink
-    serializer_class = ModuleLinkSerializer
-
-    def perform_create(self, serializer):
-        serializer.save(
-            project_id=self.kwargs.get("project_id"),
-            module_id=self.kwargs.get("module_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(module_id=self.kwargs.get("module_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-                project__archived_at__isnull=True,
-            )
-            .order_by("-created_at")
-            .distinct()
-        )
-
-
-class ModuleFavoriteViewSet(BaseViewSet):
-    model = UserFavorite
-    permission_classes = [ProjectLitePermission]
-
-    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("module")
-        )
-
-    def create(self, request, slug, project_id):
-        _ = UserFavorite.objects.create(
-            project_id=project_id,
-            user=request.user,
-            entity_type="module",
-            entity_identifier=request.data.get("module"),
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    def destroy(self, request, slug, project_id, module_id):
-        module_favorite = UserFavorite.objects.get(
-            project_id=project_id,
-            user=request.user,
-            workspace__slug=slug,
-            entity_type="module",
-            entity_identifier=module_id,
-        )
-        module_favorite.delete(soft=False)
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class ModuleUserPropertiesEndpoint(BaseAPIView):
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def patch(self, request, slug, project_id, module_id):
-        module_properties = ModuleUserProperties.objects.get(
-            user=request.user,
-            module_id=module_id,
-            project_id=project_id,
-            workspace__slug=slug,
-        )
-
-        module_properties.filters = request.data.get(
-            "filters", module_properties.filters
-        )
-        module_properties.display_filters = request.data.get(
-            "display_filters", module_properties.display_filters
-        )
-        module_properties.display_properties = request.data.get(
-            "display_properties", module_properties.display_properties
-        )
-        module_properties.save()
-
-        serializer = ModuleUserPropertiesSerializer(module_properties)
-        return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def get(self, request, slug, project_id, module_id):
-        module_properties, _ = ModuleUserProperties.objects.get_or_create(
-            user=request.user,
-            project_id=project_id,
-            module_id=module_id,
-            workspace__slug=slug,
-        )
-        serializer = ModuleUserPropertiesSerializer(module_properties)
-        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -1,315 +0,0 @@
-# Python imports
-import json
-
-from django.db.models import F, Func, OuterRef, Q, Subquery
-
-# Django Imports
-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 allow_permission, ROLE
-from plane.app.serializers import ModuleIssueSerializer
-from plane.bgtasks.issue_activities_task import issue_activity
-from plane.db.models import (
-    Issue,
-    FileAsset,
-    IssueLink,
-    ModuleIssue,
-    Project,
-    CycleIssue,
-)
-from plane.utils.grouper import (
-    issue_group_values,
-    issue_on_results,
-    issue_queryset_grouper,
-)
-from plane.utils.issue_filters import issue_filters
-from plane.utils.order_queryset import order_issue_queryset
-from plane.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPaginator
-
-# Module imports
-from .. import BaseViewSet
-
-
-class ModuleIssueViewSet(BaseViewSet):
-    serializer_class = ModuleIssueSerializer
-    model = ModuleIssue
-    webhook_event = "module_issue"
-    bulk = True
-
-    filterset_fields = ["issue__labels__id", "issue__assignees__id"]
-
-    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"),
-                issue_module__deleted_at__isnull=True,
-            )
-            .select_related("workspace", "project", "state", "parent")
-            .prefetch_related("assignees", "labels", "issue_module__module")
-            .annotate(
-                cycle_id=Subquery(
-                    CycleIssue.objects.filter(
-                        issue=OuterRef("id"), deleted_at__isnull=True
-                    ).values("cycle_id")[:1]
-                )
-            )
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
-                )
-                .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")
-            )
-        ).distinct()
-
-    @method_decorator(gzip_page)
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def list(self, request, slug, project_id, module_id):
-        filters = issue_filters(request.query_params, "GET")
-        issue_queryset = self.get_queryset().filter(**filters)
-        order_by_param = request.GET.get("order_by", "created_at")
-
-        # Issue queryset
-        issue_queryset, order_by_param = order_issue_queryset(
-            issue_queryset=issue_queryset, order_by_param=order_by_param
-        )
-
-        # Group by
-        group_by = request.GET.get("group_by", False)
-        sub_group_by = request.GET.get("sub_group_by", False)
-
-        # issue queryset
-        issue_queryset = issue_queryset_grouper(
-            queryset=issue_queryset, group_by=group_by, sub_group_by=sub_group_by
-        )
-
-        if group_by:
-            # Check group and sub group value paginate
-            if sub_group_by:
-                if group_by == sub_group_by:
-                    return Response(
-                        {
-                            "error": "Group by and sub group by cannot have same parameters"
-                        },
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                else:
-                    # group and sub group pagination
-                    return self.paginate(
-                        request=request,
-                        order_by=order_by_param,
-                        queryset=issue_queryset,
-                        on_results=lambda issues: issue_on_results(
-                            group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                        ),
-                        paginator_cls=SubGroupedOffsetPaginator,
-                        group_by_fields=issue_group_values(
-                            field=group_by,
-                            slug=slug,
-                            project_id=project_id,
-                            filters=filters,
-                        ),
-                        sub_group_by_fields=issue_group_values(
-                            field=sub_group_by,
-                            slug=slug,
-                            project_id=project_id,
-                            filters=filters,
-                        ),
-                        group_by_field_name=group_by,
-                        sub_group_by_field_name=sub_group_by,
-                        count_filter=Q(
-                            Q(issue_intake__status=1)
-                            | Q(issue_intake__status=-1)
-                            | Q(issue_intake__status=2)
-                            | Q(issue_intake__isnull=True),
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-            # Group Paginate
-            else:
-                # Group paginate
-                return self.paginate(
-                    request=request,
-                    order_by=order_by_param,
-                    queryset=issue_queryset,
-                    on_results=lambda issues: issue_on_results(
-                        group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                    ),
-                    paginator_cls=GroupedOffsetPaginator,
-                    group_by_fields=issue_group_values(
-                        field=group_by,
-                        slug=slug,
-                        project_id=project_id,
-                        filters=filters,
-                    ),
-                    group_by_field_name=group_by,
-                    count_filter=Q(
-                        Q(issue_intake__status=1)
-                        | Q(issue_intake__status=-1)
-                        | Q(issue_intake__status=2)
-                        | Q(issue_intake__isnull=True),
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                )
-        else:
-            # List Paginate
-            return self.paginate(
-                order_by=order_by_param,
-                request=request,
-                queryset=issue_queryset,
-                on_results=lambda issues: issue_on_results(
-                    group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                ),
-            )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    # 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)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    # add multiple module inside an issue and remove multiple modules from an issue
-    def create_issue_modules(self, request, slug, project_id, issue_id):
-        modules = request.data.get("modules", [])
-        removed_modules = request.data.get("removed_modules", [])
-        project = Project.objects.get(pk=project_id)
-
-        if modules:
-            _ = 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
-            ]
-
-        for module_id in removed_modules:
-            module_issue = ModuleIssue.objects.filter(
-                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.first().module.name}
-                ),
-                epoch=int(timezone.now().timestamp()),
-                notification=True,
-                origin=request.META.get("HTTP_ORIGIN"),
-            )
-            module_issue.delete()
-
-        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def destroy(self, request, slug, project_id, module_id, issue_id):
-        module_issue = ModuleIssue.objects.filter(
-            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.first().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)
@@ -1,555 +0,0 @@
-# Python imports
-import json
-import base64
-from datetime import datetime
-from django.core.serializers.json import DjangoJSONEncoder
-
-# Django imports
-from django.db import connection
-from django.db.models import Exists, OuterRef, Q, Value, UUIDField
-from django.utils.decorators import method_decorator
-from django.views.decorators.gzip import gzip_page
-from django.http import StreamingHttpResponse
-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 import status
-from rest_framework.response import Response
-
-# Module imports
-from plane.app.permissions import allow_permission, ROLE
-from plane.app.serializers import (
-    PageLogSerializer,
-    PageSerializer,
-    SubPageSerializer,
-    PageDetailSerializer,
-)
-from plane.db.models import (
-    Page,
-    PageLog,
-    UserFavorite,
-    ProjectMember,
-    ProjectPage,
-    Project,
-)
-from plane.utils.error_codes import ERROR_CODES
-from ..base import BaseAPIView, BaseViewSet
-from plane.bgtasks.page_transaction_task import page_transaction
-from plane.bgtasks.page_version_task import page_version
-from plane.bgtasks.recent_visited_task import recent_visited_task
-
-
-def unarchive_archive_page_and_descendants(page_id, archived_at):
-    # Your SQL query
-    sql = """
-    WITH RECURSIVE descendants AS (
-        SELECT id FROM pages WHERE id = %s
-        UNION ALL
-        SELECT pages.id FROM pages, descendants WHERE pages.parent_id = descendants.id
-    )
-    UPDATE pages SET archived_at = %s WHERE id IN (SELECT id FROM descendants);
-    """
-
-    # Execute the SQL query
-    with connection.cursor() as cursor:
-        cursor.execute(sql, [page_id, archived_at])
-
-
-class PageViewSet(BaseViewSet):
-    serializer_class = PageSerializer
-    model = Page
-    search_fields = ["name"]
-
-    def get_queryset(self):
-        subquery = UserFavorite.objects.filter(
-            user=self.request.user,
-            entity_type="page",
-            entity_identifier=OuterRef("pk"),
-            workspace__slug=self.kwargs.get("slug"),
-        )
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(
-                projects__project_projectmember__member=self.request.user,
-                projects__project_projectmember__is_active=True,
-                projects__archived_at__isnull=True,
-            )
-            .filter(parent__isnull=True)
-            .filter(Q(owned_by=self.request.user) | Q(access=0))
-            .prefetch_related("projects")
-            .select_related("workspace")
-            .select_related("owned_by")
-            .annotate(is_favorite=Exists(subquery))
-            .order_by(self.request.GET.get("order_by", "-created_at"))
-            .prefetch_related("labels")
-            .order_by("-is_favorite", "-created_at")
-            .annotate(
-                project=Exists(
-                    ProjectPage.objects.filter(
-                        page_id=OuterRef("id"), project_id=self.kwargs.get("project_id")
-                    )
-                )
-            )
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "page_labels__label_id",
-                        distinct=True,
-                        filter=~Q(page_labels__label_id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                project_ids=Coalesce(
-                    ArrayAgg(
-                        "projects__id", distinct=True, filter=~Q(projects__id=True)
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-            .filter(project=True)
-            .distinct()
-        )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def create(self, request, slug, project_id):
-        serializer = PageSerializer(
-            data=request.data,
-            context={
-                "project_id": project_id,
-                "owned_by_id": request.user.id,
-                "description_html": request.data.get("description_html", "<p></p>"),
-            },
-        )
-
-        if serializer.is_valid():
-            serializer.save()
-            # capture the page transaction
-            page_transaction.delay(request.data, None, serializer.data["id"])
-            page = self.get_queryset().get(pk=serializer.data["id"])
-            serializer = PageDetailSerializer(page)
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def partial_update(self, request, slug, project_id, pk):
-        try:
-            page = Page.objects.get(
-                pk=pk, workspace__slug=slug, projects__id=project_id
-            )
-
-            if page.is_locked:
-                return Response(
-                    {"error": "Page is locked"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            parent = request.data.get("parent", None)
-            if parent:
-                _ = Page.objects.get(
-                    pk=parent, workspace__slug=slug, projects__id=project_id
-                )
-
-            # Only update access if the page owner is the requesting  user
-            if (
-                page.access != request.data.get("access", page.access)
-                and page.owned_by_id != request.user.id
-            ):
-                return Response(
-                    {
-                        "error": "Access cannot be updated since this page is owned by someone else"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            serializer = PageDetailSerializer(page, data=request.data, partial=True)
-            page_description = page.description_html
-            if serializer.is_valid():
-                serializer.save()
-                # capture the page transaction
-                if request.data.get("description_html"):
-                    page_transaction.delay(
-                        new_value=request.data,
-                        old_value=json.dumps(
-                            {"description_html": page_description},
-                            cls=DjangoJSONEncoder,
-                        ),
-                        page_id=pk,
-                    )
-
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Page.DoesNotExist:
-            return Response(
-                {
-                    "error": "Access cannot be updated since this page is owned by someone else"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def retrieve(self, request, slug, project_id, pk=None):
-        page = self.get_queryset().filter(pk=pk).first()
-        project = Project.objects.get(pk=project_id)
-
-        """
-        if the role is guest and guest_view_all_features is false and owned by is not 
-        the requesting user then dont show the page
-        """
-
-        if (
-            ProjectMember.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                member=request.user,
-                role=5,
-                is_active=True,
-            ).exists()
-            and not project.guest_view_all_features
-            and not page.owned_by == request.user
-        ):
-            return Response(
-                {"error": "You are not allowed to view this page"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if page is None:
-            return Response(
-                {"error": "Page not found"}, status=status.HTTP_404_NOT_FOUND
-            )
-        else:
-            issue_ids = PageLog.objects.filter(
-                page_id=pk, entity_name="issue"
-            ).values_list("entity_identifier", flat=True)
-            data = PageDetailSerializer(page).data
-            data["issue_ids"] = issue_ids
-            recent_visited_task.delay(
-                slug=slug,
-                entity_name="page",
-                entity_identifier=pk,
-                user_id=request.user.id,
-                project_id=project_id,
-            )
-            return Response(data, status=status.HTTP_200_OK)
-
-    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
-    def lock(self, request, slug, project_id, pk):
-        page = Page.objects.filter(
-            pk=pk, workspace__slug=slug, projects__id=project_id
-        ).first()
-
-        page.is_locked = True
-        page.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
-    def unlock(self, request, slug, project_id, pk):
-        page = Page.objects.filter(
-            pk=pk, workspace__slug=slug, projects__id=project_id
-        ).first()
-
-        page.is_locked = False
-        page.save()
-
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
-    def access(self, request, slug, project_id, pk):
-        access = request.data.get("access", 0)
-        page = Page.objects.filter(
-            pk=pk, workspace__slug=slug, projects__id=project_id
-        ).first()
-
-        # Only update access if the page owner is the requesting user
-        if (
-            page.access != request.data.get("access", page.access)
-            and page.owned_by_id != request.user.id
-        ):
-            return Response(
-                {
-                    "error": "Access cannot be updated since this page is owned by someone else"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        page.access = access
-        page.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def list(self, request, slug, project_id):
-        queryset = self.get_queryset()
-        project = Project.objects.get(pk=project_id)
-        if (
-            ProjectMember.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                member=request.user,
-                role=5,
-                is_active=True,
-            ).exists()
-            and not project.guest_view_all_features
-        ):
-            queryset = queryset.filter(owned_by=request.user)
-        pages = PageSerializer(queryset, many=True).data
-        return Response(pages, status=status.HTTP_200_OK)
-
-    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
-    def archive(self, request, slug, project_id, pk):
-        page = Page.objects.get(pk=pk, workspace__slug=slug, projects__id=project_id)
-
-        # only the owner or admin can archive the page
-        if (
-            ProjectMember.objects.filter(
-                project_id=project_id, member=request.user, is_active=True, role__lte=15
-            ).exists()
-            and request.user.id != page.owned_by_id
-        ):
-            return Response(
-                {"error": "Only the owner or admin can archive the page"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        UserFavorite.objects.filter(
-            entity_type="page",
-            entity_identifier=pk,
-            project_id=project_id,
-            workspace__slug=slug,
-        ).delete()
-
-        unarchive_archive_page_and_descendants(pk, datetime.now())
-
-        return Response({"archived_at": str(datetime.now())}, status=status.HTTP_200_OK)
-
-    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
-    def unarchive(self, request, slug, project_id, pk):
-        page = Page.objects.get(pk=pk, workspace__slug=slug, projects__id=project_id)
-
-        # only the owner or admin can un archive the page
-        if (
-            ProjectMember.objects.filter(
-                project_id=project_id, member=request.user, is_active=True, role__lte=15
-            ).exists()
-            and request.user.id != page.owned_by_id
-        ):
-            return Response(
-                {"error": "Only the owner or admin can un archive the page"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # if parent page is archived then the page will be un archived breaking the hierarchy
-        if page.parent_id and page.parent.archived_at:
-            page.parent = None
-            page.save(update_fields=["parent"])
-
-        unarchive_archive_page_and_descendants(pk, None)
-
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
-    def destroy(self, request, slug, project_id, pk):
-        page = Page.objects.get(pk=pk, workspace__slug=slug, projects__id=project_id)
-
-        if page.archived_at is None:
-            return Response(
-                {"error": "The page should be archived before deleting"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if page.owned_by_id != request.user.id and (
-            not ProjectMember.objects.filter(
-                workspace__slug=slug,
-                member=request.user,
-                role=20,
-                project_id=project_id,
-                is_active=True,
-            ).exists()
-        ):
-            return Response(
-                {"error": "Only admin or owner can delete the page"},
-                status=status.HTTP_403_FORBIDDEN,
-            )
-
-        # remove parent from all the children
-        _ = Page.objects.filter(
-            parent_id=pk, projects__id=project_id, workspace__slug=slug
-        ).update(parent=None)
-
-        page.delete()
-        # Delete the user favorite page
-        UserFavorite.objects.filter(
-            project=project_id,
-            workspace__slug=slug,
-            entity_identifier=pk,
-            entity_type="page",
-        ).delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class PageFavoriteViewSet(BaseViewSet):
-    model = UserFavorite
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def create(self, request, slug, project_id, pk):
-        _ = UserFavorite.objects.create(
-            project_id=project_id,
-            entity_identifier=pk,
-            entity_type="page",
-            user=request.user,
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def destroy(self, request, slug, project_id, pk):
-        page_favorite = UserFavorite.objects.get(
-            project=project_id,
-            user=request.user,
-            workspace__slug=slug,
-            entity_identifier=pk,
-            entity_type="page",
-        )
-        page_favorite.delete(soft=False)
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class PageLogEndpoint(BaseAPIView):
-    serializer_class = PageLogSerializer
-    model = PageLog
-
-    def post(self, request, slug, project_id, page_id):
-        serializer = PageLogSerializer(data=request.data)
-        if serializer.is_valid():
-            serializer.save(project_id=project_id, page_id=page_id)
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def patch(self, request, slug, project_id, page_id, transaction):
-        page_transaction = PageLog.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            page_id=page_id,
-            transaction=transaction,
-        )
-        serializer = PageLogSerializer(
-            page_transaction, 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 delete(self, request, slug, project_id, page_id, transaction):
-        transaction = PageLog.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            page_id=page_id,
-            transaction=transaction,
-        )
-        # Delete the transaction object
-        transaction.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class SubPagesEndpoint(BaseAPIView):
-    @method_decorator(gzip_page)
-    def get(self, request, slug, project_id, page_id):
-        pages = (
-            PageLog.objects.filter(
-                page_id=page_id,
-                workspace__slug=slug,
-                entity_name__in=["forward_link", "back_link"],
-            )
-            .select_related("project")
-            .select_related("workspace")
-        )
-        return Response(
-            SubPageSerializer(pages, many=True).data, status=status.HTTP_200_OK
-        )
-
-
-class PagesDescriptionViewSet(BaseViewSet):
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def retrieve(self, request, slug, project_id, pk):
-        page = (
-            Page.objects.filter(pk=pk, workspace__slug=slug, projects__id=project_id)
-            .filter(Q(owned_by=self.request.user) | Q(access=0))
-            .first()
-        )
-        if page is None:
-            return Response({"error": "Page not found"}, status=404)
-        binary_data = page.description_binary
-
-        def stream_data():
-            if binary_data:
-                yield binary_data
-            else:
-                yield b""
-
-        response = StreamingHttpResponse(
-            stream_data(), content_type="application/octet-stream"
-        )
-        response["Content-Disposition"] = 'attachment; filename="page_description.bin"'
-        return response
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def partial_update(self, request, slug, project_id, pk):
-        page = (
-            Page.objects.filter(pk=pk, workspace__slug=slug, projects__id=project_id)
-            .filter(Q(owned_by=self.request.user) | Q(access=0))
-            .first()
-        )
-
-        if page is None:
-            return Response({"error": "Page not found"}, status=404)
-
-        if page.is_locked:
-            return Response(
-                {
-                    "error_code": ERROR_CODES["PAGE_LOCKED"],
-                    "error_message": "PAGE_LOCKED",
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if page.archived_at:
-            return Response(
-                {
-                    "error_code": ERROR_CODES["PAGE_ARCHIVED"],
-                    "error_message": "PAGE_ARCHIVED",
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Serialize the existing instance
-        existing_instance = json.dumps(
-            {"description_html": page.description_html}, cls=DjangoJSONEncoder
-        )
-
-        # Get the base64 data from the request
-        base64_data = request.data.get("description_binary")
-
-        # If base64 data is provided
-        if base64_data:
-            # Decode the base64 data to bytes
-            new_binary_data = base64.b64decode(base64_data)
-            # capture the page transaction
-            if request.data.get("description_html"):
-                page_transaction.delay(
-                    new_value=request.data, old_value=existing_instance, page_id=pk
-                )
-            # Store the updated binary data
-            page.description_binary = new_binary_data
-            page.description_html = request.data.get("description_html")
-            page.description = request.data.get("description")
-            page.save()
-            # Return a success response
-            page_version.delay(
-                page_id=page.id,
-                existing_instance=existing_instance,
-                user_id=request.user.id,
-            )
-            return Response({"message": "Updated successfully"})
-        else:
-            return Response({"error": "No binary data provided"})
@@ -1,696 +0,0 @@
-# Python imports
-import boto3
-from django.conf import settings
-from django.utils import timezone
-import json
-
-# Django imports
-from django.db import IntegrityError
-from django.db.models import Exists, F, Func, OuterRef, Prefetch, Q, Subquery
-from django.core.serializers.json import DjangoJSONEncoder
-
-# Third Party imports
-from rest_framework.response import Response
-from rest_framework import serializers, status
-from rest_framework.permissions import AllowAny
-
-# Module imports
-from plane.app.views.base import BaseViewSet, BaseAPIView
-from plane.app.serializers import (
-    ProjectSerializer,
-    ProjectListSerializer,
-    DeployBoardSerializer,
-)
-
-from plane.app.permissions import ProjectMemberPermission, allow_permission, ROLE
-from plane.db.models import (
-    UserFavorite,
-    Cycle,
-    Intake,
-    DeployBoard,
-    IssueUserProperty,
-    Issue,
-    Module,
-    Project,
-    ProjectIdentifier,
-    ProjectMember,
-    State,
-    Workspace,
-    WorkspaceMember,
-)
-from plane.utils.cache import cache_response
-from plane.bgtasks.webhook_task import model_activity
-from plane.bgtasks.recent_visited_task import recent_visited_task
-from plane.utils.exception_logger import log_exception
-
-
-class ProjectViewSet(BaseViewSet):
-    serializer_class = ProjectListSerializer
-    model = Project
-    webhook_event = "project"
-
-    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"))
-            .select_related(
-                "workspace", "workspace__owner", "default_assignee", "project_lead"
-            )
-            .annotate(
-                is_favorite=Exists(
-                    UserFavorite.objects.filter(
-                        user=self.request.user,
-                        entity_identifier=OuterRef("pk"),
-                        entity_type="project",
-                        project_id=OuterRef("pk"),
-                    )
-                )
-            )
-            .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(
-                anchor=DeployBoard.objects.filter(
-                    entity_name="project",
-                    entity_identifier=OuterRef("pk"),
-                    workspace__slug=self.kwargs.get("slug"),
-                ).values("anchor")
-            )
-            .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()
-        )
-
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
-    )
-    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 WorkspaceMember.objects.filter(
-            member=request.user, workspace__slug=slug, is_active=True, role=5
-        ).exists():
-            projects = projects.filter(
-                project_projectmember__member=self.request.user,
-                project_projectmember__is_active=True,
-            )
-
-        if WorkspaceMember.objects.filter(
-            member=request.user, workspace__slug=slug, is_active=True, role=15
-        ).exists():
-            projects = projects.filter(
-                Q(
-                    project_projectmember__member=self.request.user,
-                    project_projectmember__is_active=True,
-                )
-                | Q(network=2)
-            )
-
-        if request.GET.get("per_page", False) and request.GET.get("cursor", False):
-            return self.paginate(
-                order_by=request.GET.get("order_by", "-created_at"),
-                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)
-
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
-    )
-    def retrieve(self, request, slug, pk):
-        project = (
-            self.get_queryset()
-            .filter(
-                project_projectmember__member=self.request.user,
-                project_projectmember__is_active=True,
-            )
-            .filter(archived_at__isnull=True)
-            .filter(pk=pk)
-            .annotate(
-                total_issues=Issue.issue_objects.filter(
-                    project_id=self.kwargs.get("pk")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                sub_issues=Issue.issue_objects.filter(
-                    project_id=self.kwargs.get("pk"), parent__isnull=False
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                archived_issues=Issue.objects.filter(
-                    project_id=self.kwargs.get("pk"), archived_at__isnull=False
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                archived_sub_issues=Issue.objects.filter(
-                    project_id=self.kwargs.get("pk"),
-                    archived_at__isnull=False,
-                    parent__isnull=False,
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                draft_issues=Issue.objects.filter(
-                    project_id=self.kwargs.get("pk"), is_draft=True
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                draft_sub_issues=Issue.objects.filter(
-                    project_id=self.kwargs.get("pk"),
-                    is_draft=True,
-                    parent__isnull=False,
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-        ).first()
-
-        if project is None:
-            return Response(
-                {"error": "Project does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-
-        recent_visited_task.delay(
-            slug=slug,
-            project_id=pk,
-            entity_name="project",
-            entity_identifier=pk,
-            user_id=request.user.id,
-        )
-
-        serializer = ProjectListSerializer(project)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    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
-                _ = IssueUserProperty.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
-                    IssueUserProperty.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()
-
-                # Create the model activity
-                model_activity.delay(
-                    model_name="project",
-                    model_id=str(project.id),
-                    requested_data=request.data,
-                    current_instance=None,
-                    actor_id=request.user.id,
-                    slug=slug,
-                    origin=request.META.get("HTTP_ORIGIN"),
-                )
-
-                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:
-            return Response(
-                {"error": "Workspace does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except serializers.ValidationError:
-            return Response(
-                {"identifier": "The project identifier is already taken"},
-                status=status.HTTP_410_GONE,
-            )
-
-    def partial_update(self, request, slug, pk=None):
-        try:
-            if not ProjectMember.objects.filter(
-                member=request.user,
-                workspace__slug=slug,
-                project_id=pk,
-                role=20,
-                is_active=True,
-            ).exists():
-                return Response(
-                    {"error": "You don't have the required permissions."},
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-
-            workspace = Workspace.objects.get(slug=slug)
-
-            project = Project.objects.get(pk=pk)
-            intake_view = request.data.get("inbox_view", project.intake_view)
-            current_instance = json.dumps(
-                ProjectSerializer(project).data, cls=DjangoJSONEncoder
-            )
-            if project.archived_at:
-                return Response(
-                    {"error": "Archived projects cannot be updated"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            serializer = ProjectSerializer(
-                project,
-                data={**request.data, "intake_view": intake_view},
-                context={"workspace_id": workspace.id},
-                partial=True,
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                if intake_view:
-                    intake = Intake.objects.filter(
-                        project=project, is_default=True
-                    ).first()
-                    if not intake:
-                        Intake.objects.create(
-                            name=f"{project.name} Intake",
-                            project=project,
-                            is_default=True,
-                        )
-
-                    # Create the triage state in Backlog group
-                    State.objects.get_or_create(
-                        name="Triage",
-                        group="triage",
-                        description="Default state for managing all Intake Issues",
-                        project_id=pk,
-                        color="#ff7700",
-                        is_triage=True,
-                    )
-
-                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
-
-                model_activity.delay(
-                    model_name="project",
-                    model_id=str(project.id),
-                    requested_data=request.data,
-                    current_instance=current_instance,
-                    actor_id=request.user.id,
-                    slug=slug,
-                    origin=request.META.get("HTTP_ORIGIN"),
-                )
-                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:
-            return Response(
-                {"identifier": "The project identifier is already taken"},
-                status=status.HTTP_410_GONE,
-            )
-
-    def destroy(self, request, slug, pk):
-        if (
-            WorkspaceMember.objects.filter(
-                member=request.user, workspace__slug=slug, is_active=True, role=20
-            ).exists()
-            or ProjectMember.objects.filter(
-                member=request.user,
-                workspace__slug=slug,
-                project_id=pk,
-                role=20,
-                is_active=True,
-            ).exists()
-        ):
-            project = Project.objects.get(pk=pk)
-            project.delete()
-
-            # Delete the project members
-            DeployBoard.objects.filter(project_id=pk, workspace__slug=slug).delete()
-
-            # Delete the user favorite
-            UserFavorite.objects.filter(project_id=pk, workspace__slug=slug).delete()
-
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        else:
-            return Response(
-                {"error": "You don't have the required permissions."},
-                status=status.HTTP_403_FORBIDDEN,
-            )
-
-
-class ProjectArchiveUnarchiveEndpoint(BaseAPIView):
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def post(self, request, slug, project_id):
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-        project.archived_at = timezone.now()
-        project.save()
-        UserFavorite.objects.filter(workspace__slug=slug, project=project_id).delete()
-        return Response(
-            {"archived_at": str(project.archived_at)}, status=status.HTTP_200_OK
-        )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def delete(self, request, slug, project_id):
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-        project.archived_at = None
-        project.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class ProjectIdentifierEndpoint(BaseAPIView):
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    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
-        )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    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):
-    model = UserFavorite
-
-    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):
-        _ = UserFavorite.objects.create(
-            user=request.user,
-            entity_type="project",
-            entity_identifier=request.data.get("project"),
-            project_id=request.data.get("project"),
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    def destroy(self, request, slug, project_id):
-        project_favorite = UserFavorite.objects.get(
-            entity_identifier=project_id,
-            entity_type="project",
-            project=project_id,
-            user=request.user,
-            workspace__slug=slug,
-        )
-        project_favorite.delete(soft=False)
-        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 = []
-        if settings.USE_MINIO:
-            s3 = boto3.client(
-                "s3",
-                endpoint_url=settings.AWS_S3_ENDPOINT_URL,
-                aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
-                aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
-            )
-        else:
-            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/",
-        }
-
-        try:
-            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)
-        except Exception as e:
-            log_exception(e)
-            return Response([], status=status.HTTP_200_OK)
-
-
-class DeployBoardViewSet(BaseViewSet):
-    permission_classes = [ProjectMemberPermission]
-    serializer_class = DeployBoardSerializer
-    model = DeployBoard
-
-    def list(self, request, slug, project_id):
-        project_deploy_board = DeployBoard.objects.filter(
-            entity_name="project", entity_identifier=project_id, workspace__slug=slug
-        ).first()
-
-        serializer = DeployBoardSerializer(project_deploy_board)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def create(self, request, slug, project_id):
-        comments = request.data.get("is_comments_enabled", False)
-        reactions = request.data.get("is_reactions_enabled", False)
-        intake = request.data.get("intake", None)
-        votes = request.data.get("is_votes_enabled", False)
-        views = request.data.get(
-            "views",
-            {
-                "list": True,
-                "kanban": True,
-                "calendar": True,
-                "gantt": True,
-                "spreadsheet": True,
-            },
-        )
-
-        project_deploy_board, _ = DeployBoard.objects.get_or_create(
-            entity_name="project", entity_identifier=project_id, project_id=project_id
-        )
-        project_deploy_board.intake = intake
-        project_deploy_board.view_props = views
-        project_deploy_board.is_votes_enabled = votes
-        project_deploy_board.is_comments_enabled = comments
-        project_deploy_board.is_reactions_enabled = reactions
-
-        project_deploy_board.save()
-
-        serializer = DeployBoardSerializer(project_deploy_board)
-        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -1,262 +0,0 @@
-# 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 allow_permission, ROLE
-
-from plane.db.models import (
-    ProjectMember,
-    Workspace,
-    ProjectMemberInvite,
-    User,
-    WorkspaceMember,
-    IssueUserProperty,
-)
-
-
-class ProjectInvitationsViewset(BaseViewSet):
-    serializer_class = ProjectMemberInviteSerializer
-    model = ProjectMemberInvite
-
-    search_fields = []
-
-    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")
-        )
-
-    @allow_permission([ROLE.ADMIN])
-    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
-            )
-
-        for email in emails:
-            workspace_role = WorkspaceMember.objects.filter(
-                workspace__slug=slug, member__email=email.get("email"), is_active=True
-            ).role
-
-            if workspace_role in [5, 20] and workspace_role != email.get("role", 5):
-                return Response(
-                    {
-                        "error": "You cannot invite a user with different role than workspace role"
-                    }
-                )
-
-        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", 5),
-                        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
-        )
-
-        if workspace_member.role not in [ROLE.ADMIN.value, ROLE.MEMBER.value]:
-            return Response(
-                {"error": "You do not have permission to join the project"},
-                status=status.HTTP_403_FORBIDDEN,
-            )
-
-        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=workspace_role,
-                    workspace=workspace,
-                    created_by=request.user,
-                )
-                for project_id in project_ids
-            ],
-            ignore_conflicts=True,
-        )
-
-        IssueUserProperty.objects.bulk_create(
-            [
-                IssueUserProperty(
-                    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)
@@ -1,328 +0,0 @@
-# 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 (
-    ProjectMemberPermission,
-    ProjectLitePermission,
-    WorkspaceUserPermission,
-)
-
-from plane.db.models import Project, ProjectMember, IssueUserProperty, WorkspaceMember
-from plane.bgtasks.project_add_user_email_task import project_add_user_email
-from plane.utils.host import base_host
-from plane.app.permissions.base import allow_permission, ROLE
-
-
-class ProjectMemberViewSet(BaseViewSet):
-    serializer_class = ProjectMemberAdminSerializer
-    model = ProjectMember
-
-    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")
-        )
-
-    @allow_permission([ROLE.ADMIN])
-    def create(self, request, slug, project_id):
-        # Get the list of members to be added to the project and their roles i.e. the user_id and the role
-        members = request.data.get("members", [])
-
-        # get the project
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-
-        # Check if the members array is empty
-        if not len(members):
-            return Response(
-                {"error": "Atleast one member is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Initialize the bulk arrays
-        bulk_project_members = []
-        bulk_issue_props = []
-
-        # Create a dictionary of the member_id and their roles
-        member_roles = {
-            member.get("member_id"): member.get("role") for member in members
-        }
-
-        # check the workspace role of the new user
-        for member in member_roles:
-            workspace_member_role = WorkspaceMember.objects.get(
-                workspace__slug=slug, member=member, is_active=True
-            ).role
-            if workspace_member_role in [20] and member_roles.get(member) in [5, 15]:
-                return Response(
-                    {
-                        "error": "You cannot add a user with role lower than the workspace role"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if workspace_member_role in [5] and member_roles.get(member) in [15, 20]:
-                return Response(
-                    {
-                        "error": "You cannot add a user with role higher than the workspace role"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-        # Update roles in the members array based on the member_roles dictionary and set is_active to True
-        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
-        )
-
-        # Get the list of project members of the requested workspace with the given slug
-        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")
-        )
-
-        # Loop through requested members
-        for member in members:
-            # Get the sort orders of the member
-            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"))
-            ]
-            # Create a new project member
-            bulk_project_members.append(
-                ProjectMember(
-                    member_id=member.get("member_id"),
-                    role=member.get("role", 5),
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    sort_order=(sort_order[0] - 10000 if len(sort_order) else 65535),
-                )
-            )
-            # Create a new issue property
-            bulk_issue_props.append(
-                IssueUserProperty(
-                    user_id=member.get("member_id"),
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                )
-            )
-
-        # Bulk create the project members and issue properties
-        project_members = ProjectMember.objects.bulk_create(
-            bulk_project_members, batch_size=10, ignore_conflicts=True
-        )
-
-        _ = IssueUserProperty.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],
-        )
-        # Send emails to notify the users
-        [
-            project_add_user_email.delay(
-                base_host(request=request, is_app=True),
-                project_member.id,
-                request.user.id,
-            )
-            for project_member in project_members
-        ]
-        # Serialize the project members
-        serializer = ProjectMemberRoleSerializer(project_members, many=True)
-        # Return the serialized data
-        return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    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)
-
-    @allow_permission([ROLE.ADMIN])
-    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,
-        )
-
-        workspace_role = WorkspaceMember.objects.get(
-            workspace__slug=slug, member=project_member.member, is_active=True
-        ).role
-        if workspace_role in [5] and int(
-            request.data.get("role", project_member.role)
-        ) in [15, 20]:
-            return Response(
-                {
-                    "error": "You cannot add a user with role higher than the workspace role"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        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)
-
-    @allow_permission([ROLE.ADMIN])
-    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)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    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 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, is_active=True
-        ).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)
@@ -1,708 +0,0 @@
-# Python imports
-import re
-
-# Django imports
-from django.db import models
-from django.db.models import (
-    Q,
-    OuterRef,
-    Subquery,
-    Value,
-    UUIDField,
-    CharField,
-    When,
-    Case,
-)
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models.functions import Coalesce, Concat
-from django.utils import timezone
-
-# Third party imports
-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 (
-    Workspace,
-    Project,
-    Issue,
-    Cycle,
-    Module,
-    Page,
-    IssueView,
-    ProjectMember,
-    ProjectPage,
-    WorkspaceMember,
-)
-
-
-class GlobalSearchEndpoint(BaseAPIView):
-    """Endpoint to search across multiple fields in the workspace and
-    also show related workspace if found
-    """
-
-    def filter_workspaces(self, query, slug, project_id, workspace_search):
-        fields = ["name"]
-        q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
-        return (
-            Workspace.objects.filter(q, workspace_member__member=self.request.user)
-            .distinct()
-            .values("name", "id", "slug")
-        )
-
-    def filter_projects(self, query, slug, project_id, workspace_search):
-        fields = ["name", "identifier"]
-        q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
-        return (
-            Project.objects.filter(
-                q,
-                project_projectmember__member=self.request.user,
-                project_projectmember__is_active=True,
-                archived_at__isnull=True,
-                workspace__slug=slug,
-            )
-            .distinct()
-            .values("name", "id", "identifier", "workspace__slug")
-        )
-
-    def filter_issues(self, query, slug, project_id, workspace_search):
-        fields = ["name", "sequence_id", "project__identifier"]
-        q = Q()
-        for field in fields:
-            if field == "sequence_id":
-                # Match whole integers only (exclude decimal numbers)
-                sequences = re.findall(r"\b\d+\b", query)
-                for sequence_id in sequences:
-                    q |= Q(**{"sequence_id": sequence_id})
-            else:
-                q |= Q(**{f"{field}__icontains": query})
-
-        issues = Issue.issue_objects.filter(
-            q,
-            project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
-            project__archived_at__isnull=True,
-            workspace__slug=slug,
-        )
-
-        if workspace_search == "false" and project_id:
-            issues = issues.filter(project_id=project_id)
-
-        return issues.distinct().values(
-            "name",
-            "id",
-            "sequence_id",
-            "project__identifier",
-            "project_id",
-            "workspace__slug",
-        )[:100]
-
-    def filter_cycles(self, query, slug, project_id, workspace_search):
-        fields = ["name"]
-        q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
-
-        cycles = Cycle.objects.filter(
-            q,
-            project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
-            project__archived_at__isnull=True,
-            workspace__slug=slug,
-        )
-
-        if workspace_search == "false" and project_id:
-            cycles = cycles.filter(project_id=project_id)
-
-        return cycles.distinct().values(
-            "name", "id", "project_id", "project__identifier", "workspace__slug"
-        )
-
-    def filter_modules(self, query, slug, project_id, workspace_search):
-        fields = ["name"]
-        q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
-
-        modules = Module.objects.filter(
-            q,
-            project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
-            project__archived_at__isnull=True,
-            workspace__slug=slug,
-        )
-
-        if workspace_search == "false" and project_id:
-            modules = modules.filter(project_id=project_id)
-
-        return modules.distinct().values(
-            "name", "id", "project_id", "project__identifier", "workspace__slug"
-        )
-
-    def filter_pages(self, query, slug, project_id, workspace_search):
-        fields = ["name"]
-        q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
-
-        pages = (
-            Page.objects.filter(
-                q,
-                projects__project_projectmember__member=self.request.user,
-                projects__project_projectmember__is_active=True,
-                projects__archived_at__isnull=True,
-                workspace__slug=slug,
-            )
-            .annotate(
-                project_ids=Coalesce(
-                    ArrayAgg(
-                        "projects__id", distinct=True, filter=~Q(projects__id=True)
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                )
-            )
-            .annotate(
-                project_identifiers=Coalesce(
-                    ArrayAgg(
-                        "projects__identifier",
-                        distinct=True,
-                        filter=~Q(projects__id=True),
-                    ),
-                    Value([], output_field=ArrayField(CharField())),
-                )
-            )
-        )
-
-        if workspace_search == "false" and project_id:
-            project_subquery = ProjectPage.objects.filter(
-                page_id=OuterRef("id"), project_id=project_id
-            ).values_list("project_id", flat=True)[:1]
-
-            pages = pages.annotate(project_id=Subquery(project_subquery)).filter(
-                project_id=project_id
-            )
-
-        return pages.distinct().values(
-            "name", "id", "project_ids", "project_identifiers", "workspace__slug"
-        )
-
-    def filter_views(self, query, slug, project_id, workspace_search):
-        fields = ["name"]
-        q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
-
-        issue_views = IssueView.objects.filter(
-            q,
-            project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
-            project__archived_at__isnull=True,
-            workspace__slug=slug,
-        )
-
-        if workspace_search == "false" and project_id:
-            issue_views = issue_views.filter(project_id=project_id)
-
-        return issue_views.distinct().values(
-            "name", "id", "project_id", "project__identifier", "workspace__slug"
-        )
-
-    def get(self, request, slug):
-        query = request.query_params.get("search", False)
-        workspace_search = request.query_params.get("workspace_search", "false")
-        project_id = request.query_params.get("project_id", False)
-
-        if not query:
-            return Response(
-                {
-                    "results": {
-                        "workspace": [],
-                        "project": [],
-                        "issue": [],
-                        "cycle": [],
-                        "module": [],
-                        "issue_view": [],
-                        "page": [],
-                    }
-                },
-                status=status.HTTP_200_OK,
-            )
-
-        MODELS_MAPPER = {
-            "workspace": self.filter_workspaces,
-            "project": self.filter_projects,
-            "issue": self.filter_issues,
-            "cycle": self.filter_cycles,
-            "module": self.filter_modules,
-            "issue_view": self.filter_views,
-            "page": self.filter_pages,
-        }
-
-        results = {}
-
-        for model in MODELS_MAPPER.keys():
-            func = MODELS_MAPPER.get(model, None)
-            results[model] = func(query, slug, project_id, workspace_search)
-        return Response({"results": results}, status=status.HTTP_200_OK)
-
-
-class SearchEndpoint(BaseAPIView):
-    def get(self, request, slug):
-        query = request.query_params.get("query", False)
-        query_types = request.query_params.get("query_type", "user_mention").split(",")
-        query_types = [qt.strip() for qt in query_types]
-        count = int(request.query_params.get("count", 5))
-        project_id = request.query_params.get("project_id", None)
-        issue_id = request.query_params.get("issue_id", None)
-
-        response_data = {}
-
-        if project_id:
-            for query_type in query_types:
-                if query_type == "user_mention":
-                    fields = [
-                        "member__first_name",
-                        "member__last_name",
-                        "member__display_name",
-                    ]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            q |= Q(**{f"{field}__icontains": query})
-
-                    base_filters = Q(
-                        q,
-                        is_active=True,
-                        workspace__slug=slug,
-                        member__is_bot=False,
-                        project_id=project_id,
-                        role__gt=10,
-                    )
-                    if issue_id:
-                        issue_created_by = (
-                            Issue.objects.filter(id=issue_id)
-                            .values_list("created_by_id", flat=True)
-                            .first()
-                        )
-                        # Add condition to include `issue_created_by` in the query
-                        filters = Q(member_id=issue_created_by) | base_filters
-                    else:
-                        filters = base_filters
-
-                    # Query to fetch users
-                    users = (
-                        ProjectMember.objects.filter(filters)
-                        .annotate(
-                            member__avatar_url=Case(
-                                When(
-                                    member__avatar_asset__isnull=False,
-                                    then=Concat(
-                                        Value("/api/assets/v2/static/"),
-                                        "member__avatar_asset",
-                                        Value("/"),
-                                    ),
-                                ),
-                                When(
-                                    member__avatar_asset__isnull=True,
-                                    then="member__avatar",
-                                ),
-                                default=Value(None),
-                                output_field=CharField(),
-                            )
-                        )
-                        .order_by("-created_at")
-                        .values(
-                            "member__avatar_url",
-                            "member__display_name",
-                            "member__id",
-                        )[:count]
-                    )
-
-                    response_data["user_mention"] = list(users)
-
-                elif query_type == "project":
-                    fields = ["name", "identifier"]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            q |= Q(**{f"{field}__icontains": query})
-                    projects = (
-                        Project.objects.filter(
-                            q,
-                            Q(project_projectmember__member=self.request.user)
-                            | Q(network=2),
-                            workspace__slug=slug,
-                        )
-                        .order_by("-created_at")
-                        .distinct()
-                        .values(
-                            "name", "id", "identifier", "logo_props", "workspace__slug"
-                        )[:count]
-                    )
-                    response_data["project"] = list(projects)
-
-                elif query_type == "issue":
-                    fields = ["name", "sequence_id", "project__identifier"]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            if field == "sequence_id":
-                                sequences = re.findall(r"\b\d+\b", query)
-                                for sequence_id in sequences:
-                                    q |= Q(**{"sequence_id": sequence_id})
-                            else:
-                                q |= Q(**{f"{field}__icontains": query})
-
-                    issues = (
-                        Issue.issue_objects.filter(
-                            q,
-                            project__project_projectmember__member=self.request.user,
-                            project__project_projectmember__is_active=True,
-                            workspace__slug=slug,
-                            project_id=project_id,
-                        )
-                        .order_by("-created_at")
-                        .distinct()
-                        .values(
-                            "name",
-                            "id",
-                            "sequence_id",
-                            "project__identifier",
-                            "project_id",
-                            "priority",
-                            "state_id",
-                            "type_id",
-                        )[:count]
-                    )
-                    response_data["issue"] = list(issues)
-
-                elif query_type == "cycle":
-                    fields = ["name"]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            q |= Q(**{f"{field}__icontains": query})
-
-                    cycles = (
-                        Cycle.objects.filter(
-                            q,
-                            project__project_projectmember__member=self.request.user,
-                            project__project_projectmember__is_active=True,
-                            workspace__slug=slug,
-                            project_id=project_id,
-                        )
-                        .annotate(
-                            status=Case(
-                                When(
-                                    Q(start_date__lte=timezone.now())
-                                    & Q(end_date__gte=timezone.now()),
-                                    then=Value("CURRENT"),
-                                ),
-                                When(
-                                    start_date__gt=timezone.now(),
-                                    then=Value("UPCOMING"),
-                                ),
-                                When(
-                                    end_date__lt=timezone.now(), then=Value("COMPLETED")
-                                ),
-                                When(
-                                    Q(start_date__isnull=True)
-                                    & Q(end_date__isnull=True),
-                                    then=Value("DRAFT"),
-                                ),
-                                default=Value("DRAFT"),
-                                output_field=CharField(),
-                            )
-                        )
-                        .order_by("-created_at")
-                        .distinct()
-                        .values(
-                            "name",
-                            "id",
-                            "project_id",
-                            "project__identifier",
-                            "status",
-                            "workspace__slug",
-                        )[:count]
-                    )
-                    response_data["cycle"] = list(cycles)
-
-                elif query_type == "module":
-                    fields = ["name"]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            q |= Q(**{f"{field}__icontains": query})
-
-                    modules = (
-                        Module.objects.filter(
-                            q,
-                            project__project_projectmember__member=self.request.user,
-                            project__project_projectmember__is_active=True,
-                            workspace__slug=slug,
-                            project_id=project_id,
-                        )
-                        .order_by("-created_at")
-                        .distinct()
-                        .values(
-                            "name",
-                            "id",
-                            "project_id",
-                            "project__identifier",
-                            "status",
-                            "workspace__slug",
-                        )[:count]
-                    )
-                    response_data["module"] = list(modules)
-
-                elif query_type == "page":
-                    fields = ["name"]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            q |= Q(**{f"{field}__icontains": query})
-
-                    pages = (
-                        Page.objects.filter(
-                            q,
-                            projects__project_projectmember__member=self.request.user,
-                            projects__project_projectmember__is_active=True,
-                            projects__id=project_id,
-                            workspace__slug=slug,
-                            access=0,
-                        )
-                        .order_by("-created_at")
-                        .distinct()
-                        .values(
-                            "name",
-                            "id",
-                            "logo_props",
-                            "projects__id",
-                            "workspace__slug",
-                        )[:count]
-                    )
-                    response_data["page"] = list(pages)
-            return Response(response_data, status=status.HTTP_200_OK)
-
-        else:
-            for query_type in query_types:
-                if query_type == "user_mention":
-                    fields = [
-                        "member__first_name",
-                        "member__last_name",
-                        "member__display_name",
-                    ]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            q |= Q(**{f"{field}__icontains": query})
-                    users = (
-                        WorkspaceMember.objects.filter(
-                            q,
-                            is_active=True,
-                            workspace__slug=slug,
-                            member__is_bot=False,
-                        )
-                        .annotate(
-                            member__avatar_url=Case(
-                                When(
-                                    member__avatar_asset__isnull=False,
-                                    then=Concat(
-                                        Value("/api/assets/v2/static/"),
-                                        "member__avatar_asset",
-                                        Value("/"),
-                                    ),
-                                ),
-                                When(
-                                    member__avatar_asset__isnull=True,
-                                    then="member__avatar",
-                                ),
-                                default=Value(None),
-                                output_field=models.CharField(),
-                            )
-                        )
-                        .order_by("-created_at")
-                        .values(
-                            "member__avatar_url", "member__display_name", "member__id"
-                        )[:count]
-                    )
-                    response_data["user_mention"] = list(users)
-
-                elif query_type == "project":
-                    fields = ["name", "identifier"]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            q |= Q(**{f"{field}__icontains": query})
-                    projects = (
-                        Project.objects.filter(
-                            q,
-                            Q(project_projectmember__member=self.request.user)
-                            | Q(network=2),
-                            workspace__slug=slug,
-                        )
-                        .order_by("-created_at")
-                        .distinct()
-                        .values(
-                            "name", "id", "identifier", "logo_props", "workspace__slug"
-                        )[:count]
-                    )
-                    response_data["project"] = list(projects)
-
-                elif query_type == "issue":
-                    fields = ["name", "sequence_id", "project__identifier"]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            if field == "sequence_id":
-                                sequences = re.findall(r"\b\d+\b", query)
-                                for sequence_id in sequences:
-                                    q |= Q(**{"sequence_id": sequence_id})
-                            else:
-                                q |= Q(**{f"{field}__icontains": query})
-
-                    issues = (
-                        Issue.issue_objects.filter(
-                            q,
-                            project__project_projectmember__member=self.request.user,
-                            project__project_projectmember__is_active=True,
-                            workspace__slug=slug,
-                        )
-                        .order_by("-created_at")
-                        .distinct()
-                        .values(
-                            "name",
-                            "id",
-                            "sequence_id",
-                            "project__identifier",
-                            "project_id",
-                            "priority",
-                            "state_id",
-                            "type_id",
-                        )[:count]
-                    )
-                    response_data["issue"] = list(issues)
-
-                elif query_type == "cycle":
-                    fields = ["name"]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            q |= Q(**{f"{field}__icontains": query})
-
-                    cycles = (
-                        Cycle.objects.filter(
-                            q,
-                            project__project_projectmember__member=self.request.user,
-                            project__project_projectmember__is_active=True,
-                            workspace__slug=slug,
-                        )
-                        .annotate(
-                            status=Case(
-                                When(
-                                    Q(start_date__lte=timezone.now())
-                                    & Q(end_date__gte=timezone.now()),
-                                    then=Value("CURRENT"),
-                                ),
-                                When(
-                                    start_date__gt=timezone.now(),
-                                    then=Value("UPCOMING"),
-                                ),
-                                When(
-                                    end_date__lt=timezone.now(), then=Value("COMPLETED")
-                                ),
-                                When(
-                                    Q(start_date__isnull=True)
-                                    & Q(end_date__isnull=True),
-                                    then=Value("DRAFT"),
-                                ),
-                                default=Value("DRAFT"),
-                                output_field=CharField(),
-                            )
-                        )
-                        .order_by("-created_at")
-                        .distinct()
-                        .values(
-                            "name",
-                            "id",
-                            "project_id",
-                            "project__identifier",
-                            "status",
-                            "workspace__slug",
-                        )[:count]
-                    )
-                    response_data["cycle"] = list(cycles)
-
-                elif query_type == "module":
-                    fields = ["name"]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            q |= Q(**{f"{field}__icontains": query})
-
-                    modules = (
-                        Module.objects.filter(
-                            q,
-                            project__project_projectmember__member=self.request.user,
-                            project__project_projectmember__is_active=True,
-                            workspace__slug=slug,
-                        )
-                        .order_by("-created_at")
-                        .distinct()
-                        .values(
-                            "name",
-                            "id",
-                            "project_id",
-                            "project__identifier",
-                            "status",
-                            "workspace__slug",
-                        )[:count]
-                    )
-                    response_data["module"] = list(modules)
-
-                elif query_type == "page":
-                    fields = ["name"]
-                    q = Q()
-
-                    if query:
-                        for field in fields:
-                            q |= Q(**{f"{field}__icontains": query})
-
-                    pages = (
-                        Page.objects.filter(
-                            q,
-                            projects__project_projectmember__member=self.request.user,
-                            projects__project_projectmember__is_active=True,
-                            workspace__slug=slug,
-                            access=0,
-                            is_global=True,
-                        )
-                        .order_by("-created_at")
-                        .distinct()
-                        .values(
-                            "name",
-                            "id",
-                            "logo_props",
-                            "projects__id",
-                            "workspace__slug",
-                        )[:count]
-                    )
-                    response_data["page"] = list(pages)
-            return Response(response_data, status=status.HTTP_200_OK)
@@ -1,103 +0,0 @@
-# Python imports
-
-# Django imports
-from django.db.models import Q
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from .base import BaseAPIView
-from plane.db.models import Issue, ProjectMember
-from plane.utils.issue_search import search_issues
-
-
-class IssueSearchEndpoint(BaseAPIView):
-    def get(self, request, slug, project_id):
-        query = request.query_params.get("search", False)
-        workspace_search = request.query_params.get("workspace_search", "false")
-        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)
-        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,
-            project__archived_at__isnull=True,
-        )
-
-        if workspace_search == "false":
-            issues = issues.filter(project_id=project_id)
-
-        if query:
-            issues = search_issues(query, issues)
-
-        if parent == "true" and issue_id:
-            issue = Issue.issue_objects.filter(pk=issue_id).first()
-            if issue:
-                issues = issues.filter(
-                    ~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.filter(pk=issue_id).first()
-            if issue:
-                issues = issues.filter(
-                    ~Q(pk=issue_id),
-                    ~(
-                        Q(issue_related__issue=issue)
-                        & Q(issue_related__deleted_at__isnull=True)
-                    ),
-                    ~(
-                        Q(issue_relation__related_issue=issue)
-                        & Q(issue_relation__deleted_at__isnull=True)
-                    ),
-                )
-        if sub_issue == "true" and issue_id:
-            issue = Issue.issue_objects.filter(pk=issue_id).first()
-            if issue:
-                issues = issues.filter(~Q(pk=issue_id), parent__isnull=True)
-            if issue.parent:
-                issues = issues.filter(~Q(pk=issue.parent_id))
-
-        if cycle == "true":
-            issues = issues.exclude(
-                Q(issue_cycle__isnull=False) & Q(issue_cycle__deleted_at__isnull=True)
-            )
-
-        if module:
-            issues = issues.exclude(
-                Q(issue_module__module=module)
-                & Q(issue_module__deleted_at__isnull=True)
-            )
-
-        if target_date == "none":
-            issues = issues.filter(target_date__isnull=True)
-
-        if ProjectMember.objects.filter(
-            project_id=project_id, member=self.request.user, is_active=True, role=5
-        ).exists():
-            issues = issues.filter(created_by=self.request.user)
-
-        return Response(
-            issues.values(
-                "name",
-                "id",
-                "start_date",
-                "sequence_id",
-                "project__name",
-                "project__identifier",
-                "project_id",
-                "workspace__slug",
-                "state__name",
-                "state__group",
-                "state__color",
-            )[:100],
-            status=status.HTTP_200_OK,
-        )
@@ -1,95 +0,0 @@
-# Python imports
-from itertools import groupby
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-
-# Module imports
-from .. import BaseViewSet
-from plane.app.serializers import StateSerializer
-from plane.app.permissions import ROLE, allow_permission
-from plane.db.models import State, Issue
-from plane.utils.cache import invalidate_cache
-
-
-class StateViewSet(BaseViewSet):
-    serializer_class = StateSerializer
-    model = State
-
-    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,
-                project__project_projectmember__is_active=True,
-                project__archived_at__isnull=True,
-            )
-            .filter(is_triage=False)
-            .select_related("project")
-            .select_related("workspace")
-            .distinct()
-        )
-
-    @invalidate_cache(path="workspaces/:slug/states/", url_params=True, user=False)
-    @allow_permission([ROLE.ADMIN])
-    def create(self, request, slug, project_id):
-        serializer = StateSerializer(data=request.data)
-        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)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def list(self, request, slug, project_id):
-        states = StateSerializer(self.get_queryset(), many=True).data
-        grouped = request.GET.get("grouped", False)
-        if grouped == "true":
-            state_dict = {}
-            for key, value in groupby(
-                sorted(states, key=lambda state: state["group"]),
-                lambda state: state.get("group"),
-            ):
-                state_dict[str(key)] = list(value)
-            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)
-    @allow_permission([ROLE.ADMIN])
-    def mark_as_default(self, request, slug, project_id, pk):
-        # Select all the states which are marked as default
-        _ = State.objects.filter(
-            workspace__slug=slug, project_id=project_id, default=True
-        ).update(default=False)
-        _ = State.objects.filter(
-            workspace__slug=slug, project_id=project_id, pk=pk
-        ).update(default=True)
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    @invalidate_cache(path="workspaces/:slug/states/", url_params=True, user=False)
-    @allow_permission([ROLE.ADMIN])
-    def destroy(self, request, slug, project_id, pk):
-        state = State.objects.get(
-            is_triage=False, pk=pk, project_id=project_id, workspace__slug=slug
-        )
-
-        if state.default:
-            return Response(
-                {"error": "Default state cannot be deleted"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Check for any issues in the state
-        issue_exist = Issue.issue_objects.filter(state=pk).exists()
-
-        if issue_exist:
-            return Response(
-                {"error": "The state is not empty, only empty states can be deleted"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        state.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,247 +0,0 @@
-# Python imports
-import pytz
-from datetime import datetime
-
-# Django imports
-from django.utils.decorators import method_decorator
-from django.views.decorators.cache import cache_page
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.permissions import AllowAny
-from rest_framework.views import APIView
-
-# Module imports
-from plane.authentication.rate_limit import AuthenticationThrottle
-
-
-class TimezoneEndpoint(APIView):
-    permission_classes = [AllowAny]
-
-    throttle_classes = [AuthenticationThrottle]
-
-    @method_decorator(cache_page(60 * 60 * 24))
-    def get(self, request):
-        timezone_mapping = {
-            "-1100": [
-                ("Midway Island", "Pacific/Midway"),
-                ("American Samoa", "Pacific/Pago_Pago"),
-            ],
-            "-1000": [
-                ("Hawaii", "Pacific/Honolulu"),
-                ("Aleutian Islands", "America/Adak"),
-            ],
-            "-0930": [("Marquesas Islands", "Pacific/Marquesas")],
-            "-0900": [
-                ("Alaska", "America/Anchorage"),
-                ("Gambier Islands", "Pacific/Gambier"),
-            ],
-            "-0800": [
-                ("Pacific Time (US and Canada)", "America/Los_Angeles"),
-                ("Baja California", "America/Tijuana"),
-            ],
-            "-0700": [
-                ("Mountain Time (US and Canada)", "America/Denver"),
-                ("Arizona", "America/Phoenix"),
-                ("Chihuahua, Mazatlan", "America/Chihuahua"),
-            ],
-            "-0600": [
-                ("Central Time (US and Canada)", "America/Chicago"),
-                ("Saskatchewan", "America/Regina"),
-                ("Guadalajara, Mexico City, Monterrey", "America/Mexico_City"),
-                ("Tegucigalpa, Honduras", "America/Tegucigalpa"),
-                ("Costa Rica", "America/Costa_Rica"),
-            ],
-            "-0500": [
-                ("Eastern Time (US and Canada)", "America/New_York"),
-                ("Lima", "America/Lima"),
-                ("Bogota", "America/Bogota"),
-                ("Quito", "America/Guayaquil"),
-                ("Chetumal", "America/Cancun"),
-            ],
-            "-0430": [("Caracas (Old Venezuela Time)", "America/Caracas")],
-            "-0400": [
-                ("Atlantic Time (Canada)", "America/Halifax"),
-                ("Caracas", "America/Caracas"),
-                ("Santiago", "America/Santiago"),
-                ("La Paz", "America/La_Paz"),
-                ("Manaus", "America/Manaus"),
-                ("Georgetown", "America/Guyana"),
-                ("Bermuda", "Atlantic/Bermuda"),
-            ],
-            "-0330": [("Newfoundland Time (Canada)", "America/St_Johns")],
-            "-0300": [
-                ("Buenos Aires", "America/Argentina/Buenos_Aires"),
-                ("Brasilia", "America/Sao_Paulo"),
-                ("Greenland", "America/Godthab"),
-                ("Montevideo", "America/Montevideo"),
-                ("Falkland Islands", "Atlantic/Stanley"),
-            ],
-            "-0200": [
-                (
-                    "South Georgia and the South Sandwich Islands",
-                    "Atlantic/South_Georgia",
-                )
-            ],
-            "-0100": [
-                ("Azores", "Atlantic/Azores"),
-                ("Cape Verde Islands", "Atlantic/Cape_Verde"),
-            ],
-            "+0000": [
-                ("Dublin", "Europe/Dublin"),
-                ("Reykjavik", "Atlantic/Reykjavik"),
-                ("Lisbon", "Europe/Lisbon"),
-                ("Monrovia", "Africa/Monrovia"),
-                ("Casablanca", "Africa/Casablanca"),
-            ],
-            "+0100": [
-                ("Central European Time (Berlin, Rome, Paris)", "Europe/Paris"),
-                ("West Central Africa", "Africa/Lagos"),
-                ("Algiers", "Africa/Algiers"),
-                ("Lagos", "Africa/Lagos"),
-                ("Tunis", "Africa/Tunis"),
-            ],
-            "+0200": [
-                ("Eastern European Time (Cairo, Helsinki, Kyiv)", "Europe/Kiev"),
-                ("Athens", "Europe/Athens"),
-                ("Jerusalem", "Asia/Jerusalem"),
-                ("Johannesburg", "Africa/Johannesburg"),
-                ("Harare, Pretoria", "Africa/Harare"),
-            ],
-            "+0300": [
-                ("Moscow Time", "Europe/Moscow"),
-                ("Baghdad", "Asia/Baghdad"),
-                ("Nairobi", "Africa/Nairobi"),
-                ("Kuwait, Riyadh", "Asia/Riyadh"),
-            ],
-            "+0330": [("Tehran", "Asia/Tehran")],
-            "+0400": [
-                ("Abu Dhabi", "Asia/Dubai"),
-                ("Baku", "Asia/Baku"),
-                ("Yerevan", "Asia/Yerevan"),
-                ("Astrakhan", "Europe/Astrakhan"),
-                ("Tbilisi", "Asia/Tbilisi"),
-                ("Mauritius", "Indian/Mauritius"),
-            ],
-            "+0500": [
-                ("Islamabad", "Asia/Karachi"),
-                ("Karachi", "Asia/Karachi"),
-                ("Tashkent", "Asia/Tashkent"),
-                ("Yekaterinburg", "Asia/Yekaterinburg"),
-                ("Maldives", "Indian/Maldives"),
-                ("Chagos", "Indian/Chagos"),
-            ],
-            "+0530": [
-                ("Chennai", "Asia/Kolkata"),
-                ("Kolkata", "Asia/Kolkata"),
-                ("Mumbai", "Asia/Kolkata"),
-                ("New Delhi", "Asia/Kolkata"),
-                ("Sri Jayawardenepura", "Asia/Colombo"),
-            ],
-            "+0545": [("Kathmandu", "Asia/Kathmandu")],
-            "+0600": [
-                ("Dhaka", "Asia/Dhaka"),
-                ("Almaty", "Asia/Almaty"),
-                ("Bishkek", "Asia/Bishkek"),
-                ("Thimphu", "Asia/Thimphu"),
-            ],
-            "+0630": [
-                ("Yangon (Rangoon)", "Asia/Yangon"),
-                ("Cocos Islands", "Indian/Cocos"),
-            ],
-            "+0700": [
-                ("Bangkok", "Asia/Bangkok"),
-                ("Hanoi", "Asia/Ho_Chi_Minh"),
-                ("Jakarta", "Asia/Jakarta"),
-                ("Novosibirsk", "Asia/Novosibirsk"),
-                ("Krasnoyarsk", "Asia/Krasnoyarsk"),
-            ],
-            "+0800": [
-                ("Beijing", "Asia/Shanghai"),
-                ("Singapore", "Asia/Singapore"),
-                ("Perth", "Australia/Perth"),
-                ("Hong Kong", "Asia/Hong_Kong"),
-                ("Ulaanbaatar", "Asia/Ulaanbaatar"),
-                ("Palau", "Pacific/Palau"),
-            ],
-            "+0845": [("Eucla", "Australia/Eucla")],
-            "+0900": [
-                ("Tokyo", "Asia/Tokyo"),
-                ("Seoul", "Asia/Seoul"),
-                ("Yakutsk", "Asia/Yakutsk"),
-            ],
-            "+0930": [
-                ("Adelaide", "Australia/Adelaide"),
-                ("Darwin", "Australia/Darwin"),
-            ],
-            "+1000": [
-                ("Sydney", "Australia/Sydney"),
-                ("Brisbane", "Australia/Brisbane"),
-                ("Guam", "Pacific/Guam"),
-                ("Vladivostok", "Asia/Vladivostok"),
-                ("Tahiti", "Pacific/Tahiti"),
-            ],
-            "+1030": [("Lord Howe Island", "Australia/Lord_Howe")],
-            "+1100": [
-                ("Solomon Islands", "Pacific/Guadalcanal"),
-                ("Magadan", "Asia/Magadan"),
-                ("Norfolk Island", "Pacific/Norfolk"),
-                ("Bougainville Island", "Pacific/Bougainville"),
-                ("Chokurdakh", "Asia/Srednekolymsk"),
-            ],
-            "+1200": [
-                ("Auckland", "Pacific/Auckland"),
-                ("Wellington", "Pacific/Auckland"),
-                ("Fiji Islands", "Pacific/Fiji"),
-                ("Anadyr", "Asia/Anadyr"),
-            ],
-            "+1245": [("Chatham Islands", "Pacific/Chatham")],
-            "+1300": [("Nuku'alofa", "Pacific/Tongatapu"), ("Samoa", "Pacific/Apia")],
-            "+1400": [("Kiritimati Island", "Pacific/Kiritimati")],
-        }
-
-        timezone_list = []
-        now = datetime.now()
-
-        # Process timezone mapping
-        for offset, locations in timezone_mapping.items():
-            sign = "-" if offset.startswith("-") else "+"
-            hours = offset[1:3]
-            minutes = offset[3:] if len(offset) > 3 else "00"
-
-            for friendly_name, tz_identifier in locations:
-                try:
-                    tz = pytz.timezone(tz_identifier)
-                    current_offset = now.astimezone(tz).strftime("%z")
-
-                    # converting and formatting UTC offset to GMT offset
-                    current_utc_offset = now.astimezone(tz).utcoffset()
-                    total_seconds = int(current_utc_offset.total_seconds())
-                    hours_offset = total_seconds // 3600
-                    minutes_offset = abs(total_seconds % 3600) // 60
-                    gmt_offset = (
-                        f"GMT{'+' if hours_offset >= 0 else '-'}"
-                        f"{abs(hours_offset):02}:{minutes_offset:02}"
-                    )
-
-                    timezone_value = {
-                        "offset": int(current_offset),
-                        "utc_offset": f"UTC{sign}{hours}:{minutes}",
-                        "gmt_offset": gmt_offset,
-                        "value": tz_identifier,
-                        "label": f"{friendly_name}",
-                    }
-
-                    timezone_list.append(timezone_value)
-                except pytz.exceptions.UnknownTimeZoneError:
-                    continue
-
-        # Sort by offset and then by label
-        timezone_list.sort(key=lambda x: (x["offset"], x["label"]))
-
-        # Remove offset from final output
-        for tz in timezone_list:
-            del tz["offset"]
-
-        return Response({"timezones": timezone_list}, status=status.HTTP_200_OK)
@@ -1,538 +0,0 @@
-# Django imports
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models import Exists, F, Func, OuterRef, Q, UUIDField, Value, Subquery
-from django.db.models.functions import Coalesce
-from django.utils.decorators import method_decorator
-from django.views.decorators.gzip import gzip_page
-from django.db import transaction
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from plane.app.permissions import allow_permission, ROLE
-from plane.app.serializers import IssueViewSerializer
-from plane.db.models import (
-    Issue,
-    FileAsset,
-    IssueLink,
-    IssueView,
-    Workspace,
-    WorkspaceMember,
-    ProjectMember,
-    Project,
-    CycleIssue,
-)
-from plane.utils.grouper import (
-    issue_group_values,
-    issue_on_results,
-    issue_queryset_grouper,
-)
-from plane.utils.issue_filters import issue_filters
-from plane.utils.order_queryset import order_issue_queryset
-from plane.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPaginator
-from plane.bgtasks.recent_visited_task import recent_visited_task
-from .. import BaseViewSet
-from plane.db.models import UserFavorite
-
-
-class WorkspaceViewViewSet(BaseViewSet):
-    serializer_class = IssueViewSerializer
-    model = IssueView
-
-    def perform_create(self, serializer):
-        workspace = Workspace.objects.get(slug=self.kwargs.get("slug"))
-        serializer.save(workspace_id=workspace.id, owned_by=self.request.user)
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project__isnull=True)
-            .filter(Q(owned_by=self.request.user) | Q(access=1))
-            .select_related("workspace")
-            .order_by(self.request.GET.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
-    )
-    def list(self, request, slug):
-        queryset = self.get_queryset()
-        fields = [field for field in request.GET.get("fields", "").split(",") if field]
-        if WorkspaceMember.objects.filter(
-            workspace__slug=slug, member=request.user, role=5, is_active=True
-        ).exists():
-            queryset = queryset.filter(owned_by=request.user)
-        views = IssueViewSerializer(
-            queryset, many=True, fields=fields if fields else None
-        ).data
-        return Response(views, status=status.HTTP_200_OK)
-
-    @allow_permission(
-        allowed_roles=[], level="WORKSPACE", creator=True, model=IssueView
-    )
-    def partial_update(self, request, slug, pk):
-        with transaction.atomic():
-            workspace_view = IssueView.objects.select_for_update().get(
-                pk=pk, workspace__slug=slug
-            )
-
-            if workspace_view.is_locked:
-                return Response(
-                    {"error": "view is locked"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            # Only update the view if owner is updating
-            if workspace_view.owned_by_id != request.user.id:
-                return Response(
-                    {"error": "Only the owner of the view can update the view"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            serializer = IssueViewSerializer(
-                workspace_view, 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 retrieve(self, request, slug, pk):
-        issue_view = self.get_queryset().filter(pk=pk).first()
-        serializer = IssueViewSerializer(issue_view)
-        recent_visited_task.delay(
-            slug=slug,
-            project_id=None,
-            entity_name="view",
-            entity_identifier=pk,
-            user_id=request.user.id,
-        )
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    @allow_permission(
-        allowed_roles=[], level="WORKSPACE", creator=True, model=IssueView
-    )
-    def destroy(self, request, slug, pk):
-        workspace_view = IssueView.objects.get(pk=pk, workspace__slug=slug)
-
-        workspace_member = WorkspaceMember.objects.filter(
-            workspace__slug=slug, member=request.user, role=20, is_active=True
-        )
-        if workspace_member.exists() or workspace_view.owned_by == request.user:
-            workspace_view.delete()
-            # Delete the user favorite view
-            UserFavorite.objects.filter(
-                workspace__slug=slug,
-                entity_identifier=pk,
-                project__isnull=True,
-                entity_type="view",
-            ).delete()
-        else:
-            return Response(
-                {"error": "Only admin or owner can delete the view"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class WorkspaceViewIssuesViewSet(BaseViewSet):
-    def get_queryset(self):
-        return (
-            Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
-            .select_related("workspace", "project", "state", "parent")
-            .prefetch_related("assignees", "labels", "issue_module__module")
-            .annotate(
-                cycle_id=Subquery(
-                    CycleIssue.objects.filter(
-                        issue=OuterRef("id"), deleted_at__isnull=True
-                    ).values("cycle_id")[:1]
-                )
-            )
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
-                )
-                .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(
-                            ~Q(labels__id__isnull=True)
-                            & Q(label_issue__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=Q(
-                            ~Q(assignees__id__isnull=True)
-                            & Q(assignees__member_project__is_active=True)
-                            & Q(issue_assignee__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "issue_module__module_id",
-                        distinct=True,
-                        filter=Q(
-                            ~Q(issue_module__module_id__isnull=True)
-                            & Q(issue_module__module__archived_at__isnull=True)
-                            & Q(issue_module__deleted_at__isnull=True)
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-        )
-
-    @method_decorator(gzip_page)
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
-    )
-    def list(self, request, slug):
-        filters = issue_filters(request.query_params, "GET")
-        order_by_param = request.GET.get("order_by", "-created_at")
-
-        issue_queryset = (
-            self.get_queryset()
-            .filter(**filters)
-            .annotate(
-                cycle_id=Subquery(
-                    CycleIssue.objects.filter(
-                        issue=OuterRef("id"), deleted_at__isnull=True
-                    ).values("cycle_id")[:1]
-                )
-            )
-        )
-
-        # check for the project member role, if the role is 5 then check for the guest_view_all_features if it is true then show all the issues else show only the issues created by the user
-
-        issue_queryset = issue_queryset.filter(
-            Q(
-                project__project_projectmember__role=5,
-                project__guest_view_all_features=True,
-            )
-            | Q(
-                project__project_projectmember__role=5,
-                project__guest_view_all_features=False,
-                created_by=self.request.user,
-            )
-            |
-            # For other roles (role < 5), show all issues
-            Q(project__project_projectmember__role__gt=5),
-            project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
-        )
-
-        # Issue queryset
-        issue_queryset, order_by_param = order_issue_queryset(
-            issue_queryset=issue_queryset, order_by_param=order_by_param
-        )
-
-        # Group by
-        group_by = request.GET.get("group_by", False)
-        sub_group_by = request.GET.get("sub_group_by", False)
-
-        # issue queryset
-        issue_queryset = issue_queryset_grouper(
-            queryset=issue_queryset, group_by=group_by, sub_group_by=sub_group_by
-        )
-
-        if group_by:
-            # Check group and sub group value paginate
-            if sub_group_by:
-                if group_by == sub_group_by:
-                    return Response(
-                        {
-                            "error": "Group by and sub group by cannot have same parameters"
-                        },
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                else:
-                    # group and sub group pagination
-                    return self.paginate(
-                        request=request,
-                        order_by=order_by_param,
-                        queryset=issue_queryset,
-                        on_results=lambda issues: issue_on_results(
-                            group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                        ),
-                        paginator_cls=SubGroupedOffsetPaginator,
-                        group_by_fields=issue_group_values(
-                            field=group_by, slug=slug, project_id=None, filters=filters
-                        ),
-                        sub_group_by_fields=issue_group_values(
-                            field=sub_group_by,
-                            slug=slug,
-                            project_id=None,
-                            filters=filters,
-                        ),
-                        group_by_field_name=group_by,
-                        sub_group_by_field_name=sub_group_by,
-                        count_filter=Q(
-                            Q(issue_intake__status=1)
-                            | Q(issue_intake__status=-1)
-                            | Q(issue_intake__status=2)
-                            | Q(issue_intake__isnull=True),
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-            # Group Paginate
-            else:
-                # Group paginate
-                return self.paginate(
-                    request=request,
-                    order_by=order_by_param,
-                    queryset=issue_queryset,
-                    on_results=lambda issues: issue_on_results(
-                        group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                    ),
-                    paginator_cls=GroupedOffsetPaginator,
-                    group_by_fields=issue_group_values(
-                        field=group_by, slug=slug, project_id=None, filters=filters
-                    ),
-                    group_by_field_name=group_by,
-                    count_filter=Q(
-                        Q(issue_intake__status=1)
-                        | Q(issue_intake__status=-1)
-                        | Q(issue_intake__status=2)
-                        | Q(issue_intake__isnull=True),
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                )
-        else:
-            # List Paginate
-            return self.paginate(
-                order_by=order_by_param,
-                request=request,
-                queryset=issue_queryset,
-                on_results=lambda issues: issue_on_results(
-                    group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                ),
-            )
-
-
-class IssueViewViewSet(BaseViewSet):
-    serializer_class = IssueViewSerializer
-    model = IssueView
-
-    def perform_create(self, serializer):
-        serializer.save(
-            project_id=self.kwargs.get("project_id"), owned_by=self.request.user
-        )
-
-    def get_queryset(self):
-        subquery = UserFavorite.objects.filter(
-            user=self.request.user,
-            entity_identifier=OuterRef("pk"),
-            entity_type="view",
-            project_id=self.kwargs.get("project_id"),
-            workspace__slug=self.kwargs.get("slug"),
-        )
-        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,
-                project__project_projectmember__is_active=True,
-                project__archived_at__isnull=True,
-            )
-            .filter(Q(owned_by=self.request.user) | Q(access=1))
-            .select_related("project")
-            .select_related("workspace")
-            .annotate(is_favorite=Exists(subquery))
-            .order_by("-is_favorite", "name")
-            .distinct()
-        )
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def list(self, request, slug, project_id):
-        queryset = self.get_queryset()
-        project = Project.objects.get(id=project_id)
-        if (
-            ProjectMember.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                member=request.user,
-                role=5,
-                is_active=True,
-            ).exists()
-            and not project.guest_view_all_features
-        ):
-            queryset = queryset.filter(owned_by=request.user)
-        fields = [field for field in request.GET.get("fields", "").split(",") if field]
-        views = IssueViewSerializer(
-            queryset, many=True, fields=fields if fields else None
-        ).data
-        return Response(views, status=status.HTTP_200_OK)
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def retrieve(self, request, slug, project_id, pk):
-        issue_view = self.get_queryset().filter(pk=pk, project_id=project_id).first()
-        project = Project.objects.get(id=project_id)
-        """
-        if the role is guest and guest_view_all_features is false and owned by is not 
-        the requesting user then dont show the view
-        """
-
-        if (
-            ProjectMember.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                member=request.user,
-                role=5,
-                is_active=True,
-            ).exists()
-            and not project.guest_view_all_features
-            and not issue_view.owned_by == request.user
-        ):
-            return Response(
-                {"error": "You are not allowed to view this issue"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        serializer = IssueViewSerializer(issue_view)
-        recent_visited_task.delay(
-            slug=slug,
-            project_id=project_id,
-            entity_name="view",
-            entity_identifier=pk,
-            user_id=request.user.id,
-        )
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    @allow_permission(allowed_roles=[], creator=True, model=IssueView)
-    def partial_update(self, request, slug, project_id, pk):
-        with transaction.atomic():
-            issue_view = IssueView.objects.select_for_update().get(
-                pk=pk, workspace__slug=slug, project_id=project_id
-            )
-
-            if issue_view.is_locked:
-                return Response(
-                    {"error": "view is locked"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            # Only update the view if owner is updating
-            if issue_view.owned_by_id != request.user.id:
-                return Response(
-                    {"error": "Only the owner of the view can update the view"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            serializer = IssueViewSerializer(
-                issue_view, 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)
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=IssueView)
-    def destroy(self, request, slug, project_id, pk):
-        project_view = IssueView.objects.get(
-            pk=pk, project_id=project_id, workspace__slug=slug
-        )
-        if (
-            ProjectMember.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                member=request.user,
-                role=20,
-                is_active=True,
-            ).exists()
-            or project_view.owned_by_id == request.user.id
-        ):
-            project_view.delete()
-            # Delete the user favorite view
-            UserFavorite.objects.filter(
-                project_id=project_id,
-                workspace__slug=slug,
-                entity_identifier=pk,
-                entity_type="view",
-            ).delete()
-        else:
-            return Response(
-                {"error": "Only admin or owner can delete the view"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class IssueViewFavoriteViewSet(BaseViewSet):
-    model = UserFavorite
-
-    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("view")
-        )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def create(self, request, slug, project_id):
-        _ = UserFavorite.objects.create(
-            user=request.user,
-            entity_identifier=request.data.get("view"),
-            entity_type="view",
-            project_id=project_id,
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def destroy(self, request, slug, project_id, view_id):
-        view_favorite = UserFavorite.objects.get(
-            project=project_id,
-            user=request.user,
-            workspace__slug=slug,
-            entity_type="view",
-            entity_identifier=view_id,
-        )
-        view_favorite.delete(soft=False)
-        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,126 +0,0 @@
-# Django imports
-from django.db import IntegrityError
-
-# Third party imports
-from rest_framework import status
-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 plane.app.permissions import allow_permission, ROLE
-from plane.app.serializers import WebhookSerializer, WebhookLogSerializer
-
-
-class WebhookEndpoint(BaseAPIView):
-    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
-    def post(self, request, slug):
-        workspace = Workspace.objects.get(slug=slug)
-        try:
-            serializer = WebhookSerializer(
-                data=request.data, context={"request": request}
-            )
-            if serializer.is_valid():
-                serializer.save(workspace_id=workspace.id)
-                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(
-                    {"error": "URL already exists for the workspace"},
-                    status=status.HTTP_410_GONE,
-                )
-            raise IntegrityError
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
-    def get(self, request, slug, pk=None):
-        if pk is None:
-            webhooks = Webhook.objects.filter(workspace__slug=slug)
-            serializer = WebhookSerializer(
-                webhooks,
-                fields=(
-                    "id",
-                    "url",
-                    "is_active",
-                    "created_at",
-                    "updated_at",
-                    "project",
-                    "issue",
-                    "cycle",
-                    "module",
-                    "issue_comment",
-                ),
-                many=True,
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        else:
-            webhook = Webhook.objects.get(workspace__slug=slug, pk=pk)
-            serializer = WebhookSerializer(
-                webhook,
-                fields=(
-                    "id",
-                    "url",
-                    "is_active",
-                    "created_at",
-                    "updated_at",
-                    "project",
-                    "issue",
-                    "cycle",
-                    "module",
-                    "issue_comment",
-                ),
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
-    def patch(self, request, slug, pk):
-        webhook = Webhook.objects.get(workspace__slug=slug, pk=pk)
-        serializer = WebhookSerializer(
-            webhook,
-            data=request.data,
-            context={request: request},
-            partial=True,
-            fields=(
-                "id",
-                "url",
-                "is_active",
-                "created_at",
-                "updated_at",
-                "project",
-                "issue",
-                "cycle",
-                "module",
-                "issue_comment",
-            ),
-        )
-        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)
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
-    def delete(self, request, slug, pk):
-        webhook = Webhook.objects.get(pk=pk, workspace__slug=slug)
-        webhook.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class WebhookSecretRegenerateEndpoint(BaseAPIView):
-    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
-    def post(self, request, slug, pk):
-        webhook = Webhook.objects.get(workspace__slug=slug, pk=pk)
-        webhook.secret_key = generate_token()
-        webhook.save()
-        serializer = WebhookSerializer(webhook)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-
-class WebhookLogsEndpoint(BaseAPIView):
-    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
-    def get(self, request, slug, webhook_id):
-        webhook_logs = WebhookLog.objects.filter(
-            workspace__slug=slug, webhook_id=webhook_id
-        )
-        serializer = WebhookLogSerializer(webhook_logs, many=True)
-        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -1,391 +0,0 @@
-# Python imports
-import csv
-import io
-import os
-from datetime import date
-
-from dateutil.relativedelta import relativedelta
-from django.db import IntegrityError
-from django.db.models import Count, F, Func, OuterRef, Prefetch, Q
-from django.db.models.fields import DateField
-from django.db.models.functions import Cast, ExtractDay, ExtractWeek
-
-# Django imports
-from django.http import HttpResponse
-from django.utils import timezone
-
-# Third party modules
-from rest_framework import status
-from rest_framework.response import Response
-
-from plane.app.permissions import (
-    WorkSpaceAdminPermission,
-    WorkSpaceBasePermission,
-    WorkspaceEntityPermission,
-)
-
-# Module imports
-from plane.app.serializers import WorkSpaceSerializer, WorkspaceThemeSerializer
-from plane.app.views.base import BaseAPIView, BaseViewSet
-from plane.db.models import (
-    Issue,
-    IssueActivity,
-    Workspace,
-    WorkspaceMember,
-    WorkspaceTheme,
-)
-from plane.app.permissions import ROLE, allow_permission
-from django.utils.decorators import method_decorator
-from django.views.decorators.cache import cache_control
-from django.views.decorators.vary import vary_on_cookie
-from plane.utils.constants import RESTRICTED_WORKSPACE_SLUGS
-from plane.license.utils.instance_value import get_configuration_value
-
-
-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")
-        )
-
-    def create(self, request):
-        try:
-            (DISABLE_WORKSPACE_CREATION,) = get_configuration_value(
-                [
-                    {
-                        "key": "DISABLE_WORKSPACE_CREATION",
-                        "default": os.environ.get("DISABLE_WORKSPACE_CREATION", "0"),
-                    }
-                ]
-            )
-
-            if DISABLE_WORKSPACE_CREATION == "1":
-                return Response(
-                    {"error": "Workspace creation is not allowed"},
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-
-            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(raise_exception=True):
-                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,
-                )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
-    def list(self, request, *args, **kwargs):
-        return super().list(request, *args, **kwargs)
-
-    @allow_permission([ROLE.ADMIN], level="WORKSPACE")
-    def partial_update(self, request, *args, **kwargs):
-        return super().partial_update(request, *args, **kwargs)
-
-    @allow_permission([ROLE.ADMIN], level="WORKSPACE")
-    def destroy(self, request, *args, **kwargs):
-        return super().destroy(request, *args, **kwargs)
-
-
-class UserWorkSpacesEndpoint(BaseAPIView):
-    search_fields = ["name"]
-    filterset_fields = ["owner"]
-
-    @method_decorator(cache_control(private=True, max_age=12))
-    @method_decorator(vary_on_cookie)
-    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()
-            or slug in RESTRICTED_WORKSPACE_SLUGS
-        )
-        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,
-            project__project_projectmember__is_active=True,
-            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
@@ -1,99 +0,0 @@
-# Django imports
-from django.db.models import Q, Count
-
-# 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
-from plane.utils.timezone_converter import user_timezone_converter
-
-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")
-            .filter(archived_at__isnull=True)
-            .annotate(
-                total_issues=Count(
-                    "issue_cycle",
-                    filter=Q(
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
-                    ),
-                )
-            )
-            .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,
-                        issue_cycle__issue__deleted_at__isnull=True,
-                        issue_cycle__deleted_at__isnull=True,
-                    ),
-                )
-            )
-            .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,
-                        issue_cycle__issue__deleted_at__isnull=True,
-                        issue_cycle__deleted_at__isnull=True,
-                    ),
-                )
-            )
-            .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,
-                        issue_cycle__issue__deleted_at__isnull=True,
-                        issue_cycle__deleted_at__isnull=True,
-                    ),
-                )
-            )
-            .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,
-                        issue_cycle__issue__deleted_at__isnull=True,
-                        issue_cycle__deleted_at__isnull=True,
-                    ),
-                )
-            )
-            .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,
-                        issue_cycle__issue__deleted_at__isnull=True,
-                        issue_cycle__deleted_at__isnull=True,
-                    ),
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-        serializer = CycleSerializer(cycles, many=True).data
-        return Response(serializer, status=status.HTTP_200_OK)
@@ -1,79 +0,0 @@
-# Third party modules
-from rest_framework import status
-from rest_framework.response import Response
-
-# Django modules
-from django.db.models import Q
-
-# Module imports
-from plane.app.views.base import BaseAPIView
-from plane.db.models import UserFavorite, Workspace
-from plane.app.serializers import UserFavoriteSerializer
-from plane.app.permissions import allow_permission, ROLE
-
-
-class WorkspaceFavoriteEndpoint(BaseAPIView):
-    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    def get(self, request, slug):
-        # the second filter is to check if the user is a member of the project
-        favorites = UserFavorite.objects.filter(
-            user=request.user, workspace__slug=slug, parent__isnull=True
-        ).filter(
-            Q(project__isnull=True) & ~Q(entity_type="page")
-            | (
-                Q(project__isnull=False)
-                & Q(project__project_projectmember__member=request.user)
-                & Q(project__project_projectmember__is_active=True)
-            )
-        )
-        serializer = UserFavoriteSerializer(favorites, many=True)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    def post(self, request, slug):
-        workspace = Workspace.objects.get(slug=slug)
-        serializer = UserFavoriteSerializer(data=request.data)
-        if serializer.is_valid():
-            serializer.save(
-                user_id=request.user.id,
-                workspace=workspace,
-                project_id=request.data.get("project_id", None),
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    def patch(self, request, slug, favorite_id):
-        favorite = UserFavorite.objects.get(
-            user=request.user, workspace__slug=slug, pk=favorite_id
-        )
-        serializer = UserFavoriteSerializer(favorite, 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)
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    def delete(self, request, slug, favorite_id):
-        favorite = UserFavorite.objects.get(
-            user=request.user, workspace__slug=slug, pk=favorite_id
-        )
-        favorite.delete(soft=False)
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class WorkspaceFavoriteGroupEndpoint(BaseAPIView):
-    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
-    def get(self, request, slug, favorite_id):
-        favorites = UserFavorite.objects.filter(
-            user=request.user, workspace__slug=slug, parent_id=favorite_id
-        ).filter(
-            Q(project__isnull=True)
-            | (
-                Q(project__isnull=False)
-                & Q(project__project_projectmember__member=request.user)
-                & Q(project__project_projectmember__is_active=True)
-            )
-        )
-        serializer = UserFavoriteSerializer(favorites, many=True)
-        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -1,296 +0,0 @@
-# Python imports
-from datetime import datetime
-
-import jwt
-
-# Django imports
-from django.conf import settings
-from django.core.exceptions import ValidationError
-from django.core.validators import validate_email
-from django.db.models import Count
-from django.utils import timezone
-
-# Third party modules
-from rest_framework import status
-from rest_framework.permissions import AllowAny
-from rest_framework.response import Response
-
-# Module imports
-from plane.app.permissions import WorkSpaceAdminPermission
-from plane.app.serializers import (
-    WorkSpaceMemberInviteSerializer,
-    WorkSpaceMemberSerializer,
-)
-from plane.app.views.base import BaseAPIView
-from plane.bgtasks.event_tracking_task import workspace_invite_event
-from plane.bgtasks.workspace_invitation_task import workspace_invitation
-from plane.db.models import User, Workspace, WorkspaceMember, WorkspaceMemberInvite
-from plane.utils.cache import invalidate_cache, invalidate_cache_directly
-
-from .. import BaseViewSet
-
-
-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", 5)) > 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", 5),
-                        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/", multiple=True)
-    @invalidate_cache(
-        path="/api/workspaces/:slug/members/",
-        user=False,
-        multiple=True,
-        url_params=True,
-    )
-    @invalidate_cache(path="/api/users/me/settings/", multiple=True)
-    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/", multiple=True)
-    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:
-            invalidate_cache_directly(
-                path=f"/api/workspaces/{invitation.workspace.slug}/members/",
-                user=False,
-                request=request,
-                multiple=True,
-            )
-            # 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)
@@ -1,270 +0,0 @@
-# Django imports
-from django.db.models import Count, Q, OuterRef, Subquery, IntegerField
-from django.db.models.functions import Coalesce
-
-# Third party modules
-from rest_framework import status
-from rest_framework.response import Response
-
-from plane.app.permissions import WorkspaceEntityPermission, allow_permission, ROLE
-
-# Module imports
-from plane.app.serializers import (
-    ProjectMemberRoleSerializer,
-    WorkspaceMemberAdminSerializer,
-    WorkspaceMemberMeSerializer,
-    WorkSpaceMemberSerializer,
-)
-from plane.app.views.base import BaseAPIView
-from plane.db.models import Project, ProjectMember, WorkspaceMember, DraftIssue
-from plane.utils.cache import invalidate_cache
-
-from .. import BaseViewSet
-
-
-class WorkSpaceMemberViewSet(BaseViewSet):
-    serializer_class = WorkspaceMemberAdminSerializer
-    model = WorkspaceMember
-
-    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")
-        )
-
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
-    )
-    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 > 5:
-            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)
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
-    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,
-            )
-
-        if workspace_member.role > int(request.data.get("role")):
-            _ = ProjectMember.objects.filter(
-                workspace__slug=slug, member_id=workspace_member.member_id
-            ).update(role=int(request.data.get("role")))
-
-        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)
-
-    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
-    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,
-        multiple=True,
-    )
-    @invalidate_cache(path="/api/users/me/settings/")
-    @invalidate_cache(path="api/users/me/workspaces/", user=False, multiple=True)
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
-    )
-    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):
-        draft_issue_count = (
-            DraftIssue.objects.filter(
-                created_by=request.user, workspace_id=OuterRef("workspace_id")
-            )
-            .values("workspace_id")
-            .annotate(count=Count("id"))
-            .values("count")
-        )
-
-        workspace_member = (
-            WorkspaceMember.objects.filter(
-                member=request.user, workspace__slug=slug, is_active=True
-            )
-            .annotate(
-                draft_issue_count=Coalesce(
-                    Subquery(draft_issue_count, output_field=IntegerField()), 0
-                )
-            )
-            .first()
-        )
-        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)
@@ -1,26 +0,0 @@
-# Third party modules
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from plane.app.serializers import StateSerializer
-from plane.app.views.base import BaseAPIView
-from plane.db.models import State
-from plane.app.permissions import WorkspaceEntityPermission
-from plane.utils.cache import cache_response
-
-
-class WorkspaceStatesEndpoint(BaseAPIView):
-    permission_classes = [WorkspaceEntityPermission]
-
-    @cache_response(60 * 60 * 2)
-    def get(self, request, slug):
-        states = State.objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True,
-            project__archived_at__isnull=True,
-            is_triage=False,
-        )
-        serializer = StateSerializer(states, many=True).data
-        return Response(serializer, status=status.HTTP_200_OK)
@@ -1,537 +0,0 @@
-# Python imports
-from datetime import date
-
-from dateutil.relativedelta import relativedelta
-
-# Django imports
-from django.db.models import (
-    Case,
-    Count,
-    F,
-    Func,
-    IntegerField,
-    OuterRef,
-    Q,
-    Value,
-    When,
-    Subquery,
-)
-from django.db.models.fields import DateField
-from django.db.models.functions import Cast, ExtractWeek
-from django.utils import timezone
-
-# Third party modules
-from rest_framework import status
-from rest_framework.response import Response
-
-from plane.app.permissions import WorkspaceEntityPermission, WorkspaceViewerPermission
-
-# Module imports
-from plane.app.serializers import (
-    IssueActivitySerializer,
-    ProjectMemberSerializer,
-    WorkSpaceSerializer,
-    WorkspaceUserPropertiesSerializer,
-)
-from plane.app.views.base import BaseAPIView
-from plane.db.models import (
-    CycleIssue,
-    Issue,
-    IssueActivity,
-    FileAsset,
-    IssueLink,
-    IssueSubscriber,
-    Project,
-    ProjectMember,
-    User,
-    Workspace,
-    WorkspaceMember,
-    WorkspaceUserProperties,
-)
-from plane.utils.grouper import (
-    issue_group_values,
-    issue_on_results,
-    issue_queryset_grouper,
-)
-from plane.utils.issue_filters import issue_filters
-from plane.utils.order_queryset import order_issue_queryset
-from plane.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPaginator
-
-
-class UserLastProjectWithWorkspaceEndpoint(BaseAPIView):
-    def get(self, request):
-        user = User.objects.get(pk=request.user.id)
-
-        last_workspace_id = user.last_workspace_id
-
-        if last_workspace_id is None:
-            return Response(
-                {"project_details": [], "workspace_details": {}},
-                status=status.HTTP_200_OK,
-            )
-
-        workspace = Workspace.objects.get(pk=last_workspace_id)
-        workspace_serializer = WorkSpaceSerializer(workspace)
-
-        project_member = ProjectMember.objects.filter(
-            workspace_id=last_workspace_id, member=request.user
-        ).select_related("workspace", "project", "member", "workspace__owner")
-
-        project_member_serializer = ProjectMemberSerializer(project_member, many=True)
-
-        return Response(
-            {
-                "workspace_details": workspace_serializer.data,
-                "project_details": project_member_serializer.data,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-
-class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
-    permission_classes = [WorkspaceViewerPermission]
-
-    def get(self, request, slug, user_id):
-        filters = issue_filters(request.query_params, "GET")
-
-        order_by_param = request.GET.get("order_by", "-created_at")
-        issue_queryset = (
-            Issue.issue_objects.filter(
-                Q(assignees__in=[user_id])
-                | Q(created_by_id=user_id)
-                | Q(issue_subscribers__subscriber_id=user_id),
-                workspace__slug=slug,
-                project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True,
-            )
-            .filter(**filters)
-            .select_related("workspace", "project", "state", "parent")
-            .prefetch_related("assignees", "labels", "issue_module__module")
-            .annotate(
-                cycle_id=Subquery(
-                    CycleIssue.objects.filter(
-                        issue=OuterRef("id"), deleted_at__isnull=True
-                    ).values("cycle_id")[:1]
-                )
-            )
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
-                )
-                .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")
-            )
-            .order_by("created_at")
-        ).distinct()
-
-        # Issue queryset
-        issue_queryset, order_by_param = order_issue_queryset(
-            issue_queryset=issue_queryset, order_by_param=order_by_param
-        )
-
-        # Group by
-        group_by = request.GET.get("group_by", False)
-        sub_group_by = request.GET.get("sub_group_by", False)
-
-        # issue queryset
-        issue_queryset = issue_queryset_grouper(
-            queryset=issue_queryset, group_by=group_by, sub_group_by=sub_group_by
-        )
-
-        if group_by:
-            if sub_group_by:
-                if group_by == sub_group_by:
-                    return Response(
-                        {
-                            "error": "Group by and sub group by cannot have same parameters"
-                        },
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                else:
-                    return self.paginate(
-                        request=request,
-                        order_by=order_by_param,
-                        queryset=issue_queryset,
-                        on_results=lambda issues: issue_on_results(
-                            group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                        ),
-                        paginator_cls=SubGroupedOffsetPaginator,
-                        group_by_fields=issue_group_values(
-                            field=group_by, slug=slug, filters=filters
-                        ),
-                        sub_group_by_fields=issue_group_values(
-                            field=sub_group_by, slug=slug, filters=filters
-                        ),
-                        group_by_field_name=group_by,
-                        sub_group_by_field_name=sub_group_by,
-                        count_filter=Q(
-                            Q(issue_intake__status=1)
-                            | Q(issue_intake__status=-1)
-                            | Q(issue_intake__status=2)
-                            | Q(issue_intake__isnull=True),
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-            else:
-                # Group paginate
-                return self.paginate(
-                    request=request,
-                    order_by=order_by_param,
-                    queryset=issue_queryset,
-                    on_results=lambda issues: issue_on_results(
-                        group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                    ),
-                    paginator_cls=GroupedOffsetPaginator,
-                    group_by_fields=issue_group_values(
-                        field=group_by, slug=slug, filters=filters
-                    ),
-                    group_by_field_name=group_by,
-                    count_filter=Q(
-                        Q(issue_intake__status=1)
-                        | Q(issue_intake__status=-1)
-                        | Q(issue_intake__status=2)
-                        | Q(issue_intake__isnull=True),
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                )
-        else:
-            return self.paginate(
-                order_by=order_by_param,
-                request=request,
-                queryset=issue_queryset,
-                on_results=lambda issues: issue_on_results(
-                    group_by=group_by, issues=issues, sub_group_by=sub_group_by
-                ),
-            )
-
-
-class WorkspaceUserPropertiesEndpoint(BaseAPIView):
-    permission_classes = [WorkspaceViewerPermission]
-
-    def patch(self, request, slug):
-        workspace_properties = WorkspaceUserProperties.objects.get(
-            user=request.user, workspace__slug=slug
-        )
-
-        workspace_properties.filters = request.data.get(
-            "filters", workspace_properties.filters
-        )
-        workspace_properties.display_filters = request.data.get(
-            "display_filters", workspace_properties.display_filters
-        )
-        workspace_properties.display_properties = request.data.get(
-            "display_properties", workspace_properties.display_properties
-        )
-        workspace_properties.save()
-
-        serializer = WorkspaceUserPropertiesSerializer(workspace_properties)
-        return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-    def get(self, request, slug):
-        (workspace_properties, _) = WorkspaceUserProperties.objects.get_or_create(
-            user=request.user, workspace__slug=slug
-        )
-        serializer = WorkspaceUserPropertiesSerializer(workspace_properties)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-
-class WorkspaceUserProfileEndpoint(BaseAPIView):
-    def get(self, request, slug, user_id):
-        user_data = User.objects.get(pk=user_id)
-
-        requesting_workspace_member = WorkspaceMember.objects.get(
-            workspace__slug=slug, member=request.user, is_active=True
-        )
-        projects = []
-        if requesting_workspace_member.role >= 15:
-            projects = (
-                Project.objects.filter(
-                    workspace__slug=slug,
-                    project_projectmember__member=request.user,
-                    project_projectmember__is_active=True,
-                    archived_at__isnull=True,
-                )
-                .annotate(
-                    created_issues=Count(
-                        "project_issue",
-                        filter=Q(
-                            project_issue__created_by_id=user_id,
-                            project_issue__archived_at__isnull=True,
-                            project_issue__is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    assigned_issues=Count(
-                        "project_issue",
-                        filter=Q(
-                            project_issue__assignees__in=[user_id],
-                            project_issue__archived_at__isnull=True,
-                            project_issue__is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    completed_issues=Count(
-                        "project_issue",
-                        filter=Q(
-                            project_issue__completed_at__isnull=False,
-                            project_issue__assignees__in=[user_id],
-                            project_issue__archived_at__isnull=True,
-                            project_issue__is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    pending_issues=Count(
-                        "project_issue",
-                        filter=Q(
-                            project_issue__state__group__in=[
-                                "backlog",
-                                "unstarted",
-                                "started",
-                            ],
-                            project_issue__assignees__in=[user_id],
-                            project_issue__archived_at__isnull=True,
-                            project_issue__is_draft=False,
-                        ),
-                    )
-                )
-                .values(
-                    "id",
-                    "logo_props",
-                    "created_issues",
-                    "assigned_issues",
-                    "completed_issues",
-                    "pending_issues",
-                )
-            )
-
-        return Response(
-            {
-                "project_data": projects,
-                "user_data": {
-                    "email": user_data.email,
-                    "first_name": user_data.first_name,
-                    "last_name": user_data.last_name,
-                    "avatar_url": user_data.avatar_url,
-                    "cover_image_url": user_data.cover_image_url,
-                    "date_joined": user_data.date_joined,
-                    "user_timezone": user_data.user_timezone,
-                    "display_name": user_data.display_name,
-                },
-            },
-            status=status.HTTP_200_OK,
-        )
-
-
-class WorkspaceUserActivityEndpoint(BaseAPIView):
-    permission_classes = [WorkspaceEntityPermission]
-
-    def get(self, request, slug, user_id):
-        projects = request.query_params.getlist("project", [])
-
-        queryset = IssueActivity.objects.filter(
-            ~Q(field__in=["comment", "vote", "reaction", "draft"]),
-            workspace__slug=slug,
-            project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True,
-            project__archived_at__isnull=True,
-            actor=user_id,
-        ).select_related("actor", "workspace", "issue", "project")
-
-        if projects:
-            queryset = queryset.filter(project__in=projects)
-
-        return self.paginate(
-            order_by=request.GET.get("order_by", "-created_at"),
-            request=request,
-            queryset=queryset,
-            on_results=lambda issue_activities: IssueActivitySerializer(
-                issue_activities, many=True
-            ).data,
-        )
-
-
-class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
-    def get(self, request, slug, user_id):
-        filters = issue_filters(request.query_params, "GET")
-
-        state_distribution = (
-            Issue.issue_objects.filter(
-                workspace__slug=slug,
-                assignees__in=[user_id],
-                project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True,
-            )
-            .filter(**filters)
-            .annotate(state_group=F("state__group"))
-            .values("state_group")
-            .annotate(state_count=Count("state_group"))
-            .order_by("state_group")
-        )
-
-        priority_order = ["urgent", "high", "medium", "low", "none"]
-
-        priority_distribution = (
-            Issue.issue_objects.filter(
-                workspace__slug=slug,
-                assignees__in=[user_id],
-                project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True,
-            )
-            .filter(**filters)
-            .values("priority")
-            .annotate(priority_count=Count("priority"))
-            .filter(priority_count__gte=1)
-            .annotate(
-                priority_order=Case(
-                    *[
-                        When(priority=p, then=Value(i))
-                        for i, p in enumerate(priority_order)
-                    ],
-                    default=Value(len(priority_order)),
-                    output_field=IntegerField(),
-                )
-            )
-            .order_by("priority_order")
-        )
-
-        created_issues = (
-            Issue.issue_objects.filter(
-                workspace__slug=slug,
-                project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True,
-                created_by_id=user_id,
-            )
-            .filter(**filters)
-            .count()
-        )
-
-        assigned_issues_count = (
-            Issue.issue_objects.filter(
-                workspace__slug=slug,
-                assignees__in=[user_id],
-                project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True,
-            )
-            .filter(**filters)
-            .count()
-        )
-
-        pending_issues_count = (
-            Issue.issue_objects.filter(
-                ~Q(state__group__in=["completed", "cancelled"]),
-                workspace__slug=slug,
-                assignees__in=[user_id],
-                project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True,
-            )
-            .filter(**filters)
-            .count()
-        )
-
-        completed_issues_count = (
-            Issue.issue_objects.filter(
-                workspace__slug=slug,
-                assignees__in=[user_id],
-                state__group="completed",
-                project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True,
-            )
-            .filter(**filters)
-            .count()
-        )
-
-        subscribed_issues_count = (
-            IssueSubscriber.objects.filter(
-                workspace__slug=slug,
-                subscriber_id=user_id,
-                project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True,
-                project__archived_at__isnull=True,
-            )
-            .filter(**filters)
-            .count()
-        )
-
-        upcoming_cycles = CycleIssue.objects.filter(
-            workspace__slug=slug,
-            cycle__start_date__gt=timezone.now(),
-            issue__assignees__in=[user_id],
-        ).values("cycle__name", "cycle__id", "cycle__project_id")
-
-        present_cycle = CycleIssue.objects.filter(
-            workspace__slug=slug,
-            cycle__start_date__lt=timezone.now(),
-            cycle__end_date__gt=timezone.now(),
-            issue__assignees__in=[user_id],
-        ).values("cycle__name", "cycle__id", "cycle__project_id")
-
-        return Response(
-            {
-                "state_distribution": state_distribution,
-                "priority_distribution": priority_distribution,
-                "created_issues": created_issues,
-                "assigned_issues": assigned_issues_count,
-                "completed_issues": completed_issues_count,
-                "pending_issues": pending_issues_count,
-                "subscribed_issues": subscribed_issues_count,
-                "present_cycles": present_cycle,
-                "upcoming_cycles": upcoming_cycles,
-            }
-        )
-
-
-class UserActivityGraphEndpoint(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=-6),
-            )
-            .annotate(created_date=Cast("created_at", DateField()))
-            .values("created_date")
-            .annotate(activity_count=Count("created_date"))
-            .order_by("created_date")
-        )
-
-        return Response(issue_activities, status=status.HTTP_200_OK)
-
-
-class UserIssueCompletedGraphEndpoint(BaseAPIView):
-    def get(self, request, slug):
-        month = request.GET.get("month", 1)
-
-        issues = (
-            Issue.issue_objects.filter(
-                assignees__in=[request.user],
-                workspace__slug=slug,
-                completed_at__month=month,
-                completed_at__isnull=False,
-            )
-            .annotate(completed_week=ExtractWeek("completed_at"))
-            .annotate(week=F("completed_week") % 4)
-            .values("week")
-            .annotate(completed_count=Count("completed_week"))
-            .order_by("week")
-        )
-
-        return Response(issues, status=status.HTTP_200_OK)
@@ -1,179 +0,0 @@
-# Python imports
-import os
-import uuid
-
-# Django imports
-from django.utils import timezone
-from django.core.validators import validate_email
-from django.core.exceptions import ValidationError
-
-# Third party imports
-from zxcvbn import zxcvbn
-
-# Module imports
-from plane.db.models import Profile, User, WorkspaceMemberInvite
-from plane.license.utils.instance_value import get_configuration_value
-from .error import AuthenticationException, AUTHENTICATION_ERROR_CODES
-from plane.bgtasks.user_activation_email_task import user_activation_email
-from plane.authentication.utils.host import base_host
-
-
-class Adapter:
-    """Common interface for all auth providers"""
-
-    def __init__(self, request, provider, callback=None):
-        self.request = request
-        self.provider = provider
-        self.callback = callback
-        self.token_data = None
-        self.user_data = None
-
-    def get_user_token(self, data, headers=None):
-        raise NotImplementedError
-
-    def get_user_response(self):
-        raise NotImplementedError
-
-    def set_token_data(self, data):
-        self.token_data = data
-
-    def set_user_data(self, data):
-        self.user_data = data
-
-    def create_update_account(self, user):
-        raise NotImplementedError
-
-    def authenticate(self):
-        raise NotImplementedError
-
-    def sanitize_email(self, email):
-        # Check if email is present
-        if not email:
-            raise AuthenticationException(
-                error_code=AUTHENTICATION_ERROR_CODES["INVALID_EMAIL"],
-                error_message="INVALID_EMAIL",
-                payload={"email": email},
-            )
-
-        # Sanitize email
-        email = str(email).lower().strip()
-
-        # validate email
-        try:
-            validate_email(email)
-        except ValidationError:
-            raise AuthenticationException(
-                error_code=AUTHENTICATION_ERROR_CODES["INVALID_EMAIL"],
-                error_message="INVALID_EMAIL",
-                payload={"email": email},
-            )
-        # Return email
-        return email
-
-    def validate_password(self, email):
-        """Validate password strength"""
-        results = zxcvbn(self.code)
-        if results["score"] < 3:
-            raise AuthenticationException(
-                error_code=AUTHENTICATION_ERROR_CODES["INVALID_PASSWORD"],
-                error_message="INVALID_PASSWORD",
-                payload={"email": email},
-            )
-        return
-
-    def __check_signup(self, email):
-        """Check if sign up is enabled or not and raise exception if not enabled"""
-
-        # Get configuration value
-        (ENABLE_SIGNUP,) = get_configuration_value(
-            [{"key": "ENABLE_SIGNUP", "default": os.environ.get("ENABLE_SIGNUP", "1")}]
-        )
-
-        # Check if sign up is disabled and invite is present or not
-        if (
-            ENABLE_SIGNUP == "0"
-            and not WorkspaceMemberInvite.objects.filter(email=email).exists()
-        ):
-            # Raise exception
-            raise AuthenticationException(
-                error_code=AUTHENTICATION_ERROR_CODES["SIGNUP_DISABLED"],
-                error_message="SIGNUP_DISABLED",
-                payload={"email": email},
-            )
-
-        return True
-
-    def save_user_data(self, user):
-        # Update user details
-        user.last_login_medium = self.provider
-        user.last_active = timezone.now()
-        user.last_login_time = timezone.now()
-        user.last_login_ip = self.request.META.get("REMOTE_ADDR")
-        user.last_login_uagent = self.request.META.get("HTTP_USER_AGENT")
-        user.token_updated_at = timezone.now()
-        # If user is not active, send the activation email and set the user as active
-        if not user.is_active:
-            user_activation_email.delay(base_host(request=self.request), user.id)
-        # Set user as active
-        user.is_active = True
-        user.save()
-        return user
-
-    def complete_login_or_signup(self):
-        # Get email
-        email = self.user_data.get("email")
-
-        # Sanitize email
-        email = self.sanitize_email(email)
-
-        # Check if the user is present
-        user = User.objects.filter(email=email).first()
-        # Check if sign up case or login
-        is_signup = bool(user)
-        # If user is not present, create a new user
-        if not user:
-            # New user
-            self.__check_signup(email)
-
-            # Initialize user
-            user = User(email=email, username=uuid.uuid4().hex)
-
-            # Check if password is autoset
-            if self.user_data.get("user").get("is_password_autoset"):
-                user.set_password(uuid.uuid4().hex)
-                user.is_password_autoset = True
-                user.is_email_verified = True
-
-            # Validate password
-            else:
-                # Validate password
-                self.validate_password(email)
-                # Set password
-                user.set_password(self.code)
-                user.is_password_autoset = False
-
-            # Set user details
-            avatar = self.user_data.get("user", {}).get("avatar", "")
-            first_name = self.user_data.get("user", {}).get("first_name", "")
-            last_name = self.user_data.get("user", {}).get("last_name", "")
-            user.avatar = avatar if avatar else ""
-            user.first_name = first_name if first_name else ""
-            user.last_name = last_name if last_name else ""
-            user.save()
-
-            # Create profile
-            Profile.objects.create(user=user)
-
-        # Save user data
-        user = self.save_user_data(user=user)
-
-        # Call callback if present
-        if self.callback:
-            self.callback(user, is_signup, self.request)
-
-        # Create or update account if token data is present
-        if self.token_data:
-            self.create_update_account(user=user)
-
-        # Return user
-        return user
@@ -1,135 +0,0 @@
-# Python imports
-import os
-from datetime import datetime
-from urllib.parse import urlencode
-
-import pytz
-import requests
-
-# Module imports
-from plane.authentication.adapter.oauth import OauthAdapter
-from plane.license.utils.instance_value import get_configuration_value
-from plane.authentication.adapter.error import (
-    AuthenticationException,
-    AUTHENTICATION_ERROR_CODES,
-)
-
-
-class GitHubOAuthProvider(OauthAdapter):
-    token_url = "https://github.com/login/oauth/access_token"
-    userinfo_url = "https://api.github.com/user"
-    provider = "github"
-    scope = "read:user user:email"
-
-    def __init__(self, request, code=None, state=None, callback=None):
-        GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET = get_configuration_value(
-            [
-                {
-                    "key": "GITHUB_CLIENT_ID",
-                    "default": os.environ.get("GITHUB_CLIENT_ID"),
-                },
-                {
-                    "key": "GITHUB_CLIENT_SECRET",
-                    "default": os.environ.get("GITHUB_CLIENT_SECRET"),
-                },
-            ]
-        )
-
-        if not (GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET):
-            raise AuthenticationException(
-                error_code=AUTHENTICATION_ERROR_CODES["GITHUB_NOT_CONFIGURED"],
-                error_message="GITHUB_NOT_CONFIGURED",
-            )
-
-        client_id = GITHUB_CLIENT_ID
-        client_secret = GITHUB_CLIENT_SECRET
-
-        redirect_uri = f"""{"https" if request.is_secure() else "http"}://{request.get_host()}/auth/github/callback/"""
-        url_params = {
-            "client_id": client_id,
-            "redirect_uri": redirect_uri,
-            "scope": self.scope,
-            "state": state,
-        }
-        auth_url = f"https://github.com/login/oauth/authorize?{urlencode(url_params)}"
-        super().__init__(
-            request,
-            self.provider,
-            client_id,
-            self.scope,
-            redirect_uri,
-            auth_url,
-            self.token_url,
-            self.userinfo_url,
-            client_secret,
-            code,
-            callback=callback,
-        )
-
-    def set_token_data(self):
-        data = {
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-            "code": self.code,
-            "redirect_uri": self.redirect_uri,
-        }
-        token_response = self.get_user_token(
-            data=data, headers={"Accept": "application/json"}
-        )
-        super().set_token_data(
-            {
-                "access_token": token_response.get("access_token"),
-                "refresh_token": token_response.get("refresh_token", None),
-                "access_token_expired_at": (
-                    datetime.fromtimestamp(
-                        token_response.get("expires_in"), tz=pytz.utc
-                    )
-                    if token_response.get("expires_in")
-                    else None
-                ),
-                "refresh_token_expired_at": (
-                    datetime.fromtimestamp(
-                        token_response.get("refresh_token_expired_at"), tz=pytz.utc
-                    )
-                    if token_response.get("refresh_token_expired_at")
-                    else None
-                ),
-                "id_token": token_response.get("id_token", ""),
-            }
-        )
-
-    def __get_email(self, headers):
-        try:
-            # Github does not provide email in user response
-            emails_url = "https://api.github.com/user/emails"
-            emails_response = requests.get(emails_url, headers=headers).json()
-            email = next(
-                (email["email"] for email in emails_response if email["primary"]), None
-            )
-            return email
-        except requests.RequestException:
-            raise AuthenticationException(
-                error_code=AUTHENTICATION_ERROR_CODES["GITHUB_OAUTH_PROVIDER_ERROR"],
-                error_message="GITHUB_OAUTH_PROVIDER_ERROR",
-            )
-
-    def set_user_data(self):
-        user_info_response = self.get_user_response()
-        headers = {
-            "Authorization": f"Bearer {self.token_data.get('access_token')}",
-            "Accept": "application/json",
-        }
-        email = self.__get_email(headers=headers)
-        super().set_user_data(
-            {
-                "email": email,
-                "user": {
-                    "provider_id": user_info_response.get("id"),
-                    "email": email,
-                    "avatar": user_info_response.get("avatar_url"),
-                    "first_name": user_info_response.get("name"),
-                    "last_name": user_info_response.get("family_name"),
-                    "is_password_autoset": True,
-                },
-            }
-        )
@@ -1,133 +0,0 @@
-from django.urls import path
-
-from .views import (
-    CSRFTokenEndpoint,
-    ForgotPasswordEndpoint,
-    SetUserPasswordEndpoint,
-    ResetPasswordEndpoint,
-    ChangePasswordEndpoint,
-    # App
-    EmailCheckEndpoint,
-    GitLabCallbackEndpoint,
-    GitLabOauthInitiateEndpoint,
-    GitHubCallbackEndpoint,
-    GitHubOauthInitiateEndpoint,
-    GoogleCallbackEndpoint,
-    GoogleOauthInitiateEndpoint,
-    MagicGenerateEndpoint,
-    MagicSignInEndpoint,
-    MagicSignUpEndpoint,
-    SignInAuthEndpoint,
-    SignOutAuthEndpoint,
-    SignUpAuthEndpoint,
-    ForgotPasswordSpaceEndpoint,
-    ResetPasswordSpaceEndpoint,
-    # Space
-    EmailCheckSpaceEndpoint,
-    GitLabCallbackSpaceEndpoint,
-    GitLabOauthInitiateSpaceEndpoint,
-    GitHubCallbackSpaceEndpoint,
-    GitHubOauthInitiateSpaceEndpoint,
-    GoogleCallbackSpaceEndpoint,
-    GoogleOauthInitiateSpaceEndpoint,
-    MagicGenerateSpaceEndpoint,
-    MagicSignInSpaceEndpoint,
-    MagicSignUpSpaceEndpoint,
-    SignInAuthSpaceEndpoint,
-    SignUpAuthSpaceEndpoint,
-    SignOutAuthSpaceEndpoint,
-)
-
-urlpatterns = [
-    # credentials
-    path("sign-in/", SignInAuthEndpoint.as_view(), name="sign-in"),
-    path("sign-up/", SignUpAuthEndpoint.as_view(), name="sign-up"),
-    path("spaces/sign-in/", SignInAuthSpaceEndpoint.as_view(), name="sign-in"),
-    path("spaces/sign-up/", SignUpAuthSpaceEndpoint.as_view(), name="sign-in"),
-    # signout
-    path("sign-out/", SignOutAuthEndpoint.as_view(), name="sign-out"),
-    path("spaces/sign-out/", SignOutAuthSpaceEndpoint.as_view(), name="sign-out"),
-    # csrf token
-    path("get-csrf-token/", CSRFTokenEndpoint.as_view(), name="get_csrf_token"),
-    # Magic sign in
-    path("magic-generate/", MagicGenerateEndpoint.as_view(), name="magic-generate"),
-    path("magic-sign-in/", MagicSignInEndpoint.as_view(), name="magic-sign-in"),
-    path("magic-sign-up/", MagicSignUpEndpoint.as_view(), name="magic-sign-up"),
-    path("get-csrf-token/", CSRFTokenEndpoint.as_view(), name="get_csrf_token"),
-    path(
-        "spaces/magic-generate/",
-        MagicGenerateSpaceEndpoint.as_view(),
-        name="magic-generate",
-    ),
-    path(
-        "spaces/magic-sign-in/",
-        MagicSignInSpaceEndpoint.as_view(),
-        name="magic-sign-in",
-    ),
-    path(
-        "spaces/magic-sign-up/",
-        MagicSignUpSpaceEndpoint.as_view(),
-        name="magic-sign-up",
-    ),
-    ## Google Oauth
-    path("google/", GoogleOauthInitiateEndpoint.as_view(), name="google-initiate"),
-    path("google/callback/", GoogleCallbackEndpoint.as_view(), name="google-callback"),
-    path(
-        "spaces/google/",
-        GoogleOauthInitiateSpaceEndpoint.as_view(),
-        name="google-initiate",
-    ),
-    path(
-        "google/callback/",
-        GoogleCallbackSpaceEndpoint.as_view(),
-        name="google-callback",
-    ),
-    ## Github Oauth
-    path("github/", GitHubOauthInitiateEndpoint.as_view(), name="github-initiate"),
-    path("github/callback/", GitHubCallbackEndpoint.as_view(), name="github-callback"),
-    path(
-        "spaces/github/",
-        GitHubOauthInitiateSpaceEndpoint.as_view(),
-        name="github-initiate",
-    ),
-    path(
-        "spaces/github/callback/",
-        GitHubCallbackSpaceEndpoint.as_view(),
-        name="github-callback",
-    ),
-    ## Gitlab Oauth
-    path("gitlab/", GitLabOauthInitiateEndpoint.as_view(), name="gitlab-initiate"),
-    path("gitlab/callback/", GitLabCallbackEndpoint.as_view(), name="gitlab-callback"),
-    path(
-        "spaces/gitlab/",
-        GitLabOauthInitiateSpaceEndpoint.as_view(),
-        name="gitlab-initiate",
-    ),
-    path(
-        "spaces/gitlab/callback/",
-        GitLabCallbackSpaceEndpoint.as_view(),
-        name="gitlab-callback",
-    ),
-    # Email Check
-    path("email-check/", EmailCheckEndpoint.as_view(), name="email-check"),
-    path("spaces/email-check/", EmailCheckSpaceEndpoint.as_view(), name="email-check"),
-    # Password
-    path("forgot-password/", ForgotPasswordEndpoint.as_view(), name="forgot-password"),
-    path(
-        "reset-password/<uidb64>/<token>/",
-        ResetPasswordEndpoint.as_view(),
-        name="forgot-password",
-    ),
-    path(
-        "spaces/forgot-password/",
-        ForgotPasswordSpaceEndpoint.as_view(),
-        name="forgot-password",
-    ),
-    path(
-        "spaces/reset-password/<uidb64>/<token>/",
-        ResetPasswordSpaceEndpoint.as_view(),
-        name="forgot-password",
-    ),
-    path("change-password/", ChangePasswordEndpoint.as_view(), name="forgot-password"),
-    path("set-password/", SetUserPasswordEndpoint.as_view(), name="set-password"),
-]
--- a/Show More
+++ b/Show More