feat: embed component

fix: email error handling on magic auth
chore: added dates in issue export (#6088 )
2024-11-25 18:43:42 +05:30 · 2024-11-25 15:02:50 +05:30 · 2024-11-22 19:59:08 +05:30 · 2024-11-22 17:00:20 +05:30 · 2024-11-22 16:05:58 +05:30 · 2024-11-22 16:02:11 +05:30
903 changed files with 29789 additions and 19455 deletions
@@ -0,0 +1,126 @@
+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 }}
@@ -83,7 +83,7 @@ jobs:
          endpoint: ${{ env.BUILDX_ENDPOINT }}

      - name: Build and Push to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+        uses: docker/build-push-action@v6.9.0
        with:
          context: ./aio
          file: ./aio/Dockerfile-base-full
@@ -124,7 +124,7 @@ jobs:
          endpoint: ${{ env.BUILDX_ENDPOINT }}

      - name: Build and Push to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+        uses: docker/build-push-action@v6.9.0
        with:
          context: ./aio
          file: ./aio/Dockerfile-base-slim
@@ -128,7 +128,7 @@ jobs:
        uses: actions/checkout@v4

      - name: Build and Push to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+        uses: docker/build-push-action@v6.9.0
        with:
          context: .
          file: ./aio/Dockerfile-app
@@ -188,7 +188,7 @@ jobs:
        uses: actions/checkout@v4

      - name: Build and Push to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+        uses: docker/build-push-action@v6.9.0
        with:
          context: .
          file: ./aio/Dockerfile-app
@@ -1,29 +1,45 @@
-name: Branch Build
+name: Branch Build CE

 on:
  workflow_dispatch:
    inputs:
+      build_type:
+        description: "Type of build to run"
+        required: true
+        type: choice
+        default: "Build"
+        options:
+          - "Build"
+          - "Release"
+      releaseVersion:
+        description: "Release Version"
+        type: string
+        default: v0.0.0
+      isPrerelease:
+        description: "Is Pre-release"
+        type: boolean
+        default: false
+        required: true
      arm64:
        description: "Build for ARM64 architecture"
        required: false
        default: false
        type: boolean
-  push:
-    branches:
-      - master
-      - preview
-  release:
-    types: [released, prereleased]
+  # push:
+  #   branches:
+  #     - master

 env:
-  TARGET_BRANCH: ${{ github.ref_name || github.event.release.target_commitish }}
+  TARGET_BRANCH: ${{ github.ref_name }}
  ARM64_BUILD: ${{ github.event.inputs.arm64 }}
-  IS_PRERELEASE: ${{ github.event.release.prerelease }}
+  BUILD_TYPE: ${{ github.event.inputs.build_type }}
+  RELEASE_VERSION: ${{ github.event.inputs.releaseVersion }}
+  IS_PRERELEASE: ${{ github.event.inputs.isPrerelease }}

 jobs:
  branch_build_setup:
    name: Build Setup
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    outputs:
      gh_branch_name: ${{ steps.set_env_variables.outputs.TARGET_BRANCH }}
      gh_buildx_driver: ${{ steps.set_env_variables.outputs.BUILDX_DRIVER }}
@@ -36,13 +52,24 @@ jobs:
      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 }}
-      flat_branch_name: ${{ steps.set_env_variables.outputs.FLAT_BRANCH_NAME }}
+
+      dh_img_web: ${{ steps.set_env_variables.outputs.DH_IMG_WEB }}
+      dh_img_space: ${{ steps.set_env_variables.outputs.DH_IMG_SPACE }}
+      dh_img_admin: ${{ steps.set_env_variables.outputs.DH_IMG_ADMIN }}
+      dh_img_live: ${{ steps.set_env_variables.outputs.DH_IMG_LIVE }}
+      dh_img_backend: ${{ steps.set_env_variables.outputs.DH_IMG_BACKEND }}
+      dh_img_proxy: ${{ steps.set_env_variables.outputs.DH_IMG_PROXY }}
+
+      build_type: ${{steps.set_env_variables.outputs.BUILD_TYPE}}
+      build_release: ${{ steps.set_env_variables.outputs.BUILD_RELEASE }}
+      build_prerelease: ${{ steps.set_env_variables.outputs.BUILD_PRERELEASE }}
+      release_version: ${{ steps.set_env_variables.outputs.RELEASE_VERSION }}

    steps:
      - id: set_env_variables
        name: Set Environment Variables
        run: |
-          if [ "${{ env.TARGET_BRANCH }}" == "master" ] || [ "${{ env.ARM64_BUILD }}" == "true" ] || ([ "${{ github.event_name }}" == "release" ] && [ "${{ env.IS_PRERELEASE }}" != "true" ]); then
+          if [ "${{ env.ARM64_BUILD }}" == "true" ] || ([ "${{ env.BUILD_TYPE }}" == "Release" ] && [ "${{ env.IS_PRERELEASE }}" != "true" ]); then
            echo "BUILDX_DRIVER=cloud" >> $GITHUB_OUTPUT
            echo "BUILDX_VERSION=lab:latest" >> $GITHUB_OUTPUT
            echo "BUILDX_PLATFORMS=linux/amd64,linux/arm64" >> $GITHUB_OUTPUT
@@ -53,9 +80,43 @@ jobs:
            echo "BUILDX_PLATFORMS=linux/amd64" >> $GITHUB_OUTPUT
            echo "BUILDX_ENDPOINT=" >> $GITHUB_OUTPUT
          fi
-          echo "TARGET_BRANCH=${{ env.TARGET_BRANCH }}" >> $GITHUB_OUTPUT
-          flat_branch_name=$(echo ${{ env.TARGET_BRANCH }} | sed 's/[^a-zA-Z0-9\._]/-/g')
-          echo "FLAT_BRANCH_NAME=${flat_branch_name}" >> $GITHUB_OUTPUT
+          BR_NAME=$( echo "${{ env.TARGET_BRANCH }}" |sed 's/[^a-zA-Z0-9.-]//g')
+          echo "TARGET_BRANCH=$BR_NAME" >> $GITHUB_OUTPUT
+
+          echo "DH_IMG_WEB=plane-frontend" >> $GITHUB_OUTPUT
+          echo "DH_IMG_SPACE=plane-space" >> $GITHUB_OUTPUT
+          echo "DH_IMG_ADMIN=plane-admin" >> $GITHUB_OUTPUT
+          echo "DH_IMG_LIVE=plane-live" >> $GITHUB_OUTPUT
+          echo "DH_IMG_BACKEND=plane-backend" >> $GITHUB_OUTPUT
+          echo "DH_IMG_PROXY=plane-proxy" >> $GITHUB_OUTPUT
+
+          echo "BUILD_TYPE=${{env.BUILD_TYPE}}" >> $GITHUB_OUTPUT
+          BUILD_RELEASE=false
+          BUILD_PRERELEASE=false
+          RELVERSION="latest"
+
+          if [ "${{ env.BUILD_TYPE }}" == "Release" ]; then
+            FLAT_RELEASE_VERSION=$(echo "${{ env.RELEASE_VERSION }}" | sed 's/[^a-zA-Z0-9.-]//g')
+            echo "FLAT_RELEASE_VERSION=${FLAT_RELEASE_VERSION}" >> $GITHUB_OUTPUT
+
+            semver_regex="^v([0-9]+)\.([0-9]+)\.([0-9]+)(-[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*)?$"
+            if [[ ! $FLAT_RELEASE_VERSION =~ $semver_regex ]]; then
+              echo "Invalid Release Version Format : $FLAT_RELEASE_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
+            BUILD_RELEASE=true
+            RELVERSION=$FLAT_RELEASE_VERSION
+
+            if [ "${{ env.IS_PRERELEASE }}" == "true" ]; then
+              BUILD_PRERELEASE=true
+            fi
+          fi
+          echo "BUILD_RELEASE=${BUILD_RELEASE}" >> $GITHUB_OUTPUT
+          echo "BUILD_PRERELEASE=${BUILD_PRERELEASE}" >> $GITHUB_OUTPUT
+          echo "RELEASE_VERSION=${RELVERSION}" >> $GITHUB_OUTPUT

      - id: checkout_files
        name: Checkout Files
@@ -73,24 +134,24 @@ jobs:
            admin:
              - admin/**
              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
+              - "package.json"
+              - "yarn.lock"
+              - "tsconfig.json"
+              - "turbo.json"
            space:
              - space/**
              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
+              - "package.json"
+              - "yarn.lock"
+              - "tsconfig.json"
+              - "turbo.json"
            web:
              - web/**
              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
+              - "package.json"
+              - "yarn.lock"
+              - "tsconfig.json"
+              - "turbo.json"
            live:
              - live/**
              - packages/**
@@ -99,338 +160,224 @@ jobs:
              - 'tsconfig.json'
              - 'turbo.json'

-  branch_build_push_web:
-    if: ${{ needs.branch_build_setup.outputs.build_web == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
-    name: Build-Push Web Docker Image
-    runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
-    env:
-      FRONTEND_TAG: makeplane/plane-frontend:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
-    steps:
-      - name: Set Frontend Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-frontend:${{ github.event.release.tag_name }}
-            if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-frontend:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-frontend:latest
-          else
-            TAG=${{ env.FRONTEND_TAG }}
-          fi
-          echo "FRONTEND_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
-        uses: actions/checkout@v4
-
-      - name: Build and Push Frontend to Docker Container Registry
-        uses: docker/build-push-action@v5.1.0
-        with:
-          context: .
-          file: ./web/Dockerfile.web
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          tags: ${{ env.FRONTEND_TAG }}
-          push: true
-        env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
-
  branch_build_push_admin:
-    if: ${{ needs.branch_build_setup.outputs.build_admin== 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    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
    needs: [branch_build_setup]
-    env:
-      ADMIN_TAG: makeplane/plane-admin:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
    steps:
-      - name: Set Admin Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-admin:${{ github.event.release.tag_name }}
-            if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-admin:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-admin:latest
-          else
-            TAG=${{ env.ADMIN_TAG }}
-          fi
-          echo "ADMIN_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
+      - id: checkout_files
+        name: Checkout Files
        uses: actions/checkout@v4
-
-      - name: Build and Push Frontend to Docker Container Registry
-        uses: docker/build-push-action@v5.1.0
+      - name: Admin Build and Push
+        uses: ./.github/actions/build-push-ce
        with:
-          context: .
-          file: ./admin/Dockerfile.admin
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          tags: ${{ env.ADMIN_TAG }}
-          push: true
-        env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+          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 }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_admin }}
+          build-context: .
+          dockerfile-path: ./admin/Dockerfile.admin
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  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
+    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
+        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 }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_web }}
+          build-context: .
+          dockerfile-path: ./web/Dockerfile.web
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}

  branch_build_push_space:
-    if: ${{ needs.branch_build_setup.outputs.build_space == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    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
    needs: [branch_build_setup]
-    env:
-      SPACE_TAG: makeplane/plane-space:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
    steps:
-      - name: Set Space Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-space:${{ github.event.release.tag_name }}
-            if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-space:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-space:latest
-          else
-            TAG=${{ env.SPACE_TAG }}
-          fi
-          echo "SPACE_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
+      - id: checkout_files
+        name: Checkout Files
        uses: actions/checkout@v4
-
-      - name: Build and Push Space to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+      - name: Space Build and Push
+        uses: ./.github/actions/build-push-ce
        with:
-          context: .
-          file: ./space/Dockerfile.space
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          tags: ${{ env.SPACE_TAG }}
-          push: true
-        env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
-
-  branch_build_push_apiserver:
-    if: ${{ needs.branch_build_setup.outputs.build_apiserver == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
-    name: Build-Push API Server Docker Image
-    runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
-    env:
-      BACKEND_TAG: makeplane/plane-backend:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
-    steps:
-      - name: Set Backend Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-backend:${{ github.event.release.tag_name }}
-            if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-backend:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-backend:latest
-          else
-            TAG=${{ env.BACKEND_TAG }}
-          fi
-          echo "BACKEND_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
-        uses: actions/checkout@v4
-
-      - name: Build and Push Backend to Docker Hub
-        uses: docker/build-push-action@v5.1.0
-        with:
-          context: ./apiserver
-          file: ./apiserver/Dockerfile.api
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          push: true
-          tags: ${{ env.BACKEND_TAG }}
-        env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+          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 }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_space }}
+          build-context: .
+          dockerfile-path: ./space/Dockerfile.space
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}

  branch_build_push_live:
-    if: ${{ needs.branch_build_setup.outputs.build_live == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    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
    needs: [branch_build_setup]
-    env:
-      LIVE_TAG: makeplane/plane-live:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
    steps:
-      - name: Set Live Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-live:${{ github.event.release.tag_name }}
-            if [ "${{ github.event.release.prerelease }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-live:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-live:latest
-          else
-            TAG=${{ env.LIVE_TAG }}
-          fi
-          echo "LIVE_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
+      - id: checkout_files
+        name: Checkout Files
        uses: actions/checkout@v4
-
-      - name: Build and Push Live Server to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+      - name: Live Build and Push
+        uses: ./.github/actions/build-push-ce
        with:
-          context: .
-          file: ./live/Dockerfile.live
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          tags: ${{ env.LIVE_TAG }}
-          push: true
-        env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+          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 }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_live }}
+          build-context: .
+          dockerfile-path: ./live/Dockerfile.live
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  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
+    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
+        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 }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_backend }}
+          build-context: ./apiserver
+          dockerfile-path: ./apiserver/Dockerfile.api
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}

  branch_build_push_proxy:
-    if: ${{ needs.branch_build_setup.outputs.build_proxy == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    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
    needs: [branch_build_setup]
-    env:
-      PROXY_TAG: makeplane/plane-proxy:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
    steps:
-      - name: Set Proxy Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-proxy:${{ github.event.release.tag_name }}
-            if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-proxy:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-proxy:latest
-          else
-            TAG=${{ env.PROXY_TAG }}
-          fi
-          echo "PROXY_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
+      - id: checkout_files
+        name: Checkout Files
+        uses: actions/checkout@v4
+      - name: Proxy Build and Push
+        uses: ./.github/actions/build-push-ce
        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
+          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 }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_proxy }}
+          build-context: ./nginx
+          dockerfile-path: ./nginx/Dockerfile
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}

-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
+  attach_assets_to_build:
+    if: ${{ needs.branch_build_setup.outputs.build_type == 'Build' }}
+    name: Attach Assets to Build
+    runs-on: ubuntu-20.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Checkout
        uses: actions/checkout@v4

-      - name: Build and Push Plane-Proxy to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+      - 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:
-          context: ./nginx
-          file: ./nginx/Dockerfile
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          tags: ${{ env.PROXY_TAG }}
-          push: true
+          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
+    needs:
+      [
+        branch_build_setup,
+        branch_build_push_admin,
+        branch_build_push_web,
+        branch_build_push_space,
+        branch_build_push_live,
+        branch_build_push_apiserver,
+        branch_build_push_proxy,
+      ]
+    env:
+      REL_VERSION: ${{ needs.branch_build_setup.outputs.release_version }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Update Assets
+        run: |
+          cp ./deploy/selfhost/install.sh deploy/selfhost/setup.sh
+
+      - name: Create Release
+        id: create_release
+        uses: softprops/action-gh-release@v2.1.0
        env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
+        with:
+          tag_name: ${{ env.REL_VERSION }}
+          name: ${{ env.REL_VERSION }}
+          draft: false
+          prerelease: ${{ env.IS_PRERELEASE }}
+          generate_release_notes: true
+          files: |
+            ${{ 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
@@ -29,11 +29,11 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4

      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
+        uses: github/codeql-action/init@v3
        with:
          languages: ${{ matrix.language }}
          # If you wish to specify custom queries, you can do so here or in a config file.
@@ -46,7 +46,7 @@ jobs:
      # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
      # If this step fails, then you should remove it and run the build manually (see below)
      - name: Autobuild
-        uses: github/codeql-action/autobuild@v2
+        uses: github/codeql-action/autobuild@v3

      # ℹ️ Command-line programs to run using the OS shell.
      # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
@@ -59,6 +59,6 @@ jobs:
      #     ./location_of_script_within_repo/buildscript.sh

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2
+        uses: github/codeql-action/analyze@v3
        with:
          category: "/language:${{matrix.language}}"
@@ -79,7 +79,7 @@ jobs:
        uses: actions/checkout@v4

      - name: Build and Push to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+        uses: docker/build-push-action@v6.9.0
        with:
          context: .
          file: ./aio/Dockerfile-app
@@ -8,21 +8,20 @@ on:

 env:
  CURRENT_BRANCH: ${{ github.ref_name }}
-  TARGET_BRANCH: ${{ vars.SYNC_TARGET_BRANCH_NAME }} # The target branch that you would like to merge changes like develop
+  TARGET_BRANCH: "preview" # The target branch that you would like to merge changes like develop
  GITHUB_TOKEN: ${{ secrets.ACCESS_TOKEN }} # Personal access token required to modify contents and workflows
-  REVIEWER: ${{ vars.SYNC_PR_REVIEWER }}
  ACCOUNT_USER_NAME: ${{ vars.ACCOUNT_USER_NAME }}
  ACCOUNT_USER_EMAIL: ${{ vars.ACCOUNT_USER_EMAIL }}

 jobs:
-  Create_PR:
+  create_pull_request:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: write
    steps:
      - name: Checkout code
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v4
        with:
          fetch-depth: 0 # Fetch all history for all branches and tags

@@ -48,6 +47,6 @@ jobs:
            echo "Pull Request already exists: $PR_EXISTS"
          else
            echo "Creating new pull request"
-            PR_URL=$(gh pr create --base $TARGET_BRANCH --head $CURRENT_BRANCH --title "sync: community changes" --body "")
+            PR_URL=$(gh pr create --base $TARGET_BRANCH --head $CURRENT_BRANCH --title "${{ vars.SYNC_PR_TITLE }}" --body "")
            echo "Pull Request created: $PR_URL"
          fi
@@ -17,7 +17,7 @@ jobs:
      contents: read
    steps:
      - name: Checkout Code
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v4
        with:
          persist-credentials: false
          fetch-depth: 0
@@ -35,9 +35,8 @@ jobs:
        env:
          GH_TOKEN: ${{ secrets.ACCESS_TOKEN }}
        run: |
-          RUN_ID="${{ github.run_id }}"
          TARGET_REPO="${{ vars.SYNC_TARGET_REPO }}"
-          TARGET_BRANCH="sync/${RUN_ID}"
+          TARGET_BRANCH="${{ vars.SYNC_TARGET_BRANCH_NAME }}"
          SOURCE_BRANCH="${{ env.SOURCE_BRANCH_NAME }}"

          git checkout $SOURCE_BRANCH
@@ -5,11 +5,13 @@ import { observer } from "mobx-react";
 import { useTheme as useNextTheme } from "next-themes";
 import { LogOut, UserCog2, Palette } from "lucide-react";
 import { Menu, Transition } from "@headlessui/react";
+// plane ui
 import { Avatar } from "@plane/ui";
-// hooks
-import { API_BASE_URL, cn } from "@/helpers/common.helper";
-import { useTheme, useUser } from "@/hooks/store";
 // helpers
+import { API_BASE_URL, cn } from "@/helpers/common.helper";
+import { getFileURL } from "@/helpers/file.helper";
+// hooks
+import { useTheme, useUser } from "@/hooks/store";
 // services
 import { AuthService } from "@/services/auth.service";

@@ -122,7 +124,7 @@ export const SidebarDropdown = observer(() => {
          <Menu.Button className="grid place-items-center outline-none">
            <Avatar
              name={currentUser.display_name}
-              src={currentUser.avatar ?? undefined}
+              src={getFileURL(currentUser.avatar_url)}
              size={24}
              shape="square"
              className="!text-base"
@@ -0,0 +1,14 @@
+// helpers
+import { API_BASE_URL } from "@/helpers/common.helper";
+
+/**
+ * @description combine the file path with the base URL
+ * @param {string} path
+ * @returns {string} final URL with the base URL
+ */
+export const getFileURL = (path: string): string | undefined => {
+  if (!path) return undefined;
+  const isValidURL = path.startsWith("http");
+  if (isValidURL) return path;
+  return `${API_BASE_URL}${path}`;
+};
@@ -0,0 +1,21 @@
+/**
+ * @description
+ * This function test whether a URL is valid or not.
+ *
+ * It accepts URLs with or without the protocol.
+ * @param {string} url
+ * @returns {boolean}
+ * @example
+ * checkURLValidity("https://example.com") => true
+ * checkURLValidity("example.com") => true
+ * checkURLValidity("example") => false
+ */
+export const checkURLValidity = (url: string): boolean => {
+  if (!url) return false;
+
+  // regex to support complex query parameters and fragments
+  const urlPattern =
+    /^(https?:\/\/)?((([a-z\d-]+\.)*[a-z\d-]+\.[a-z]{2,6})|(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}))(:\d+)?(\/[\w.-]*)*(\?[^#\s]*)?(#[\w-]*)?$/i;
+
+  return urlPattern.test(url);
+};
@@ -1,6 +1,6 @@
 {
  "name": "admin",
-  "version": "0.23.0",
+  "version": "0.23.1",
  "private": true,
  "scripts": {
    "dev": "turbo run develop",
@@ -22,7 +22,6 @@
    "@types/lodash": "^4.17.0",
    "autoprefixer": "10.4.14",
    "axios": "^1.7.4",
-    "js-cookie": "^3.0.5",
    "lodash": "^4.17.21",
    "lucide-react": "^0.356.0",
    "mobx": "^6.12.0",
@@ -41,9 +40,8 @@
  "devDependencies": {
    "@plane/eslint-config": "*",
    "@plane/typescript-config": "*",
-    "@types/js-cookie": "^3.0.6",
    "@types/node": "18.16.1",
-    "@types/react": "^18.2.48",
+    "@types/react": "^18.3.11",
    "@types/react-dom": "^18.2.18",
    "@types/uuid": "^9.0.8",
    "@types/zxcvbn": "^4.4.4",
@@ -57,5 +57,6 @@ ADMIN_BASE_URL=
 SPACE_BASE_URL=
 APP_BASE_URL=

+
 # Hard delete files after days
-HARD_DELETE_AFTER_DAYS=60
+HARD_DELETE_AFTER_DAYS=60
@@ -4,6 +4,7 @@ FROM python:3.12.5-alpine AS backend
 ENV PYTHONDONTWRITEBYTECODE 1
 ENV PYTHONUNBUFFERED 1
 ENV PIP_DISABLE_PIP_VERSION_CHECK=1 
+ENV INSTANCE_CHANGELOG_URL https://api.plane.so/api/public/anchor/8e1c2e4c7bc5493eb7731be3862f6960/pages/

 WORKDIR /code

@@ -4,6 +4,7 @@ FROM python:3.12.5-alpine AS backend
 ENV PYTHONDONTWRITEBYTECODE 1
 ENV PYTHONUNBUFFERED 1
 ENV PIP_DISABLE_PIP_VERSION_CHECK=1 
+ENV INSTANCE_CHANGELOG_URL https://api.plane.so/api/public/anchor/8e1c2e4c7bc5493eb7731be3862f6960/pages/

 RUN apk --no-cache add \
    "bash~=5.2" \
@@ -26,9 +26,7 @@ def update_description():
            updated_issues.append(issue)

        Issue.objects.bulk_update(
-            updated_issues,
-            ["description_html", "description_stripped"],
-            batch_size=100,
+            updated_issues, ["description_html", "description_stripped"], batch_size=100
        )
        print("Success")
    except Exception as e:
@@ -42,9 +40,7 @@ def update_comments():
        updated_issue_comments = []

        for issue_comment in issue_comments:
-            issue_comment.comment_html = (
-                f"<p>{issue_comment.comment_stripped}</p>"
-            )
+            issue_comment.comment_html = f"<p>{issue_comment.comment_stripped}</p>"
            updated_issue_comments.append(issue_comment)

        IssueComment.objects.bulk_update(
@@ -103,9 +99,7 @@ def updated_issue_sort_order():
            issue.sort_order = issue.sequence_id * random.randint(100, 500)
            updated_issues.append(issue)

-        Issue.objects.bulk_update(
-            updated_issues, ["sort_order"], batch_size=100
-        )
+        Issue.objects.bulk_update(updated_issues, ["sort_order"], batch_size=100)
        print("Success")
    except Exception as e:
        print(e)
@@ -143,9 +137,7 @@ def update_project_cover_images():
            project.cover_image = project_cover_images[random.randint(0, 19)]
            updated_projects.append(project)

-        Project.objects.bulk_update(
-            updated_projects, ["cover_image"], batch_size=100
-        )
+        Project.objects.bulk_update(updated_projects, ["cover_image"], batch_size=100)
        print("Success")
    except Exception as e:
        print(e)
@@ -194,9 +186,7 @@ def update_label_color():

 def create_slack_integration():
    try:
-        _ = Integration.objects.create(
-            provider="slack", network=2, title="Slack"
-        )
+        _ = Integration.objects.create(provider="slack", network=2, title="Slack")
        print("Success")
    except Exception as e:
        print(e)
@@ -222,16 +212,12 @@ def update_integration_verified():

 def update_start_date():
    try:
-        issues = Issue.objects.filter(
-            state__group__in=["started", "completed"]
-        )
+        issues = Issue.objects.filter(state__group__in=["started", "completed"])
        updated_issues = []
        for issue in issues:
            issue.start_date = issue.created_at.date()
            updated_issues.append(issue)
-        Issue.objects.bulk_update(
-            updated_issues, ["start_date"], batch_size=500
-        )
+        Issue.objects.bulk_update(updated_issues, ["start_date"], batch_size=500)
        print("Success")
    except Exception as e:
        print(e)
@@ -3,9 +3,7 @@ import os
 import sys

 if __name__ == "__main__":
-    os.environ.setdefault(
-        "DJANGO_SETTINGS_MODULE", "plane.settings.production"
-    )
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "plane.settings.production")
    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
@@ -1,4 +1,4 @@
 {
  "name": "plane-api",
-  "version": "0.23.0"
+  "version": "0.23.1"
 }
@@ -25,10 +25,7 @@ class APIKeyAuthentication(authentication.BaseAuthentication):
    def validate_api_token(self, token):
        try:
            api_token = APIToken.objects.get(
-                Q(
-                    Q(expired_at__gt=timezone.now())
-                    | Q(expired_at__isnull=True)
-                ),
+                Q(Q(expired_at__gt=timezone.now()) | Q(expired_at__isnull=True)),
                token=token,
                is_active=True,
            )
@@ -80,4 +80,4 @@ class ServiceTokenRateThrottle(SimpleRateThrottle):
            request.META["X-RateLimit-Remaining"] = max(0, available)
            request.META["X-RateLimit-Reset"] = reset_time

-        return allowed
+        return allowed
@@ -5,7 +5,6 @@ from .issue import (
    IssueSerializer,
    LabelSerializer,
    IssueLinkSerializer,
-    IssueAttachmentSerializer,
    IssueCommentSerializer,
    IssueAttachmentSerializer,
    IssueActivitySerializer,
@@ -14,9 +13,5 @@ from .issue import (
 )
 from .state import StateLiteSerializer, StateSerializer
 from .cycle import CycleSerializer, CycleIssueSerializer, CycleLiteSerializer
-from .module import (
-    ModuleSerializer,
-    ModuleIssueSerializer,
-    ModuleLiteSerializer,
-)
-from .inbox import InboxIssueSerializer
+from .module import ModuleSerializer, ModuleIssueSerializer, ModuleLiteSerializer
+from .intake import IntakeIssueSerializer
@@ -102,8 +102,6 @@ class BaseSerializer(serializers.ModelSerializer):
                        response[expand] = exp_serializer.data
                    else:
                        # You might need to handle this case differently
-                        response[expand] = getattr(
-                            instance, f"{expand}_id", None
-                        )
+                        response[expand] = getattr(instance, f"{expand}_id", None)

        return response
@@ -23,9 +23,7 @@ class CycleSerializer(BaseSerializer):
            and data.get("end_date", None) is not None
            and data.get("start_date", None) > data.get("end_date", None)
        ):
-            raise serializers.ValidationError(
-                "Start date cannot exceed end date"
-            )
+            raise serializers.ValidationError("Start date cannot exceed end date")
        return data

    class Meta:
@@ -50,11 +48,7 @@ class CycleIssueSerializer(BaseSerializer):
    class Meta:
        model = CycleIssue
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "cycle",
-        ]
+        read_only_fields = ["workspace", "project", "cycle"]


 class CycleLiteSerializer(BaseSerializer):
@@ -1,15 +1,16 @@
 # Module improts
 from .base import BaseSerializer
 from .issue import IssueExpandSerializer
-from plane.db.models import InboxIssue
+from plane.db.models import IntakeIssue
+from rest_framework import serializers


-class InboxIssueSerializer(BaseSerializer):
-
+class IntakeIssueSerializer(BaseSerializer):
    issue_detail = IssueExpandSerializer(read_only=True, source="issue")
+    inbox = serializers.UUIDField(source="intake.id", read_only=True)

    class Meta:
-        model = InboxIssue
+        model = IntakeIssue
        fields = "__all__"
        read_only_fields = [
            "id",
@@ -11,7 +11,7 @@ from plane.db.models import (
    IssueType,
    IssueActivity,
    IssueAssignee,
-    IssueAttachment,
+    FileAsset,
    IssueComment,
    IssueLabel,
    IssueLink,
@@ -31,6 +31,7 @@ from .user import UserLiteSerializer
 from django.core.exceptions import ValidationError
 from django.core.validators import URLValidator

+
 class IssueSerializer(BaseSerializer):
    assignees = serializers.ListField(
        child=serializers.PrimaryKeyRelatedField(
@@ -48,25 +49,13 @@ class IssueSerializer(BaseSerializer):
        required=False,
    )
    type_id = serializers.PrimaryKeyRelatedField(
-        source="type",
-        queryset=IssueType.objects.all(),
-        required=False,
-        allow_null=True,
+        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",
-        ]
+        read_only_fields = ["id", "workspace", "project", "updated_by", "updated_at"]
+        exclude = ["description", "description_stripped"]

    def validate(self, data):
        if (
@@ -74,9 +63,7 @@ class IssueSerializer(BaseSerializer):
            and data.get("target_date", None) is not None
            and data.get("start_date", None) > data.get("target_date", None)
        ):
-            raise serializers.ValidationError(
-                "Start date cannot exceed target date"
-            )
+            raise serializers.ValidationError("Start date cannot exceed target date")

        try:
            if data.get("description_html", None) is not None:
@@ -98,16 +85,14 @@ class IssueSerializer(BaseSerializer):
        # 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"],
+                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,
+                project_id=self.context.get("project_id"), pk=data.get("state").id
            ).exists()
        ):
            raise serializers.ValidationError(
@@ -118,8 +103,7 @@ class IssueSerializer(BaseSerializer):
        if (
            data.get("parent")
            and not Issue.objects.filter(
-                workspace_id=self.context.get("workspace_id"),
-                pk=data.get("parent").id,
+                workspace_id=self.context.get("workspace_id"), pk=data.get("parent").id
            ).exists()
        ):
            raise serializers.ValidationError(
@@ -146,9 +130,7 @@ class IssueSerializer(BaseSerializer):
            issue_type = issue_type

        issue = Issue.objects.create(
-            **validated_data,
-            project_id=project_id,
-            type=issue_type,
+            **validated_data, project_id=project_id, type=issue_type
        )

        # Issue Audit Users
@@ -263,13 +245,9 @@ class IssueSerializer(BaseSerializer):
                ]
        if "labels" in self.fields:
            if "labels" in self.expand:
-                data["labels"] = LabelSerializer(
-                    instance.labels.all(), many=True
-                ).data
+                data["labels"] = LabelSerializer(instance.labels.all(), many=True).data
            else:
-                data["labels"] = [
-                    str(label.id) for label in instance.labels.all()
-                ]
+                data["labels"] = [str(label.id) for label in instance.labels.all()]

        return data

@@ -277,11 +255,7 @@ class IssueSerializer(BaseSerializer):
 class IssueLiteSerializer(BaseSerializer):
    class Meta:
        model = Issue
-        fields = [
-            "id",
-            "sequence_id",
-            "project_id",
-        ]
+        fields = ["id", "sequence_id", "project_id"]
        read_only_fields = fields


@@ -315,7 +289,7 @@ class IssueLinkSerializer(BaseSerializer):
            "created_at",
            "updated_at",
        ]
-    
+
    def validate_url(self, value):
        # Check URL format
        validate_url = URLValidator()
@@ -333,8 +307,7 @@ class IssueLinkSerializer(BaseSerializer):
    # Validation if url already exists
    def create(self, validated_data):
        if IssueLink.objects.filter(
-            url=validated_data.get("url"),
-            issue_id=validated_data.get("issue_id"),
+            url=validated_data.get("url"), issue_id=validated_data.get("issue_id")
        ).exists():
            raise serializers.ValidationError(
                {"error": "URL already exists for this Issue"}
@@ -344,8 +317,7 @@ class IssueLinkSerializer(BaseSerializer):
    def update(self, instance, validated_data):
        if (
            IssueLink.objects.filter(
-                url=validated_data.get("url"),
-                issue_id=instance.issue_id,
+                url=validated_data.get("url"), issue_id=instance.issue_id
            )
            .exclude(pk=instance.id)
            .exists()
@@ -359,7 +331,7 @@ class IssueLinkSerializer(BaseSerializer):

 class IssueAttachmentSerializer(BaseSerializer):
    class Meta:
-        model = IssueAttachment
+        model = FileAsset
        fields = "__all__"
        read_only_fields = [
            "id",
@@ -386,10 +358,7 @@ class IssueCommentSerializer(BaseSerializer):
            "created_at",
            "updated_at",
        ]
-        exclude = [
-            "comment_stripped",
-            "comment_json",
-        ]
+        exclude = ["comment_stripped", "comment_json"]

    def validate(self, data):
        try:
@@ -406,38 +375,27 @@ class IssueCommentSerializer(BaseSerializer):
 class IssueActivitySerializer(BaseSerializer):
    class Meta:
        model = IssueActivity
-        exclude = [
-            "created_by",
-            "updated_by",
-        ]
+        exclude = ["created_by", "updated_by"]


 class CycleIssueSerializer(BaseSerializer):
    cycle = CycleSerializer(read_only=True)

    class Meta:
-        fields = [
-            "cycle",
-        ]
+        fields = ["cycle"]


 class ModuleIssueSerializer(BaseSerializer):
    module = ModuleSerializer(read_only=True)

    class Meta:
-        fields = [
-            "module",
-        ]
+        fields = ["module"]


 class LabelLiteSerializer(BaseSerializer):
    class Meta:
        model = Label
-        fields = [
-            "id",
-            "name",
-            "color",
-        ]
+        fields = ["id", "name", "color"]


 class IssueExpandSerializer(BaseSerializer):
@@ -53,14 +53,11 @@ class ModuleSerializer(BaseSerializer):
            and data.get("target_date", None) is not None
            and data.get("start_date", None) > data.get("target_date", None)
        ):
-            raise serializers.ValidationError(
-                "Start date cannot exceed target date"
-            )
+            raise serializers.ValidationError("Start date cannot exceed target date")

        if data.get("members", []):
            data["members"] = ProjectMember.objects.filter(
-                project_id=self.context.get("project_id"),
-                member_id__in=data["members"],
+                project_id=self.context.get("project_id"), member_id__in=data["members"]
            ).values_list("member_id", flat=True)

        return data
@@ -74,9 +71,7 @@ class ModuleSerializer(BaseSerializer):
        module_name = validated_data.get("name")
        if module_name:
            # Lookup for the module name in the module table for that project
-            if Module.objects.filter(
-                name=module_name, project_id=project_id
-            ).exists():
+            if Module.objects.filter(name=module_name, project_id=project_id).exists():
                raise serializers.ValidationError(
                    {"error": "Module with this name already exists"}
                )
@@ -107,9 +102,7 @@ class ModuleSerializer(BaseSerializer):
        if module_name:
            # Lookup for the module name in the module table for that project
            if (
-                Module.objects.filter(
-                    name=module_name, project=instance.project
-                )
+                Module.objects.filter(name=module_name, project=instance.project)
                .exclude(id=instance.id)
                .exists()
            ):
@@ -172,8 +165,7 @@ class ModuleLinkSerializer(BaseSerializer):
    # Validation if url already exists
    def create(self, validated_data):
        if ModuleLink.objects.filter(
-            url=validated_data.get("url"),
-            module_id=validated_data.get("module_id"),
+            url=validated_data.get("url"), module_id=validated_data.get("module_id")
        ).exists():
            raise serializers.ValidationError(
                {"error": "URL already exists for this Issue"}
@@ -2,11 +2,7 @@
 from rest_framework import serializers

 # Module imports
-from plane.db.models import (
-    Project,
-    ProjectIdentifier,
-    WorkspaceMember,
-)
+from plane.db.models import Project, ProjectIdentifier, WorkspaceMember

 from .base import BaseSerializer

@@ -19,6 +15,8 @@ class ProjectSerializer(BaseSerializer):
    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
@@ -32,6 +30,7 @@ class ProjectSerializer(BaseSerializer):
            "created_by",
            "updated_by",
            "deleted_at",
+            "cover_image_url",
        ]

    def validate(self, data):
@@ -64,16 +63,12 @@ class ProjectSerializer(BaseSerializer):
    def create(self, validated_data):
        identifier = validated_data.get("identifier", "").strip().upper()
        if identifier == "":
-            raise serializers.ValidationError(
-                detail="Project Identifier is required"
-            )
+            raise serializers.ValidationError(detail="Project Identifier is required")

        if ProjectIdentifier.objects.filter(
            name=identifier, workspace_id=self.context["workspace_id"]
        ).exists():
-            raise serializers.ValidationError(
-                detail="Project Identifier is taken"
-            )
+            raise serializers.ValidationError(detail="Project Identifier is taken")

        project = Project.objects.create(
            **validated_data, workspace_id=self.context["workspace_id"]
@@ -87,6 +82,8 @@ class ProjectSerializer(BaseSerializer):


 class ProjectLiteSerializer(BaseSerializer):
+    cover_image_url = serializers.CharField(read_only=True)
+
    class Meta:
        model = Project
        fields = [
@@ -97,5 +94,6 @@ class ProjectLiteSerializer(BaseSerializer):
            "icon_prop",
            "emoji",
            "description",
+            "cover_image_url",
        ]
        read_only_fields = fields
@@ -7,9 +7,9 @@ class StateSerializer(BaseSerializer):
    def validate(self, data):
        # If the default is being provided then make all other states default False
        if data.get("default", False):
-            State.objects.filter(
-                project_id=self.context.get("project_id")
-            ).update(default=False)
+            State.objects.filter(project_id=self.context.get("project_id")).update(
+                default=False
+            )
        return data

    class Meta:
@@ -30,10 +30,5 @@ class StateSerializer(BaseSerializer):
 class StateLiteSerializer(BaseSerializer):
    class Meta:
        model = State
-        fields = [
-            "id",
-            "name",
-            "color",
-            "group",
-        ]
+        fields = ["id", "name", "color", "group"]
        read_only_fields = fields
@@ -13,6 +13,7 @@ class UserLiteSerializer(BaseSerializer):
            "last_name",
            "email",
            "avatar",
+            "avatar_url",
            "display_name",
            "email",
        ]
@@ -8,9 +8,5 @@ class WorkspaceLiteSerializer(BaseSerializer):

    class Meta:
        model = Workspace
-        fields = [
-            "name",
-            "slug",
-            "id",
-        ]
+        fields = ["name", "slug", "id"]
        read_only_fields = fields
@@ -3,7 +3,7 @@ from .state import urlpatterns as state_patterns
 from .issue import urlpatterns as issue_patterns
 from .cycle import urlpatterns as cycle_patterns
 from .module import urlpatterns as module_patterns
-from .inbox import urlpatterns as inbox_patterns
+from .intake import urlpatterns as intake_patterns
 from .member import urlpatterns as member_patterns

 urlpatterns = [
@@ -12,6 +12,6 @@ urlpatterns = [
    *issue_patterns,
    *cycle_patterns,
    *module_patterns,
-    *inbox_patterns,
+    *intake_patterns,
    *member_patterns,
 ]
@@ -1,17 +0,0 @@
-from django.urls import path
-
-from plane.api.views import InboxIssueAPIEndpoint
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
-        InboxIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:issue_id>/",
-        InboxIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
-]
@@ -0,0 +1,27 @@
+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,13 +1,11 @@
 from django.urls import path

-from plane.api.views import (
-    ProjectMemberAPIEndpoint,
-)
+from plane.api.views import ProjectMemberAPIEndpoint

 urlpatterns = [
    path(
        "workspaces/<str:slug>/projects/<str:project_id>/members/",
        ProjectMemberAPIEndpoint.as_view(),
        name="users",
-    ),
+    )
 ]
@@ -1,15 +1,10 @@
 from django.urls import path

-from plane.api.views import (
-    ProjectAPIEndpoint,
-    ProjectArchiveUnarchiveAPIEndpoint,
-)
+from plane.api.views import ProjectAPIEndpoint, ProjectArchiveUnarchiveAPIEndpoint

 urlpatterns = [
    path(
-        "workspaces/<str:slug>/projects/",
-        ProjectAPIEndpoint.as_view(),
-        name="project",
+        "workspaces/<str:slug>/projects/", ProjectAPIEndpoint.as_view(), name="project"
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:pk>/",
@@ -27,5 +27,4 @@ from .module import (

 from .member import ProjectMemberAPIEndpoint

-from .inbox import InboxIssueAPIEndpoint
-
+from .intake import IntakeIssueAPIEndpoint
@@ -37,13 +37,9 @@ class TimezoneMixin:


 class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
-    authentication_classes = [
-        APIKeyAuthentication,
-    ]
+    authentication_classes = [APIKeyAuthentication]

-    permission_classes = [
-        IsAuthenticated,
-    ]
+    permission_classes = [IsAuthenticated]

    def filter_queryset(self, queryset):
        for backend in list(self.filter_backends):
@@ -56,8 +52,7 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):

        if api_key:
            service_token = APIToken.objects.filter(
-                token=api_key,
-                is_service=True,
+                token=api_key, is_service=True
            ).first()

            if service_token:
@@ -123,9 +118,7 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):

    def finalize_response(self, request, response, *args, **kwargs):
        # Call super to get the default response
-        response = super().finalize_response(
-            request, response, *args, **kwargs
-        )
+        response = super().finalize_response(request, response, *args, **kwargs)

        # Add custom headers if they exist in the request META
        ratelimit_remaining = request.META.get("X-RateLimit-Remaining")
@@ -154,17 +147,13 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
    @property
    def fields(self):
        fields = [
-            field
-            for field in self.request.GET.get("fields", "").split(",")
-            if field
+            field for field in self.request.GET.get("fields", "").split(",") if field
        ]
        return fields if fields else None

    @property
    def expand(self):
        expand = [
-            expand
-            for expand in self.request.GET.get("expand", "").split(",")
-            if expand
+            expand for expand in self.request.GET.get("expand", "").split(",") if expand
        ]
-        return expand if expand else None
+        return expand if expand else None
@@ -13,18 +13,19 @@ from django.db.models import (
    Q,
    Sum,
    FloatField,
+    Case,
+    When,
+    Value,
 )
-from django.db.models.functions import Cast
+from django.db.models.functions import Cast, Concat
+from django.db import models

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

 # Module imports
-from plane.api.serializers import (
-    CycleIssueSerializer,
-    CycleSerializer,
-)
+from plane.api.serializers import CycleIssueSerializer, CycleSerializer
 from plane.app.permissions import ProjectEntityPermission
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.db.models import (
@@ -32,7 +33,7 @@ from plane.db.models import (
    CycleIssue,
    Issue,
    Project,
-    IssueAttachment,
+    FileAsset,
    IssueLink,
    ProjectMember,
    UserFavorite,
@@ -53,9 +54,7 @@ class CycleAPIEndpoint(BaseAPIView):
    serializer_class = CycleSerializer
    model = Cycle
    webhook_event = "cycle"
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]

    def get_queryset(self):
        return (
@@ -74,6 +73,7 @@ class CycleAPIEndpoint(BaseAPIView):
                    filter=Q(
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -84,6 +84,7 @@ class CycleAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="completed",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -94,6 +95,7 @@ class CycleAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="cancelled",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -104,6 +106,7 @@ class CycleAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="started",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -114,6 +117,7 @@ class CycleAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="unstarted",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -124,6 +128,7 @@ class CycleAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="backlog",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -133,26 +138,18 @@ class CycleAPIEndpoint(BaseAPIView):

    def get(self, request, slug, project_id, pk=None):
        if pk:
-            queryset = (
-                self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
-            )
+            queryset = self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
            data = CycleSerializer(
-                queryset,
-                fields=self.fields,
-                expand=self.expand,
+                queryset, fields=self.fields, expand=self.expand
            ).data
-            return Response(
-                data,
-                status=status.HTTP_200_OK,
-            )
+            return Response(data, status=status.HTTP_200_OK)
        queryset = self.get_queryset().filter(archived_at__isnull=True)
        cycle_view = request.GET.get("cycle_view", "all")

        # Current Cycle
        if cycle_view == "current":
            queryset = queryset.filter(
-                start_date__lte=timezone.now(),
-                end_date__gte=timezone.now(),
+                start_date__lte=timezone.now(), end_date__gte=timezone.now()
            )
            data = CycleSerializer(
                queryset, many=True, fields=self.fields, expand=self.expand
@@ -166,10 +163,7 @@ class CycleAPIEndpoint(BaseAPIView):
                request=request,
                queryset=(queryset),
                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
+                    cycles, many=True, fields=self.fields, expand=self.expand
                ).data,
            )

@@ -180,54 +174,38 @@ class CycleAPIEndpoint(BaseAPIView):
                request=request,
                queryset=(queryset),
                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
+                    cycles, many=True, fields=self.fields, expand=self.expand
                ).data,
            )

        # Draft Cycles
        if cycle_view == "draft":
-            queryset = queryset.filter(
-                end_date=None,
-                start_date=None,
-            )
+            queryset = queryset.filter(end_date=None, start_date=None)
            return self.paginate(
                request=request,
                queryset=(queryset),
                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
+                    cycles, many=True, fields=self.fields, expand=self.expand
                ).data,
            )

        # Incomplete Cycles
        if cycle_view == "incomplete":
            queryset = queryset.filter(
-                Q(end_date__gte=timezone.now())
-                | Q(end_date__isnull=True),
+                Q(end_date__gte=timezone.now()) | Q(end_date__isnull=True)
            )
            return self.paginate(
                request=request,
                queryset=(queryset),
                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
+                    cycles, many=True, fields=self.fields, expand=self.expand
                ).data,
            )
        return self.paginate(
            request=request,
            queryset=(queryset),
            on_results=lambda cycles: CycleSerializer(
-                cycles,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
+                cycles, many=True, fields=self.fields, expand=self.expand
            ).data,
        )

@@ -264,10 +242,7 @@ class CycleAPIEndpoint(BaseAPIView):
                        },
                        status=status.HTTP_409_CONFLICT,
                    )
-                serializer.save(
-                    project_id=project_id,
-                    owned_by=request.user,
-                )
+                serializer.save(project_id=project_id, owned_by=request.user)
                # Send the model activity
                model_activity.delay(
                    model_name="cycle",
@@ -278,12 +253,8 @@ class CycleAPIEndpoint(BaseAPIView):
                    slug=slug,
                    origin=request.META.get("HTTP_ORIGIN"),
                )
-                return Response(
-                    serializer.data, status=status.HTTP_201_CREATED
-                )
-            return Response(
-                serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            )
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        else:
            return Response(
                {
@@ -293,9 +264,7 @@ class CycleAPIEndpoint(BaseAPIView):
            )

    def patch(self, request, slug, project_id, pk):
-        cycle = Cycle.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=pk
-        )
+        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)

        current_instance = json.dumps(
            CycleSerializer(cycle).data, cls=DjangoJSONEncoder
@@ -309,16 +278,11 @@ class CycleAPIEndpoint(BaseAPIView):

        request_data = request.data

-        if (
-            cycle.end_date is not None
-            and cycle.end_date < timezone.now()
-        ):
+        if cycle.end_date is not None and cycle.end_date < timezone.now():
            if "sort_order" in request_data:
                # Can only change sort order
                request_data = {
-                    "sort_order": request_data.get(
-                        "sort_order", cycle.sort_order
-                    )
+                    "sort_order": request_data.get("sort_order", cycle.sort_order)
                }
            else:
                return Response(
@@ -365,9 +329,7 @@ class CycleAPIEndpoint(BaseAPIView):
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def delete(self, request, slug, project_id, pk):
-        cycle = Cycle.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=pk
-        )
+        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
        if cycle.owned_by_id != request.user.id and (
            not ProjectMember.objects.filter(
                workspace__slug=slug,
@@ -383,9 +345,9 @@ class CycleAPIEndpoint(BaseAPIView):
            )

        cycle_issues = list(
-            CycleIssue.objects.filter(
-                cycle_id=self.kwargs.get("pk")
-            ).values_list("issue", flat=True)
+            CycleIssue.objects.filter(cycle_id=self.kwargs.get("pk")).values_list(
+                "issue", flat=True
+            )
        )

        issue_activity.delay(
@@ -405,23 +367,15 @@ class CycleAPIEndpoint(BaseAPIView):
        )
        # Delete the cycle
        cycle.delete()
-        # Delete the cycle issues
-        CycleIssue.objects.filter(
-            cycle_id=self.kwargs.get("pk"),
-        ).delete()
        # Delete the user favorite cycle
        UserFavorite.objects.filter(
-            entity_type="cycle",
-            entity_identifier=pk,
-            project_id=project_id,
+            entity_type="cycle", entity_identifier=pk, project_id=project_id
        ).delete()
        return Response(status=status.HTTP_204_NO_CONTENT)


 class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]

    def get_queryset(self):
        return (
@@ -441,6 +395,7 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                    filter=Q(
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -451,6 +406,7 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="completed",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -461,6 +417,7 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="cancelled",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -471,6 +428,7 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="started",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -481,6 +439,7 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="unstarted",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -491,12 +450,11 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="backlog",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
-            .annotate(
-                total_estimates=Sum("issue_cycle__issue__estimate_point")
-            )
+            .annotate(total_estimates=Sum("issue_cycle__issue__estimate_point"))
            .annotate(
                completed_estimates=Sum(
                    "issue_cycle__issue__estimate_point",
@@ -504,6 +462,7 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="completed",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -514,6 +473,7 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="started",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -526,10 +486,7 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
            request=request,
            queryset=(self.get_queryset()),
            on_results=lambda cycles: CycleSerializer(
-                cycles,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
+                cycles, many=True, fields=self.fields, expand=self.expand
            ).data,
        )

@@ -572,16 +529,12 @@ class CycleIssueAPIEndpoint(BaseAPIView):
    model = CycleIssue
    webhook_event = "cycle_issue"
    bulk = True
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]

    def get_queryset(self):
        return (
            CycleIssue.objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("issue_id")
-                )
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("issue_id"))
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
@@ -619,11 +572,11 @@ class CycleIssueAPIEndpoint(BaseAPIView):
        # List
        order_by = request.GET.get("order_by", "created_at")
        issues = (
-            Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
+            Issue.issue_objects.filter(
+                issue_cycle__cycle_id=cycle_id, issue_cycle__deleted_at__isnull=True
+            )
            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
@@ -645,8 +598,9 @@ class CycleIssueAPIEndpoint(BaseAPIView):
                .values("count")
            )
            .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                )
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
@@ -658,10 +612,7 @@ class CycleIssueAPIEndpoint(BaseAPIView):
            request=request,
            queryset=(issues),
            on_results=lambda issues: CycleSerializer(
-                issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
+                issues, many=True, fields=self.fields, expand=self.expand
            ).data,
        )

@@ -670,8 +621,7 @@ class CycleIssueAPIEndpoint(BaseAPIView):

        if not issues:
            return Response(
-                {"error": "Issues are required"},
-                status=status.HTTP_400_BAD_REQUEST,
+                {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
            )

        cycle = Cycle.objects.get(
@@ -680,9 +630,7 @@ class CycleIssueAPIEndpoint(BaseAPIView):

        # Get all CycleIssues already created
        cycle_issues = list(
-            CycleIssue.objects.filter(
-                ~Q(cycle_id=cycle_id), issue_id__in=issues
-            )
+            CycleIssue.objects.filter(~Q(cycle_id=cycle_id), issue_id__in=issues)
        )

        existing_issues = [
@@ -727,9 +675,7 @@ class CycleIssueAPIEndpoint(BaseAPIView):
            )

        # Update the cycle issues
-        CycleIssue.objects.bulk_update(
-            updated_records, ["cycle_id"], batch_size=100
-        )
+        CycleIssue.objects.bulk_update(updated_records, ["cycle_id"], batch_size=100)

        # Capture Issue Activity
        issue_activity.delay(
@@ -788,9 +734,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):

    """

-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]

    def post(self, request, slug, project_id, cycle_id):
        new_cycle_id = request.data.get("new_cycle_id", False)
@@ -815,6 +759,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                    filter=Q(
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -825,6 +770,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="completed",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -835,6 +781,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="cancelled",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -845,6 +792,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="started",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -855,6 +803,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="unstarted",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -865,6 +814,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                        issue_cycle__issue__state__group="backlog",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -881,18 +831,37 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
            assignee_estimate_data = (
                Issue.issue_objects.filter(
                    issue_cycle__cycle_id=cycle_id,
+                    issue_cycle__deleted_at__isnull=True,
                    workspace__slug=slug,
                    project_id=project_id,
                )
                .annotate(display_name=F("assignees__display_name"))
                .annotate(assignee_id=F("assignees__id"))
                .annotate(avatar=F("assignees__avatar"))
-                .values("display_name", "assignee_id", "avatar")
                .annotate(
-                    total_estimates=Sum(
-                        Cast("estimate_point__value", FloatField())
+                    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("display_name", "assignee_id", "avatar", "avatar_url")
+                .annotate(
+                    total_estimates=Sum(Cast("estimate_point__value", FloatField()))
+                )
                .annotate(
                    completed_estimates=Sum(
                        Cast("estimate_point__value", FloatField()),
@@ -920,11 +889,10 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                {
                    "display_name": item["display_name"],
                    "assignee_id": (
-                        str(item["assignee_id"])
-                        if item["assignee_id"]
-                        else None
+                        str(item["assignee_id"]) if item["assignee_id"] else None
                    ),
-                    "avatar": item["avatar"],
+                    "avatar": item.get("avatar", None),
+                    "avatar_url": item.get("avatar_url", None),
                    "total_estimates": item["total_estimates"],
                    "completed_estimates": item["completed_estimates"],
                    "pending_estimates": item["pending_estimates"],
@@ -935,6 +903,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
            label_distribution_data = (
                Issue.issue_objects.filter(
                    issue_cycle__cycle_id=cycle_id,
+                    issue_cycle__deleted_at__isnull=True,
                    workspace__slug=slug,
                    project_id=project_id,
                )
@@ -943,9 +912,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                .annotate(label_id=F("labels__id"))
                .values("label_name", "color", "label_id")
                .annotate(
-                    total_estimates=Sum(
-                        Cast("estimate_point__value", FloatField())
-                    )
+                    total_estimates=Sum(Cast("estimate_point__value", FloatField()))
                )
                .annotate(
                    completed_estimates=Sum(
@@ -982,9 +949,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                {
                    "label_name": item["label_name"],
                    "color": item["color"],
-                    "label_id": (
-                        str(item["label_id"]) if item["label_id"] else None
-                    ),
+                    "label_id": (str(item["label_id"]) if item["label_id"] else None),
                    "total_estimates": item["total_estimates"],
                    "completed_estimates": item["completed_estimates"],
                    "pending_estimates": item["pending_estimates"],
@@ -996,21 +961,37 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
        assignee_distribution = (
            Issue.issue_objects.filter(
                issue_cycle__cycle_id=cycle_id,
+                issue_cycle__deleted_at__isnull=True,
                workspace__slug=slug,
                project_id=project_id,
            )
            .annotate(display_name=F("assignees__display_name"))
            .annotate(assignee_id=F("assignees__id"))
            .annotate(avatar=F("assignees__avatar"))
-            .values("display_name", "assignee_id", "avatar")
+            .annotate(
+                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("display_name", "assignee_id", "avatar_url")
            .annotate(
                total_issues=Count(
-                    "id",
-                    filter=Q(
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                ),
+                    "id", filter=Q(archived_at__isnull=True, is_draft=False)
+                )
            )
            .annotate(
                completed_issues=Count(
@@ -1041,7 +1022,8 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                "assignee_id": (
                    str(item["assignee_id"]) if item["assignee_id"] else None
                ),
-                "avatar": item["avatar"],
+                "avatar": item.get("avatar", None),
+                "avatar_url": item.get("avatar_url", None),
                "total_issues": item["total_issues"],
                "completed_issues": item["completed_issues"],
                "pending_issues": item["pending_issues"],
@@ -1053,6 +1035,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
        label_distribution = (
            Issue.issue_objects.filter(
                issue_cycle__cycle_id=cycle_id,
+                issue_cycle__deleted_at__isnull=True,
                workspace__slug=slug,
                project_id=project_id,
            )
@@ -1062,12 +1045,8 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
            .values("label_name", "color", "label_id")
            .annotate(
                total_issues=Count(
-                    "id",
-                    filter=Q(
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                ),
+                    "id", filter=Q(archived_at__isnull=True, is_draft=False)
+                )
            )
            .annotate(
                completed_issues=Count(
@@ -1097,9 +1076,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
            {
                "label_name": item["label_name"],
                "color": item["color"],
-                "label_id": (
-                    str(item["label_id"]) if item["label_id"] else None
-                ),
+                "label_id": (str(item["label_id"]) if item["label_id"] else None),
                "total_issues": item["total_issues"],
                "completed_issues": item["completed_issues"],
                "pending_issues": item["pending_issues"],
@@ -1144,10 +1121,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
        }
        current_cycle.save(update_fields=["progress_snapshot"])

-        if (
-            new_cycle.end_date is not None
-            and new_cycle.end_date < timezone.now()
-        ):
+        if new_cycle.end_date is not None and new_cycle.end_date < timezone.now():
            return Response(
                {
                    "error": "The cycle where the issues are transferred is already completed"
@@ -14,60 +14,47 @@ from rest_framework import status
 from rest_framework.response import Response

 # Module imports
-from plane.api.serializers import InboxIssueSerializer, IssueSerializer
+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 (
-    Inbox,
-    InboxIssue,
-    Issue,
-    Project,
-    ProjectMember,
-    State,
-)
+from plane.db.models import Intake, IntakeIssue, Issue, Project, ProjectMember, State

 from .base import BaseAPIView


-class InboxIssueAPIEndpoint(BaseAPIView):
+class IntakeIssueAPIEndpoint(BaseAPIView):
    """
    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to inbox issues.
+    `update` and `destroy` actions related to intake issues.

    """

-    permission_classes = [
-        ProjectLitePermission,
-    ]
+    permission_classes = [ProjectLitePermission]

-    serializer_class = InboxIssueSerializer
-    model = InboxIssue
+    serializer_class = IntakeIssueSerializer
+    model = IntakeIssue

-    filterset_fields = [
-        "status",
-    ]
+    filterset_fields = ["status"]

    def get_queryset(self):
-        inbox = Inbox.objects.filter(
+        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"),
+            workspace__slug=self.kwargs.get("slug"), pk=self.kwargs.get("project_id")
        )

-        if inbox is None and not project.inbox_view:
-            return InboxIssue.objects.none()
+        if intake is None and not project.intake_view:
+            return IntakeIssue.objects.none()

        return (
-            InboxIssue.objects.filter(
-                Q(snoozed_till__gte=timezone.now())
-                | Q(snoozed_till__isnull=True),
+            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"),
-                inbox_id=inbox.id,
+                intake_id=intake.id,
            )
            .select_related("issue", "workspace", "project")
            .order_by(self.kwargs.get("order_by", "-created_at"))
@@ -75,49 +62,37 @@ class InboxIssueAPIEndpoint(BaseAPIView):

    def get(self, request, slug, project_id, issue_id=None):
        if issue_id:
-            inbox_issue_queryset = self.get_queryset().get(issue_id=issue_id)
-            inbox_issue_data = InboxIssueSerializer(
-                inbox_issue_queryset,
-                fields=self.fields,
-                expand=self.expand,
+            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(
-                inbox_issue_data,
-                status=status.HTTP_200_OK,
-            )
+            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 inbox_issues: InboxIssueSerializer(
-                inbox_issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
+            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,
+                {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
            )

-        inbox = Inbox.objects.filter(
+        intake = Intake.objects.filter(
            workspace__slug=slug, project_id=project_id
        ).first()

-        project = Project.objects.get(
-            workspace__slug=slug,
-            pk=project_id,
-        )
+        project = Project.objects.get(workspace__slug=slug, pk=project_id)

-        # Inbox view
-        if inbox is None and not project.inbox_view:
+        # Intake view
+        if intake is None and not project.intake_view:
            return Response(
                {
-                    "error": "Inbox is not enabled for this project enable it through the project's api"
+                    "error": "Intake is not enabled for this project enable it through the project's api"
                },
                status=status.HTTP_400_BAD_REQUEST,
            )
@@ -131,15 +106,14 @@ class InboxIssueAPIEndpoint(BaseAPIView):
            "none",
        ]:
            return Response(
-                {"error": "Invalid priority"},
-                status=status.HTTP_400_BAD_REQUEST,
+                {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
            )

        # Create or get state
        state, _ = State.objects.get_or_create(
            name="Triage",
            group="triage",
-            description="Default state for managing all Inbox Issues",
+            description="Default state for managing all Intake Issues",
            project_id=project_id,
            color="#ff7700",
            is_triage=True,
@@ -157,12 +131,12 @@ class InboxIssueAPIEndpoint(BaseAPIView):
            state=state,
        )

-        # create an inbox issue
-        inbox_issue = InboxIssue.objects.create(
-            inbox_id=inbox.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"),
+            source=request.data.get("source", "IN-APP"),
        )
        # Create an Issue Activity
        issue_activity.delay(
@@ -173,32 +147,34 @@ class InboxIssueAPIEndpoint(BaseAPIView):
            project_id=str(project_id),
            current_instance=None,
            epoch=int(timezone.now().timestamp()),
-            inbox=str(inbox_issue.id),
+            intake=str(intake_issue.id),
        )

-        serializer = InboxIssueSerializer(inbox_issue)
+        serializer = IntakeIssueSerializer(intake_issue)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def patch(self, request, slug, project_id, issue_id):
-        inbox = Inbox.objects.filter(
+        intake = Intake.objects.filter(
            workspace__slug=slug, project_id=project_id
        ).first()

-        # Inbox view
-        if inbox is None:
+        project = Project.objects.get(workspace__slug=slug, pk=project_id)
+
+        # Intake view
+        if intake is None and not project.intake_view:
            return Response(
                {
-                    "error": "Inbox is not enabled for this project enable it through the project's api"
+                    "error": "Intake is not enabled for this project enable it through the project's api"
                },
                status=status.HTTP_400_BAD_REQUEST,
            )

-        # Get the inbox issue
-        inbox_issue = InboxIssue.objects.get(
+        # Get the intake issue
+        intake_issue = IntakeIssue.objects.get(
            issue_id=issue_id,
            workspace__slug=slug,
            project_id=project_id,
-            inbox_id=inbox.id,
+            intake_id=intake.id,
        )

        # Get the project member
@@ -210,11 +186,11 @@ class InboxIssueAPIEndpoint(BaseAPIView):
        )

        # Only project members admins and created_by users can access this endpoint
-        if project_member.role <= 5 and str(inbox_issue.created_by_id) != str(
+        if project_member.role <= 5 and str(intake_issue.created_by_id) != str(
            request.user.id
        ):
            return Response(
-                {"error": "You cannot edit inbox issues"},
+                {"error": "You cannot edit intake issues"},
                status=status.HTTP_400_BAD_REQUEST,
            )

@@ -227,7 +203,10 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                    ArrayAgg(
                        "labels__id",
                        distinct=True,
-                        filter=~Q(labels__id__isnull=True),
+                        filter=Q(
+                            ~Q(labels__id__isnull=True)
+                            & Q(label_issue__deleted_at__isnull=True)
+                        ),
                    ),
                    Value([], output_field=ArrayField(UUIDField())),
                ),
@@ -235,15 +214,15 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                    ArrayAgg(
                        "assignees__id",
                        distinct=True,
-                        filter=~Q(assignees__id__isnull=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,
-            )
+            ).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 = {
@@ -251,14 +230,10 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                    "description_html": issue_data.get(
                        "description_html", issue.description_html
                    ),
-                    "description": issue_data.get(
-                        "description", issue.description
-                    ),
+                    "description": issue_data.get("description", issue.description),
                }

-            issue_serializer = IssueSerializer(
-                issue, data=issue_data, partial=True
-            )
+            issue_serializer = IssueSerializer(issue, data=issue_data, partial=True)

            if issue_serializer.is_valid():
                current_instance = issue
@@ -276,7 +251,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                            cls=DjangoJSONEncoder,
                        ),
                        epoch=int(timezone.now().timestamp()),
-                        inbox=(inbox_issue.id),
+                        intake=(intake_issue.id),
                    )
                issue_serializer.save()
            else:
@@ -284,13 +259,13 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                    issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
                )

-        # Only project admins and members can edit inbox issue attributes
-        if project_member.role > 5:
-            serializer = InboxIssueSerializer(
-                inbox_issue, data=request.data, partial=True
+        # 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(
-                InboxIssueSerializer(inbox_issue).data, cls=DjangoJSONEncoder
+                IntakeIssueSerializer(intake_issue).data, cls=DjangoJSONEncoder
            )

            if serializer.is_valid():
@@ -298,14 +273,10 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                # 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,
+                        pk=issue_id, workspace__slug=slug, project_id=project_id
                    )
                    state = State.objects.filter(
-                        group="cancelled",
-                        workspace__slug=slug,
-                        project_id=project_id,
+                        group="cancelled", workspace__slug=slug, project_id=project_id
                    ).first()
                    if state is not None:
                        issue.state = state
@@ -314,18 +285,14 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                # 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,
+                        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,
+                            workspace__slug=slug, project_id=project_id, default=True
                        ).first()
                        if state is not None:
                            issue.state = state
@@ -333,10 +300,8 @@ class InboxIssueAPIEndpoint(BaseAPIView):

                # create a activity for status change
                issue_activity.delay(
-                    type="inbox.activity.created",
-                    requested_data=json.dumps(
-                        request.data, cls=DjangoJSONEncoder
-                    ),
+                    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),
@@ -344,48 +309,42 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                    epoch=int(timezone.now().timestamp()),
                    notification=False,
                    origin=request.META.get("HTTP_ORIGIN"),
-                    inbox=str(inbox_issue.id),
+                    intake=str(intake_issue.id),
                )

                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(
-                serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            )
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        else:
            return Response(
-                InboxIssueSerializer(inbox_issue).data,
-                status=status.HTTP_200_OK,
+                IntakeIssueSerializer(intake_issue).data, status=status.HTTP_200_OK
            )

    def delete(self, request, slug, project_id, issue_id):
-        inbox = Inbox.objects.filter(
+        intake = Intake.objects.filter(
            workspace__slug=slug, project_id=project_id
        ).first()

-        project = Project.objects.get(
-            workspace__slug=slug,
-            pk=project_id,
-        )
+        project = Project.objects.get(workspace__slug=slug, pk=project_id)

-        # Inbox view
-        if inbox is None and not project.inbox_view:
+        # Intake view
+        if intake is None and not project.intake_view:
            return Response(
                {
-                    "error": "Inbox is not enabled for this project enable it through the project's api"
+                    "error": "Intake is not enabled for this project enable it through the project's api"
                },
                status=status.HTTP_400_BAD_REQUEST,
            )

-        # Get the inbox issue
-        inbox_issue = InboxIssue.objects.get(
+        # Get the intake issue
+        intake_issue = IntakeIssue.objects.get(
            issue_id=issue_id,
            workspace__slug=slug,
            project_id=project_id,
-            inbox_id=inbox.id,
+            intake_id=intake.id,
        )

        # Check the issue status
-        if inbox_issue.status in [-2, -1, 0, 2]:
+        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
@@ -405,5 +364,5 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                )
            issue.delete()

-        inbox_issue.delete()
+        intake_issue.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -16,6 +16,7 @@ from django.db.models import (
    Q,
    Value,
    When,
+    Subquery,
 )
 from django.utils import timezone

@@ -42,12 +43,13 @@ from plane.bgtasks.issue_activities_task import issue_activity
 from plane.db.models import (
    Issue,
    IssueActivity,
-    IssueAttachment,
+    FileAsset,
    IssueComment,
    IssueLink,
    Label,
    Project,
    ProjectMember,
+    CycleIssue,
 )

 from .base import BaseAPIView
@@ -71,9 +73,7 @@ class WorkspaceIssueAPIEndpoint(BaseAPIView):
    def get_queryset(self):
        return (
            Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
@@ -89,14 +89,10 @@ class WorkspaceIssueAPIEndpoint(BaseAPIView):
            .order_by(self.kwargs.get("order_by", "-created_at"))
        ).distinct()

-    def get(
-        self, request, slug, project__identifier=None, issue__identifier=None
-    ):
+    def get(self, request, slug, project__identifier=None, issue__identifier=None):
        if issue__identifier and project__identifier:
            issue = Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
@@ -106,11 +102,7 @@ class WorkspaceIssueAPIEndpoint(BaseAPIView):
                sequence_id=issue__identifier,
            )
            return Response(
-                IssueSerializer(
-                    issue,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
+                IssueSerializer(issue, fields=self.fields, expand=self.expand).data,
                status=status.HTTP_200_OK,
            )

@@ -124,17 +116,13 @@ class IssueAPIEndpoint(BaseAPIView):

    model = Issue
    webhook_event = "issue"
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]
    serializer_class = IssueSerializer

    def get_queryset(self):
        return (
            Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
@@ -162,47 +150,37 @@ class IssueAPIEndpoint(BaseAPIView):
                project_id=project_id,
            )
            return Response(
-                IssueSerializer(
-                    issue,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
+                IssueSerializer(issue, fields=self.fields, expand=self.expand).data,
                status=status.HTTP_200_OK,
            )

        if pk:
            issue = Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
            ).get(workspace__slug=slug, project_id=project_id, pk=pk)
            return Response(
-                IssueSerializer(
-                    issue,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
+                IssueSerializer(issue, fields=self.fields, expand=self.expand).data,
                status=status.HTTP_200_OK,
            )

        # Custom ordering for priority and state
        priority_order = ["urgent", "high", "medium", "low", "none"]
-        state_order = [
-            "backlog",
-            "unstarted",
-            "started",
-            "completed",
-            "cancelled",
-        ]
+        state_order = ["backlog", "unstarted", "started", "completed", "cancelled"]

        order_by_param = request.GET.get("order_by", "-created_at")

        issue_queryset = (
            self.get_queryset()
-            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .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()
@@ -210,8 +188,9 @@ class IssueAPIEndpoint(BaseAPIView):
                .values("count")
            )
            .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                )
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
@@ -222,9 +201,7 @@ class IssueAPIEndpoint(BaseAPIView):
        # Priority Ordering
        if order_by_param == "priority" or order_by_param == "-priority":
            priority_order = (
-                priority_order
-                if order_by_param == "priority"
-                else priority_order[::-1]
+                priority_order if order_by_param == "priority" else priority_order[::-1]
            )
            issue_queryset = issue_queryset.annotate(
                priority_order=Case(
@@ -272,9 +249,7 @@ class IssueAPIEndpoint(BaseAPIView):
                    else order_by_param
                )
            ).order_by(
-                "-max_values"
-                if order_by_param.startswith("-")
-                else "max_values"
+                "-max_values" if order_by_param.startswith("-") else "max_values"
            )
        else:
            issue_queryset = issue_queryset.order_by(order_by_param)
@@ -283,10 +258,7 @@ class IssueAPIEndpoint(BaseAPIView):
            request=request,
            queryset=(issue_queryset),
            on_results=lambda issues: IssueSerializer(
-                issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
+                issues, many=True, fields=self.fields, expand=self.expand
            ).data,
        )

@@ -330,22 +302,16 @@ class IssueAPIEndpoint(BaseAPIView):
            serializer.save()
            # Refetch the issue
            issue = Issue.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                pk=serializer.data["id"],
+                workspace__slug=slug, project_id=project_id, pk=serializer.data["id"]
            ).first()
            issue.created_at = request.data.get("created_at", timezone.now())
-            issue.created_by_id = request.data.get(
-                "created_by", request.user.id
-            )
+            issue.created_by_id = request.data.get("created_by", request.user.id)
            issue.save(update_fields=["created_at", "created_by"])

            # Track the issue
            issue_activity.delay(
                type="issue.activity.created",
-                requested_data=json.dumps(
-                    self.request.data, cls=DjangoJSONEncoder
-                ),
+                requested_data=json.dumps(self.request.data, cls=DjangoJSONEncoder),
                actor_id=str(request.user.id),
                issue_id=str(serializer.data.get("id", None)),
                project_id=str(project_id),
@@ -382,9 +348,7 @@ class IssueAPIEndpoint(BaseAPIView):

                # Get the requested data, encode it as django object and pass it
                # to serializer to validation
-                requested_data = json.dumps(
-                    self.request.data, cls=DjangoJSONEncoder
-                )
+                requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
                serializer = IssueSerializer(
                    issue,
                    data=request.data,
@@ -442,9 +406,7 @@ class IssueAPIEndpoint(BaseAPIView):
                    # If any of the created_at or created_by is present, update
                    # the issue with the provided data, else return with the
                    # default states given.
-                    issue.created_at = request.data.get(
-                        "created_at", timezone.now()
-                    )
+                    issue.created_at = request.data.get("created_at", timezone.now())
                    issue.created_by_id = request.data.get(
                        "created_by", request.user.id
                    )
@@ -461,12 +423,8 @@ class IssueAPIEndpoint(BaseAPIView):
                        current_instance=None,
                        epoch=int(timezone.now().timestamp()),
                    )
-                    return Response(
-                        serializer.data, status=status.HTTP_201_CREATED
-                    )
-                return Response(
-                    serializer.errors, status=status.HTTP_400_BAD_REQUEST
-                )
+                    return Response(serializer.data, status=status.HTTP_201_CREATED)
+                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        else:
            return Response(
                {"error": "external_id and external_source are required"},
@@ -474,9 +432,7 @@ class IssueAPIEndpoint(BaseAPIView):
            )

    def patch(self, request, slug, project_id, pk=None):
-        issue = Issue.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=pk
-        )
+        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
        project = Project.objects.get(pk=project_id)
        current_instance = json.dumps(
            IssueSerializer(issue).data, cls=DjangoJSONEncoder
@@ -485,10 +441,7 @@ class IssueAPIEndpoint(BaseAPIView):
        serializer = IssueSerializer(
            issue,
            data=request.data,
-            context={
-                "project_id": project_id,
-                "workspace_id": project.workspace_id,
-            },
+            context={"project_id": project_id, "workspace_id": project.workspace_id},
            partial=True,
        )
        if serializer.is_valid():
@@ -526,9 +479,7 @@ class IssueAPIEndpoint(BaseAPIView):
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def delete(self, request, slug, project_id, pk=None):
-        issue = Issue.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=pk
-        )
+        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
        if issue.created_by_id != request.user.id and (
            not ProjectMember.objects.filter(
                workspace__slug=slug,
@@ -567,9 +518,7 @@ class LabelAPIEndpoint(BaseAPIView):

    serializer_class = LabelSerializer
    model = Label
-    permission_classes = [
-        ProjectMemberPermission,
-    ]
+    permission_classes = [ProjectMemberPermission]

    def get_queryset(self):
        return (
@@ -616,12 +565,8 @@ class LabelAPIEndpoint(BaseAPIView):
                    )

                serializer.save(project_id=project_id)
-                return Response(
-                    serializer.data, status=status.HTTP_201_CREATED
-                )
-            return Response(
-                serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            )
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        except IntegrityError:
            label = Label.objects.filter(
                workspace__slug=slug,
@@ -642,18 +587,11 @@ class LabelAPIEndpoint(BaseAPIView):
                request=request,
                queryset=(self.get_queryset()),
                on_results=lambda labels: LabelSerializer(
-                    labels,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
+                    labels, many=True, fields=self.fields, expand=self.expand
                ).data,
            )
        label = self.get_queryset().get(pk=pk)
-        serializer = LabelSerializer(
-            label,
-            fields=self.fields,
-            expand=self.expand,
-        )
+        serializer = LabelSerializer(label, fields=self.fields, expand=self.expand)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def patch(self, request, slug, project_id, pk=None):
@@ -696,9 +634,7 @@ class IssueLinkAPIEndpoint(BaseAPIView):

    """

-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]

    model = IssueLink
    serializer_class = IssueLinkSerializer
@@ -721,46 +657,32 @@ class IssueLinkAPIEndpoint(BaseAPIView):
        if pk is None:
            issue_links = self.get_queryset()
            serializer = IssueLinkSerializer(
-                issue_links,
-                fields=self.fields,
-                expand=self.expand,
+                issue_links, fields=self.fields, expand=self.expand
            )
            return self.paginate(
                request=request,
                queryset=(self.get_queryset()),
                on_results=lambda issue_links: IssueLinkSerializer(
-                    issue_links,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
+                    issue_links, many=True, fields=self.fields, expand=self.expand
                ).data,
            )
        issue_link = self.get_queryset().get(pk=pk)
        serializer = IssueLinkSerializer(
-            issue_link,
-            fields=self.fields,
-            expand=self.expand,
+            issue_link, fields=self.fields, expand=self.expand
        )
        return Response(serializer.data, status=status.HTTP_200_OK)

    def post(self, request, slug, project_id, issue_id):
        serializer = IssueLinkSerializer(data=request.data)
        if serializer.is_valid():
-            serializer.save(
-                project_id=project_id,
-                issue_id=issue_id,
-            )
+            serializer.save(project_id=project_id, issue_id=issue_id)

            link = IssueLink.objects.get(pk=serializer.data["id"])
-            link.created_by_id = request.data.get(
-                "created_by", request.user.id
-            )
+            link.created_by_id = request.data.get("created_by", request.user.id)
            link.save(update_fields=["created_by"])
            issue_activity.delay(
                type="link.activity.created",
-                requested_data=json.dumps(
-                    serializer.data, cls=DjangoJSONEncoder
-                ),
+                requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
                issue_id=str(self.kwargs.get("issue_id")),
                project_id=str(self.kwargs.get("project_id")),
                actor_id=str(link.created_by_id),
@@ -772,19 +694,13 @@ class IssueLinkAPIEndpoint(BaseAPIView):

    def patch(self, request, slug, project_id, issue_id, pk):
        issue_link = IssueLink.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            issue_id=issue_id,
-            pk=pk,
+            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
        )
        requested_data = json.dumps(request.data, cls=DjangoJSONEncoder)
        current_instance = json.dumps(
-            IssueLinkSerializer(issue_link).data,
-            cls=DjangoJSONEncoder,
-        )
-        serializer = IssueLinkSerializer(
-            issue_link, data=request.data, partial=True
+            IssueLinkSerializer(issue_link).data, cls=DjangoJSONEncoder
        )
+        serializer = IssueLinkSerializer(issue_link, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
            issue_activity.delay(
@@ -801,14 +717,10 @@ class IssueLinkAPIEndpoint(BaseAPIView):

    def delete(self, request, slug, project_id, issue_id, pk):
        issue_link = IssueLink.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            issue_id=issue_id,
-            pk=pk,
+            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
        )
        current_instance = json.dumps(
-            IssueLinkSerializer(issue_link).data,
-            cls=DjangoJSONEncoder,
+            IssueLinkSerializer(issue_link).data, cls=DjangoJSONEncoder
        )
        issue_activity.delay(
            type="link.activity.deleted",
@@ -833,15 +745,11 @@ class IssueCommentAPIEndpoint(BaseAPIView):
    serializer_class = IssueCommentSerializer
    model = IssueComment
    webhook_event = "issue_comment"
-    permission_classes = [
-        ProjectLitePermission,
-    ]
+    permission_classes = [ProjectLitePermission]

    def get_queryset(self):
        return (
-            IssueComment.objects.filter(
-                workspace__slug=self.kwargs.get("slug")
-            )
+            IssueComment.objects.filter(workspace__slug=self.kwargs.get("slug"))
            .filter(project_id=self.kwargs.get("project_id"))
            .filter(issue_id=self.kwargs.get("issue_id"))
            .filter(
@@ -868,19 +776,14 @@ class IssueCommentAPIEndpoint(BaseAPIView):
        if pk:
            issue_comment = self.get_queryset().get(pk=pk)
            serializer = IssueCommentSerializer(
-                issue_comment,
-                fields=self.fields,
-                expand=self.expand,
+                issue_comment, fields=self.fields, expand=self.expand
            )
            return Response(serializer.data, status=status.HTTP_200_OK)
        return self.paginate(
            request=request,
            queryset=(self.get_queryset()),
            on_results=lambda issue_comment: IssueCommentSerializer(
-                issue_comment,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
+                issue_comment, many=True, fields=self.fields, expand=self.expand
            ).data,
        )

@@ -913,17 +816,11 @@ class IssueCommentAPIEndpoint(BaseAPIView):
        serializer = IssueCommentSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save(
-                project_id=project_id,
-                issue_id=issue_id,
-                actor=request.user,
-            )
-            issue_comment = IssueComment.objects.get(
-                pk=serializer.data.get("id")
+                project_id=project_id, issue_id=issue_id, actor=request.user
            )
+            issue_comment = IssueComment.objects.get(pk=serializer.data.get("id"))
            # Update the created_at and the created_by and save the comment
-            issue_comment.created_at = request.data.get(
-                "created_at", timezone.now()
-            )
+            issue_comment.created_at = request.data.get("created_at", timezone.now())
            issue_comment.created_by_id = request.data.get(
                "created_by", request.user.id
            )
@@ -931,9 +828,7 @@ class IssueCommentAPIEndpoint(BaseAPIView):

            issue_activity.delay(
                type="comment.activity.created",
-                requested_data=json.dumps(
-                    serializer.data, cls=DjangoJSONEncoder
-                ),
+                requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
                actor_id=str(issue_comment.created_by_id),
                issue_id=str(self.kwargs.get("issue_id")),
                project_id=str(self.kwargs.get("project_id")),
@@ -945,24 +840,17 @@ class IssueCommentAPIEndpoint(BaseAPIView):

    def patch(self, request, slug, project_id, issue_id, pk):
        issue_comment = IssueComment.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            issue_id=issue_id,
-            pk=pk,
+            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
        )
        requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
        current_instance = json.dumps(
-            IssueCommentSerializer(issue_comment).data,
-            cls=DjangoJSONEncoder,
+            IssueCommentSerializer(issue_comment).data, cls=DjangoJSONEncoder
        )

        # Validation check if the issue already exists
        if (
            request.data.get("external_id")
-            and (
-                issue_comment.external_id
-                != str(request.data.get("external_id"))
-            )
+            and (issue_comment.external_id != str(request.data.get("external_id")))
            and IssueComment.objects.filter(
                project_id=project_id,
                workspace__slug=slug,
@@ -999,14 +887,10 @@ class IssueCommentAPIEndpoint(BaseAPIView):

    def delete(self, request, slug, project_id, issue_id, pk):
        issue_comment = IssueComment.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            issue_id=issue_id,
-            pk=pk,
+            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
        )
        current_instance = json.dumps(
-            IssueCommentSerializer(issue_comment).data,
-            cls=DjangoJSONEncoder,
+            IssueCommentSerializer(issue_comment).data, cls=DjangoJSONEncoder
        )
        issue_comment.delete()
        issue_activity.delay(
@@ -1022,9 +906,7 @@ class IssueCommentAPIEndpoint(BaseAPIView):


 class IssueActivityAPIEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]

    def get(self, request, slug, project_id, issue_id, pk=None):
        issue_activities = (
@@ -1049,20 +931,15 @@ class IssueActivityAPIEndpoint(BaseAPIView):
            request=request,
            queryset=(issue_activities),
            on_results=lambda issue_activity: IssueActivitySerializer(
-                issue_activity,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
+                issue_activity, many=True, fields=self.fields, expand=self.expand
            ).data,
        )


 class IssueAttachmentEndpoint(BaseAPIView):
    serializer_class = IssueAttachmentSerializer
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-    model = IssueAttachment
+    permission_classes = [ProjectEntityPermission]
+    model = FileAsset
    parser_classes = (MultiPartParser, FormParser)

    def post(self, request, slug, project_id, issue_id):
@@ -1070,7 +947,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
        if (
            request.data.get("external_id")
            and request.data.get("external_source")
-            and IssueAttachment.objects.filter(
+            and FileAsset.objects.filter(
                project_id=project_id,
                workspace__slug=slug,
                issue_id=issue_id,
@@ -1078,7 +955,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
                external_id=request.data.get("external_id"),
            ).exists()
        ):
-            issue_attachment = IssueAttachment.objects.filter(
+            issue_attachment = FileAsset.objects.filter(
                workspace__slug=slug,
                project_id=project_id,
                external_id=request.data.get("external_id"),
@@ -1100,10 +977,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
                actor_id=str(self.request.user.id),
                issue_id=str(self.kwargs.get("issue_id", None)),
                project_id=str(self.kwargs.get("project_id", None)),
-                current_instance=json.dumps(
-                    serializer.data,
-                    cls=DjangoJSONEncoder,
-                ),
+                current_instance=json.dumps(serializer.data, cls=DjangoJSONEncoder),
                epoch=int(timezone.now().timestamp()),
                notification=True,
                origin=request.META.get("HTTP_ORIGIN"),
@@ -1112,7 +986,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def delete(self, request, slug, project_id, issue_id, pk):
-        issue_attachment = IssueAttachment.objects.get(pk=pk)
+        issue_attachment = FileAsset.objects.get(pk=pk)
        issue_attachment.asset.delete(save=False)
        issue_attachment.delete()
        issue_activity.delay(
@@ -1130,7 +1004,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
        return Response(status=status.HTTP_204_NO_CONTENT)

    def get(self, request, slug, project_id, issue_id):
-        issue_attachments = IssueAttachment.objects.filter(
+        issue_attachments = FileAsset.objects.filter(
            issue_id=issue_id, workspace__slug=slug, project_id=project_id
        )
        serializer = IssueAttachmentSerializer(issue_attachments, many=True)
@@ -13,24 +13,14 @@ from rest_framework import status
 # Module imports
 from .base import BaseAPIView
 from plane.api.serializers import UserLiteSerializer
-from plane.db.models import (
-    User,
-    Workspace,
-    Project,
-    WorkspaceMember,
-    ProjectMember,
-)
+from plane.db.models import User, Workspace, Project, WorkspaceMember, ProjectMember

-from plane.app.permissions import (
-    ProjectMemberPermission,
-)
+from plane.app.permissions import ProjectMemberPermission


 # API endpoint to get and insert users inside the workspace
 class ProjectMemberAPIEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectMemberPermission,
-    ]
+    permission_classes = [ProjectMemberPermission]

    # Get all the users that are present inside the workspace
    def get(self, request, slug, project_id):
@@ -48,10 +38,7 @@ class ProjectMemberAPIEndpoint(BaseAPIView):

        # Get all the users that are present inside the workspace
        users = UserLiteSerializer(
-            User.objects.filter(
-                id__in=project_members,
-            ),
-            many=True,
+            User.objects.filter(id__in=project_members), many=True
        ).data

        return Response(users, status=status.HTTP_200_OK)
@@ -78,8 +65,7 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
            validate_email(email)
        except ValidationError:
            return Response(
-                {"error": "Invalid email provided"},
-                status=status.HTTP_400_BAD_REQUEST,
+                {"error": "Invalid email provided"}, status=status.HTTP_400_BAD_REQUEST
            )

        workspace = Workspace.objects.filter(slug=slug).first()
@@ -108,9 +94,7 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
                ).first()
                if project_member:
                    return Response(
-                        {
-                            "error": "User is already part of the workspace and project"
-                        },
+                        {"error": "User is already part of the workspace and project"},
                        status=status.HTTP_400_BAD_REQUEST,
                    )

@@ -131,18 +115,14 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
        # Create a workspace member for the user if not already a member
        if not workspace_member:
            workspace_member = WorkspaceMember.objects.create(
-                workspace=workspace,
-                member=user,
-                role=request.data.get("role", 5),
+                workspace=workspace, member=user, role=request.data.get("role", 5)
            )
            workspace_member.save()

        # Create a project member for the user if not already a member
        if not project_member:
            project_member = ProjectMember.objects.create(
-                project=project,
-                member=user,
-                role=request.data.get("role", 5),
+                project=project, member=user, role=request.data.get("role", 5)
            )
            project_member.save()

@@ -150,4 +130,3 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
        user_data = UserLiteSerializer(user).data

        return Response(user_data, status=status.HTTP_201_CREATED)
-
@@ -21,7 +21,7 @@ from plane.app.permissions import ProjectEntityPermission
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.db.models import (
    Issue,
-    IssueAttachment,
+    FileAsset,
    IssueLink,
    Module,
    ModuleIssue,
@@ -43,9 +43,7 @@ class ModuleAPIEndpoint(BaseAPIView):
    """

    model = Module
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]
    serializer_class = ModuleSerializer
    webhook_event = "module"

@@ -60,9 +58,7 @@ class ModuleAPIEndpoint(BaseAPIView):
            .prefetch_related(
                Prefetch(
                    "link_module",
-                    queryset=ModuleLink.objects.select_related(
-                        "module", "created_by"
-                    ),
+                    queryset=ModuleLink.objects.select_related("module", "created_by"),
                )
            )
            .annotate(
@@ -71,9 +67,10 @@ class ModuleAPIEndpoint(BaseAPIView):
                    filter=Q(
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
-                ),
+                )
            )
            .annotate(
                completed_issues=Count(
@@ -82,6 +79,7 @@ class ModuleAPIEndpoint(BaseAPIView):
                        issue_module__issue__state__group="completed",
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
                )
@@ -93,6 +91,7 @@ class ModuleAPIEndpoint(BaseAPIView):
                        issue_module__issue__state__group="cancelled",
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
                )
@@ -104,6 +103,7 @@ class ModuleAPIEndpoint(BaseAPIView):
                        issue_module__issue__state__group="started",
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
                )
@@ -115,6 +115,7 @@ class ModuleAPIEndpoint(BaseAPIView):
                        issue_module__issue__state__group="unstarted",
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
                )
@@ -126,6 +127,7 @@ class ModuleAPIEndpoint(BaseAPIView):
                        issue_module__issue__state__group="backlog",
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
                )
@@ -137,10 +139,7 @@ class ModuleAPIEndpoint(BaseAPIView):
        project = Project.objects.get(pk=project_id, workspace__slug=slug)
        serializer = ModuleSerializer(
            data=request.data,
-            context={
-                "project_id": project_id,
-                "workspace_id": project.workspace_id,
-            },
+            context={"project_id": project_id, "workspace_id": project.workspace_id},
        )
        if serializer.is_valid():
            if (
@@ -183,9 +182,7 @@ class ModuleAPIEndpoint(BaseAPIView):
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def patch(self, request, slug, project_id, pk):
-        module = Module.objects.get(
-            pk=pk, project_id=project_id, workspace__slug=slug
-        )
+        module = Module.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)

        current_instance = json.dumps(
            ModuleSerializer(module).data, cls=DjangoJSONEncoder
@@ -197,10 +194,7 @@ class ModuleAPIEndpoint(BaseAPIView):
                status=status.HTTP_400_BAD_REQUEST,
            )
        serializer = ModuleSerializer(
-            module,
-            data=request.data,
-            context={"project_id": project_id},
-            partial=True,
+            module, data=request.data, context={"project_id": project_id}, partial=True
        )
        if serializer.is_valid():
            if (
@@ -240,33 +234,21 @@ class ModuleAPIEndpoint(BaseAPIView):

    def get(self, request, slug, project_id, pk=None):
        if pk:
-            queryset = (
-                self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
-            )
+            queryset = self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
            data = ModuleSerializer(
-                queryset,
-                fields=self.fields,
-                expand=self.expand,
+                queryset, fields=self.fields, expand=self.expand
            ).data
-            return Response(
-                data,
-                status=status.HTTP_200_OK,
-            )
+            return Response(data, status=status.HTTP_200_OK)
        return self.paginate(
            request=request,
            queryset=(self.get_queryset().filter(archived_at__isnull=True)),
            on_results=lambda modules: ModuleSerializer(
-                modules,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
+                modules, many=True, fields=self.fields, expand=self.expand
            ).data,
        )

    def delete(self, request, slug, project_id, pk):
-        module = Module.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=pk
-        )
+        module = Module.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
        if module.created_by_id != request.user.id and (
            not ProjectMember.objects.filter(
                workspace__slug=slug,
@@ -282,9 +264,7 @@ class ModuleAPIEndpoint(BaseAPIView):
            )

        module_issues = list(
-            ModuleIssue.objects.filter(module_id=pk).values_list(
-                "issue", flat=True
-            )
+            ModuleIssue.objects.filter(module_id=pk).values_list("issue", flat=True)
        )
        issue_activity.delay(
            type="module.activity.deleted",
@@ -298,24 +278,15 @@ class ModuleAPIEndpoint(BaseAPIView):
            actor_id=str(request.user.id),
            issue_id=None,
            project_id=str(project_id),
-            current_instance=json.dumps(
-                {
-                    "module_name": str(module.name),
-                }
-            ),
+            current_instance=json.dumps({"module_name": str(module.name)}),
            epoch=int(timezone.now().timestamp()),
        )
        module.delete()
        # Delete the module issues
-        ModuleIssue.objects.filter(
-            module=pk,
-            project_id=project_id,
-        ).delete()
+        ModuleIssue.objects.filter(module=pk, project_id=project_id).delete()
        # Delete the user favorite module
        UserFavorite.objects.filter(
-            entity_type="module",
-            entity_identifier=pk,
-            project_id=project_id,
+            entity_type="module", entity_identifier=pk, project_id=project_id
        ).delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

@@ -332,16 +303,12 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
    webhook_event = "module_issue"
    bulk = True

-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]

    def get_queryset(self):
        return (
            ModuleIssue.objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("issue")
-                )
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("issue"))
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
@@ -367,11 +334,11 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
    def get(self, request, slug, project_id, module_id):
        order_by = request.GET.get("order_by", "created_at")
        issues = (
-            Issue.issue_objects.filter(issue_module__module_id=module_id)
+            Issue.issue_objects.filter(
+                issue_module__module_id=module_id, issue_module__deleted_at__isnull=True
+            )
            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
@@ -393,8 +360,9 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
                .values("count")
            )
            .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                )
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
@@ -405,10 +373,7 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
            request=request,
            queryset=(issues),
            on_results=lambda issues: IssueSerializer(
-                issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
+                issues, many=True, fields=self.fields, expand=self.expand
            ).data,
        )

@@ -416,8 +381,7 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
        issues = request.data.get("issues", [])
        if not len(issues):
            return Response(
-                {"error": "Issues are required"},
-                status=status.HTTP_400_BAD_REQUEST,
+                {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
            )
        module = Module.objects.get(
            workspace__slug=slug, project_id=project_id, pk=module_id
@@ -464,16 +428,10 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
                )

        ModuleIssue.objects.bulk_create(
-            record_to_create,
-            batch_size=10,
-            ignore_conflicts=True,
+            record_to_create, batch_size=10, ignore_conflicts=True
        )

-        ModuleIssue.objects.bulk_update(
-            records_to_update,
-            ["module"],
-            batch_size=10,
-        )
+        ModuleIssue.objects.bulk_update(records_to_update, ["module"], batch_size=10)

        # Capture Issue Activity
        issue_activity.delay(
@@ -509,10 +467,7 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
        issue_activity.delay(
            type="module.activity.deleted",
            requested_data=json.dumps(
-                {
-                    "module_id": str(module_id),
-                    "issues": [str(module_issue.issue_id)],
-                }
+                {"module_id": str(module_id), "issues": [str(module_issue.issue_id)]}
            ),
            actor_id=str(request.user.id),
            issue_id=str(issue_id),
@@ -524,9 +479,7 @@ class ModuleIssueAPIEndpoint(BaseAPIView):


 class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]

    def get_queryset(self):
        return (
@@ -540,9 +493,7 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
            .prefetch_related(
                Prefetch(
                    "link_module",
-                    queryset=ModuleLink.objects.select_related(
-                        "module", "created_by"
-                    ),
+                    queryset=ModuleLink.objects.select_related("module", "created_by"),
                )
            )
            .annotate(
@@ -551,9 +502,10 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                    filter=Q(
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
-                ),
+                )
            )
            .annotate(
                completed_issues=Count(
@@ -562,6 +514,7 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_module__issue__state__group="completed",
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
                )
@@ -573,6 +526,7 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_module__issue__state__group="cancelled",
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
                )
@@ -584,6 +538,7 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_module__issue__state__group="started",
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
                )
@@ -595,6 +550,7 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_module__issue__state__group="unstarted",
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
                )
@@ -606,6 +562,7 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                        issue_module__issue__state__group="backlog",
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
                    ),
                    distinct=True,
                )
@@ -618,22 +575,15 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
            request=request,
            queryset=(self.get_queryset()),
            on_results=lambda modules: ModuleSerializer(
-                modules,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
+                modules, many=True, fields=self.fields, expand=self.expand
            ).data,
        )

    def post(self, request, slug, project_id, pk):
-        module = Module.objects.get(
-            pk=pk, project_id=project_id, workspace__slug=slug
-        )
+        module = Module.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
        if module.status not in ["completed", "cancelled"]:
            return Response(
-                {
-                    "error": "Only completed or cancelled modules can be archived"
-                },
+                {"error": "Only completed or cancelled modules can be archived"},
                status=status.HTTP_400_BAD_REQUEST,
            )
        module.archived_at = timezone.now()
@@ -647,9 +597,7 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
        return Response(status=status.HTTP_204_NO_CONTENT)

    def delete(self, request, slug, project_id, pk):
-        module = Module.objects.get(
-            pk=pk, project_id=project_id, workspace__slug=slug
-        )
+        module = Module.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
        module.archived_at = None
        module.save()
        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -18,7 +18,7 @@ from plane.app.permissions import ProjectBasePermission
 # Module imports
 from plane.db.models import (
    Cycle,
-    Inbox,
+    Intake,
    IssueUserProperty,
    Module,
    Project,
@@ -39,9 +39,7 @@ class ProjectAPIEndpoint(BaseAPIView):
    model = Project
    webhook_event = "project"

-    permission_classes = [
-        ProjectBasePermission,
-    ]
+    permission_classes = [ProjectBasePermission]

    def get_queryset(self):
        return (
@@ -54,10 +52,7 @@ class ProjectAPIEndpoint(BaseAPIView):
                | Q(network=2)
            )
            .select_related(
-                "workspace",
-                "workspace__owner",
-                "default_assignee",
-                "project_lead",
+                "workspace", "workspace__owner", "default_assignee", "project_lead"
            )
            .annotate(
                is_member=Exists(
@@ -71,9 +66,7 @@ class ProjectAPIEndpoint(BaseAPIView):
            )
            .annotate(
                total_members=ProjectMember.objects.filter(
-                    project_id=OuterRef("id"),
-                    member__is_bot=False,
-                    is_active=True,
+                    project_id=OuterRef("id"), member__is_bot=False, is_active=True
                )
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
@@ -125,8 +118,7 @@ class ProjectAPIEndpoint(BaseAPIView):
                    Prefetch(
                        "project_projectmember",
                        queryset=ProjectMember.objects.filter(
-                            workspace__slug=slug,
-                            is_active=True,
+                            workspace__slug=slug, is_active=True
                        ).select_related("member"),
                    )
                )
@@ -136,18 +128,11 @@ class ProjectAPIEndpoint(BaseAPIView):
                request=request,
                queryset=(projects),
                on_results=lambda projects: ProjectSerializer(
-                    projects,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
+                    projects, many=True, fields=self.fields, expand=self.expand
                ).data,
            )
        project = self.get_queryset().get(workspace__slug=slug, pk=pk)
-        serializer = ProjectSerializer(
-            project,
-            fields=self.fields,
-            expand=self.expand,
-        )
+        serializer = ProjectSerializer(project, fields=self.fields, expand=self.expand)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def post(self, request, slug):
@@ -161,14 +146,11 @@ class ProjectAPIEndpoint(BaseAPIView):

                # Add the user as Administrator to the project
                _ = ProjectMember.objects.create(
-                    project_id=serializer.data["id"],
-                    member=request.user,
-                    role=20,
+                    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,
+                    project_id=serializer.data["id"], user=request.user
                )

                if serializer.data["project_lead"] is not None and str(
@@ -236,11 +218,7 @@ class ProjectAPIEndpoint(BaseAPIView):
                    ]
                )

-                project = (
-                    self.get_queryset()
-                    .filter(pk=serializer.data["id"])
-                    .first()
-                )
+                project = self.get_queryset().filter(pk=serializer.data["id"]).first()

                # Model activity
                model_activity.delay(
@@ -254,13 +232,8 @@ class ProjectAPIEndpoint(BaseAPIView):
                )

                serializer = ProjectSerializer(project)
-                return Response(
-                    serializer.data, status=status.HTTP_201_CREATED
-                )
-            return Response(
-                serializer.errors,
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        except IntegrityError as e:
            if "already exists" in str(e):
                return Response(
@@ -269,8 +242,7 @@ class ProjectAPIEndpoint(BaseAPIView):
                )
        except Workspace.DoesNotExist:
            return Response(
-                {"error": "Workspace does not exist"},
-                status=status.HTTP_404_NOT_FOUND,
+                {"error": "Workspace does not exist"}, status=status.HTTP_404_NOT_FOUND
            )
        except ValidationError:
            return Response(
@@ -285,6 +257,11 @@ class ProjectAPIEndpoint(BaseAPIView):
            current_instance = json.dumps(
                ProjectSerializer(project).data, cls=DjangoJSONEncoder
            )
+
+            intake_view = request.data.get(
+                "inbox_view", request.data.get("intake_view", False)
+            )
+
            if project.archived_at:
                return Response(
                    {"error": "Archived project cannot be updated"},
@@ -293,21 +270,20 @@ class ProjectAPIEndpoint(BaseAPIView):

            serializer = ProjectSerializer(
                project,
-                data={**request.data},
+                data={**request.data, "intake_view": intake_view},
                context={"workspace_id": workspace.id},
                partial=True,
            )

            if serializer.is_valid():
                serializer.save()
-                if serializer.data["inbox_view"]:
-                    inbox = Inbox.objects.filter(
-                        project=project,
-                        is_default=True,
+                if serializer.data["intake_view"]:
+                    intake = Intake.objects.filter(
+                        project=project, is_default=True
                    ).first()
-                    if not inbox:
-                        Inbox.objects.create(
-                            name=f"{project.name} Inbox",
+                    if not intake:
+                        Intake.objects.create(
+                            name=f"{project.name} Intake",
                            project=project,
                            is_default=True,
                        )
@@ -316,17 +292,13 @@ class ProjectAPIEndpoint(BaseAPIView):
                    State.objects.get_or_create(
                        name="Triage",
                        group="triage",
-                        description="Default state for managing all Inbox Issues",
+                        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()
-                )
+                project = self.get_queryset().filter(pk=serializer.data["id"]).first()

                model_activity.delay(
                    model_name="project",
@@ -340,9 +312,7 @@ class ProjectAPIEndpoint(BaseAPIView):

                serializer = ProjectSerializer(project)
                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(
-                serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            )
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        except IntegrityError as e:
            if "already exists" in str(e):
                return Response(
@@ -351,8 +321,7 @@ class ProjectAPIEndpoint(BaseAPIView):
                )
        except (Project.DoesNotExist, Workspace.DoesNotExist):
            return Response(
-                {"error": "Project does not exist"},
-                status=status.HTTP_404_NOT_FOUND,
+                {"error": "Project does not exist"}, status=status.HTTP_404_NOT_FOUND
            )
        except ValidationError:
            return Response(
@@ -364,28 +333,20 @@ class ProjectAPIEndpoint(BaseAPIView):
        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,
+            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,
-    ]
+    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()
+        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):
@@ -16,9 +16,7 @@ from .base import BaseAPIView
 class StateAPIEndpoint(BaseAPIView):
    serializer_class = StateSerializer
    model = State
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]

    def get_queryset(self):
        return (
@@ -67,9 +65,7 @@ class StateAPIEndpoint(BaseAPIView):

                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
-            )
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        except IntegrityError:
            state = State.objects.filter(
                workspace__slug=slug,
@@ -96,19 +92,13 @@ class StateAPIEndpoint(BaseAPIView):
            request=request,
            queryset=(self.get_queryset()),
            on_results=lambda states: StateSerializer(
-                states,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
+                states, many=True, fields=self.fields, expand=self.expand
            ).data,
        )

    def delete(self, request, slug, project_id, state_id):
        state = State.objects.get(
-            is_triage=False,
-            pk=state_id,
-            project_id=project_id,
-            workspace__slug=slug,
+            is_triage=False, pk=state_id, project_id=project_id, workspace__slug=slug
        )

        if state.default:
@@ -122,9 +112,7 @@ class StateAPIEndpoint(BaseAPIView):

        if issue_exist:
            return Response(
-                {
-                    "error": "The state is not empty, only empty states can be deleted"
-                },
+                {"error": "The state is not empty, only empty states can be deleted"},
                status=status.HTTP_400_BAD_REQUEST,
            )

@@ -25,10 +25,7 @@ class APIKeyAuthentication(authentication.BaseAuthentication):
    def validate_api_token(self, token):
        try:
            api_token = APIToken.objects.get(
-                Q(
-                    Q(expired_at__gt=timezone.now())
-                    | Q(expired_at__isnull=True)
-                ),
+                Q(Q(expired_at__gt=timezone.now()) | Q(expired_at__isnull=True)),
                token=token,
                is_active=True,
            )
@@ -12,4 +12,4 @@ from .project import (
    ProjectMemberPermission,
    ProjectLitePermission,
 )
-from .base import allow_permission, ROLE
+from .base import allow_permission, ROLE
@@ -5,6 +5,7 @@ from rest_framework import status

 from enum import Enum

+
 class ROLE(Enum):
    ADMIN = 20
    MEMBER = 15
@@ -15,7 +16,6 @@ def allow_permission(allowed_roles, level="PROJECT", creator=False, model=None):
    def decorator(view_func):
        @wraps(view_func)
        def _wrapped_view(instance, request, *args, **kwargs):
-
            # Check for creator if required
            if creator and model:
                obj = model.objects.filter(
@@ -26,8 +26,7 @@ def allow_permission(allowed_roles, level="PROJECT", creator=False, model=None):

            # Convert allowed_roles to their values if they are enum members
            allowed_role_values = [
-                role.value if isinstance(role, ROLE) else role
-                for role in allowed_roles
+                role.value if isinstance(role, ROLE) else role for role in allowed_roles
            ]

            # Check role permissions
@@ -18,9 +18,7 @@ class ProjectBasePermission(BasePermission):
        ## Safe Methods -> Handle the filtering logic in queryset
        if request.method in SAFE_METHODS:
            return WorkspaceMember.objects.filter(
-                workspace__slug=view.workspace_slug,
-                member=request.user,
-                is_active=True,
+                workspace__slug=view.workspace_slug, member=request.user, is_active=True
            ).exists()

        ## Only workspace owners or admins can create the projects
@@ -50,9 +48,7 @@ class ProjectMemberPermission(BasePermission):
        ## Safe Methods -> Handle the filtering logic in queryset
        if request.method in SAFE_METHODS:
            return ProjectMember.objects.filter(
-                workspace__slug=view.workspace_slug,
-                member=request.user,
-                is_active=True,
+                workspace__slug=view.workspace_slug, member=request.user, is_active=True
            ).exists()
        ## Only workspace owners or admins can create the projects
        if request.method == "POST":
@@ -50,9 +50,7 @@ class WorkspaceOwnerPermission(BasePermission):
            return False

        return WorkspaceMember.objects.filter(
-            workspace__slug=view.workspace_slug,
-            member=request.user,
-            role=Admin,
+            workspace__slug=view.workspace_slug, member=request.user, role=Admin
        ).exists()


@@ -77,9 +75,7 @@ class WorkspaceEntityPermission(BasePermission):
        ## Safe Methods -> Handle the filtering logic in queryset
        if request.method in SAFE_METHODS:
            return WorkspaceMember.objects.filter(
-                workspace__slug=view.workspace_slug,
-                member=request.user,
-                is_active=True,
+                workspace__slug=view.workspace_slug, member=request.user, is_active=True
            ).exists()

        return WorkspaceMember.objects.filter(
@@ -96,9 +92,7 @@ class WorkspaceViewerPermission(BasePermission):
            return False

        return WorkspaceMember.objects.filter(
-            member=request.user,
-            workspace__slug=view.workspace_slug,
-            is_active=True,
+            member=request.user, workspace__slug=view.workspace_slug, is_active=True
        ).exists()


@@ -108,7 +102,5 @@ class WorkspaceUserPermission(BasePermission):
            return False

        return WorkspaceMember.objects.filter(
-            member=request.user,
-            workspace__slug=view.workspace_slug,
-            is_active=True,
+            member=request.user, workspace__slug=view.workspace_slug, is_active=True
        ).exists()
@@ -36,9 +36,7 @@ from .project import (
    ProjectMemberRoleSerializer,
 )
 from .state import StateSerializer, StateLiteSerializer
-from .view import (
-    IssueViewSerializer,
-)
+from .view import IssueViewSerializer
 from .cycle import (
    CycleSerializer,
    CycleIssueSerializer,
@@ -57,7 +55,7 @@ from .issue import (
    IssueFlatSerializer,
    IssueStateSerializer,
    IssueLinkSerializer,
-    IssueInboxSerializer,
+    IssueIntakeSerializer,
    IssueLiteSerializer,
    IssueAttachmentSerializer,
    IssueSubscriberSerializer,
@@ -102,20 +100,17 @@ from .estimate import (
    WorkspaceEstimateSerializer,
 )

-from .inbox import (
-    InboxSerializer,
-    InboxIssueSerializer,
-    IssueStateInboxSerializer,
-    InboxIssueLiteSerializer,
-    InboxIssueDetailSerializer,
+from .intake import (
+    IntakeSerializer,
+    IntakeIssueSerializer,
+    IssueStateIntakeSerializer,
+    IntakeIssueLiteSerializer,
+    IntakeIssueDetailSerializer,
 )

 from .analytic import AnalyticViewSerializer

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

 from .exporter import ExporterHistorySerializer

@@ -7,10 +7,7 @@ class AnalyticViewSerializer(BaseSerializer):
    class Meta:
        model = AnalyticView
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "query",
-        ]
+        read_only_fields = ["workspace", "query"]

    def create(self, validated_data):
        query_params = validated_data.get("query_dict", {})
@@ -6,9 +6,4 @@ class FileAssetSerializer(BaseSerializer):
    class Meta:
        model = FileAsset
        fields = "__all__"
-        read_only_fields = [
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
+        read_only_fields = ["created_by", "updated_by", "created_at", "updated_at"]
@@ -60,10 +60,10 @@ class DynamicBaseSerializer(BaseSerializer):
                    CycleIssueSerializer,
                    IssueLiteSerializer,
                    IssueRelationSerializer,
-                    InboxIssueLiteSerializer,
+                    IntakeIssueLiteSerializer,
                    IssueReactionLiteSerializer,
-                    IssueAttachmentLiteSerializer,
                    IssueLinkLiteSerializer,
+                    RelatedIssueSerializer,
                )

                # Expansion mapper
@@ -84,13 +84,14 @@ class DynamicBaseSerializer(BaseSerializer):
                    "issue_cycle": CycleIssueSerializer,
                    "parent": IssueLiteSerializer,
                    "issue_relation": IssueRelationSerializer,
-                    "issue_inbox": InboxIssueLiteSerializer,
+                    "issue_intake": IntakeIssueLiteSerializer,
+                    "issue_related": RelatedIssueSerializer,
                    "issue_reactions": IssueReactionLiteSerializer,
-                    "issue_attachment": IssueAttachmentLiteSerializer,
                    "issue_link": IssueLinkLiteSerializer,
                    "sub_issues": IssueLiteSerializer,
                }

+            if field not in self.fields and field in expansion:
                self.fields[field] = expansion[field](
                    many=(
                        True
@@ -101,11 +102,12 @@ class DynamicBaseSerializer(BaseSerializer):
                            "labels",
                            "issue_cycle",
                            "issue_relation",
-                            "issue_inbox",
+                            "issue_intake",
                            "issue_reactions",
                            "issue_attachment",
                            "issue_link",
                            "sub_issues",
+                            "issue_related",
                        ]
                        else False
                    )
@@ -130,11 +132,12 @@ class DynamicBaseSerializer(BaseSerializer):
                        LabelSerializer,
                        CycleIssueSerializer,
                        IssueRelationSerializer,
-                        InboxIssueLiteSerializer,
+                        IntakeIssueLiteSerializer,
                        IssueLiteSerializer,
                        IssueReactionLiteSerializer,
                        IssueAttachmentLiteSerializer,
                        IssueLinkLiteSerializer,
+                        RelatedIssueSerializer,
                    )

                    # Expansion mapper
@@ -155,7 +158,8 @@ class DynamicBaseSerializer(BaseSerializer):
                        "issue_cycle": CycleIssueSerializer,
                        "parent": IssueLiteSerializer,
                        "issue_relation": IssueRelationSerializer,
-                        "issue_inbox": InboxIssueLiteSerializer,
+                        "issue_intake": IntakeIssueLiteSerializer,
+                        "issue_related": RelatedIssueSerializer,
                        "issue_reactions": IssueReactionLiteSerializer,
                        "issue_attachment": IssueAttachmentLiteSerializer,
                        "issue_link": IssueLinkLiteSerializer,
@@ -174,8 +178,26 @@ class DynamicBaseSerializer(BaseSerializer):
                        response[expand] = exp_serializer.data
                    else:
                        # You might need to handle this case differently
-                        response[expand] = getattr(
-                            instance, f"{expand}_id", None
-                        )
+                        response[expand] = getattr(instance, f"{expand}_id", None)
+
+            # Check if issue_attachments is in fields or expand
+            if "issue_attachments" in self.fields or "issue_attachments" in self.expand:
+                # Import the model here to avoid circular imports
+                from plane.db.models import FileAsset
+
+                issue_id = getattr(instance, "id", None)
+
+                if issue_id:
+                    # Fetch related issue_attachments
+                    issue_attachments = FileAsset.objects.filter(
+                        issue_id=issue_id,
+                        entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                    )
+                    # Serialize issue_attachments and add them to the response
+                    response["issue_attachments"] = IssueAttachmentLiteSerializer(
+                        issue_attachments, many=True
+                    ).data
+                else:
+                    response["issue_attachments"] = []

        return response
@@ -4,11 +4,7 @@ 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.db.models import Cycle, CycleIssue, CycleUserProperties


 class CycleWriteSerializer(BaseSerializer):
@@ -18,20 +14,13 @@ class CycleWriteSerializer(BaseSerializer):
            and data.get("end_date", None) is not None
            and data.get("start_date", None) > data.get("end_date", None)
        ):
-            raise serializers.ValidationError(
-                "Start date cannot exceed end date"
-            )
+            raise serializers.ValidationError("Start date cannot exceed end date")
        return data

    class Meta:
        model = Cycle
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "owned_by",
-            "archived_at",
-        ]
+        read_only_fields = ["workspace", "project", "owned_by", "archived_at"]


 class CycleSerializer(BaseSerializer):
@@ -87,18 +76,11 @@ class CycleIssueSerializer(BaseSerializer):
    class Meta:
        model = CycleIssue
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "cycle",
-        ]
+        read_only_fields = ["workspace", "project", "cycle"]
+

 class CycleUserPropertiesSerializer(BaseSerializer):
    class Meta:
        model = CycleUserProperties
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "cycle" "user",
-        ]
+        read_only_fields = ["workspace", "project", "cycle" "user"]
@@ -22,16 +22,10 @@ from plane.db.models import (
 class DraftIssueCreateSerializer(BaseSerializer):
    # ids
    state_id = serializers.PrimaryKeyRelatedField(
-        source="state",
-        queryset=State.objects.all(),
-        required=False,
-        allow_null=True,
+        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,
+        source="parent", queryset=Issue.objects.all(), required=False, allow_null=True
    )
    label_ids = serializers.ListField(
        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
@@ -49,7 +43,6 @@ class DraftIssueCreateSerializer(BaseSerializer):
        fields = "__all__"
        read_only_fields = [
            "workspace",
-            "project",
            "created_by",
            "updated_by",
            "created_at",
@@ -70,9 +63,7 @@ class DraftIssueCreateSerializer(BaseSerializer):
            and data.get("target_date", None) is not None
            and data.get("start_date", None) > data.get("target_date", None)
        ):
-            raise serializers.ValidationError(
-                "Start date cannot exceed target date"
-            )
+            raise serializers.ValidationError("Start date cannot exceed target date")
        return data

    def create(self, validated_data):
@@ -83,11 +74,11 @@ class DraftIssueCreateSerializer(BaseSerializer):
        modules = self.initial_data.get("module_ids", None)

        workspace_id = self.context["workspace_id"]
+        project_id = self.context["project_id"]

        # Create Issue
        issue = DraftIssue.objects.create(
-            **validated_data,
-            workspace_id=workspace_id,
+            **validated_data, workspace_id=workspace_id, project_id=project_id
        )

        # Issue Audit Users
@@ -99,8 +90,9 @@ class DraftIssueCreateSerializer(BaseSerializer):
                [
                    DraftIssueAssignee(
                        assignee=user,
-                        issue=issue,
+                        draft_issue=issue,
                        workspace_id=workspace_id,
+                        project_id=project_id,
                        created_by_id=created_by_id,
                        updated_by_id=updated_by_id,
                    )
@@ -114,7 +106,8 @@ class DraftIssueCreateSerializer(BaseSerializer):
                [
                    DraftIssueLabel(
                        label=label,
-                        issue=issue,
+                        draft_issue=issue,
+                        project_id=project_id,
                        workspace_id=workspace_id,
                        created_by_id=created_by_id,
                        updated_by_id=updated_by_id,
@@ -128,6 +121,7 @@ class DraftIssueCreateSerializer(BaseSerializer):
            DraftIssueCycle.objects.create(
                cycle_id=cycle_id,
                draft_issue=issue,
+                project_id=project_id,
                workspace_id=workspace_id,
                created_by_id=created_by_id,
                updated_by_id=updated_by_id,
@@ -139,6 +133,7 @@ class DraftIssueCreateSerializer(BaseSerializer):
                    DraftIssueModule(
                        module_id=module_id,
                        draft_issue=issue,
+                        project_id=project_id,
                        workspace_id=workspace_id,
                        created_by_id=created_by_id,
                        updated_by_id=updated_by_id,
@@ -153,22 +148,25 @@ class DraftIssueCreateSerializer(BaseSerializer):
    def update(self, instance, validated_data):
        assignees = validated_data.pop("assignee_ids", None)
        labels = validated_data.pop("label_ids", None)
-        cycle_id = self.initial_data.get("cycle_id", None)
+        cycle_id = self.context.get("cycle_id", None)
        modules = self.initial_data.get("module_ids", None)

        # Related models
        workspace_id = instance.workspace_id
+        project_id = instance.project_id
+
        created_by_id = instance.created_by_id
        updated_by_id = instance.updated_by_id

        if assignees is not None:
-            DraftIssueAssignee.objects.filter(issue=instance).delete()
+            DraftIssueAssignee.objects.filter(draft_issue=instance).delete()
            DraftIssueAssignee.objects.bulk_create(
                [
                    DraftIssueAssignee(
                        assignee=user,
-                        issue=instance,
+                        draft_issue=instance,
                        workspace_id=workspace_id,
+                        project_id=project_id,
                        created_by_id=created_by_id,
                        updated_by_id=updated_by_id,
                    )
@@ -178,13 +176,14 @@ class DraftIssueCreateSerializer(BaseSerializer):
            )

        if labels is not None:
-            DraftIssueLabel.objects.filter(issue=instance).delete()
+            DraftIssueLabel.objects.filter(draft_issue=instance).delete()
            DraftIssueLabel.objects.bulk_create(
                [
                    DraftIssueLabel(
                        label=label,
-                        issue=instance,
+                        draft_issue=instance,
                        workspace_id=workspace_id,
+                        project_id=project_id,
                        created_by_id=created_by_id,
                        updated_by_id=updated_by_id,
                    )
@@ -193,28 +192,31 @@ class DraftIssueCreateSerializer(BaseSerializer):
                batch_size=10,
            )

-        if cycle_id is not None:
+        if cycle_id != "not_provided":
            DraftIssueCycle.objects.filter(draft_issue=instance).delete()
-            DraftIssueCycle.objects.create(
-                cycle_id=cycle_id,
-                draft_issue=instance,
-                workspace_id=workspace_id,
-                created_by_id=created_by_id,
-                updated_by_id=updated_by_id,
-            )
+            if cycle_id:
+                DraftIssueCycle.objects.create(
+                    cycle_id=cycle_id,
+                    draft_issue=instance,
+                    workspace_id=workspace_id,
+                    project_id=project_id,
+                    created_by_id=created_by_id,
+                    updated_by_id=updated_by_id,
+                )

        if modules is not None:
            DraftIssueModule.objects.filter(draft_issue=instance).delete()
            DraftIssueModule.objects.bulk_create(
                [
                    DraftIssueModule(
-                        module=module,
+                        module_id=module_id,
                        draft_issue=instance,
                        workspace_id=workspace_id,
+                        project_id=project_id,
                        created_by_id=created_by_id,
                        updated_by_id=updated_by_id,
                    )
-                    for module in modules
+                    for module_id in modules
                ],
                batch_size=10,
            )
@@ -227,20 +229,11 @@ class DraftIssueCreateSerializer(BaseSerializer):
 class DraftIssueSerializer(BaseSerializer):
    # ids
    cycle_id = serializers.PrimaryKeyRelatedField(read_only=True)
-    module_ids = serializers.ListField(
-        child=serializers.UUIDField(),
-        required=False,
-    )
+    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,
-    )
+    label_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
+    assignee_ids = serializers.ListField(child=serializers.UUIDField(), required=False)

    class Meta:
        model = DraftIssue
@@ -264,6 +257,8 @@ class DraftIssueSerializer(BaseSerializer):
            "updated_at",
            "created_by",
            "updated_by",
+            "type_id",
+            "description_html",
        ]
        read_only_fields = fields

@@ -272,7 +267,5 @@ class DraftIssueDetailSerializer(DraftIssueSerializer):
    description_html = serializers.CharField()

    class Meta(DraftIssueSerializer.Meta):
-        fields = DraftIssueSerializer.Meta.fields + [
-            "description_html",
-        ]
+        fields = DraftIssueSerializer.Meta.fields + ["description_html"]
        read_only_fields = fields
@@ -7,14 +7,10 @@ from rest_framework import serializers


 class EstimateSerializer(BaseSerializer):
-
    class Meta:
        model = Estimate
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-        ]
+        read_only_fields = ["workspace", "project"]


 class EstimatePointSerializer(BaseSerializer):
@@ -23,19 +19,13 @@ class EstimatePointSerializer(BaseSerializer):
            raise serializers.ValidationError("Estimate points are required")
        value = data.get("value")
        if value and len(value) > 20:
-            raise serializers.ValidationError(
-                "Value can't be more than 20 characters"
-            )
+            raise serializers.ValidationError("Value can't be more than 20 characters")
        return data

    class Meta:
        model = EstimatePoint
        fields = "__all__"
-        read_only_fields = [
-            "estimate",
-            "workspace",
-            "project",
-        ]
+        read_only_fields = ["estimate", "workspace", "project"]


 class EstimateReadSerializer(BaseSerializer):
@@ -44,11 +34,7 @@ class EstimateReadSerializer(BaseSerializer):
    class Meta:
        model = Estimate
        fields = "__all__"
-        read_only_fields = [
-            "points",
-            "name",
-            "description",
-        ]
+        read_only_fields = ["points", "name", "description"]


 class WorkspaceEstimateSerializer(BaseSerializer):
@@ -57,8 +43,4 @@ class WorkspaceEstimateSerializer(BaseSerializer):
    class Meta:
        model = Estimate
        fields = "__all__"
-        read_only_fields = [
-            "points",
-            "name",
-            "description",
-        ]
+        read_only_fields = ["points", "name", "description"]
@@ -5,9 +5,7 @@ from .user import UserLiteSerializer


 class ExporterHistorySerializer(BaseSerializer):
-    initiated_by_detail = UserLiteSerializer(
-        source="initiated_by", read_only=True
-    )
+    initiated_by_detail = UserLiteSerializer(source="initiated_by", read_only=True)

    class Meta:
        model = ExporterHistory
@@ -1,18 +1,9 @@
 from rest_framework import serializers

-from plane.db.models import (
-    UserFavorite,
-    Cycle,
-    Module,
-    Issue,
-    IssueView,
-    Page,
-    Project,
-)
+from plane.db.models import UserFavorite, Cycle, Module, Issue, IssueView, Page, Project


 class ProjectFavoriteLiteSerializer(serializers.ModelSerializer):
-
    class Meta:
        model = Project
        fields = ["id", "name", "logo_props"]
@@ -33,21 +24,18 @@ class PageFavoriteLiteSerializer(serializers.ModelSerializer):


 class CycleFavoriteLiteSerializer(serializers.ModelSerializer):
-
    class Meta:
        model = Cycle
        fields = ["id", "name", "logo_props", "project_id"]


 class ModuleFavoriteLiteSerializer(serializers.ModelSerializer):
-
    class Meta:
        model = Module
        fields = ["id", "name", "logo_props", "project_id"]


 class ViewFavoriteSerializer(serializers.ModelSerializer):
-
    class Meta:
        model = IssueView
        fields = ["id", "name", "logo_props", "project_id"]
@@ -89,9 +77,7 @@ class UserFavoriteSerializer(serializers.ModelSerializer):
        entity_type = obj.entity_type
        entity_identifier = obj.entity_identifier

-        entity_model, entity_serializer = get_entity_model_and_serializer(
-            entity_type
-        )
+        entity_model, entity_serializer = get_entity_model_and_serializer(entity_type)
        if entity_model and entity_serializer:
            try:
                entity = entity_model.objects.get(pk=entity_identifier)
@@ -7,13 +7,9 @@ from plane.db.models import Importer


 class ImporterSerializer(BaseSerializer):
-    initiated_by_detail = UserLiteSerializer(
-        source="initiated_by", read_only=True
-    )
+    initiated_by_detail = UserLiteSerializer(source="initiated_by", read_only=True)
    project_detail = ProjectLiteSerializer(source="project", read_only=True)
-    workspace_detail = WorkspaceLiteSerializer(
-        source="workspace", read_only=True
-    )
+    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)

    class Meta:
        model = Importer
@@ -3,35 +3,28 @@ from rest_framework import serializers

 # Module imports
 from .base import BaseSerializer
-from .issue import (
-    IssueInboxSerializer,
-    LabelLiteSerializer,
-    IssueDetailSerializer,
-)
+from .issue import IssueIntakeSerializer, LabelLiteSerializer, IssueDetailSerializer
 from .project import ProjectLiteSerializer
 from .state import StateLiteSerializer
 from .user import UserLiteSerializer
-from plane.db.models import Inbox, InboxIssue, Issue
+from plane.db.models import Intake, IntakeIssue, Issue


-class InboxSerializer(BaseSerializer):
+class IntakeSerializer(BaseSerializer):
    project_detail = ProjectLiteSerializer(source="project", read_only=True)
    pending_issue_count = serializers.IntegerField(read_only=True)

    class Meta:
-        model = Inbox
+        model = Intake
        fields = "__all__"
-        read_only_fields = [
-            "project",
-            "workspace",
-        ]
+        read_only_fields = ["project", "workspace"]


-class InboxIssueSerializer(BaseSerializer):
-    issue = IssueInboxSerializer(read_only=True)
+class IntakeIssueSerializer(BaseSerializer):
+    issue = IssueIntakeSerializer(read_only=True)

    class Meta:
-        model = InboxIssue
+        model = IntakeIssue
        fields = [
            "id",
            "status",
@@ -41,10 +34,7 @@ class InboxIssueSerializer(BaseSerializer):
            "issue",
            "created_by",
        ]
-        read_only_fields = [
-            "project",
-            "workspace",
-        ]
+        read_only_fields = ["project", "workspace"]

    def to_representation(self, instance):
        # Pass the annotated fields to the Issue instance if they exist
@@ -53,14 +43,14 @@ class InboxIssueSerializer(BaseSerializer):
        return super().to_representation(instance)


-class InboxIssueDetailSerializer(BaseSerializer):
+class IntakeIssueDetailSerializer(BaseSerializer):
    issue = IssueDetailSerializer(read_only=True)
-    duplicate_issue_detail = IssueInboxSerializer(
+    duplicate_issue_detail = IssueIntakeSerializer(
        read_only=True, source="duplicate_to"
    )

    class Meta:
-        model = InboxIssue
+        model = IntakeIssue
        fields = [
            "id",
            "status",
@@ -70,10 +60,7 @@ class InboxIssueDetailSerializer(BaseSerializer):
            "source",
            "issue",
        ]
-        read_only_fields = [
-            "project",
-            "workspace",
-        ]
+        read_only_fields = ["project", "workspace"]

    def to_representation(self, instance):
        # Pass the annotated fields to the Issue instance if they exist
@@ -85,24 +72,20 @@ class InboxIssueDetailSerializer(BaseSerializer):
        return super().to_representation(instance)


-class InboxIssueLiteSerializer(BaseSerializer):
+class IntakeIssueLiteSerializer(BaseSerializer):
    class Meta:
-        model = InboxIssue
+        model = IntakeIssue
        fields = ["id", "status", "duplicate_to", "snoozed_till", "source"]
        read_only_fields = fields


-class IssueStateInboxSerializer(BaseSerializer):
+class IssueStateIntakeSerializer(BaseSerializer):
    state_detail = StateLiteSerializer(read_only=True, source="state")
    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    label_details = LabelLiteSerializer(
-        read_only=True, source="labels", many=True
-    )
-    assignee_details = UserLiteSerializer(
-        read_only=True, source="assignees", many=True
-    )
+    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
+    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
    sub_issues_count = serializers.IntegerField(read_only=True)
-    issue_inbox = InboxIssueLiteSerializer(read_only=True, many=True)
+    issue_intake = IntakeIssueLiteSerializer(read_only=True, many=True)

    class Meta:
        model = Issue
@@ -27,7 +27,7 @@ from plane.db.models import (
    Module,
    ModuleIssue,
    IssueLink,
-    IssueAttachment,
+    FileAsset,
    IssueReaction,
    CommentReaction,
    IssueVote,
@@ -60,12 +60,7 @@ class IssueProjectLiteSerializer(BaseSerializer):

    class Meta:
        model = Issue
-        fields = [
-            "id",
-            "project_detail",
-            "name",
-            "sequence_id",
-        ]
+        fields = ["id", "project_detail", "name", "sequence_id"]
        read_only_fields = fields


@@ -74,16 +69,10 @@ class IssueProjectLiteSerializer(BaseSerializer):
 class IssueCreateSerializer(BaseSerializer):
    # ids
    state_id = serializers.PrimaryKeyRelatedField(
-        source="state",
-        queryset=State.objects.all(),
-        required=False,
-        allow_null=True,
+        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,
+        source="parent", queryset=Issue.objects.all(), required=False, allow_null=True
    )
    label_ids = serializers.ListField(
        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
@@ -95,6 +84,8 @@ class IssueCreateSerializer(BaseSerializer):
        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
@@ -122,9 +113,7 @@ class IssueCreateSerializer(BaseSerializer):
            and data.get("target_date", None) is not None
            and data.get("start_date", None) > data.get("target_date", None)
        ):
-            raise serializers.ValidationError(
-                "Start date cannot exceed target date"
-            )
+            raise serializers.ValidationError("Start date cannot exceed target date")
        return data

    def create(self, validated_data):
@@ -136,10 +125,7 @@ class IssueCreateSerializer(BaseSerializer):
        default_assignee_id = self.context["default_assignee_id"]

        # Create Issue
-        issue = Issue.objects.create(
-            **validated_data,
-            project_id=project_id,
-        )
+        issue = Issue.objects.create(**validated_data, project_id=project_id)

        # Issue Audit Users
        created_by_id = issue.created_by_id
@@ -243,9 +229,7 @@ class IssueActivitySerializer(BaseSerializer):
    actor_detail = UserLiteSerializer(read_only=True, source="actor")
    issue_detail = IssueFlatSerializer(read_only=True, source="issue")
    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(
-        read_only=True, source="workspace"
-    )
+    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")

    class Meta:
        model = IssueActivity
@@ -256,11 +240,7 @@ class IssueUserPropertySerializer(BaseSerializer):
    class Meta:
        model = IssueUserProperty
        fields = "__all__"
-        read_only_fields = [
-            "user",
-            "workspace",
-            "project",
-        ]
+        read_only_fields = ["user", "workspace", "project"]


 class LabelSerializer(BaseSerializer):
@@ -275,30 +255,20 @@ class LabelSerializer(BaseSerializer):
            "workspace_id",
            "sort_order",
        ]
-        read_only_fields = [
-            "workspace",
-            "project",
-        ]
+        read_only_fields = ["workspace", "project"]


 class LabelLiteSerializer(BaseSerializer):
    class Meta:
        model = Label
-        fields = [
-            "id",
-            "name",
-            "color",
-        ]
+        fields = ["id", "name", "color"]


 class IssueLabelSerializer(BaseSerializer):
    class Meta:
        model = IssueLabel
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-        ]
+        read_only_fields = ["workspace", "project"]


 class IssueRelationSerializer(BaseSerializer):
@@ -314,17 +284,8 @@ class IssueRelationSerializer(BaseSerializer):

    class Meta:
        model = IssueRelation
-        fields = [
-            "id",
-            "project_id",
-            "sequence_id",
-            "relation_type",
-            "name",
-        ]
-        read_only_fields = [
-            "workspace",
-            "project",
-        ]
+        fields = ["id", "project_id", "sequence_id", "relation_type", "name"]
+        read_only_fields = ["workspace", "project"]


 class RelatedIssueSerializer(BaseSerializer):
@@ -332,25 +293,14 @@ class RelatedIssueSerializer(BaseSerializer):
    project_id = serializers.PrimaryKeyRelatedField(
        source="issue.project_id", read_only=True
    )
-    sequence_id = serializers.IntegerField(
-        source="issue.sequence_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",
-        ]
+        fields = ["id", "project_id", "sequence_id", "relation_type", "name"]
+        read_only_fields = ["workspace", "project"]


 class IssueAssigneeSerializer(BaseSerializer):
@@ -458,8 +408,7 @@ class IssueLinkSerializer(BaseSerializer):
    # Validation if url already exists
    def create(self, validated_data):
        if IssueLink.objects.filter(
-            url=validated_data.get("url"),
-            issue_id=validated_data.get("issue_id"),
+            url=validated_data.get("url"), issue_id=validated_data.get("issue_id")
        ).exists():
            raise serializers.ValidationError(
                {"error": "URL already exists for this Issue"}
@@ -469,8 +418,7 @@ class IssueLinkSerializer(BaseSerializer):
    def update(self, instance, validated_data):
        if (
            IssueLink.objects.filter(
-                url=validated_data.get("url"),
-                issue_id=instance.issue_id,
+                url=validated_data.get("url"), issue_id=instance.issue_id
            )
            .exclude(pk=instance.id)
            .exists()
@@ -498,8 +446,10 @@ class IssueLinkLiteSerializer(BaseSerializer):


 class IssueAttachmentSerializer(BaseSerializer):
+    asset_url = serializers.CharField(read_only=True)
+
    class Meta:
-        model = IssueAttachment
+        model = FileAsset
        fields = "__all__"
        read_only_fields = [
            "created_by",
@@ -514,14 +464,15 @@ class IssueAttachmentSerializer(BaseSerializer):

 class IssueAttachmentLiteSerializer(DynamicBaseSerializer):
    class Meta:
-        model = IssueAttachment
+        model = FileAsset
        fields = [
            "id",
            "asset",
            "attributes",
-            "issue_id",
+            # "issue_id",
            "updated_at",
            "updated_by",
+            "asset_url",
        ]
        read_only_fields = fields

@@ -532,37 +483,20 @@ class IssueReactionSerializer(BaseSerializer):
    class Meta:
        model = IssueReaction
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "issue",
-            "actor",
-            "deleted_at",
-        ]
+        read_only_fields = ["workspace", "project", "issue", "actor", "deleted_at"]


 class IssueReactionLiteSerializer(DynamicBaseSerializer):
    class Meta:
        model = IssueReaction
-        fields = [
-            "id",
-            "actor",
-            "issue",
-            "reaction",
-        ]
+        fields = ["id", "actor", "issue", "reaction"]


 class CommentReactionSerializer(BaseSerializer):
    class Meta:
        model = CommentReaction
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "comment",
-            "actor",
-            "deleted_at",
-        ]
+        read_only_fields = ["workspace", "project", "comment", "actor", "deleted_at"]


 class IssueVoteSerializer(BaseSerializer):
@@ -570,14 +504,7 @@ class IssueVoteSerializer(BaseSerializer):

    class Meta:
        model = IssueVote
-        fields = [
-            "issue",
-            "vote",
-            "workspace",
-            "project",
-            "actor",
-            "actor_detail",
-        ]
+        fields = ["issue", "vote", "workspace", "project", "actor", "actor_detail"]
        read_only_fields = fields


@@ -585,9 +512,7 @@ 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"
-    )
+    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
    comment_reactions = CommentReactionSerializer(read_only=True, many=True)
    is_member = serializers.BooleanField(read_only=True)

@@ -611,25 +536,15 @@ class IssueStateFlatSerializer(BaseSerializer):

    class Meta:
        model = Issue
-        fields = [
-            "id",
-            "sequence_id",
-            "name",
-            "state_detail",
-            "project_detail",
-        ]
+        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
-    )
+    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
    state_detail = StateLiteSerializer(read_only=True, source="state")
    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    assignee_details = UserLiteSerializer(
-        read_only=True, source="assignees", many=True
-    )
+    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
    sub_issues_count = serializers.IntegerField(read_only=True)
    attachment_count = serializers.IntegerField(read_only=True)
    link_count = serializers.IntegerField(read_only=True)
@@ -639,11 +554,8 @@ class IssueStateSerializer(DynamicBaseSerializer):
        fields = "__all__"


-class IssueInboxSerializer(DynamicBaseSerializer):
-    label_ids = serializers.ListField(
-        child=serializers.UUIDField(),
-        required=False,
-    )
+class IssueIntakeSerializer(DynamicBaseSerializer):
+    label_ids = serializers.ListField(child=serializers.UUIDField(), required=False)

    class Meta:
        model = Issue
@@ -663,20 +575,11 @@ class IssueInboxSerializer(DynamicBaseSerializer):
 class IssueSerializer(DynamicBaseSerializer):
    # ids
    cycle_id = serializers.PrimaryKeyRelatedField(read_only=True)
-    module_ids = serializers.ListField(
-        child=serializers.UUIDField(),
-        required=False,
-    )
+    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,
-    )
+    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)
@@ -718,11 +621,7 @@ class IssueSerializer(DynamicBaseSerializer):
 class IssueLiteSerializer(DynamicBaseSerializer):
    class Meta:
        model = Issue
-        fields = [
-            "id",
-            "sequence_id",
-            "project_id",
-        ]
+        fields = ["id", "sequence_id", "project_id"]
        read_only_fields = fields


@@ -731,10 +630,7 @@ class IssueDetailSerializer(IssueSerializer):
    is_subscribed = serializers.BooleanField(read_only=True)

    class Meta(IssueSerializer.Meta):
-        fields = IssueSerializer.Meta.fields + [
-            "description_html",
-            "is_subscribed",
-        ]
+        fields = IssueSerializer.Meta.fields + ["description_html", "is_subscribed"]
        read_only_fields = fields


@@ -770,8 +666,4 @@ class IssueSubscriberSerializer(BaseSerializer):
    class Meta:
        model = IssueSubscriber
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "issue",
-        ]
+        read_only_fields = ["workspace", "project", "issue"]
@@ -21,10 +21,7 @@ from plane.db.models import (

 class ModuleWriteSerializer(BaseSerializer):
    lead_id = serializers.PrimaryKeyRelatedField(
-        source="lead",
-        queryset=User.objects.all(),
-        required=False,
-        allow_null=True,
+        source="lead", queryset=User.objects.all(), required=False, allow_null=True
    )
    member_ids = serializers.ListField(
        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
@@ -48,9 +45,7 @@ class ModuleWriteSerializer(BaseSerializer):

    def to_representation(self, instance):
        data = super().to_representation(instance)
-        data["member_ids"] = [
-            str(member.id) for member in instance.members.all()
-        ]
+        data["member_ids"] = [str(member.id) for member in instance.members.all()]
        return data

    def validate(self, data):
@@ -59,9 +54,7 @@ class ModuleWriteSerializer(BaseSerializer):
            and data.get("target_date", None) is not None
            and data.get("start_date", None) > data.get("target_date", None)
        ):
-            raise serializers.ValidationError(
-                "Start date cannot exceed target date"
-            )
+            raise serializers.ValidationError("Start date cannot exceed target date")
        return data

    def create(self, validated_data):
@@ -71,9 +64,7 @@ class ModuleWriteSerializer(BaseSerializer):
        module_name = validated_data.get("name")
        if module_name:
            # Lookup for the module name in the module table for that project
-            if Module.objects.filter(
-                name=module_name, project=project
-            ).exists():
+            if Module.objects.filter(name=module_name, project=project).exists():
                raise serializers.ValidationError(
                    {"error": "Module with this name already exists"}
                )
@@ -104,9 +95,7 @@ class ModuleWriteSerializer(BaseSerializer):
        if module_name:
            # Lookup for the module name in the module table for that project
            if (
-                Module.objects.filter(
-                    name=module_name, project=instance.project
-                )
+                Module.objects.filter(name=module_name, project=instance.project)
                .exclude(id=instance.id)
                .exists()
            ):
@@ -203,8 +192,7 @@ class ModuleLinkSerializer(BaseSerializer):
    def create(self, validated_data):
        validated_data["url"] = self.validate_url(validated_data.get("url"))
        if ModuleLink.objects.filter(
-            url=validated_data.get("url"),
-            module_id=validated_data.get("module_id"),
+            url=validated_data.get("url"), module_id=validated_data.get("module_id")
        ).exists():
            raise serializers.ValidationError({"error": "URL already exists."})
        return super().create(validated_data)
@@ -213,8 +201,7 @@ class ModuleLinkSerializer(BaseSerializer):
        validated_data["url"] = self.validate_url(validated_data.get("url"))
        if (
            ModuleLink.objects.filter(
-                url=validated_data.get("url"),
-                module_id=instance.module_id,
+                url=validated_data.get("url"), module_id=instance.module_id
            )
            .exclude(pk=instance.id)
            .exists()
@@ -8,10 +8,9 @@ from rest_framework import serializers


 class NotificationSerializer(BaseSerializer):
-    triggered_by_details = UserLiteSerializer(
-        read_only=True, source="triggered_by"
-    )
+    triggered_by_details = UserLiteSerializer(read_only=True, source="triggered_by")
    is_inbox_issue = serializers.BooleanField(read_only=True)
+    is_intake_issue = serializers.BooleanField(read_only=True)
    is_mentioned_notification = serializers.BooleanField(read_only=True)

    class Meta:
@@ -22,14 +22,8 @@ class PageSerializer(BaseSerializer):
        required=False,
    )
    # Many to many
-    label_ids = serializers.ListField(
-        child=serializers.UUIDField(),
-        required=False,
-    )
-    project_ids = serializers.ListField(
-        child=serializers.UUIDField(),
-        required=False,
-    )
+    label_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
+    project_ids = serializers.ListField(child=serializers.UUIDField(), required=False)

    class Meta:
        model = Page
@@ -54,10 +48,7 @@ class PageSerializer(BaseSerializer):
            "label_ids",
            "project_ids",
        ]
-        read_only_fields = [
-            "workspace",
-            "owned_by",
-        ]
+        read_only_fields = ["workspace", "owned_by"]

    def create(self, validated_data):
        labels = validated_data.pop("labels", None)
@@ -127,9 +118,7 @@ class PageDetailSerializer(PageSerializer):
    description_html = serializers.CharField()

    class Meta(PageSerializer.Meta):
-        fields = PageSerializer.Meta.fields + [
-            "description_html",
-        ]
+        fields = PageSerializer.Meta.fields + ["description_html"]


 class SubPageSerializer(BaseSerializer):
@@ -138,10 +127,7 @@ class SubPageSerializer(BaseSerializer):
    class Meta:
        model = PageLog
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "page",
-        ]
+        read_only_fields = ["workspace", "page"]

    def get_entity_details(self, obj):
        entity_name = obj.entity_name
@@ -158,10 +144,7 @@ class PageLogSerializer(BaseSerializer):
    class Meta:
        model = PageLog
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "page",
-        ]
+        read_only_fields = ["workspace", "page"]


 class PageVersionSerializer(BaseSerializer):
@@ -178,10 +161,7 @@ class PageVersionSerializer(BaseSerializer):
            "created_by",
            "updated_by",
        ]
-        read_only_fields = [
-            "workspace",
-            "page",
-        ]
+        read_only_fields = ["workspace", "page"]


 class PageVersionDetailSerializer(BaseSerializer):
@@ -201,7 +181,4 @@ class PageVersionDetailSerializer(BaseSerializer):
            "created_by",
            "updated_by",
        ]
-        read_only_fields = [
-            "workspace",
-            "page",
-        ]
+        read_only_fields = ["workspace", "page"]
@@ -4,10 +4,7 @@ from rest_framework import serializers
 # Module imports
 from .base import BaseSerializer, DynamicBaseSerializer
 from plane.app.serializers.workspace import WorkspaceLiteSerializer
-from plane.app.serializers.user import (
-    UserLiteSerializer,
-    UserAdminLiteSerializer,
-)
+from plane.app.serializers.user import UserLiteSerializer, UserAdminLiteSerializer
 from plane.db.models import (
    Project,
    ProjectMember,
@@ -19,31 +16,23 @@ from plane.db.models import (


 class ProjectSerializer(BaseSerializer):
-    workspace_detail = WorkspaceLiteSerializer(
-        source="workspace", read_only=True
-    )
+    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",
-        ]
+        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"
-            )
+            raise serializers.ValidationError(detail="Project Identifier is required")

        if ProjectIdentifier.objects.filter(
            name=identifier, workspace_id=self.context["workspace_id"]
        ).exists():
-            raise serializers.ValidationError(
-                detail="Project Identifier is taken"
-            )
+            raise serializers.ValidationError(detail="Project Identifier is taken")
        project = Project.objects.create(
            **validated_data, workspace_id=self.context["workspace_id"]
        )
@@ -82,9 +71,7 @@ class ProjectSerializer(BaseSerializer):
            return project

        # If not same fail update
-        raise serializers.ValidationError(
-            detail="Project Identifier is already taken"
-        )
+        raise serializers.ValidationError(detail="Project Identifier is already taken")


 class ProjectLiteSerializer(BaseSerializer):
@@ -95,6 +82,7 @@ class ProjectLiteSerializer(BaseSerializer):
            "identifier",
            "name",
            "cover_image",
+            "cover_image_url",
            "logo_props",
            "description",
        ]
@@ -117,6 +105,8 @@ class ProjectListSerializer(DynamicBaseSerializer):
    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)
@@ -128,6 +118,7 @@ class ProjectListSerializer(DynamicBaseSerializer):
                    "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
            ]
@@ -209,26 +200,16 @@ class ProjectMemberLiteSerializer(BaseSerializer):

 class DeployBoardSerializer(BaseSerializer):
    project_details = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(
-        read_only=True, source="workspace"
-    )
+    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")

    class Meta:
        model = DeployBoard
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "anchor",
-        ]
+        read_only_fields = ["workspace", "project", "anchor"]


 class ProjectPublicMemberSerializer(BaseSerializer):
    class Meta:
        model = ProjectPublicMember
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "member",
-        ]
+        read_only_fields = ["workspace", "project", "member"]
@@ -19,19 +19,11 @@ class StateSerializer(BaseSerializer):
            "description",
            "sequence",
        ]
-        read_only_fields = [
-            "workspace",
-            "project",
-        ]
+        read_only_fields = ["workspace", "project"]


 class StateLiteSerializer(BaseSerializer):
    class Meta:
        model = State
-        fields = [
-            "id",
-            "name",
-            "color",
-            "group",
-        ]
+        fields = ["id", "name", "color", "group"]
        read_only_fields = fields
@@ -2,13 +2,7 @@
 from rest_framework import serializers

 # Module import
-from plane.db.models import (
-    Account,
-    Profile,
-    User,
-    Workspace,
-    WorkspaceMemberInvite,
-)
+from plane.db.models import Account, Profile, User, Workspace, WorkspaceMemberInvite

 from .base import BaseSerializer

@@ -17,11 +11,7 @@ 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"
-        ]
+        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",
@@ -62,6 +52,8 @@ class UserMeSerializer(BaseSerializer):
            "id",
            "avatar",
            "cover_image",
+            "avatar_url",
+            "cover_image_url",
            "date_joined",
            "display_name",
            "email",
@@ -84,11 +76,7 @@ class UserMeSettingsSerializer(BaseSerializer):

    class Meta:
        model = User
-        fields = [
-            "id",
-            "email",
-            "workspace",
-        ]
+        fields = ["id", "email", "workspace"]
        read_only_fields = fields

    def get_workspace(self, obj):
@@ -125,8 +113,7 @@ class UserMeSettingsSerializer(BaseSerializer):
        else:
            fallback_workspace = (
                Workspace.objects.filter(
-                    workspace_member__member_id=obj.id,
-                    workspace_member__is_active=True,
+                    workspace_member__member_id=obj.id, workspace_member__is_active=True
                )
                .order_by("created_at")
                .first()
@@ -135,14 +122,10 @@ class UserMeSettingsSerializer(BaseSerializer):
                "last_workspace_id": None,
                "last_workspace_slug": None,
                "fallback_workspace_id": (
-                    fallback_workspace.id
-                    if fallback_workspace is not None
-                    else None
+                    fallback_workspace.id if fallback_workspace is not None else None
                ),
                "fallback_workspace_slug": (
-                    fallback_workspace.slug
-                    if fallback_workspace is not None
-                    else None
+                    fallback_workspace.slug if fallback_workspace is not None else None
                ),
                "invites": workspace_invites,
            }
@@ -156,13 +139,11 @@ class UserLiteSerializer(BaseSerializer):
            "first_name",
            "last_name",
            "avatar",
+            "avatar_url",
            "is_bot",
            "display_name",
        ]
-        read_only_fields = [
-            "id",
-            "is_bot",
-        ]
+        read_only_fields = ["id", "is_bot"]


 class UserAdminLiteSerializer(BaseSerializer):
@@ -173,15 +154,13 @@ class UserAdminLiteSerializer(BaseSerializer):
            "first_name",
            "last_name",
            "avatar",
+            "avatar_url",
            "is_bot",
            "display_name",
            "email",
            "last_login_medium",
        ]
-        read_only_fields = [
-            "id",
-            "is_bot",
-        ]
+        read_only_fields = ["id", "is_bot"]


 class ChangePasswordSerializer(serializers.Serializer):
@@ -202,9 +181,7 @@ class ChangePasswordSerializer(serializers.Serializer):

        if data.get("new_password") != data.get("confirm_password"):
            raise serializers.ValidationError(
-                {
-                    "error": "Confirm password should be same as the new password."
-                }
+                {"error": "Confirm password should be same as the new password."}
            )

        return data
@@ -222,15 +199,11 @@ class ProfileSerializer(BaseSerializer):
    class Meta:
        model = Profile
        fields = "__all__"
-        read_only_fields = [
-            "user",
-        ]
+        read_only_fields = ["user"]


 class AccountSerializer(BaseSerializer):
    class Meta:
        model = Account
        fields = "__all__"
-        read_only_fields = [
-            "user",
-        ]
+        read_only_fields = ["user"]
@@ -47,13 +47,9 @@ class WebhookSerializer(DynamicBaseSerializer):

        # Additional validation for multiple request domains and their subdomains
        request = self.context.get("request")
-        disallowed_domains = [
-            "plane.so",
-        ]  # Add your disallowed domains here
+        disallowed_domains = ["plane.so"]  # Add your disallowed domains here
        if request:
-            request_host = request.get_host().split(":")[
-                0
-            ]  # Remove port if present
+            request_host = request.get_host().split(":")[0]  # Remove port if present
            disallowed_domains.append(request_host)

        # Check if hostname is a subdomain or exact match of any disallowed domain
@@ -99,9 +95,7 @@ class WebhookSerializer(DynamicBaseSerializer):

            # Additional validation for multiple request domains and their subdomains
            request = self.context.get("request")
-            disallowed_domains = [
-                "plane.so",
-            ]  # Add your disallowed domains here
+            disallowed_domains = ["plane.so"]  # Add your disallowed domains here
            if request:
                request_host = request.get_host().split(":")[
                    0
@@ -122,10 +116,7 @@ class WebhookSerializer(DynamicBaseSerializer):
    class Meta:
        model = Webhook
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "secret_key",
-        ]
+        read_only_fields = ["workspace", "secret_key"]


 class WebhookLogSerializer(DynamicBaseSerializer):
@@ -22,6 +22,7 @@ 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
@@ -39,17 +40,14 @@ class WorkSpaceSerializer(DynamicBaseSerializer):
            "created_at",
            "updated_at",
            "owner",
+            "logo_url",
        ]


 class WorkspaceLiteSerializer(BaseSerializer):
    class Meta:
        model = Workspace
-        fields = [
-            "name",
-            "slug",
-            "id",
-        ]
+        fields = ["name", "slug", "id"]
        read_only_fields = fields


@@ -63,6 +61,8 @@ class WorkSpaceMemberSerializer(DynamicBaseSerializer):


 class WorkspaceMemberMeSerializer(BaseSerializer):
+    draft_issue_count = serializers.IntegerField(read_only=True)
+
    class Meta:
        model = WorkspaceMember
        fields = "__all__"
@@ -98,9 +98,7 @@ class WorkSpaceMemberInviteSerializer(BaseSerializer):


 class TeamSerializer(BaseSerializer):
-    members_detail = UserLiteSerializer(
-        read_only=True, source="members", many=True
-    )
+    members_detail = UserLiteSerializer(read_only=True, source="members", many=True)
    members = serializers.ListField(
        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
        write_only=True,
@@ -137,9 +135,7 @@ class TeamSerializer(BaseSerializer):
            members = validated_data.pop("members")
            TeamMember.objects.filter(team=instance).delete()
            team_members = [
-                TeamMember(
-                    member=member, team=instance, workspace=instance.workspace
-                )
+                TeamMember(member=member, team=instance, workspace=instance.workspace)
                for member in members
            ]
            TeamMember.objects.bulk_create(team_members, batch_size=10)
@@ -151,17 +147,11 @@ class WorkspaceThemeSerializer(BaseSerializer):
    class Meta:
        model = WorkspaceTheme
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "actor",
-        ]
+        read_only_fields = ["workspace", "actor"]


 class WorkspaceUserPropertiesSerializer(BaseSerializer):
    class Meta:
        model = WorkspaceUserProperties
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "user",
-        ]
+        read_only_fields = ["workspace", "user"]
@@ -5,7 +5,7 @@ from .cycle import urlpatterns as cycle_urls
 from .dashboard import urlpatterns as dashboard_urls
 from .estimate import urlpatterns as estimate_urls
 from .external import urlpatterns as external_urls
-from .inbox import urlpatterns as inbox_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
@@ -25,7 +25,7 @@ urlpatterns = [
    *dashboard_urls,
    *estimate_urls,
    *external_urls,
-    *inbox_urls,
+    *intake_urls,
    *issue_urls,
    *module_urls,
    *notification_urls,
@@ -5,6 +5,13 @@ from plane.app.views import (
    FileAssetEndpoint,
    UserAssetsEndpoint,
    FileAssetViewSet,
+    # V2 Endpoints
+    WorkspaceFileAssetEndpoint,
+    UserAssetsV2Endpoint,
+    StaticFileAssetEndpoint,
+    AssetRestoreEndpoint,
+    ProjectAssetEndpoint,
+    ProjectBulkAssetEndpoint,
 )


@@ -19,11 +26,7 @@ urlpatterns = [
        FileAssetEndpoint.as_view(),
        name="file-assets",
    ),
-    path(
-        "users/file-assets/",
-        UserAssetsEndpoint.as_view(),
-        name="user-file-assets",
-    ),
+    path("users/file-assets/", UserAssetsEndpoint.as_view(), name="user-file-assets"),
    path(
        "users/file-assets/<str:asset_key>/",
        UserAssetsEndpoint.as_view(),
@@ -31,11 +34,52 @@ urlpatterns = [
    ),
    path(
        "workspaces/file-assets/<uuid:workspace_id>/<str:asset_key>/restore/",
-        FileAssetViewSet.as_view(
-            {
-                "post": "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(),
+    ),
 ]
@@ -17,12 +17,7 @@ from plane.app.views import (
 urlpatterns = [
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/",
-        CycleViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        CycleViewSet.as_view({"get": "list", "post": "create"}),
        name="project-cycle",
    ),
    path(
@@ -39,12 +34,7 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/",
-        CycleIssueViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        CycleIssueViewSet.as_view({"get": "list", "post": "create"}),
        name="project-issue-cycle",
    ),
    path(
@@ -66,21 +56,12 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-cycles/",
-        CycleFavoriteViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        CycleFavoriteViewSet.as_view({"get": "list", "post": "create"}),
        name="user-favorite-cycle",
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-cycles/<uuid:cycle_id>/",
-        CycleFavoriteViewSet.as_view(
-            {
-                "delete": "destroy",
-            }
-        ),
+        CycleFavoriteViewSet.as_view({"delete": "destroy"}),
        name="user-favorite-cycle",
    ),
    path(
@@ -16,42 +16,24 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/estimates/",
-        BulkEstimatePointEndpoint.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        BulkEstimatePointEndpoint.as_view({"get": "list", "post": "create"}),
        name="bulk-create-estimate-points",
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/estimates/<uuid:estimate_id>/",
        BulkEstimatePointEndpoint.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
+            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
        ),
        name="bulk-create-estimate-points",
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/estimates/<uuid:estimate_id>/estimate-points/",
-        EstimatePointEndpoint.as_view(
-            {
-                "post": "create",
-            }
-        ),
+        EstimatePointEndpoint.as_view({"post": "create"}),
        name="estimate-points",
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/estimates/<uuid:estimate_id>/estimate-points/<estimate_point_id>/",
-        EstimatePointEndpoint.as_view(
-            {
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
+        EstimatePointEndpoint.as_view({"patch": "partial_update", "delete": "destroy"}),
        name="estimate-points",
    ),
 ]
@@ -6,17 +6,13 @@ from plane.app.views import GPTIntegrationEndpoint, WorkspaceGPTIntegrationEndpo


 urlpatterns = [
-    path(
-        "unsplash/",
-        UnsplashEndpoint.as_view(),
-        name="unsplash",
-    ),
+    path("unsplash/", UnsplashEndpoint.as_view(), name="unsplash"),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/ai-assistant/",
        GPTIntegrationEndpoint.as_view(),
        name="importer",
    ),
-   path(
+    path(
        "workspaces/<str:slug>/ai-assistant/",
        WorkspaceGPTIntegrationEndpoint.as_view(),
        name="importer",
@@ -1,53 +0,0 @@
-from django.urls import path
-
-
-from plane.app.views import (
-    InboxViewSet,
-    InboxIssueViewSet,
-)
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/",
-        InboxViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
-        name="inbox",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:pk>/",
-        InboxViewSet.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="inbox",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
-        InboxIssueViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
-        name="inbox-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:pk>/",
-        InboxIssueViewSet.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="inbox-issue",
-    ),
-]
@@ -0,0 +1,56 @@
+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",
+    ),
+]
@@ -21,6 +21,9 @@ from plane.app.views import (
    BulkArchiveIssuesEndpoint,
    DeletedIssuesListViewSet,
    IssuePaginatedViewSet,
+    IssueDetailEndpoint,
+    IssueAttachmentV2Endpoint,
+    IssueBulkUpdateDateEndpoint,
 )

 urlpatterns = [
@@ -31,14 +34,15 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/",
-        IssueViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        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/",
@@ -59,12 +63,7 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/",
-        LabelViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        LabelViewSet.as_view({"get": "list", "post": "create"}),
        name="project-issue-labels",
    ),
    path(
@@ -102,12 +101,7 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-links/",
-        IssueLinkViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        IssueLinkViewSet.as_view({"get": "list", "post": "create"}),
        name="project-issue-links",
    ),
    path(
@@ -132,6 +126,18 @@ urlpatterns = [
        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(),
@@ -148,12 +154,7 @@ urlpatterns = [
    ## IssueComments
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/",
-        IssueCommentViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        IssueCommentViewSet.as_view({"get": "list", "post": "create"}),
        name="project-issue-comment",
    ),
    path(
@@ -172,12 +173,7 @@ urlpatterns = [
    # Issue Subscribers
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-subscribers/",
-        IssueSubscriberViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        IssueSubscriberViewSet.as_view({"get": "list", "post": "create"}),
        name="project-issue-subscribers",
    ),
    path(
@@ -188,11 +184,7 @@ urlpatterns = [
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/subscribe/",
        IssueSubscriberViewSet.as_view(
-            {
-                "get": "subscription_status",
-                "post": "subscribe",
-                "delete": "unsubscribe",
-            }
+            {"get": "subscription_status", "post": "subscribe", "delete": "unsubscribe"}
        ),
        name="project-issue-subscribers",
    ),
@@ -200,42 +192,24 @@ urlpatterns = [
    # Issue Reactions
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/reactions/",
-        IssueReactionViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        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",
-            }
-        ),
+        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",
-            }
-        ),
+        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",
-            }
-        ),
+        CommentReactionViewSet.as_view({"delete": "destroy"}),
        name="project-issue-comment-reactions",
    ),
    ## End Comment Reactions
@@ -249,21 +223,13 @@ urlpatterns = [
    ## Issue Archives
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-issues/",
-        IssueArchiveViewSet.as_view(
-            {
-                "get": "list",
-            }
-        ),
+        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",
-            }
+            {"get": "retrieve", "post": "archive", "delete": "unarchive"}
        ),
        name="project-issue-archive-unarchive",
    ),
@@ -271,21 +237,12 @@ urlpatterns = [
    ## Issue Relation
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-relation/",
-        IssueRelationViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        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",
-            }
-        ),
+        IssueRelationViewSet.as_view({"post": "remove_relation"}),
        name="issue-relation",
    ),
    ## End Issue Relation
@@ -294,4 +251,9 @@ urlpatterns = [
        DeletedIssuesListViewSet.as_view(),
        name="deleted-issues",
    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-dates/",
+        IssueBulkUpdateDateEndpoint.as_view(),
+        name="project-issue-dates",
+    ),
 ]
@@ -14,12 +14,7 @@ from plane.app.views import (
 urlpatterns = [
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/",
-        ModuleViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        ModuleViewSet.as_view({"get": "list", "post": "create"}),
        name="project-modules",
    ),
    path(
@@ -36,21 +31,12 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/modules/",
-        ModuleIssueViewSet.as_view(
-            {
-                "post": "create_issue_modules",
-            }
-        ),
+        ModuleIssueViewSet.as_view({"post": "create_issue_modules"}),
        name="issue-module",
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/issues/",
-        ModuleIssueViewSet.as_view(
-            {
-                "post": "create_module_issues",
-                "get": "list",
-            }
-        ),
+        ModuleIssueViewSet.as_view({"post": "create_module_issues", "get": "list"}),
        name="project-module-issues",
    ),
    path(
@@ -67,12 +53,7 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-links/",
-        ModuleLinkViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        ModuleLinkViewSet.as_view({"get": "list", "post": "create"}),
        name="project-issue-module-links",
    ),
    path(
@@ -89,21 +70,12 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-modules/",
-        ModuleFavoriteViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        ModuleFavoriteViewSet.as_view({"get": "list", "post": "create"}),
        name="user-favorite-module",
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-modules/<uuid:module_id>/",
-        ModuleFavoriteViewSet.as_view(
-            {
-                "delete": "destroy",
-            }
-        ),
+        ModuleFavoriteViewSet.as_view({"delete": "destroy"}),
        name="user-favorite-module",
    ),
    path(
@@ -12,42 +12,24 @@ from plane.app.views import (
 urlpatterns = [
    path(
        "workspaces/<str:slug>/users/notifications/",
-        NotificationViewSet.as_view(
-            {
-                "get": "list",
-            }
-        ),
+        NotificationViewSet.as_view({"get": "list"}),
        name="notifications",
    ),
    path(
        "workspaces/<str:slug>/users/notifications/<uuid:pk>/",
        NotificationViewSet.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
+            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
        ),
        name="notifications",
    ),
    path(
        "workspaces/<str:slug>/users/notifications/<uuid:pk>/read/",
-        NotificationViewSet.as_view(
-            {
-                "post": "mark_read",
-                "delete": "mark_unread",
-            }
-        ),
+        NotificationViewSet.as_view({"post": "mark_read", "delete": "mark_unread"}),
        name="notifications",
    ),
    path(
        "workspaces/<str:slug>/users/notifications/<uuid:pk>/archive/",
-        NotificationViewSet.as_view(
-            {
-                "post": "archive",
-                "delete": "unarchive",
-            }
-        ),
+        NotificationViewSet.as_view({"post": "archive", "delete": "unarchive"}),
        name="notifications",
    ),
    path(
@@ -57,11 +39,7 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/users/notifications/mark-all-read/",
-        MarkAllReadNotificationViewSet.as_view(
-            {
-                "post": "create",
-            }
-        ),
+        MarkAllReadNotificationViewSet.as_view({"post": "create"}),
        name="mark-all-read-notifications",
    ),
    path(
@@ -14,66 +14,38 @@ from plane.app.views import (
 urlpatterns = [
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/",
-        PageViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        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",
-            }
+            {"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",
-            }
-        ),
+        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",
-            }
-        ),
+        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",
-            }
-        ),
+        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",
-            }
-        ),
+        PageViewSet.as_view({"post": "access"}),
        name="project-pages-access",
    ),
    path(
@@ -93,12 +65,7 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/description/",
-        PagesDescriptionViewSet.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-            }
-        ),
+        PagesDescriptionViewSet.as_view({"get": "retrieve", "patch": "partial_update"}),
        name="page-description",
    ),
    path(
@@ -21,12 +21,7 @@ from plane.app.views import (
 urlpatterns = [
    path(
        "workspaces/<str:slug>/projects/",
-        ProjectViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        ProjectViewSet.as_view({"get": "list", "post": "create"}),
        name="project",
    ),
    path(
@@ -48,32 +43,17 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/invitations/",
-        ProjectInvitationsViewset.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            },
-        ),
+        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",
-            }
-        ),
+        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",
-            },
-        ),
+        UserProjectInvitationsViewset.as_view({"get": "list", "post": "create"}),
        name="user-project-invitations",
    ),
    path(
@@ -88,32 +68,19 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/members/",
-        ProjectMemberViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        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",
-            }
+            {"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",
-            }
-        ),
+        ProjectMemberViewSet.as_view({"post": "leave"}),
        name="project-member",
    ),
    path(
@@ -133,21 +100,12 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/user-favorite-projects/",
-        ProjectFavoritesViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        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",
-            }
-        ),
+        ProjectFavoritesViewSet.as_view({"delete": "destroy"}),
        name="project-favorite",
    ),
    path(
@@ -157,22 +115,13 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/project-deploy-boards/",
-        DeployBoardViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        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",
-            }
+            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
        ),
        name="project-deploy-board",
    ),
@@ -1,10 +1,7 @@
 from django.urls import path


-from plane.app.views import (
-    GlobalSearchEndpoint,
-    IssueSearchEndpoint,
-)
+from plane.app.views import GlobalSearchEndpoint, IssueSearchEndpoint


 urlpatterns = [
@@ -7,32 +7,19 @@ from plane.app.views import StateViewSet
 urlpatterns = [
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/states/",
-        StateViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        StateViewSet.as_view({"get": "list", "post": "create"}),
        name="project-states",
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/states/<uuid:pk>/",
        StateViewSet.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
+            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
        ),
        name="project-state",
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/states/<uuid:pk>/mark-default/",
-        StateViewSet.as_view(
-            {
-                "post": "mark_as_default",
-            }
-        ),
+        StateViewSet.as_view({"post": "mark_as_default"}),
        name="project-state",
    ),
 ]
@@ -22,60 +22,30 @@ urlpatterns = [
    path(
        "users/me/",
        UserEndpoint.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "deactivate",
-            }
+            {"get": "retrieve", "patch": "partial_update", "delete": "deactivate"}
        ),
        name="users",
    ),
-    path(
-        "users/session/",
-        UserSessionEndpoint.as_view(),
-        name="user-session",
-    ),
+    path("users/session/", UserSessionEndpoint.as_view(), name="user-session"),
    path(
        "users/me/settings/",
-        UserEndpoint.as_view(
-            {
-                "get": "retrieve_user_settings",
-            }
-        ),
+        UserEndpoint.as_view({"get": "retrieve_user_settings"}),
        name="users",
    ),
    # Profile
-    path(
-        "users/me/profile/",
-        ProfileEndpoint.as_view(),
-        name="accounts",
-    ),
+    path("users/me/profile/", ProfileEndpoint.as_view(), name="accounts"),
    # End profile
    # Accounts
-    path(
-        "users/me/accounts/",
-        AccountEndpoint.as_view(),
-        name="accounts",
-    ),
-    path(
-        "users/me/accounts/<uuid:pk>/",
-        AccountEndpoint.as_view(),
-        name="accounts",
-    ),
+    path("users/me/accounts/", AccountEndpoint.as_view(), name="accounts"),
+    path("users/me/accounts/<uuid:pk>/", AccountEndpoint.as_view(), name="accounts"),
    ## End Accounts
    path(
        "users/me/instance-admin/",
-        UserEndpoint.as_view(
-            {
-                "get": "retrieve_instance_admin",
-            }
-        ),
+        UserEndpoint.as_view({"get": "retrieve_instance_admin"}),
        name="users",
    ),
    path(
-        "users/me/onboard/",
-        UpdateUserOnBoardedEndpoint.as_view(),
-        name="user-onboard",
+        "users/me/onboard/", UpdateUserOnBoardedEndpoint.as_view(), name="user-onboard"
    ),
    path(
        "users/me/tour-completed/",
@@ -83,15 +53,11 @@ urlpatterns = [
        name="user-tour",
    ),
    path(
-        "users/me/activities/",
-        UserActivityEndpoint.as_view(),
-        name="user-activities",
+        "users/me/activities/", UserActivityEndpoint.as_view(), name="user-activities"
    ),
    # user workspaces
    path(
-        "users/me/workspaces/",
-        UserWorkSpacesEndpoint.as_view(),
-        name="user-workspace",
+        "users/me/workspaces/", UserWorkSpacesEndpoint.as_view(), name="user-workspace"
    ),
    # User Graphs
    path(
@@ -12,12 +12,7 @@ from plane.app.views import (
 urlpatterns = [
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/views/",
-        IssueViewViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        IssueViewViewSet.as_view({"get": "list", "post": "create"}),
        name="project-view",
    ),
    path(
@@ -34,12 +29,7 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/views/",
-        WorkspaceViewViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        WorkspaceViewViewSet.as_view({"get": "list", "post": "create"}),
        name="global-view",
    ),
    path(
@@ -56,30 +46,17 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/issues/",
-        WorkspaceViewIssuesViewSet.as_view(
-            {
-                "get": "list",
-            }
-        ),
+        WorkspaceViewIssuesViewSet.as_view({"get": "list"}),
        name="global-view-issues",
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-views/",
-        IssueViewFavoriteViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        IssueViewFavoriteViewSet.as_view({"get": "list", "post": "create"}),
        name="user-favorite-view",
    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-views/<uuid:view_id>/",
-        IssueViewFavoriteViewSet.as_view(
-            {
-                "delete": "destroy",
-            }
-        ),
+        IssueViewFavoriteViewSet.as_view({"delete": "destroy"}),
        name="user-favorite-view",
    ),
 ]
@@ -8,11 +8,7 @@ from plane.app.views import (


 urlpatterns = [
-    path(
-        "workspaces/<str:slug>/webhooks/",
-        WebhookEndpoint.as_view(),
-        name="webhooks",
-    ),
+    path("workspaces/<str:slug>/webhooks/", WebhookEndpoint.as_view(), name="webhooks"),
    path(
        "workspaces/<str:slug>/webhooks/<uuid:pk>/",
        WebhookEndpoint.as_view(),
@@ -39,12 +39,7 @@ urlpatterns = [
    ),
    path(
        "workspaces/",
-        WorkSpaceViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        WorkSpaceViewSet.as_view({"get": "list", "post": "create"}),
        name="workspace",
    ),
    path(
@@ -61,34 +56,20 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/invitations/",
-        WorkspaceInvitationsViewset.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            },
-        ),
+        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",
-            }
+            {"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",
-            },
-        ),
+        UserWorkspaceInvitationsViewSet.as_view({"get": "list", "post": "create"}),
        name="user-workspace-invitations",
    ),
    path(
@@ -110,31 +91,18 @@ urlpatterns = [
    path(
        "workspaces/<str:slug>/members/<uuid:pk>/",
        WorkSpaceMemberViewSet.as_view(
-            {
-                "patch": "partial_update",
-                "delete": "destroy",
-                "get": "retrieve",
-            }
+            {"patch": "partial_update", "delete": "destroy", "get": "retrieve"}
        ),
        name="workspace-member",
    ),
    path(
        "workspaces/<str:slug>/members/leave/",
-        WorkSpaceMemberViewSet.as_view(
-            {
-                "post": "leave",
-            },
-        ),
+        WorkSpaceMemberViewSet.as_view({"post": "leave"}),
        name="leave-workspace-members",
    ),
    path(
        "workspaces/<str:slug>/teams/",
-        TeamMemberViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        TeamMemberViewSet.as_view({"get": "list", "post": "create"}),
        name="workspace-team-members",
    ),
    path(
@@ -166,22 +134,13 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/workspace-themes/",
-        WorkspaceThemeViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        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",
-            }
+            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
        ),
        name="workspace-themes",
    ),
@@ -257,23 +216,19 @@ urlpatterns = [
    ),
    path(
        "workspaces/<str:slug>/draft-issues/",
-        WorkspaceDraftIssueViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
+        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",
-            }
+            {"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",
+    ),
 ]
@@ -59,12 +59,8 @@ from .workspace.invite import (
    WorkspaceJoinEndpoint,
    UserWorkspaceInvitationsViewSet,
 )
-from .workspace.label import (
-    WorkspaceLabelsEndpoint,
-)
-from .workspace.state import (
-    WorkspaceStatesEndpoint,
-)
+from .workspace.label import WorkspaceLabelsEndpoint
+from .workspace.state import WorkspaceStatesEndpoint
 from .workspace.user import (
    UserLastProjectWithWorkspaceEndpoint,
    WorkspaceUserProfileIssuesEndpoint,
@@ -75,15 +71,9 @@ from .workspace.user import (
    UserActivityGraphEndpoint,
    UserIssueCompletedGraphEndpoint,
 )
-from .workspace.estimate import (
-    WorkspaceEstimatesEndpoint,
-)
-from .workspace.module import (
-    WorkspaceModulesEndpoint,
-)
-from .workspace.cycle import (
-    WorkspaceCyclesEndpoint,
-)
+from .workspace.estimate import WorkspaceEstimatesEndpoint
+from .workspace.module import WorkspaceModulesEndpoint
+from .workspace.cycle import WorkspaceCyclesEndpoint

 from .state.base import StateViewSet
 from .view.base import (
@@ -103,14 +93,18 @@ from .cycle.base import (
    CycleAnalyticsEndpoint,
    CycleProgressEndpoint,
 )
-from .cycle.issue import (
-    CycleIssueViewSet,
-)
-from .cycle.archive import (
-    CycleArchiveUnarchiveEndpoint,
-)
+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,
@@ -118,47 +112,33 @@ from .issue.base import (
    BulkDeleteIssuesEndpoint,
    DeletedIssuesListViewSet,
    IssuePaginatedViewSet,
+    IssueDetailEndpoint,
+    IssueBulkUpdateDateEndpoint,
 )

-from .issue.activity import (
-    IssueActivityEndpoint,
-)
+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.comment import IssueCommentViewSet, CommentReactionViewSet

-from .issue.label import (
-    LabelViewSet,
-    BulkCreateIssueLabelsEndpoint,
-)
+from .issue.label import LabelViewSet, BulkCreateIssueLabelsEndpoint

-from .issue.link import (
-    IssueLinkViewSet,
-)
+from .issue.link import IssueLinkViewSet

-from .issue.relation import (
-    IssueRelationViewSet,
-)
+from .issue.relation import IssueRelationViewSet

-from .issue.reaction import (
-    IssueReactionViewSet,
-)
+from .issue.reaction import IssueReactionViewSet

-from .issue.sub_issue import (
-    SubIssuesEndpoint,
-)
+from .issue.sub_issue import SubIssuesEndpoint

-from .issue.subscriber import (
-    IssueSubscriberViewSet,
-)
+from .issue.subscriber import IssueSubscriberViewSet

 from .module.base import (
    ModuleViewSet,
@@ -167,18 +147,11 @@ from .module.base import (
    ModuleUserPropertiesEndpoint,
 )

-from .module.issue import (
-    ModuleIssueViewSet,
-)
+from .module.issue import ModuleIssueViewSet

-from .module.archive import (
-    ModuleArchiveUnarchiveEndpoint,
-)
+from .module.archive import ModuleArchiveUnarchiveEndpoint

-from .api import (
-    ApiTokenEndpoint,
-    ServiceApiTokenEndpoint,
-)
+from .api import ApiTokenEndpoint, ServiceApiTokenEndpoint

 from .page.base import (
    PageViewSet,
@@ -204,7 +177,7 @@ from .estimate.base import (
    EstimatePointEndpoint,
 )

-from .inbox.base import InboxViewSet, InboxIssueViewSet
+from .intake.base import IntakeViewSet, IntakeIssueViewSet

 from .analytic.base import (
    AnalyticsEndpoint,
@@ -1,7 +1,10 @@
 # Django imports
-from django.db.models import Count, F, Sum
+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
@@ -19,14 +22,7 @@ from plane.app.permissions import allow_permission, ROLE


 class AnalyticsEndpoint(BaseAPIView):
-
-    @allow_permission(
-        [
-            ROLE.ADMIN,
-            ROLE.MEMBER,
-        ],
-        level="WORKSPACE",
-    )
+    @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)
@@ -47,10 +43,7 @@ class AnalyticsEndpoint(BaseAPIView):
            "completed_at",
        ]

-        valid_yaxis = [
-            "issue_count",
-            "estimate",
-        ]
+        valid_yaxis = ["issue_count", "estimate"]

        # Check for x-axis and y-axis as thery are required parameters
        if (
@@ -67,9 +60,7 @@ class AnalyticsEndpoint(BaseAPIView):
            )

        # If segment is present it cannot be same as x-axis
-        if segment and (
-            segment not in valid_xaxis_segment or x_axis == segment
-        ):
+        if segment and (segment not in valid_xaxis_segment or x_axis == segment):
            return Response(
                {
                    "error": "Both segment and x axis cannot be same and segment should be valid"
@@ -94,10 +85,7 @@ class AnalyticsEndpoint(BaseAPIView):
        state_details = {}
        if x_axis in ["state_id"] or segment in ["state_id"]:
            state_details = (
-                Issue.issue_objects.filter(
-                    workspace__slug=slug,
-                    **filters,
-                )
+                Issue.issue_objects.filter(workspace__slug=slug, **filters)
                .distinct("state_id")
                .order_by("state_id")
                .values("state_id", "state__name", "state__color")
@@ -107,7 +95,10 @@ class AnalyticsEndpoint(BaseAPIView):
        if x_axis in ["labels__id"] or segment in ["labels__id"]:
            label_details = (
                Issue.objects.filter(
-                    workspace__slug=slug, **filters, labels__id__isnull=False
+                    workspace__slug=slug,
+                    **filters,
+                    labels__id__isnull=False,
+                    label_issue__deleted_at__isnull=True,
                )
                .distinct("labels__id")
                .order_by("labels__id")
@@ -118,14 +109,37 @@ class AnalyticsEndpoint(BaseAPIView):
        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,
-                    assignees__avatar__isnull=False,
+                )
+                .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",
+                    "assignees__avatar_url",
                    "assignees__display_name",
                    "assignees__first_name",
                    "assignees__last_name",
@@ -134,21 +148,17 @@ class AnalyticsEndpoint(BaseAPIView):
            )

        cycle_details = {}
-        if x_axis in ["issue_cycle__cycle_id"] or segment in [
-            "issue_cycle__cycle_id"
-        ]:
+        if x_axis in ["issue_cycle__cycle_id"] or segment in ["issue_cycle__cycle_id"]:
            cycle_details = (
                Issue.issue_objects.filter(
                    workspace__slug=slug,
                    **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",
-                )
+                .values("issue_cycle__cycle_id", "issue_cycle__cycle__name")
            )

        module_details = {}
@@ -160,13 +170,11 @@ class AnalyticsEndpoint(BaseAPIView):
                    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",
-                )
+                .values("issue_module__module_id", "issue_module__module__name")
            )

        return Response(
@@ -186,9 +194,7 @@ class AnalyticsEndpoint(BaseAPIView):


 class AnalyticViewViewset(BaseViewSet):
-    permission_classes = [
-        WorkSpaceAdminPermission,
-    ]
+    permission_classes = [WorkSpaceAdminPermission]
    model = AnalyticView
    serializer_class = AnalyticViewSerializer

@@ -198,25 +204,14 @@ class AnalyticViewViewset(BaseViewSet):

    def get_queryset(self):
        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
+            super().get_queryset().filter(workspace__slug=self.kwargs.get("slug"))
        )


 class SavedAnalyticEndpoint(BaseAPIView):
-
-    @allow_permission(
-        [
-            ROLE.ADMIN,
-            ROLE.MEMBER,
-        ],
-        level="WORKSPACE",
-    )
+    @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
-        )
+        analytic_view = AnalyticView.objects.get(pk=analytic_id, workspace__slug=slug)

        filter = analytic_view.query
        queryset = Issue.issue_objects.filter(**filter)
@@ -242,14 +237,7 @@ class SavedAnalyticEndpoint(BaseAPIView):


 class ExportAnalyticsEndpoint(BaseAPIView):
-
-    @allow_permission(
-        [
-            ROLE.ADMIN,
-            ROLE.MEMBER,
-        ],
-        level="WORKSPACE",
-    )
+    @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)
@@ -270,10 +258,7 @@ class ExportAnalyticsEndpoint(BaseAPIView):
            "completed_at",
        ]

-        valid_yaxis = [
-            "issue_count",
-            "estimate",
-        ]
+        valid_yaxis = ["issue_count", "estimate"]

        # Check for x-axis and y-axis as thery are required parameters
        if (
@@ -290,9 +275,7 @@ class ExportAnalyticsEndpoint(BaseAPIView):
            )

        # If segment is present it cannot be same as x-axis
-        if segment and (
-            segment not in valid_xaxis_segment or x_axis == segment
-        ):
+        if segment and (segment not in valid_xaxis_segment or x_axis == segment):
            return Response(
                {
                    "error": "Both segment and x axis cannot be same and segment should be valid"
@@ -313,13 +296,10 @@ class ExportAnalyticsEndpoint(BaseAPIView):


 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
-        )
+        base_issues = Issue.issue_objects.filter(workspace__slug=slug, **filters)

        total_issues = base_issues.count()

@@ -332,9 +312,7 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
        )

        open_issues_groups = ["backlog", "unstarted", "started"]
-        open_issues_queryset = state_groups.filter(
-            state__group__in=open_issues_groups
-        )
+        open_issues_queryset = state_groups.filter(state__group__in=open_issues_groups)

        open_issues = open_issues_queryset.count()
        open_issues_classified = (
@@ -355,7 +333,6 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
        user_details = [
            "created_by__first_name",
            "created_by__last_name",
-            "created_by__avatar",
            "created_by__display_name",
            "created_by__id",
        ]
@@ -364,13 +341,31 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
            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__avatar",
            "assignees__display_name",
            "assignees__id",
        ]
@@ -379,6 +374,25 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
            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]
        )
@@ -387,12 +401,29 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
            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"
-        ]
+        open_estimate_sum = open_issues_queryset.aggregate(sum=Sum("point"))["sum"]
        total_estimate_sum = base_issues.aggregate(sum=Sum("point"))["sum"]

        return Response(
@@ -13,9 +13,7 @@ from plane.app.permissions import WorkspaceOwnerPermission


 class ApiTokenEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkspaceOwnerPermission,
-    ]
+    permission_classes = [WorkspaceOwnerPermission]

    def post(self, request, slug):
        label = request.data.get("label", str(uuid4().hex))
@@ -37,10 +35,7 @@ class ApiTokenEndpoint(BaseAPIView):

        serializer = APITokenSerializer(api_token)
        # Token will be only visible while creating
-        return Response(
-            serializer.data,
-            status=status.HTTP_201_CREATED,
-        )
+        return Response(serializer.data, status=status.HTTP_201_CREATED)

    def get(self, request, slug, pk=None):
        if pk is None:
@@ -58,23 +53,14 @@ class ApiTokenEndpoint(BaseAPIView):

    def delete(self, request, slug, pk):
        api_token = APIToken.objects.get(
-            workspace__slug=slug,
-            user=request.user,
-            pk=pk,
-            is_service=False,
+            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
-        )
+        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)
@@ -82,25 +68,17 @@ class ApiTokenEndpoint(BaseAPIView):


 class ServiceApiTokenEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkspaceOwnerPermission,
-    ]
+    permission_classes = [WorkspaceOwnerPermission]

    def post(self, request, slug):
        workspace = Workspace.objects.get(slug=slug)

        api_token = APIToken.objects.filter(
-            workspace=workspace,
-            is_service=True,
+            workspace=workspace, is_service=True
        ).first()

        if api_token:
-            return Response(
-                {
-                    "token": str(api_token.token),
-                },
-                status=status.HTTP_200_OK,
-            )
+            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
@@ -114,9 +92,5 @@ class ServiceApiTokenEndpoint(BaseAPIView):
                is_service=True,
            )
            return Response(
-                {
-                    "token": str(api_token.token),
-                },
-                status=status.HTTP_201_CREATED,
+                {"token": str(api_token.token)}, status=status.HTTP_201_CREATED
            )
-
@@ -10,11 +10,7 @@ from plane.app.serializers import FileAssetSerializer


 class FileAssetEndpoint(BaseAPIView):
-    parser_classes = (
-        MultiPartParser,
-        FormParser,
-        JSONParser,
-    )
+    parser_classes = (MultiPartParser, FormParser, JSONParser)

    """
    A viewset for viewing and editing task instances.
@@ -28,8 +24,7 @@ class FileAssetEndpoint(BaseAPIView):
                files, context={"request": request}, many=True
            )
            return Response(
-                {"data": serializer.data, "status": True},
-                status=status.HTTP_200_OK,
+                {"data": serializer.data, "status": True}, status=status.HTTP_200_OK
            )
        else:
            return Response(
@@ -50,7 +45,7 @@ class FileAssetEndpoint(BaseAPIView):
        asset_key = str(workspace_id) + "/" + asset_key
        file_asset = FileAsset.objects.get(asset=asset_key)
        file_asset.is_deleted = True
-        file_asset.save()
+        file_asset.save(update_fields=["is_deleted"])
        return Response(status=status.HTTP_204_NO_CONTENT)


@@ -59,7 +54,7 @@ class FileAssetViewSet(BaseViewSet):
        asset_key = str(workspace_id) + "/" + asset_key
        file_asset = FileAsset.objects.get(asset=asset_key)
        file_asset.is_deleted = False
-        file_asset.save()
+        file_asset.save(update_fields=["is_deleted"])
        return Response(status=status.HTTP_204_NO_CONTENT)


@@ -67,16 +62,11 @@ class UserAssetsEndpoint(BaseAPIView):
    parser_classes = (MultiPartParser, FormParser)

    def get(self, request, asset_key):
-        files = FileAsset.objects.filter(
-            asset=asset_key, created_by=request.user
-        )
+        files = FileAsset.objects.filter(asset=asset_key, created_by=request.user)
        if files.exists():
-            serializer = FileAssetSerializer(
-                files, context={"request": request}
-            )
+            serializer = FileAssetSerializer(files, context={"request": request})
            return Response(
-                {"data": serializer.data, "status": True},
-                status=status.HTTP_200_OK,
+                {"data": serializer.data, "status": True}, status=status.HTTP_200_OK
            )
        else:
            return Response(
@@ -92,9 +82,7 @@ class UserAssetsEndpoint(BaseAPIView):
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def delete(self, request, asset_key):
-        file_asset = FileAsset.objects.get(
-            asset=asset_key, created_by=request.user
-        )
+        file_asset = FileAsset.objects.get(asset=asset_key, created_by=request.user)
        file_asset.is_deleted = True
-        file_asset.save()
+        file_asset.save(update_fields=["is_deleted"])
        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -0,0 +1,687 @@
+# Python imports
+import uuid
+
+# Django imports
+from django.conf import settings
+from django.http import HttpResponseRedirect
+from django.utils import timezone
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+
+# Module imports
+from ..base import BaseAPIView
+from plane.db.models import FileAsset, Workspace, Project, User
+from plane.settings.storage import S3Storage
+from plane.app.permissions import allow_permission, ROLE
+from plane.utils.cache import invalidate_cache_directly
+from plane.bgtasks.storage_metadata_task import get_asset_object_metadata
+
+
+class UserAssetsV2Endpoint(BaseAPIView):
+    """This endpoint is used to upload user profile images."""
+
+    def asset_delete(self, asset_id):
+        asset = FileAsset.objects.filter(id=asset_id).first()
+        if asset is None:
+            return
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return
+
+    def entity_asset_save(self, asset_id, entity_type, asset, request):
+        # User Avatar
+        if entity_type == FileAsset.EntityTypeContext.USER_AVATAR:
+            user = User.objects.get(id=asset.user_id)
+            user.avatar = ""
+            # Delete the previous avatar
+            if user.avatar_asset_id:
+                self.asset_delete(user.avatar_asset_id)
+            # Save the new avatar
+            user.avatar_asset_id = asset_id
+            user.save()
+            invalidate_cache_directly(
+                path="/api/users/me/", url_params=False, user=True, request=request
+            )
+            invalidate_cache_directly(
+                path="/api/users/me/settings/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            return
+        # User Cover
+        if entity_type == FileAsset.EntityTypeContext.USER_COVER:
+            user = User.objects.get(id=asset.user_id)
+            user.cover_image = None
+            # Delete the previous cover image
+            if user.cover_image_asset_id:
+                self.asset_delete(user.cover_image_asset_id)
+            # Save the new cover image
+            user.cover_image_asset_id = asset_id
+            user.save()
+            invalidate_cache_directly(
+                path="/api/users/me/", url_params=False, user=True, request=request
+            )
+            invalidate_cache_directly(
+                path="/api/users/me/settings/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            return
+        return
+
+    def entity_asset_delete(self, entity_type, asset, request):
+        # User Avatar
+        if entity_type == FileAsset.EntityTypeContext.USER_AVATAR:
+            user = User.objects.get(id=asset.user_id)
+            user.avatar_asset_id = None
+            user.save()
+            invalidate_cache_directly(
+                path="/api/users/me/", url_params=False, user=True, request=request
+            )
+            invalidate_cache_directly(
+                path="/api/users/me/settings/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            return
+        # User Cover
+        if entity_type == FileAsset.EntityTypeContext.USER_COVER:
+            user = User.objects.get(id=asset.user_id)
+            user.cover_image_asset_id = None
+            user.save()
+            invalidate_cache_directly(
+                path="/api/users/me/", url_params=False, user=True, request=request
+            )
+            invalidate_cache_directly(
+                path="/api/users/me/settings/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            return
+        return
+
+    def post(self, request):
+        # get the asset key
+        name = request.data.get("name")
+        type = request.data.get("type", "image/jpeg")
+        size = int(request.data.get("size", settings.FILE_SIZE_LIMIT))
+        entity_type = request.data.get("entity_type", False)
+
+        # Check if the file size is within the limit
+        size_limit = min(size, settings.FILE_SIZE_LIMIT)
+
+        #  Check if the entity type is allowed
+        if not entity_type or entity_type not in ["USER_AVATAR", "USER_COVER"]:
+            return Response(
+                {"error": "Invalid entity type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if the file type is allowed
+        allowed_types = ["image/jpeg", "image/png", "image/webp", "image/jpg"]
+        if type not in allowed_types:
+            return Response(
+                {
+                    "error": "Invalid file type. Only JPEG and PNG files are allowed.",
+                    "status": False,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # asset key
+        asset_key = f"{uuid.uuid4().hex}-{name}"
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={"name": name, "type": type, "size": size_limit},
+            asset=asset_key,
+            size=size_limit,
+            user=request.user,
+            created_by=request.user,
+            entity_type=entity_type,
+        )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        presigned_url = storage.generate_presigned_post(
+            object_name=asset_key, file_type=type, file_size=size_limit
+        )
+        # Return the presigned URL
+        return Response(
+            {
+                "upload_data": presigned_url,
+                "asset_id": str(asset.id),
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    def patch(self, request, asset_id):
+        # get the asset id
+        asset = FileAsset.objects.get(id=asset_id, user_id=request.user.id)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if not asset.storage_metadata:
+            get_asset_object_metadata.delay(asset_id=str(asset_id))
+        # get the entity and save the asset id for the request field
+        self.entity_asset_save(
+            asset_id=asset_id,
+            entity_type=asset.entity_type,
+            asset=asset,
+            request=request,
+        )
+        # update the attributes
+        asset.attributes = request.data.get("attributes", asset.attributes)
+        # save the asset
+        asset.save(update_fields=["is_uploaded", "attributes"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def delete(self, request, asset_id):
+        asset = FileAsset.objects.get(id=asset_id, user_id=request.user.id)
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        # get the entity and save the asset id for the request field
+        self.entity_asset_delete(
+            entity_type=asset.entity_type, asset=asset, request=request
+        )
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WorkspaceFileAssetEndpoint(BaseAPIView):
+    """This endpoint is used to upload cover images/logos etc for workspace, projects and users."""
+
+    def get_entity_id_field(self, entity_type, entity_id):
+        # Workspace Logo
+        if entity_type == FileAsset.EntityTypeContext.WORKSPACE_LOGO:
+            return {"workspace_id": entity_id}
+
+        # Project Cover
+        if entity_type == FileAsset.EntityTypeContext.PROJECT_COVER:
+            return {"project_id": entity_id}
+
+        # User Avatar and Cover
+        if entity_type in [
+            FileAsset.EntityTypeContext.USER_AVATAR,
+            FileAsset.EntityTypeContext.USER_COVER,
+        ]:
+            return {"user_id": entity_id}
+
+        # Issue Attachment and Description
+        if entity_type in [
+            FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            FileAsset.EntityTypeContext.ISSUE_DESCRIPTION,
+        ]:
+            return {"issue_id": entity_id}
+
+        # Page Description
+        if entity_type == FileAsset.EntityTypeContext.PAGE_DESCRIPTION:
+            return {"page_id": entity_id}
+
+        # Comment Description
+        if entity_type == FileAsset.EntityTypeContext.COMMENT_DESCRIPTION:
+            return {"comment_id": entity_id}
+        return {}
+
+    def asset_delete(self, asset_id):
+        asset = FileAsset.objects.filter(id=asset_id).first()
+        # Check if the asset exists
+        if asset is None:
+            return
+        # Mark the asset as deleted
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return
+
+    def entity_asset_save(self, asset_id, entity_type, asset, request):
+        # Workspace Logo
+        if entity_type == FileAsset.EntityTypeContext.WORKSPACE_LOGO:
+            workspace = Workspace.objects.filter(id=asset.workspace_id).first()
+            if workspace is None:
+                return
+            # Delete the previous logo
+            if workspace.logo_asset_id:
+                self.asset_delete(workspace.logo_asset_id)
+            # Save the new logo
+            workspace.logo = ""
+            workspace.logo_asset_id = asset_id
+            workspace.save()
+            invalidate_cache_directly(
+                path="/api/workspaces/", url_params=False, user=False, request=request
+            )
+            invalidate_cache_directly(
+                path="/api/users/me/workspaces/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            invalidate_cache_directly(
+                path="/api/instances/", url_params=False, user=False, request=request
+            )
+            return
+
+        # Project Cover
+        elif entity_type == FileAsset.EntityTypeContext.PROJECT_COVER:
+            project = Project.objects.filter(id=asset.project_id).first()
+            if project is None:
+                return
+            # Delete the previous cover image
+            if project.cover_image_asset_id:
+                self.asset_delete(project.cover_image_asset_id)
+            # Save the new cover image
+            project.cover_image = ""
+            project.cover_image_asset_id = asset_id
+            project.save()
+            return
+        else:
+            return
+
+    def entity_asset_delete(self, entity_type, asset, request):
+        # Workspace Logo
+        if entity_type == FileAsset.EntityTypeContext.WORKSPACE_LOGO:
+            workspace = Workspace.objects.get(id=asset.workspace_id)
+            if workspace is None:
+                return
+            workspace.logo_asset_id = None
+            workspace.save()
+            invalidate_cache_directly(
+                path="/api/workspaces/", url_params=False, user=False, request=request
+            )
+            invalidate_cache_directly(
+                path="/api/users/me/workspaces/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            invalidate_cache_directly(
+                path="/api/instances/", url_params=False, user=False, request=request
+            )
+            return
+        # Project Cover
+        elif entity_type == FileAsset.EntityTypeContext.PROJECT_COVER:
+            project = Project.objects.filter(id=asset.project_id).first()
+            if project is None:
+                return
+            project.cover_image_asset_id = None
+            project.save()
+            return
+        else:
+            return
+
+    def post(self, request, slug):
+        name = request.data.get("name")
+        type = request.data.get("type", "image/jpeg")
+        size = int(request.data.get("size", settings.FILE_SIZE_LIMIT))
+        entity_type = request.data.get("entity_type")
+        entity_identifier = request.data.get("entity_identifier", False)
+
+        # Check if the entity type is allowed
+        if entity_type not in FileAsset.EntityTypeContext.values:
+            return Response(
+                {"error": "Invalid entity type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if the file type is allowed
+        allowed_types = [
+            "image/jpeg",
+            "image/png",
+            "image/webp",
+            "image/jpg",
+            "image/gif",
+        ]
+        if type not in allowed_types:
+            return Response(
+                {
+                    "error": "Invalid file type. Only JPEG and PNG files are allowed.",
+                    "status": False,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the size limit
+        size_limit = min(settings.FILE_SIZE_LIMIT, size)
+
+        # Get the workspace
+        workspace = Workspace.objects.get(slug=slug)
+
+        # asset key
+        asset_key = f"{workspace.id}/{uuid.uuid4().hex}-{name}"
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={"name": name, "type": type, "size": size_limit},
+            asset=asset_key,
+            size=size_limit,
+            workspace=workspace,
+            created_by=request.user,
+            entity_type=entity_type,
+            **self.get_entity_id_field(
+                entity_type=entity_type, entity_id=entity_identifier
+            ),
+        )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        presigned_url = storage.generate_presigned_post(
+            object_name=asset_key, file_type=type, file_size=size_limit
+        )
+        # Return the presigned URL
+        return Response(
+            {
+                "upload_data": presigned_url,
+                "asset_id": str(asset.id),
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    def patch(self, request, slug, asset_id):
+        # get the asset id
+        asset = FileAsset.objects.get(id=asset_id, workspace__slug=slug)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if not asset.storage_metadata:
+            get_asset_object_metadata.delay(asset_id=str(asset_id))
+        # get the entity and save the asset id for the request field
+        self.entity_asset_save(
+            asset_id=asset_id,
+            entity_type=asset.entity_type,
+            asset=asset,
+            request=request,
+        )
+        # update the attributes
+        asset.attributes = request.data.get("attributes", asset.attributes)
+        # save the asset
+        asset.save(update_fields=["is_uploaded", "attributes"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def delete(self, request, slug, asset_id):
+        asset = FileAsset.objects.get(id=asset_id, workspace__slug=slug)
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        # get the entity and save the asset id for the request field
+        self.entity_asset_delete(
+            entity_type=asset.entity_type, asset=asset, request=request
+        )
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def get(self, request, slug, asset_id):
+        # get the asset id
+        asset = FileAsset.objects.get(id=asset_id, workspace__slug=slug)
+
+        # Check if the asset is uploaded
+        if not asset.is_uploaded:
+            return Response(
+                {"error": "The requested asset could not be found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        signed_url = storage.generate_presigned_url(object_name=asset.asset.name)
+        # Redirect to the signed URL
+        return HttpResponseRedirect(signed_url)
+
+
+class StaticFileAssetEndpoint(BaseAPIView):
+    """This endpoint is used to get the signed URL for a static asset."""
+
+    permission_classes = [AllowAny]
+
+    def get(self, request, asset_id):
+        # get the asset id
+        asset = FileAsset.objects.get(id=asset_id)
+
+        # Check if the asset is uploaded
+        if not asset.is_uploaded:
+            return Response(
+                {"error": "The requested asset could not be found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Check if the entity type is allowed
+        if asset.entity_type not in [
+            FileAsset.EntityTypeContext.USER_AVATAR,
+            FileAsset.EntityTypeContext.USER_COVER,
+            FileAsset.EntityTypeContext.WORKSPACE_LOGO,
+            FileAsset.EntityTypeContext.PROJECT_COVER,
+        ]:
+            return Response(
+                {"error": "Invalid entity type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        signed_url = storage.generate_presigned_url(object_name=asset.asset.name)
+        # Redirect to the signed URL
+        return HttpResponseRedirect(signed_url)
+
+
+class AssetRestoreEndpoint(BaseAPIView):
+    """Endpoint to restore a deleted assets."""
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def post(self, request, slug, asset_id):
+        asset = FileAsset.all_objects.get(id=asset_id, workspace__slug=slug)
+        asset.is_deleted = False
+        asset.deleted_at = None
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ProjectAssetEndpoint(BaseAPIView):
+    """This endpoint is used to upload cover images/logos etc for workspace, projects and users."""
+
+    def get_entity_id_field(self, entity_type, entity_id):
+        if entity_type == FileAsset.EntityTypeContext.WORKSPACE_LOGO:
+            return {"workspace_id": entity_id}
+
+        if entity_type == FileAsset.EntityTypeContext.PROJECT_COVER:
+            return {"project_id": entity_id}
+
+        if entity_type in [
+            FileAsset.EntityTypeContext.USER_AVATAR,
+            FileAsset.EntityTypeContext.USER_COVER,
+        ]:
+            return {"user_id": entity_id}
+
+        if entity_type in [
+            FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            FileAsset.EntityTypeContext.ISSUE_DESCRIPTION,
+        ]:
+            return {"issue_id": entity_id}
+
+        if entity_type == FileAsset.EntityTypeContext.PAGE_DESCRIPTION:
+            return {"page_id": entity_id}
+
+        if entity_type == FileAsset.EntityTypeContext.COMMENT_DESCRIPTION:
+            return {"comment_id": entity_id}
+
+        if entity_type == FileAsset.EntityTypeContext.DRAFT_ISSUE_DESCRIPTION:
+            return {"draft_issue_id": entity_id}
+        return {}
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def post(self, request, slug, project_id):
+        name = request.data.get("name")
+        type = request.data.get("type", "image/jpeg")
+        size = int(request.data.get("size", settings.FILE_SIZE_LIMIT))
+        entity_type = request.data.get("entity_type", "")
+        entity_identifier = request.data.get("entity_identifier")
+
+        # Check if the entity type is allowed
+        if entity_type not in FileAsset.EntityTypeContext.values:
+            return Response(
+                {"error": "Invalid entity type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if the file type is allowed
+        allowed_types = [
+            "image/jpeg",
+            "image/png",
+            "image/webp",
+            "image/jpg",
+            "image/gif",
+        ]
+        if type not in allowed_types:
+            return Response(
+                {
+                    "error": "Invalid file type. Only JPEG and PNG files are allowed.",
+                    "status": False,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the size limit
+        size_limit = min(settings.FILE_SIZE_LIMIT, size)
+
+        # Get the workspace
+        workspace = Workspace.objects.get(slug=slug)
+
+        # asset key
+        asset_key = f"{workspace.id}/{uuid.uuid4().hex}-{name}"
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={"name": name, "type": type, "size": size_limit},
+            asset=asset_key,
+            size=size_limit,
+            workspace=workspace,
+            created_by=request.user,
+            entity_type=entity_type,
+            project_id=project_id,
+            **self.get_entity_id_field(entity_type, entity_identifier),
+        )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        presigned_url = storage.generate_presigned_post(
+            object_name=asset_key, file_type=type, file_size=size_limit
+        )
+        # Return the presigned URL
+        return Response(
+            {
+                "upload_data": presigned_url,
+                "asset_id": str(asset.id),
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def patch(self, request, slug, project_id, pk):
+        # get the asset id
+        asset = FileAsset.objects.get(id=pk)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if not asset.storage_metadata:
+            get_asset_object_metadata.delay(asset_id=str(pk))
+
+        # update the attributes
+        asset.attributes = request.data.get("attributes", asset.attributes)
+        # save the asset
+        asset.save(update_fields=["is_uploaded", "attributes"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def delete(self, request, slug, project_id, pk):
+        # Get the asset
+        asset = FileAsset.objects.get(
+            id=pk, workspace__slug=slug, project_id=project_id
+        )
+        # Check deleted assets
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        # Save the asset
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id, pk):
+        # get the asset id
+        asset = FileAsset.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
+
+        # Check if the asset is uploaded
+        if not asset.is_uploaded:
+            return Response(
+                {"error": "The requested asset could not be found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        signed_url = storage.generate_presigned_url(object_name=asset.asset.name)
+        # Redirect to the signed URL
+        return HttpResponseRedirect(signed_url)
+
+
+class ProjectBulkAssetEndpoint(BaseAPIView):
+    def save_project_cover(self, asset, project_id):
+        project = Project.objects.get(id=project_id)
+        project.cover_image_asset_id = asset.id
+        project.save()
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def post(self, request, slug, project_id, entity_id):
+        asset_ids = request.data.get("asset_ids", [])
+
+        # Check if the asset ids are provided
+        if not asset_ids:
+            return Response(
+                {"error": "No asset ids provided."}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # get the asset id
+        assets = FileAsset.objects.filter(id__in=asset_ids, workspace__slug=slug)
+
+        # Get the first asset
+        asset = assets.first()
+
+        if not asset:
+            return Response(
+                {"error": "The requested asset could not be found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Check if the asset is uploaded
+        if asset.entity_type == FileAsset.EntityTypeContext.PROJECT_COVER:
+            assets.update(project_id=project_id)
+            [self.save_project_cover(asset, project_id) for asset in assets]
+
+        if asset.entity_type == FileAsset.EntityTypeContext.ISSUE_DESCRIPTION:
+            assets.update(issue_id=entity_id)
+
+        if asset.entity_type == FileAsset.EntityTypeContext.COMMENT_DESCRIPTION:
+            assets.update(comment_id=entity_id)
+
+        if asset.entity_type == FileAsset.EntityTypeContext.PAGE_DESCRIPTION:
+            assets.update(page_id=entity_id)
+
+        if asset.entity_type == FileAsset.EntityTypeContext.DRAFT_ISSUE_DESCRIPTION:
+            assets.update(draft_issue_id=entity_id)
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -43,18 +43,11 @@ class TimezoneMixin:
 class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
    model = None

-    permission_classes = [
-        IsAuthenticated,
-    ]
+    permission_classes = [IsAuthenticated]

-    filter_backends = (
-        DjangoFilterBackend,
-        SearchFilter,
-    )
+    filter_backends = (DjangoFilterBackend, SearchFilter)

-    authentication_classes = [
-        BaseSessionAuthentication,
-    ]
+    authentication_classes = [BaseSessionAuthentication]

    filterset_fields = []

@@ -65,9 +58,7 @@ class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
            return self.model.objects.all()
        except Exception as e:
            log_exception(e)
-            raise APIException(
-                "Please check the view", status.HTTP_400_BAD_REQUEST
-            )
+            raise APIException("Please check the view", status.HTTP_400_BAD_REQUEST)

    def handle_exception(self, exc):
        """
@@ -146,35 +137,24 @@ class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
    @property
    def fields(self):
        fields = [
-            field
-            for field in self.request.GET.get("fields", "").split(",")
-            if field
+            field for field in self.request.GET.get("fields", "").split(",") if field
        ]
        return fields if fields else None

    @property
    def expand(self):
        expand = [
-            expand
-            for expand in self.request.GET.get("expand", "").split(",")
-            if expand
+            expand for expand in self.request.GET.get("expand", "").split(",") if expand
        ]
        return expand if expand else None


 class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
-    permission_classes = [
-        IsAuthenticated,
-    ]
+    permission_classes = [IsAuthenticated]

-    filter_backends = (
-        DjangoFilterBackend,
-        SearchFilter,
-    )
+    filter_backends = (DjangoFilterBackend, SearchFilter)

-    authentication_classes = [
-        BaseSessionAuthentication,
-    ]
+    authentication_classes = [BaseSessionAuthentication]

    filterset_fields = []

@@ -251,17 +231,13 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
    @property
    def fields(self):
        fields = [
-            field
-            for field in self.request.GET.get("fields", "").split(",")
-            if field
+            field for field in self.request.GET.get("fields", "").split(",") if field
        ]
        return fields if fields else None

    @property
    def expand(self):
        expand = [
-            expand
-            for expand in self.request.GET.get("expand", "").split(",")
-            if expand
+            expand for expand in self.request.GET.get("expand", "").split(",") if expand
        ]
        return expand if expand else None
@@ -1,6 +1,7 @@
 # Django imports
 from django.contrib.postgres.aggregates import ArrayAgg
 from django.contrib.postgres.fields import ArrayField
+from django.db import models
 from django.db.models import (
    Case,
    CharField,
@@ -18,7 +19,7 @@ from django.db.models import (
    Sum,
    FloatField,
 )
-from django.db.models.functions import Coalesce, Cast
+from django.db.models.functions import Coalesce, Cast, Concat
 from django.utils import timezone

 # Third party imports
@@ -33,7 +34,6 @@ from .. import BaseAPIView


 class CycleArchiveUnarchiveEndpoint(BaseAPIView):
-
    def get_queryset(self):
        favorite_subquery = UserFavorite.objects.filter(
            user=self.request.user,
@@ -47,12 +47,11 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                estimate_point__estimate__type="points",
                state__group="backlog",
                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
            )
            .values("issue_cycle__cycle_id")
            .annotate(
-                backlog_estimate_point=Sum(
-                    Cast("estimate_point__value", FloatField())
-                )
+                backlog_estimate_point=Sum(Cast("estimate_point__value", FloatField()))
            )
            .values("backlog_estimate_point")[:1]
        )
@@ -61,6 +60,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                estimate_point__estimate__type="points",
                state__group="unstarted",
                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
            )
            .values("issue_cycle__cycle_id")
            .annotate(
@@ -75,12 +75,11 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                estimate_point__estimate__type="points",
                state__group="started",
                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
            )
            .values("issue_cycle__cycle_id")
            .annotate(
-                started_estimate_point=Sum(
-                    Cast("estimate_point__value", FloatField())
-                )
+                started_estimate_point=Sum(Cast("estimate_point__value", FloatField()))
            )
            .values("started_estimate_point")[:1]
        )
@@ -89,6 +88,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                estimate_point__estimate__type="points",
                state__group="cancelled",
                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
            )
            .values("issue_cycle__cycle_id")
            .annotate(
@@ -103,6 +103,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                estimate_point__estimate__type="points",
                state__group="completed",
                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
            )
            .values("issue_cycle__cycle_id")
            .annotate(
@@ -116,12 +117,11 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
            Issue.issue_objects.filter(
                estimate_point__estimate__type="points",
                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
            )
            .values("issue_cycle__cycle_id")
            .annotate(
-                total_estimate_points=Sum(
-                    Cast("estimate_point__value", FloatField())
-                )
+                total_estimate_points=Sum(Cast("estimate_point__value", FloatField()))
            )
            .values("total_estimate_points")[:1]
        )
@@ -139,16 +139,14 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                Prefetch(
                    "issue_cycle__issue__assignees",
                    queryset=User.objects.only(
-                        "avatar", "first_name", "id"
+                        "avatar_asset", "first_name", "id"
                    ).distinct(),
                )
            )
            .prefetch_related(
                Prefetch(
                    "issue_cycle__issue__labels",
-                    queryset=Label.objects.only(
-                        "name", "color", "id"
-                    ).distinct(),
+                    queryset=Label.objects.only("name", "color", "id").distinct(),
                )
            )
            .annotate(is_favorite=Exists(favorite_subquery))
@@ -159,6 +157,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                    filter=Q(
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
                    ),
                )
            )
@@ -170,6 +169,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                        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,
                    ),
                )
            )
@@ -181,6 +181,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                        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,
                    ),
                )
            )
@@ -192,6 +193,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                        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,
                    ),
                )
            )
@@ -203,6 +205,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                        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,
                    ),
                )
            )
@@ -214,6 +217,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                        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,
                    ),
                )
            )
@@ -224,9 +228,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                        & Q(end_date__gte=timezone.now()),
                        then=Value("CURRENT"),
                    ),
-                    When(
-                        start_date__gt=timezone.now(), then=Value("UPCOMING")
-                    ),
+                    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),
@@ -241,9 +243,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                    ArrayAgg(
                        "issue_cycle__issue__assignees__id",
                        distinct=True,
-                        filter=~Q(
-                            issue_cycle__issue__assignees__id__isnull=True
-                        ),
+                        filter=~Q(issue_cycle__issue__assignees__id__isnull=True),
                    ),
                    Value([], output_field=ArrayField(UUIDField())),
                )
@@ -252,48 +252,42 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                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()),
-                ),
+                    Subquery(total_estimate_point), Value(0, output_field=FloatField())
+                )
            )
            .order_by("-is_favorite", "name")
            .distinct()
        )

-    @allow_permission(
-        [
-            ROLE.ADMIN,
-            ROLE.MEMBER,
-        ]
-    )
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
    def get(self, request, slug, project_id, pk=None):
        if pk is None:
            queryset = (
@@ -329,9 +323,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
            return Response(queryset, status=status.HTTP_200_OK)
        else:
            queryset = (
-                self.get_queryset()
-                .filter(archived_at__isnull=False)
-                .filter(pk=pk)
+                self.get_queryset().filter(archived_at__isnull=False).filter(pk=pk)
            )
            data = (
                self.get_queryset()
@@ -341,6 +333,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                        project_id=self.kwargs.get("project_id"),
                        parent__isnull=False,
                        issue_cycle__cycle_id=pk,
+                        issue_cycle__deleted_at__isnull=True,
                    )
                    .order_by()
                    .annotate(count=Func(F("id"), function="Count"))
@@ -395,18 +388,36 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                assignee_distribution = (
                    Issue.issue_objects.filter(
                        issue_cycle__cycle_id=pk,
+                        issue_cycle__deleted_at__isnull=True,
                        workspace__slug=slug,
                        project_id=project_id,
                    )
                    .annotate(display_name=F("assignees__display_name"))
                    .annotate(assignee_id=F("assignees__id"))
-                    .annotate(avatar=F("assignees__avatar"))
-                    .values("display_name", "assignee_id", "avatar")
                    .annotate(
-                        total_estimates=Sum(
-                            Cast("estimate_point__value", FloatField())
+                        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("display_name", "assignee_id", "avatar_url")
+                    .annotate(
+                        total_estimates=Sum(Cast("estimate_point__value", FloatField()))
+                    )
                    .annotate(
                        completed_estimates=Sum(
                            Cast("estimate_point__value", FloatField()),
@@ -433,6 +444,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                label_distribution = (
                    Issue.issue_objects.filter(
                        issue_cycle__cycle_id=pk,
+                        issue_cycle__deleted_at__isnull=True,
                        workspace__slug=slug,
                        project_id=project_id,
                    )
@@ -441,9 +453,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                    .annotate(label_id=F("labels__id"))
                    .values("label_name", "color", "label_id")
                    .annotate(
-                        total_estimates=Sum(
-                            Cast("estimate_point__value", FloatField())
-                        )
+                        total_estimates=Sum(Cast("estimate_point__value", FloatField()))
                    )
                    .annotate(
                        completed_estimates=Sum(
@@ -474,43 +484,57 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                }

                if data["start_date"] and data["end_date"]:
-                    data["estimate_distribution"]["completion_chart"] = (
-                        burndown_plot(
-                            queryset=queryset,
-                            slug=slug,
-                            project_id=project_id,
-                            plot_type="points",
-                            cycle_id=pk,
-                        )
+                    data["estimate_distribution"]["completion_chart"] = burndown_plot(
+                        queryset=queryset,
+                        slug=slug,
+                        project_id=project_id,
+                        plot_type="points",
+                        cycle_id=pk,
                    )

            # Assignee Distribution
            assignee_distribution = (
                Issue.issue_objects.filter(
                    issue_cycle__cycle_id=pk,
+                    issue_cycle__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(avatar=F("assignees__avatar"))
+                .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(),
+                    )
+                )
                .annotate(display_name=F("assignees__display_name"))
                .values(
                    "first_name",
                    "last_name",
                    "assignee_id",
-                    "avatar",
+                    "avatar_url",
                    "display_name",
                )
                .annotate(
                    total_issues=Count(
-                        "id",
-                        filter=Q(
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    ),
+                        "id", filter=Q(archived_at__isnull=True, is_draft=False)
+                    )
                )
                .annotate(
                    completed_issues=Count(
@@ -539,6 +563,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
            label_distribution = (
                Issue.issue_objects.filter(
                    issue_cycle__cycle_id=pk,
+                    issue_cycle__deleted_at__isnull=True,
                    workspace__slug=slug,
                    project_id=project_id,
                )
@@ -548,12 +573,8 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                .values("label_name", "color", "label_id")
                .annotate(
                    total_issues=Count(
-                        "id",
-                        filter=Q(
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    ),
+                        "id", filter=Q(archived_at__isnull=True, is_draft=False)
+                    )
                )
                .annotate(
                    completed_issues=Count(
@@ -593,10 +614,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                    cycle_id=pk,
                )

-            return Response(
-                data,
-                status=status.HTTP_200_OK,
-            )
+            return Response(data, status=status.HTTP_200_OK)

    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
    def post(self, request, slug, project_id, cycle_id):
@@ -619,8 +637,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
            workspace__slug=slug,
        ).delete()
        return Response(
-            {"archived_at": str(cycle.archived_at)},
-            status=status.HTTP_200_OK,
+            {"archived_at": str(cycle.archived_at)}, status=status.HTTP_200_OK
        )

    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
@@ -20,7 +20,8 @@ from django.db.models import (
    Sum,
    FloatField,
 )
-from django.db.models.functions import Coalesce, Cast
+from django.db import models
+from django.db.models.functions import Coalesce, Cast, Concat
 from django.utils import timezone
 from django.core.serializers.json import DjangoJSONEncoder

@@ -81,16 +82,14 @@ class CycleViewSet(BaseViewSet):
                Prefetch(
                    "issue_cycle__issue__assignees",
                    queryset=User.objects.only(
-                        "avatar", "first_name", "id"
+                        "avatar_asset", "first_name", "id"
                    ).distinct(),
                )
            )
            .prefetch_related(
                Prefetch(
                    "issue_cycle__issue__labels",
-                    queryset=Label.objects.only(
-                        "name", "color", "id"
-                    ).distinct(),
+                    queryset=Label.objects.only("name", "color", "id").distinct(),
                )
            )
            .annotate(is_favorite=Exists(favorite_subquery))
@@ -101,6 +100,7 @@ class CycleViewSet(BaseViewSet):
                    filter=Q(
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -112,6 +112,7 @@ class CycleViewSet(BaseViewSet):
                        issue_cycle__issue__state__group="completed",
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -122,9 +123,7 @@ class CycleViewSet(BaseViewSet):
                        & Q(end_date__gte=timezone.now()),
                        then=Value("CURRENT"),
                    ),
-                    When(
-                        start_date__gt=timezone.now(), then=Value("UPCOMING")
-                    ),
+                    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),
@@ -139,8 +138,11 @@ class CycleViewSet(BaseViewSet):
                    ArrayAgg(
                        "issue_cycle__issue__assignees__id",
                        distinct=True,
-                        filter=~Q(
-                            issue_cycle__issue__assignees__id__isnull=True
+                        filter=~Q(issue_cycle__issue__assignees__id__isnull=True)
+                        & (
+                            Q(
+                                issue_cycle__issue__issue_assignee__deleted_at__isnull=True
+                            )
                        ),
                    ),
                    Value([], output_field=ArrayField(UUIDField())),
@@ -161,8 +163,7 @@ class CycleViewSet(BaseViewSet):
        # Current Cycle
        if cycle_view == "current":
            queryset = queryset.filter(
-                start_date__lte=timezone.now(),
-                end_date__gte=timezone.now(),
+                start_date__lte=timezone.now(), end_date__gte=timezone.now()
            )

            data = queryset.values(
@@ -187,6 +188,7 @@ class CycleViewSet(BaseViewSet):
                "completed_issues",
                "assignee_ids",
                "status",
+                "version",
                "created_by",
            )

@@ -216,6 +218,7 @@ class CycleViewSet(BaseViewSet):
            "completed_issues",
            "assignee_ids",
            "status",
+            "version",
            "created_by",
        )
        return Response(data, status=status.HTTP_200_OK)
@@ -231,10 +234,7 @@ class CycleViewSet(BaseViewSet):
        ):
            serializer = CycleWriteSerializer(data=request.data)
            if serializer.is_valid():
-                serializer.save(
-                    project_id=project_id,
-                    owned_by=request.user,
-                )
+                serializer.save(project_id=project_id, owned_by=request.user)
                cycle = (
                    self.get_queryset()
                    .filter(pk=serializer.data["id"])
@@ -255,6 +255,7 @@ class CycleViewSet(BaseViewSet):
                        "external_id",
                        "progress_snapshot",
                        "logo_props",
+                        "version",
                        # meta fields
                        "is_favorite",
                        "total_issues",
@@ -277,9 +278,7 @@ class CycleViewSet(BaseViewSet):
                    origin=request.META.get("HTTP_ORIGIN"),
                )
                return Response(cycle, status=status.HTTP_201_CREATED)
-            return Response(
-                serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            )
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        else:
            return Response(
                {
@@ -306,16 +305,11 @@ class CycleViewSet(BaseViewSet):

        request_data = request.data

-        if (
-            cycle.end_date is not None
-            and cycle.end_date < timezone.now()
-        ):
+        if cycle.end_date is not None and cycle.end_date < timezone.now():
            if "sort_order" in request_data:
                # Can only change sort order for a completed cycle``
                request_data = {
-                    "sort_order": request_data.get(
-                        "sort_order", cycle.sort_order
-                    )
+                    "sort_order": request_data.get("sort_order", cycle.sort_order)
                }
            else:
                return Response(
@@ -325,9 +319,7 @@ class CycleViewSet(BaseViewSet):
                    status=status.HTTP_400_BAD_REQUEST,
                )

-        serializer = CycleWriteSerializer(
-            cycle, data=request.data, partial=True
-        )
+        serializer = CycleWriteSerializer(cycle, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
            cycle = queryset.values(
@@ -347,6 +339,7 @@ class CycleViewSet(BaseViewSet):
                "external_id",
                "progress_snapshot",
                "logo_props",
+                "version",
                # meta fields
                "is_favorite",
                "total_issues",
@@ -370,16 +363,9 @@ class CycleViewSet(BaseViewSet):
            return Response(cycle, status=status.HTTP_200_OK)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

-    @allow_permission(
-        [
-            ROLE.ADMIN,
-            ROLE.MEMBER,
-        ]
-    )
+    @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)
-        )
+        queryset = self.get_queryset().filter(archived_at__isnull=True).filter(pk=pk)
        data = (
            self.get_queryset()
            .filter(pk=pk)
@@ -389,6 +375,7 @@ class CycleViewSet(BaseViewSet):
                    project_id=self.kwargs.get("project_id"),
                    parent__isnull=False,
                    issue_cycle__cycle_id=pk,
+                    issue_cycle__deleted_at__isnull=True,
                )
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
@@ -412,6 +399,7 @@ class CycleViewSet(BaseViewSet):
                "progress_snapshot",
                "sub_issues",
                "logo_props",
+                "version",
                # meta fields
                "is_favorite",
                "total_issues",
@@ -425,8 +413,7 @@ class CycleViewSet(BaseViewSet):

        if data is None:
            return Response(
-                {"error": "Cycle not found"},
-                status=status.HTTP_404_NOT_FOUND,
+                {"error": "Cycle not found"}, status=status.HTTP_404_NOT_FOUND
            )

        queryset = queryset.first()
@@ -438,16 +425,11 @@ class CycleViewSet(BaseViewSet):
            user_id=request.user.id,
            project_id=project_id,
        )
-        return Response(
-            data,
-            status=status.HTTP_200_OK,
-        )
+        return Response(data, status=status.HTTP_200_OK)

    @allow_permission([ROLE.ADMIN], creator=True, model=Cycle)
    def destroy(self, request, slug, project_id, pk):
-        cycle = Cycle.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=pk
-        )
+        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
        if cycle.owned_by_id != request.user.id and not (
            ProjectMember.objects.filter(
                workspace__slug=slug,
@@ -463,9 +445,9 @@ class CycleViewSet(BaseViewSet):
            )

        cycle_issues = list(
-            CycleIssue.objects.filter(
-                cycle_id=self.kwargs.get("pk")
-            ).values_list("issue", flat=True)
+            CycleIssue.objects.filter(cycle_id=self.kwargs.get("pk")).values_list(
+                "issue", flat=True
+            )
        )

        issue_activity.delay(
@@ -485,12 +467,9 @@ class CycleViewSet(BaseViewSet):
            notification=True,
            origin=request.META.get("HTTP_ORIGIN"),
        )
-        # Delete the cycle
+        # TODO: Soft delete the cycle break the onetoone relationship with cycle issue
        cycle.delete()
-        # Delete the cycle issues
-        CycleIssue.objects.filter(
-            cycle_id=self.kwargs.get("pk"),
-        ).delete()
+
        # Delete the user favorite cycle
        UserFavorite.objects.filter(
            user=request.user,
@@ -594,6 +573,7 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                    filter=Q(
                        issue_cycle__issue__archived_at__isnull=True,
                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
                    ),
                )
            )
@@ -604,6 +584,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                        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,
                    ),
                )
            )
@@ -614,6 +596,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                        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,
                    ),
                )
            )
@@ -624,6 +608,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                        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,
                    ),
                )
            )
@@ -634,6 +620,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                        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,
                    ),
                )
            )
@@ -644,6 +632,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                        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,
                    ),
                )
            )
@@ -660,18 +650,36 @@ class TransferCycleIssueEndpoint(BaseAPIView):
            assignee_estimate_data = (
                Issue.issue_objects.filter(
                    issue_cycle__cycle_id=cycle_id,
+                    issue_cycle__deleted_at__isnull=True,
                    workspace__slug=slug,
                    project_id=project_id,
                )
                .annotate(display_name=F("assignees__display_name"))
                .annotate(assignee_id=F("assignees__id"))
-                .annotate(avatar=F("assignees__avatar"))
-                .values("display_name", "assignee_id", "avatar")
                .annotate(
-                    total_estimates=Sum(
-                        Cast("estimate_point__value", FloatField())
+                    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("display_name", "assignee_id", "avatar_url")
+                .annotate(
+                    total_estimates=Sum(Cast("estimate_point__value", FloatField()))
+                )
                .annotate(
                    completed_estimates=Sum(
                        Cast("estimate_point__value", FloatField()),
@@ -699,11 +707,10 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                {
                    "display_name": item["display_name"],
                    "assignee_id": (
-                        str(item["assignee_id"])
-                        if item["assignee_id"]
-                        else None
+                        str(item["assignee_id"]) if item["assignee_id"] else None
                    ),
-                    "avatar": item["avatar"],
+                    "avatar": item.get("avatar"),
+                    "avatar_url": item.get("avatar_url"),
                    "total_estimates": item["total_estimates"],
                    "completed_estimates": item["completed_estimates"],
                    "pending_estimates": item["pending_estimates"],
@@ -714,6 +721,7 @@ class TransferCycleIssueEndpoint(BaseAPIView):
            label_distribution_data = (
                Issue.issue_objects.filter(
                    issue_cycle__cycle_id=cycle_id,
+                    issue_cycle__deleted_at__isnull=True,
                    workspace__slug=slug,
                    project_id=project_id,
                )
@@ -722,9 +730,7 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                .annotate(label_id=F("labels__id"))
                .values("label_name", "color", "label_id")
                .annotate(
-                    total_estimates=Sum(
-                        Cast("estimate_point__value", FloatField())
-                    )
+                    total_estimates=Sum(Cast("estimate_point__value", FloatField()))
                )
                .annotate(
                    completed_estimates=Sum(
@@ -761,9 +767,7 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                {
                    "label_name": item["label_name"],
                    "color": item["color"],
-                    "label_id": (
-                        str(item["label_id"]) if item["label_id"] else None
-                    ),
+                    "label_id": (str(item["label_id"]) if item["label_id"] else None),
                    "total_estimates": item["total_estimates"],
                    "completed_estimates": item["completed_estimates"],
                    "pending_estimates": item["pending_estimates"],
@@ -775,21 +779,36 @@ class TransferCycleIssueEndpoint(BaseAPIView):
        assignee_distribution = (
            Issue.issue_objects.filter(
                issue_cycle__cycle_id=cycle_id,
+                issue_cycle__deleted_at__isnull=True,
                workspace__slug=slug,
                project_id=project_id,
            )
            .annotate(display_name=F("assignees__display_name"))
            .annotate(assignee_id=F("assignees__id"))
-            .annotate(avatar=F("assignees__avatar"))
-            .values("display_name", "assignee_id", "avatar")
+            .annotate(
+                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("display_name", "assignee_id", "avatar_url")
            .annotate(
                total_issues=Count(
-                    "id",
-                    filter=Q(
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                ),
+                    "id", filter=Q(archived_at__isnull=True, is_draft=False)
+                )
            )
            .annotate(
                completed_issues=Count(
@@ -820,7 +839,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                "assignee_id": (
                    str(item["assignee_id"]) if item["assignee_id"] else None
                ),
-                "avatar": item["avatar"],
+                "avatar": item.get("avatar"),
+                "avatar_url": item.get("avatar_url"),
                "total_issues": item["total_issues"],
                "completed_issues": item["completed_issues"],
                "pending_issues": item["pending_issues"],
@@ -832,6 +852,7 @@ class TransferCycleIssueEndpoint(BaseAPIView):
        label_distribution = (
            Issue.issue_objects.filter(
                issue_cycle__cycle_id=cycle_id,
+                issue_cycle__deleted_at__isnull=True,
                workspace__slug=slug,
                project_id=project_id,
            )
@@ -841,12 +862,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
            .values("label_name", "color", "label_id")
            .annotate(
                total_issues=Count(
-                    "id",
-                    filter=Q(
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                ),
+                    "id", filter=Q(archived_at__isnull=True, is_draft=False)
+                )
            )
            .annotate(
                completed_issues=Count(
@@ -876,9 +893,7 @@ class TransferCycleIssueEndpoint(BaseAPIView):
            {
                "label_name": item["label_name"],
                "color": item["color"],
-                "label_id": (
-                    str(item["label_id"]) if item["label_id"] else None
-                ),
+                "label_id": (str(item["label_id"]) if item["label_id"] else None),
                "total_issues": item["total_issues"],
                "completed_issues": item["completed_issues"],
                "pending_issues": item["pending_issues"],
@@ -923,10 +938,7 @@ class TransferCycleIssueEndpoint(BaseAPIView):
        }
        current_cycle.save(update_fields=["progress_snapshot"])

-        if (
-            new_cycle.end_date is not None
-            and new_cycle.end_date < timezone.now()
-        ):
+        if new_cycle.end_date is not None and new_cycle.end_date < timezone.now():
            return Response(
                {
                    "error": "The cycle where the issues are transferred is already completed"
@@ -989,9 +1001,7 @@ class CycleUserPropertiesEndpoint(BaseAPIView):
            workspace__slug=slug,
        )

-        cycle_properties.filters = request.data.get(
-            "filters", cycle_properties.filters
-        )
+        cycle_properties.filters = request.data.get("filters", cycle_properties.filters)
        cycle_properties.display_filters = request.data.get(
            "display_filters", cycle_properties.display_filters
        )
@@ -1022,12 +1032,11 @@ class CycleProgressEndpoint(BaseAPIView):
            Issue.issue_objects.filter(
                estimate_point__estimate__type="points",
                issue_cycle__cycle_id=cycle_id,
+                issue_cycle__deleted_at__isnull=True,
                workspace__slug=slug,
                project_id=project_id,
            )
-            .annotate(
-                value_as_float=Cast("estimate_point__value", FloatField())
-            )
+            .annotate(value_as_float=Cast("estimate_point__value", FloatField()))
            .aggregate(
                backlog_estimate_point=Sum(
                    Case(
@@ -1065,15 +1074,14 @@ class CycleProgressEndpoint(BaseAPIView):
                    )
                ),
                total_estimate_points=Sum(
-                    "value_as_float",
-                    default=Value(0),
-                    output_field=FloatField(),
+                    "value_as_float", default=Value(0), output_field=FloatField()
                ),
            )
        )

        backlog_issues = Issue.issue_objects.filter(
            issue_cycle__cycle_id=cycle_id,
+            issue_cycle__deleted_at__isnull=True,
            workspace__slug=slug,
            project_id=project_id,
            state__group="backlog",
@@ -1081,6 +1089,7 @@ class CycleProgressEndpoint(BaseAPIView):

        unstarted_issues = Issue.issue_objects.filter(
            issue_cycle__cycle_id=cycle_id,
+            issue_cycle__deleted_at__isnull=True,
            workspace__slug=slug,
            project_id=project_id,
            state__group="unstarted",
@@ -1088,6 +1097,7 @@ class CycleProgressEndpoint(BaseAPIView):

        started_issues = Issue.issue_objects.filter(
            issue_cycle__cycle_id=cycle_id,
+            issue_cycle__deleted_at__isnull=True,
            workspace__slug=slug,
            project_id=project_id,
            state__group="started",
@@ -1095,6 +1105,7 @@ class CycleProgressEndpoint(BaseAPIView):

        cancelled_issues = Issue.issue_objects.filter(
            issue_cycle__cycle_id=cycle_id,
+            issue_cycle__deleted_at__isnull=True,
            workspace__slug=slug,
            project_id=project_id,
            state__group="cancelled",
@@ -1102,6 +1113,7 @@ class CycleProgressEndpoint(BaseAPIView):

        completed_issues = Issue.issue_objects.filter(
            issue_cycle__cycle_id=cycle_id,
+            issue_cycle__deleted_at__isnull=True,
            workspace__slug=slug,
            project_id=project_id,
            state__group="completed",
@@ -1109,23 +1121,20 @@ class CycleProgressEndpoint(BaseAPIView):

        total_issues = Issue.issue_objects.filter(
            issue_cycle__cycle_id=cycle_id,
+            issue_cycle__deleted_at__isnull=True,
            workspace__slug=slug,
            project_id=project_id,
        ).count()

        return Response(
            {
-                "backlog_estimate_points": aggregate_estimates[
-                    "backlog_estimate_point"
-                ]
+                "backlog_estimate_points": aggregate_estimates["backlog_estimate_point"]
                or 0,
                "unstarted_estimate_points": aggregate_estimates[
                    "unstarted_estimate_point"
                ]
                or 0,
-                "started_estimate_points": aggregate_estimates[
-                    "started_estimate_point"
-                ]
+                "started_estimate_points": aggregate_estimates["started_estimate_point"]
                or 0,
                "cancelled_estimate_points": aggregate_estimates[
                    "cancelled_estimate_point"
@@ -1135,9 +1144,7 @@ class CycleProgressEndpoint(BaseAPIView):
                    "completed_estimate_points"
                ]
                or 0,
-                "total_estimate_points": aggregate_estimates[
-                    "total_estimate_points"
-                ],
+                "total_estimate_points": aggregate_estimates["total_estimate_points"],
                "backlog_issues": backlog_issues,
                "total_issues": total_issues,
                "completed_issues": completed_issues,
@@ -1148,16 +1155,14 @@ class CycleProgressEndpoint(BaseAPIView):
            status=status.HTTP_200_OK,
        )

-class CycleAnalyticsEndpoint(BaseAPIView):

+class CycleAnalyticsEndpoint(BaseAPIView):
    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
    def get(self, request, slug, project_id, cycle_id):
        analytic_type = request.GET.get("type", "issues")
        cycle = (
            Cycle.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                id=cycle_id,
+                workspace__slug=slug, project_id=project_id, id=cycle_id
            )
            .annotate(
                total_issues=Count(
@@ -1166,6 +1171,8 @@ class CycleAnalyticsEndpoint(BaseAPIView):
                    filter=Q(
                        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,
                    ),
                )
            )
@@ -1193,18 +1200,36 @@ class CycleAnalyticsEndpoint(BaseAPIView):
            assignee_distribution = (
                Issue.issue_objects.filter(
                    issue_cycle__cycle_id=cycle_id,
+                    issue_cycle__deleted_at__isnull=True,
                    workspace__slug=slug,
                    project_id=project_id,
                )
                .annotate(display_name=F("assignees__display_name"))
                .annotate(assignee_id=F("assignees__id"))
-                .annotate(avatar=F("assignees__avatar"))
-                .values("display_name", "assignee_id", "avatar")
                .annotate(
-                    total_estimates=Sum(
-                        Cast("estimate_point__value", FloatField())
+                    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("display_name", "assignee_id", "avatar_url")
+                .annotate(
+                    total_estimates=Sum(Cast("estimate_point__value", FloatField()))
+                )
                .annotate(
                    completed_estimates=Sum(
                        Cast("estimate_point__value", FloatField()),
@@ -1231,6 +1256,7 @@ class CycleAnalyticsEndpoint(BaseAPIView):
            label_distribution = (
                Issue.issue_objects.filter(
                    issue_cycle__cycle_id=cycle_id,
+                    issue_cycle__deleted_at__isnull=True,
                    workspace__slug=slug,
                    project_id=project_id,
                )
@@ -1239,9 +1265,7 @@ class CycleAnalyticsEndpoint(BaseAPIView):
                .annotate(label_id=F("labels__id"))
                .values("label_name", "color", "label_id")
                .annotate(
-                    total_estimates=Sum(
-                        Cast("estimate_point__value", FloatField())
-                    )
+                    total_estimates=Sum(Cast("estimate_point__value", FloatField()))
                )
                .annotate(
                    completed_estimates=Sum(
@@ -1277,18 +1301,38 @@ class CycleAnalyticsEndpoint(BaseAPIView):
            assignee_distribution = (
                Issue.issue_objects.filter(
                    issue_cycle__cycle_id=cycle_id,
+                    issue_cycle__deleted_at__isnull=True,
                    project_id=project_id,
                    workspace__slug=slug,
                )
                .annotate(display_name=F("assignees__display_name"))
                .annotate(assignee_id=F("assignees__id"))
-                .annotate(avatar=F("assignees__avatar"))
-                .values("display_name", "assignee_id", "avatar")
+                .annotate(
+                    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("display_name", "assignee_id", "avatar_url")
                .annotate(
                    total_issues=Count(
                        "assignee_id",
                        filter=Q(archived_at__isnull=True, is_draft=False),
-                    ),
+                    )
                )
                .annotate(
                    completed_issues=Count(
@@ -1316,6 +1360,7 @@ class CycleAnalyticsEndpoint(BaseAPIView):
            label_distribution = (
                Issue.issue_objects.filter(
                    issue_cycle__cycle_id=cycle_id,
+                    issue_cycle__deleted_at__isnull=True,
                    project_id=project_id,
                    workspace__slug=slug,
                )
@@ -1325,8 +1370,7 @@ class CycleAnalyticsEndpoint(BaseAPIView):
                .values("label_name", "color", "label_id")
                .annotate(
                    total_issues=Count(
-                        "label_id",
-                        filter=Q(archived_at__isnull=True, is_draft=False),
+                        "label_id", filter=Q(archived_at__isnull=True, is_draft=False)
                    )
                )
                .annotate(
@@ -3,7 +3,7 @@ import json

 # Django imports
 from django.core import serializers
-from django.db.models import F, Func, OuterRef, Q
+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
@@ -12,19 +12,12 @@ from django.views.decorators.gzip import gzip_page
 from rest_framework import status
 from rest_framework.response import Response

+
 # Module imports
 from .. import BaseViewSet
-from plane.app.serializers import (
-    CycleIssueSerializer,
-)
+from plane.app.serializers import CycleIssueSerializer
 from plane.bgtasks.issue_activities_task import issue_activity
-from plane.db.models import (
-    Cycle,
-    CycleIssue,
-    Issue,
-    IssueAttachment,
-    IssueLink,
-)
+from plane.db.models import Cycle, CycleIssue, Issue, FileAsset, IssueLink
 from plane.utils.grouper import (
    issue_group_values,
    issue_on_results,
@@ -32,10 +25,7 @@ from plane.utils.grouper import (
 )
 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.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPaginator
 from plane.app.permissions import allow_permission, ROLE


@@ -46,19 +36,14 @@ class CycleIssueViewSet(BaseViewSet):
    webhook_event = "cycle_issue"
    bulk = True

-    filterset_fields = [
-        "issue__labels__id",
-        "issue__assignees__id",
-    ]
+    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")
-                )
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("issue_id"))
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
@@ -80,29 +65,29 @@ class CycleIssueViewSet(BaseViewSet):
        )

    @method_decorator(gzip_page)
-    @allow_permission(
-        [
-            ROLE.ADMIN,
-            ROLE.MEMBER,
-        ]
-    )
+    @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.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",
+                "assignees", "labels", "issue_module__module", "issue_cycle__cycle"
            )
            .filter(**filters)
-            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .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()
@@ -110,17 +95,16 @@ class CycleIssueViewSet(BaseViewSet):
                .values("count")
            )
            .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                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")
-                )
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
                .order_by()
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
@@ -132,8 +116,7 @@ class CycleIssueViewSet(BaseViewSet):
        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,
+            issue_queryset=issue_queryset, order_by_param=order_by_param
        )

        # Group by
@@ -142,9 +125,7 @@ class CycleIssueViewSet(BaseViewSet):

        # issue queryset
        issue_queryset = issue_queryset_grouper(
-            queryset=issue_queryset,
-            group_by=group_by,
-            sub_group_by=sub_group_by,
+            queryset=issue_queryset, group_by=group_by, sub_group_by=sub_group_by
        )

        if group_by:
@@ -164,9 +145,7 @@ class CycleIssueViewSet(BaseViewSet):
                        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,
+                            group_by=group_by, issues=issues, sub_group_by=sub_group_by
                        ),
                        paginator_cls=SubGroupedOffsetPaginator,
                        group_by_fields=issue_group_values(
@@ -184,10 +163,10 @@ class CycleIssueViewSet(BaseViewSet):
                        group_by_field_name=group_by,
                        sub_group_by_field_name=sub_group_by,
                        count_filter=Q(
-                            Q(issue_inbox__status=1)
-                            | Q(issue_inbox__status=-1)
-                            | Q(issue_inbox__status=2)
-                            | Q(issue_inbox__isnull=True),
+                            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,
                        ),
@@ -200,9 +179,7 @@ class CycleIssueViewSet(BaseViewSet):
                    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,
+                        group_by=group_by, issues=issues, sub_group_by=sub_group_by
                    ),
                    paginator_cls=GroupedOffsetPaginator,
                    group_by_fields=issue_group_values(
@@ -213,10 +190,10 @@ class CycleIssueViewSet(BaseViewSet):
                    ),
                    group_by_field_name=group_by,
                    count_filter=Q(
-                        Q(issue_inbox__status=1)
-                        | Q(issue_inbox__status=-1)
-                        | Q(issue_inbox__status=2)
-                        | Q(issue_inbox__isnull=True),
+                        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,
                    ),
@@ -238,18 +215,14 @@ class CycleIssueViewSet(BaseViewSet):

        if not issues:
            return Response(
-                {"error": "Issues are required"},
-                status=status.HTTP_400_BAD_REQUEST,
+                {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
            )

        cycle = Cycle.objects.get(
            workspace__slug=slug, project_id=project_id, pk=cycle_id
        )

-        if (
-            cycle.end_date is not None
-            and cycle.end_date < timezone.now()
-        ):
+        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"
@@ -259,13 +232,9 @@ class CycleIssueViewSet(BaseViewSet):

        # Get all CycleIssues already created
        cycle_issues = list(
-            CycleIssue.objects.filter(
-                ~Q(cycle_id=cycle_id), issue_id__in=issues
-            )
+            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
-        ]
+        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
@@ -304,9 +273,7 @@ class CycleIssueViewSet(BaseViewSet):
            )

        # Update the cycle issues
-        CycleIssue.objects.bulk_update(
-            updated_records, ["cycle_id"], batch_size=100
-        )
+        CycleIssue.objects.bulk_update(updated_records, ["cycle_id"], batch_size=100)
        # Capture Issue Activity
        issue_activity.delay(
            type="cycle.activity.created",
@@ -36,12 +36,13 @@ from plane.db.models import (
    DashboardWidget,
    Issue,
    IssueActivity,
-    IssueAttachment,
+    FileAsset,
    IssueLink,
    IssueRelation,
    Project,
    Widget,
    WorkspaceMember,
+    CycleIssue,
 )
 from plane.utils.issue_filters import issue_filters

@@ -56,7 +57,8 @@ def dashboard_overview_stats(self, request, slug):
            project__project_projectmember__member=request.user,
            workspace__slug=slug,
            assignees__in=[request.user],
-        ).filter(
+        )
+        .filter(
            Q(
                project__project_projectmember__role=5,
                project__guest_view_all_features=True,
@@ -83,7 +85,8 @@ def dashboard_overview_stats(self, request, slug):
            project__project_projectmember__member=request.user,
            workspace__slug=slug,
            assignees__in=[request.user],
-        ).filter(
+        )
+        .filter(
            Q(
                project__project_projectmember__role=5,
                project__guest_view_all_features=True,
@@ -108,7 +111,8 @@ def dashboard_overview_stats(self, request, slug):
            project__project_projectmember__is_active=True,
            project__project_projectmember__member=request.user,
            created_by_id=request.user.id,
-        ).filter(
+        )
+        .filter(
            Q(
                project__project_projectmember__role=5,
                project__guest_view_all_features=True,
@@ -134,7 +138,8 @@ def dashboard_overview_stats(self, request, slug):
            project__project_projectmember__member=request.user,
            assignees__in=[request.user],
            state__group="completed",
-        ).filter(
+        )
+        .filter(
            Q(
                project__project_projectmember__role=5,
                project__guest_view_all_features=True,
@@ -187,7 +192,13 @@ def dashboard_assigned_issues(self, request, slug):
                ).select_related("issue"),
            )
        )
-        .annotate(cycle_id=F("issue_cycle__cycle_id"))
+        .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()
@@ -195,8 +206,9 @@ def dashboard_assigned_issues(self, request, slug):
            .values("count")
        )
        .annotate(
-            attachment_count=IssueAttachment.objects.filter(
-                issue=OuterRef("id")
+            attachment_count=FileAsset.objects.filter(
+                issue_id=OuterRef("id"),
+                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
            )
            .order_by()
            .annotate(count=Func(F("id"), function="Count"))
@@ -213,7 +225,10 @@ def dashboard_assigned_issues(self, request, slug):
                ArrayAgg(
                    "labels__id",
                    distinct=True,
-                    filter=~Q(labels__id__isnull=True),
+                    filter=Q(
+                        ~Q(labels__id__isnull=True)
+                        & Q(label_issue__deleted_at__isnull=True)
+                    ),
                ),
                Value([], output_field=ArrayField(UUIDField())),
            ),
@@ -221,8 +236,11 @@ def dashboard_assigned_issues(self, request, slug):
                ArrayAgg(
                    "assignees__id",
                    distinct=True,
-                    filter=~Q(assignees__id__isnull=True)
-                    & Q(assignees__member_project__is_active=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())),
            ),
@@ -230,7 +248,11 @@ def dashboard_assigned_issues(self, request, slug):
                ArrayAgg(
                    "issue_module__module_id",
                    distinct=True,
-                    filter=~Q(issue_module__module_id__isnull=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())),
            ),
@@ -238,10 +260,7 @@ def dashboard_assigned_issues(self, request, slug):
    )

    if WorkspaceMember.objects.filter(
-        workspace__slug=slug,
-        member=request.user,
-        role=5,
-        is_active=True,
+        workspace__slug=slug, member=request.user, role=5, is_active=True
    ).exists():
        assigned_issues = assigned_issues.filter(created_by=request.user)

@@ -249,10 +268,7 @@ def dashboard_assigned_issues(self, request, slug):
    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)
-            ],
+            *[When(priority=p, then=Value(i)) for i, p in enumerate(priority_order)],
            output_field=CharField(),
        )
    ).order_by("priority_order")
@@ -278,9 +294,7 @@ def dashboard_assigned_issues(self, request, slug):
        completed_issues_count = assigned_issues.filter(
            state__group__in=["completed"]
        ).count()
-        completed_issues = assigned_issues.filter(
-            state__group__in=["completed"]
-        )[:5]
+        completed_issues = assigned_issues.filter(state__group__in=["completed"])[:5]
        return Response(
            {
                "issues": IssueSerializer(
@@ -350,7 +364,13 @@ def dashboard_created_issues(self, request, slug):
        .filter(**filters)
        .select_related("workspace", "project", "state", "parent")
        .prefetch_related("assignees", "labels", "issue_module__module")
-        .annotate(cycle_id=F("issue_cycle__cycle_id"))
+        .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()
@@ -358,8 +378,9 @@ def dashboard_created_issues(self, request, slug):
            .values("count")
        )
        .annotate(
-            attachment_count=IssueAttachment.objects.filter(
-                issue=OuterRef("id")
+            attachment_count=FileAsset.objects.filter(
+                issue_id=OuterRef("id"),
+                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
            )
            .order_by()
            .annotate(count=Func(F("id"), function="Count"))
@@ -376,7 +397,10 @@ def dashboard_created_issues(self, request, slug):
                ArrayAgg(
                    "labels__id",
                    distinct=True,
-                    filter=~Q(labels__id__isnull=True),
+                    filter=Q(
+                        ~Q(labels__id__isnull=True)
+                        & Q(label_issue__deleted_at__isnull=True)
+                    ),
                ),
                Value([], output_field=ArrayField(UUIDField())),
            ),
@@ -384,8 +408,11 @@ def dashboard_created_issues(self, request, slug):
                ArrayAgg(
                    "assignees__id",
                    distinct=True,
-                    filter=~Q(assignees__id__isnull=True)
-                    & Q(assignees__member_project__is_active=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())),
            ),
@@ -393,7 +420,11 @@ def dashboard_created_issues(self, request, slug):
                ArrayAgg(
                    "issue_module__module_id",
                    distinct=True,
-                    filter=~Q(issue_module__module_id__isnull=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())),
            ),
@@ -405,10 +436,7 @@ def dashboard_created_issues(self, request, slug):
    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)
-            ],
+            *[When(priority=p, then=Value(i)) for i, p in enumerate(priority_order)],
            output_field=CharField(),
        )
    ).order_by("priority_order")
@@ -434,9 +462,7 @@ def dashboard_created_issues(self, request, slug):
        completed_issues_count = created_issues.filter(
            state__group__in=["completed"]
        ).count()
-        completed_issues = created_issues.filter(
-            state__group__in=["completed"]
-        )[:5]
+        completed_issues = created_issues.filter(state__group__in=["completed"])[:5]
        return Response(
            {
                "issues": IssueSerializer(completed_issues, many=True).data,
@@ -491,10 +517,7 @@ def dashboard_issues_by_state_groups(self, request, slug):
    extra_filters = {}

    if WorkspaceMember.objects.filter(
-        workspace__slug=slug,
-        member=request.user,
-        role=5,
-        is_active=True,
+        workspace__slug=slug, member=request.user, role=5, is_active=True
    ).exists():
        extra_filters = {"created_by": request.user}

@@ -531,10 +554,7 @@ def dashboard_issues_by_priority(self, request, slug):
    extra_filters = {}

    if WorkspaceMember.objects.filter(
-        workspace__slug=slug,
-        member=request.user,
-        role=5,
-        is_active=True,
+        workspace__slug=slug, member=request.user, role=5, is_active=True
    ).exists():
        extra_filters = {"created_by": request.user}

@@ -559,8 +579,7 @@ def dashboard_issues_by_priority(self, request, slug):

    # Prepare output including all groups with their counts
    output_data = [
-        {"priority": group, "count": count}
-        for group, count in all_groups.items()
+        {"priority": group, "count": count} for group, count in all_groups.items()
    ]

    return Response(output_data, status=status.HTTP_200_OK)
@@ -577,8 +596,7 @@ def dashboard_recent_activity(self, request, slug):
    ).select_related("actor", "workspace", "issue", "project")[:8]

    return Response(
-        IssueActivitySerializer(queryset, many=True).data,
-        status=status.HTTP_200_OK,
+        IssueActivitySerializer(queryset, many=True).data, status=status.HTTP_200_OK
    )


@@ -608,22 +626,14 @@ def dashboard_recent_projects(self, request, slug):
        ).exclude(id__in=unique_project_ids)

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

-    return Response(
-        list(unique_project_ids)[:4],
-        status=status.HTTP_200_OK,
-    )
+    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,
-        )
+        WorkspaceMember.objects.filter(workspace__slug=slug, is_active=True)
        .annotate(
            active_issue_count=Count(
                Case(
@@ -648,10 +658,7 @@ def dashboard_recent_collaborators(self, request, slug):
        .order_by("-active_issue_count")
        .distinct()
    )
-    return Response(
-        (project_members_with_activities),
-        status=status.HTTP_200_OK,
-    )
+    return Response((project_members_with_activities), status=status.HTTP_200_OK)


 class DashboardEndpoint(BaseAPIView):
@@ -700,14 +707,13 @@ class DashboardEndpoint(BaseAPIView):

                    updated_dashboard_widgets = []
                    for widget_key in widgets_to_fetch:
-                        widget = Widget.objects.filter(
-                            key=widget_key
-                        ).values_list("id", flat=True)
+                        widget = Widget.objects.filter(key=widget_key).values_list(
+                            "id", flat=True
+                        )
                        if widget:
                            updated_dashboard_widgets.append(
                                DashboardWidget(
-                                    widget_id=widget,
-                                    dashboard_id=dashboard.id,
+                                    widget_id=widget, dashboard_id=dashboard.id
                                )
                            )

@@ -774,11 +780,7 @@ class DashboardEndpoint(BaseAPIView):

        func = WIDGETS_MAPPER.get(widget_key)
        if func is not None:
-            response = func(
-                self,
-                request=request,
-                slug=slug,
-            )
+            response = func(self, request=request, slug=slug)
            if isinstance(response, Response):
                return response

@@ -791,8 +793,7 @@ class DashboardEndpoint(BaseAPIView):
 class WidgetsEndpoint(BaseAPIView):
    def patch(self, request, dashboard_id, widget_id):
        dashboard_widget = DashboardWidget.objects.filter(
-            widget_id=widget_id,
-            dashboard_id=dashboard_id,
+            widget_id=widget_id, dashboard_id=dashboard_id
        ).first()
        dashboard_widget.is_visible = request.data.get(
            "is_visible", dashboard_widget.is_visible
@@ -800,10 +801,6 @@ class WidgetsEndpoint(BaseAPIView):
        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.filters = request.data.get("filters", dashboard_widget.filters)
        dashboard_widget.save()
-        return Response(
-            {"message": "successfully updated"}, status=status.HTTP_200_OK
-        )
+        return Response({"message": "successfully updated"}, status=status.HTTP_200_OK)
@@ -1,5 +1,6 @@
 # views.py
 from django.http import JsonResponse

+
 def custom_404_view(request, exception=None):
    return JsonResponse({"error": "Page not found."}, status=404)
@@ -11,11 +11,7 @@ from rest_framework import status

 # Module imports
 from ..base import BaseViewSet, BaseAPIView
-from plane.app.permissions import (
-    ProjectEntityPermission,
-    allow_permission,
-    ROLE,
-)
+from plane.app.permissions import ProjectEntityPermission, allow_permission, ROLE
 from plane.db.models import Project, Estimate, EstimatePoint, Issue
 from plane.app.serializers import (
    EstimateSerializer,
@@ -32,13 +28,7 @@ def generate_random_name(length=10):


 class ProjectEstimatePointEndpoint(BaseAPIView):
-
-    @allow_permission(
-        [
-            ROLE.ADMIN,
-            ROLE.MEMBER,
-        ]
-    )
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
    def get(self, request, slug, project_id):
        project = Project.objects.get(workspace__slug=slug, pk=project_id)
        if project.estimate_id is not None:
@@ -53,17 +43,13 @@ class ProjectEstimatePointEndpoint(BaseAPIView):


 class BulkEstimatePointEndpoint(BaseViewSet):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
+    permission_classes = [ProjectEntityPermission]
    model = Estimate
    serializer_class = EstimateSerializer

    def list(self, request, slug, project_id):
        estimates = (
-            Estimate.objects.filter(
-                workspace__slug=slug, project_id=project_id
-            )
+            Estimate.objects.filter(workspace__slug=slug, project_id=project_id)
            .prefetch_related("points")
            .select_related("workspace", "project")
        )
@@ -91,9 +77,7 @@ class BulkEstimatePointEndpoint(BaseViewSet):
            data=request.data.get("estimate_points"), many=True
        )
        if not serializer.is_valid():
-            return Response(
-                serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            )
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        estimate_points = EstimatePoint.objects.bulk_create(
            [
@@ -121,16 +105,12 @@ class BulkEstimatePointEndpoint(BaseViewSet):
            pk=estimate_id, workspace__slug=slug, project_id=project_id
        )
        serializer = EstimateReadSerializer(estimate)
-        return Response(
-            serializer.data,
-            status=status.HTTP_200_OK,
-        )
+        return Response(serializer.data, status=status.HTTP_200_OK)

    @invalidate_cache(
        path="/api/workspaces/:slug/estimates/", url_params=True, user=False
    )
    def partial_update(self, request, slug, project_id, estimate_id):
-
        if not len(request.data.get("estimate_points", [])):
            return Response(
                {"error": "Estimate points are required"},
@@ -140,20 +120,15 @@ class BulkEstimatePointEndpoint(BaseViewSet):
        estimate = Estimate.objects.get(pk=estimate_id)

        if request.data.get("estimate"):
-            estimate.name = request.data.get("estimate").get(
-                "name", estimate.name
-            )
-            estimate.type = request.data.get("estimate").get(
-                "type", estimate.type
-            )
+            estimate.name = request.data.get("estimate").get("name", estimate.name)
+            estimate.type = request.data.get("estimate").get("type", estimate.type)
            estimate.save()

        estimate_points_data = request.data.get("estimate_points", [])

        estimate_points = EstimatePoint.objects.filter(
            pk__in=[
-                estimate_point.get("id")
-                for estimate_point in estimate_points_data
+                estimate_point.get("id") for estimate_point in estimate_points_data
            ],
            workspace__slug=slug,
            project_id=project_id,
@@ -178,16 +153,11 @@ class BulkEstimatePointEndpoint(BaseViewSet):
                updated_estimate_points.append(estimate_point)

        EstimatePoint.objects.bulk_update(
-            updated_estimate_points,
-            ["key", "value"],
-            batch_size=10,
+            updated_estimate_points, ["key", "value"], batch_size=10
        )

        estimate_serializer = EstimateReadSerializer(estimate)
-        return Response(
-            estimate_serializer.data,
-            status=status.HTTP_200_OK,
-        )
+        return Response(estimate_serializer.data, status=status.HTTP_200_OK)

    @invalidate_cache(
        path="/api/workspaces/:slug/estimates/", url_params=True, user=False
@@ -201,7 +171,6 @@ class BulkEstimatePointEndpoint(BaseViewSet):


 class EstimatePointEndpoint(BaseViewSet):
-
    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
    def create(self, request, slug, project_id, estimate_id):
        #  TODO: add a key validation if the same key already exists
@@ -213,18 +182,13 @@ class EstimatePointEndpoint(BaseViewSet):
        key = request.data.get("key", 0)
        value = request.data.get("value", "")
        estimate_point = EstimatePoint.objects.create(
-            estimate_id=estimate_id,
-            project_id=project_id,
-            key=key,
-            value=value,
+            estimate_id=estimate_id, project_id=project_id, key=key, value=value
        )
        serializer = EstimatePointSerializer(estimate_point).data
        return Response(serializer, status=status.HTTP_200_OK)

    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def partial_update(
-        self, request, slug, project_id, estimate_id, estimate_point_id
-    ):
+    def partial_update(self, request, slug, project_id, estimate_id, estimate_point_id):
        #  TODO: add a key validation if the same key already exists
        estimate_point = EstimatePoint.objects.get(
            pk=estimate_point_id,
@@ -236,21 +200,15 @@ class EstimatePointEndpoint(BaseViewSet):
            estimate_point, data=request.data, partial=True
        )
        if not serializer.is_valid():
-            return Response(
-                serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            )
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        serializer.save()
        return Response(serializer.data, status=status.HTTP_200_OK)

    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def destroy(
-        self, request, slug, project_id, estimate_id, estimate_point_id
-    ):
+    def destroy(self, request, slug, project_id, estimate_id, estimate_point_id):
        new_estimate_id = request.data.get("new_estimate_id", None)
        estimate_points = EstimatePoint.objects.filter(
-            estimate_id=estimate_id,
-            project_id=project_id,
-            workspace__slug=slug,
+            estimate_id=estimate_id, project_id=project_id, workspace__slug=slug
        )
        # update all the issues with the new estimate
        if new_estimate_id:
@@ -265,10 +223,8 @@ class EstimatePointEndpoint(BaseViewSet):
                    requested_data=json.dumps(
                        {
                            "estimate_point": (
-                                str(new_estimate_id)
-                                if new_estimate_id
-                                else None
-                            ),
+                                str(new_estimate_id) if new_estimate_id else None
+                            )
                        }
                    ),
                    actor_id=str(request.user.id),
@@ -280,7 +236,7 @@ class EstimatePointEndpoint(BaseViewSet):
                                str(issue.estimate_point_id)
                                if issue.estimate_point_id
                                else None
-                            ),
+                            )
                        }
                    ),
                    epoch=int(timezone.now().timestamp()),
@@ -295,11 +251,7 @@ class EstimatePointEndpoint(BaseViewSet):
            for issue in issues:
                issue_activity.delay(
                    type="issue.activity.updated",
-                    requested_data=json.dumps(
-                        {
-                            "estimate_point": None,
-                        }
-                    ),
+                    requested_data=json.dumps({"estimate_point": None}),
                    actor_id=str(request.user.id),
                    issue_id=issue.id,
                    project_id=str(project_id),
@@ -309,16 +261,14 @@ class EstimatePointEndpoint(BaseViewSet):
                                str(issue.estimate_point_id)
                                if issue.estimate_point_id
                                else None
-                            ),
+                            )
                        }
                    ),
                    epoch=int(timezone.now().timestamp()),
                )

        # delete the estimate point
-        old_estimate_point = EstimatePoint.objects.filter(
-            pk=estimate_point_id
-        ).first()
+        old_estimate_point = EstimatePoint.objects.filter(pk=estimate_point_id).first()

        # rearrange the estimate points
        updated_estimate_points = []
@@ -328,9 +278,7 @@ class EstimatePointEndpoint(BaseViewSet):
                updated_estimate_points.append(estimate_point)

        EstimatePoint.objects.bulk_update(
-            updated_estimate_points,
-            ["key"],
-            batch_size=10,
+            updated_estimate_points, ["key"], batch_size=10
        )

        old_estimate_point.delete()
@@ -51,9 +51,7 @@ class ExportIssuesEndpoint(BaseAPIView):
                slug=slug,
            )
            return Response(
-                {
-                    "message": "Once the export is ready you will be able to download it"
-                },
+                {"message": "Once the export is ready you will be able to download it"},
                status=status.HTTP_200_OK,
            )
        else:
@@ -62,18 +60,13 @@ class ExportIssuesEndpoint(BaseAPIView):
                status=status.HTTP_400_BAD_REQUEST,
            )

-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE"
-    )
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
    def get(self, request, slug):
        exporter_history = ExporterHistory.objects.filter(
-            workspace__slug=slug,
-            type="issue_exports",
+            workspace__slug=slug, type="issue_exports"
        ).select_related("workspace", "initiated_by")

-        if request.GET.get("per_page", False) and request.GET.get(
-            "cursor", False
-        ):
+        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,
--- a/Show More
+++ b/Show More