chore: migration for user notification preference

* migration: external source and id for issues

* fix: cleaning up deprecated favorite tables

* fix: removing deprecated models

---------

Co-authored-by: sriram veeraghanta <veeraghanta.sriram@gmail.com>

.github/actions/buildpush-action/action.yml

@@ -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 }}

.github/workflows/build-branch.yml

@@ -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/buildpush-action
         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/buildpush-action
+        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/buildpush-action
         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/buildpush-action
         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/buildpush-action
+        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/buildpush-action
         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.0.8
         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

admin/core/components/admin-sidebar/sidebar-dropdown.tsx

@@ -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"

admin/helpers/file.helper.ts

@@ -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}`;
+};

admin/helpers/string.helper.ts

@@ -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);
+};

admin/package.json

@@ -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,7 +40,6 @@
   "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-dom": "^18.2.18",

apiserver/plane/api/serializers/__init__.py

@@ -5,7 +5,6 @@ from .issue import (
     IssueSerializer,
     LabelSerializer,
     IssueLinkSerializer,
-    IssueAttachmentSerializer,
     IssueCommentSerializer,
     IssueAttachmentSerializer,
     IssueActivitySerializer,

apiserver/plane/api/serializers/issue.py

@@ -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(
@@ -315,7 +316,7 @@ class IssueLinkSerializer(BaseSerializer):
             "created_at",
             "updated_at",
         ]
-    
+
     def validate_url(self, value):
         # Check URL format
         validate_url = URLValidator()
@@ -359,7 +360,7 @@ class IssueLinkSerializer(BaseSerializer):
 
 class IssueAttachmentSerializer(BaseSerializer):
     class Meta:
-        model = IssueAttachment
+        model = FileAsset
         fields = "__all__"
         read_only_fields = [
             "id",

apiserver/plane/api/serializers/project.py

@@ -19,6 +19,7 @@ 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)
 
     class Meta:
         model = Project
@@ -32,6 +33,7 @@ class ProjectSerializer(BaseSerializer):
             "created_by",
             "updated_by",
             "deleted_at",
+            "cover_image_url",
         ]
 
     def validate(self, data):
@@ -87,6 +89,8 @@ class ProjectSerializer(BaseSerializer):
 
 
 class ProjectLiteSerializer(BaseSerializer):
+    cover_image_url = serializers.CharField(read_only=True)
+
     class Meta:
         model = Project
         fields = [
@@ -97,5 +101,6 @@ class ProjectLiteSerializer(BaseSerializer):
             "icon_prop",
             "emoji",
             "description",
+            "cover_image_url",
         ]
         read_only_fields = fields

apiserver/plane/api/serializers/user.py

@@ -13,6 +13,7 @@ class UserLiteSerializer(BaseSerializer):
             "last_name",
             "email",
             "avatar",
+            "avatar_url",
             "display_name",
             "email",
         ]

apiserver/plane/api/views/cycle.py

@@ -13,8 +13,12 @@ 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
@@ -32,7 +36,7 @@ from plane.db.models import (
     CycleIssue,
     Issue,
     Project,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     ProjectMember,
     UserFavorite,
@@ -641,8 +645,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"))
@@ -883,7 +888,27 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                 .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", "avatar_url")
                 .annotate(
                     total_estimates=Sum(
                         Cast("estimate_point__value", FloatField())
@@ -920,7 +945,8 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                         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"],
@@ -998,7 +1024,27 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
             .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",
@@ -1037,7 +1083,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"],

apiserver/plane/api/views/issue.py

@@ -42,7 +42,7 @@ from plane.bgtasks.issue_activities_task import issue_activity
 from plane.db.models import (
     Issue,
     IssueActivity,
-    IssueAttachment,
+    FileAsset,
     IssueComment,
     IssueLink,
     Label,
@@ -210,8 +210,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"))
@@ -1062,7 +1063,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
     permission_classes = [
         ProjectEntityPermission,
     ]
-    model = IssueAttachment
+    model = FileAsset
     parser_classes = (MultiPartParser, FormParser)
 
     def post(self, request, slug, project_id, issue_id):
@@ -1070,7 +1071,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 +1079,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"),
@@ -1112,7 +1113,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 +1131,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)

apiserver/plane/api/views/module.py

@@ -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,
@@ -393,8 +393,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"))

apiserver/plane/app/serializers/base.py

@@ -49,48 +49,46 @@ class DynamicBaseSerializer(BaseSerializer):
                 allowed.append(list(item.keys())[0])
 
         for field in allowed:
-            if field not in self.fields:
-                from . import (
-                    WorkspaceLiteSerializer,
-                    ProjectLiteSerializer,
-                    UserLiteSerializer,
-                    StateLiteSerializer,
-                    IssueSerializer,
-                    LabelSerializer,
-                    CycleIssueSerializer,
-                    IssueLiteSerializer,
-                    IssueRelationSerializer,
-                    InboxIssueLiteSerializer,
-                    IssueReactionLiteSerializer,
-                    IssueAttachmentLiteSerializer,
-                    IssueLinkLiteSerializer,
-                )
+            from . import (
+                WorkspaceLiteSerializer,
+                ProjectLiteSerializer,
+                UserLiteSerializer,
+                StateLiteSerializer,
+                IssueSerializer,
+                LabelSerializer,
+                CycleIssueSerializer,
+                IssueLiteSerializer,
+                IssueRelationSerializer,
+                InboxIssueLiteSerializer,
+                IssueReactionLiteSerializer,
+                IssueLinkLiteSerializer,
+            )
 
-                # Expansion mapper
-                expansion = {
-                    "user": UserLiteSerializer,
-                    "workspace": WorkspaceLiteSerializer,
-                    "project": ProjectLiteSerializer,
-                    "default_assignee": UserLiteSerializer,
-                    "project_lead": UserLiteSerializer,
-                    "state": StateLiteSerializer,
-                    "created_by": UserLiteSerializer,
-                    "issue": IssueSerializer,
-                    "actor": UserLiteSerializer,
-                    "owned_by": UserLiteSerializer,
-                    "members": UserLiteSerializer,
-                    "assignees": UserLiteSerializer,
-                    "labels": LabelSerializer,
-                    "issue_cycle": CycleIssueSerializer,
-                    "parent": IssueLiteSerializer,
-                    "issue_relation": IssueRelationSerializer,
-                    "issue_inbox": InboxIssueLiteSerializer,
-                    "issue_reactions": IssueReactionLiteSerializer,
-                    "issue_attachment": IssueAttachmentLiteSerializer,
-                    "issue_link": IssueLinkLiteSerializer,
-                    "sub_issues": IssueLiteSerializer,
-                }
+            # Expansion mapper
+            expansion = {
+                "user": UserLiteSerializer,
+                "workspace": WorkspaceLiteSerializer,
+                "project": ProjectLiteSerializer,
+                "default_assignee": UserLiteSerializer,
+                "project_lead": UserLiteSerializer,
+                "state": StateLiteSerializer,
+                "created_by": UserLiteSerializer,
+                "issue": IssueSerializer,
+                "actor": UserLiteSerializer,
+                "owned_by": UserLiteSerializer,
+                "members": UserLiteSerializer,
+                "assignees": UserLiteSerializer,
+                "labels": LabelSerializer,
+                "issue_cycle": CycleIssueSerializer,
+                "parent": IssueLiteSerializer,
+                "issue_relation": IssueRelationSerializer,
+                "issue_inbox": InboxIssueLiteSerializer,
+                "issue_reactions": IssueReactionLiteSerializer,
+                "issue_link": IssueLinkLiteSerializer,
+                "sub_issues": IssueLiteSerializer,
+            }
 
+            if field not in self.fields and field in expansion:
                 self.fields[field] = expansion[field](
                     many=(
                         True
@@ -178,4 +176,29 @@ class DynamicBaseSerializer(BaseSerializer):
                             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

apiserver/plane/app/serializers/draft.py

@@ -276,6 +276,8 @@ class DraftIssueSerializer(BaseSerializer):
             "updated_at",
             "created_by",
             "updated_by",
+            "type_id",
+            "description_html",
         ]
         read_only_fields = fields
 

apiserver/plane/app/serializers/issue.py

@@ -27,7 +27,7 @@ from plane.db.models import (
     Module,
     ModuleIssue,
     IssueLink,
-    IssueAttachment,
+    FileAsset,
     IssueReaction,
     CommentReaction,
     IssueVote,
@@ -498,8 +498,11 @@ 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 +517,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
 

apiserver/plane/app/serializers/project.py

@@ -95,6 +95,7 @@ class ProjectLiteSerializer(BaseSerializer):
             "identifier",
             "name",
             "cover_image",
+            "cover_image_url",
             "logo_props",
             "description",
         ]
@@ -117,6 +118,7 @@ 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)
 
     def get_members(self, obj):
         project_members = getattr(obj, "members_list", None)
@@ -128,6 +130,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
             ]

apiserver/plane/app/serializers/user.py

@@ -56,12 +56,15 @@ class UserSerializer(BaseSerializer):
 
 
 class UserMeSerializer(BaseSerializer):
+
     class Meta:
         model = User
         fields = [
             "id",
             "avatar",
             "cover_image",
+            "avatar_url",
+            "cover_image_url",
             "date_joined",
             "display_name",
             "email",
@@ -156,6 +159,7 @@ class UserLiteSerializer(BaseSerializer):
             "first_name",
             "last_name",
             "avatar",
+            "avatar_url",
             "is_bot",
             "display_name",
         ]
@@ -173,6 +177,7 @@ class UserAdminLiteSerializer(BaseSerializer):
             "first_name",
             "last_name",
             "avatar",
+            "avatar_url",
             "is_bot",
             "display_name",
             "email",

apiserver/plane/app/serializers/workspace.py

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

apiserver/plane/app/urls/asset.py

@@ -5,6 +5,13 @@ from plane.app.views import (
     FileAssetEndpoint,
     UserAssetsEndpoint,
     FileAssetViewSet,
+    # V2 Endpoints
+    WorkspaceFileAssetEndpoint,
+    UserAssetsV2Endpoint,
+    StaticFileAssetEndpoint,
+    AssetRestoreEndpoint,
+    ProjectAssetEndpoint,
+    ProjectBulkAssetEndpoint,
 )
 
 
@@ -38,4 +45,49 @@ urlpatterns = [
         ),
         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(),
+    ),
 ]

apiserver/plane/app/urls/issue.py

@@ -21,6 +21,7 @@ from plane.app.views import (
     BulkArchiveIssuesEndpoint,
     DeletedIssuesListViewSet,
     IssuePaginatedViewSet,
+    IssueAttachmentV2Endpoint,
 )
 
 urlpatterns = [
@@ -132,6 +133,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(),

apiserver/plane/app/views/__init__.py

@@ -110,7 +110,19 @@ from .cycle.archive import (
     CycleArchiveUnarchiveEndpoint,
 )
 
-from .asset.base import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
+from .asset.base import (
+    FileAssetEndpoint,
+    UserAssetsEndpoint,
+    FileAssetViewSet,
+)
+from .asset.v2 import (
+    WorkspaceFileAssetEndpoint,
+    UserAssetsV2Endpoint,
+    StaticFileAssetEndpoint,
+    AssetRestoreEndpoint,
+    ProjectAssetEndpoint,
+    ProjectBulkAssetEndpoint,
+)
 from .issue.base import (
     IssueListEndpoint,
     IssueViewSet,
@@ -128,6 +140,8 @@ from .issue.archive import IssueArchiveViewSet, BulkArchiveIssuesEndpoint
 
 from .issue.attachment import (
     IssueAttachmentEndpoint,
+    # V2
+    IssueAttachmentV2Endpoint,
 )
 
 from .issue.comment import (

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

@@ -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
@@ -118,14 +121,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",
@@ -355,7 +381,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 +389,32 @@ 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 +423,26 @@ 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,6 +451,26 @@ 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")
         )
 

apiserver/plane/app/views/asset/v2.py

@@ -0,0 +1,811 @@
+# 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
+
+
+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()
+        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)
+        storage = S3Storage(request=request)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if asset.storage_metadata is None:
+            asset.storage_metadata = storage.get_object_metadata(
+                object_name=asset.asset.name
+            )
+        # 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()
+        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()
+        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()
+        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.workspace_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"]
+        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)
+        storage = S3Storage(request=request)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if asset.storage_metadata is None:
+            asset.storage_metadata = storage.get_object_metadata(
+                object_name=asset.asset.name
+            )
+        # 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()
+        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()
+        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()
+        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"]
+        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,
+        )
+        storage = S3Storage(request=request)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if asset.storage_metadata is None:
+            asset.storage_metadata = storage.get_object_metadata(
+                object_name=asset.asset.name
+            )
+
+        # update the attributes
+        asset.attributes = request.data.get("attributes", asset.attributes)
+        # save the asset
+        asset.save()
+        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()
+        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):
+
+    @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,
+            )
+
+        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)

apiserver/plane/app/views/cycle/archive.py

@@ -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
@@ -139,7 +140,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                 Prefetch(
                     "issue_cycle__issue__assignees",
                     queryset=User.objects.only(
-                        "avatar", "first_name", "id"
+                        "avatar_asset", "first_name", "id"
                     ).distinct(),
                 )
             )
@@ -159,6 +160,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 +172,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 +184,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 +196,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 +208,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 +220,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,
                     ),
                 )
             )
@@ -400,8 +407,27 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                     )
                     .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_estimates=Sum(
                             Cast("estimate_point__value", FloatField())
@@ -494,13 +520,13 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                 .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=F("assignees__avatar_url"))
                 .annotate(display_name=F("assignees__display_name"))
                 .values(
                     "first_name",
                     "last_name",
                     "assignee_id",
-                    "avatar",
+                    "avatar_url",
                     "display_name",
                 )
                 .annotate(

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

@@ -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,7 +82,7 @@ class CycleViewSet(BaseViewSet):
                 Prefetch(
                     "issue_cycle__issue__assignees",
                     queryset=User.objects.only(
-                        "avatar", "first_name", "id"
+                        "avatar_asset", "first_name", "id"
                     ).distinct(),
                 )
             )
@@ -101,6 +102,7 @@ class CycleViewSet(BaseViewSet):
                     filter=Q(
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -112,6 +114,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__issue__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -606,6 +609,7 @@ 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,
                     ),
                 )
             )
@@ -616,6 +620,7 @@ 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,
                     ),
                 )
             )
@@ -626,6 +631,7 @@ 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,
                     ),
                 )
             )
@@ -636,6 +642,7 @@ 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,
                     ),
                 )
             )
@@ -646,6 +653,7 @@ 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,
                     ),
                 )
             )
@@ -667,8 +675,27 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                 )
                 .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_estimates=Sum(
                         Cast("estimate_point__value", FloatField())
@@ -705,7 +732,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                         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"],
@@ -782,8 +810,27 @@ class TransferCycleIssueEndpoint(BaseAPIView):
             )
             .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",
@@ -822,7 +869,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"],
@@ -1169,6 +1217,7 @@ 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,
                     ),
                 )
             )
@@ -1201,8 +1250,27 @@ class CycleAnalyticsEndpoint(BaseAPIView):
                 )
                 .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_estimates=Sum(
                         Cast("estimate_point__value", FloatField())
@@ -1285,8 +1353,27 @@ class CycleAnalyticsEndpoint(BaseAPIView):
                 )
                 .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",

apiserver/plane/app/views/cycle/issue.py

@@ -22,7 +22,7 @@ from plane.db.models import (
     Cycle,
     CycleIssue,
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
 )
 from plane.utils.grouper import (
@@ -110,8 +110,9 @@ 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"))
@@ -246,10 +247,7 @@ class CycleIssueViewSet(BaseViewSet):
             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"

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

@@ -36,7 +36,7 @@ from plane.db.models import (
     DashboardWidget,
     Issue,
     IssueActivity,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     IssueRelation,
     Project,
@@ -56,7 +56,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 +84,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 +110,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 +137,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,
@@ -195,8 +199,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"))
@@ -358,8 +363,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"))

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

@@ -23,7 +23,7 @@ from plane.db.models import (
     Issue,
     State,
     IssueLink,
-    IssueAttachment,
+    FileAsset,
     Project,
     ProjectMember,
 )
@@ -120,8 +120,9 @@ class InboxIssueViewSet(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"))

apiserver/plane/app/views/issue/archive.py

@@ -30,7 +30,7 @@ from plane.app.serializers import (
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.db.models import (
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     IssueSubscriber,
     IssueReaction,
@@ -79,8 +79,9 @@ class IssueArchiveViewSet(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"))
@@ -236,12 +237,6 @@ class IssueArchiveViewSet(BaseViewSet):
                     ),
                 )
             )
-            .prefetch_related(
-                Prefetch(
-                    "issue_attachment",
-                    queryset=IssueAttachment.objects.select_related("issue"),
-                )
-            )
             .prefetch_related(
                 Prefetch(
                     "issue_link",

apiserver/plane/app/views/issue/attachment.py

@@ -1,9 +1,12 @@
 # Python imports
 import json
+import uuid
 
 # Django imports
 from django.utils import timezone
 from django.core.serializers.json import DjangoJSONEncoder
+from django.conf import settings
+from django.http import HttpResponseRedirect
 
 # Third Party imports
 from rest_framework.response import Response
@@ -13,21 +16,28 @@ from rest_framework.parsers import MultiPartParser, FormParser
 # Module imports
 from .. import BaseAPIView
 from plane.app.serializers import IssueAttachmentSerializer
-from plane.db.models import IssueAttachment
+from plane.db.models import FileAsset, Workspace
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.app.permissions import allow_permission, ROLE
+from plane.settings.storage import S3Storage
 
 
 class IssueAttachmentEndpoint(BaseAPIView):
     serializer_class = IssueAttachmentSerializer
-    model = IssueAttachment
+    model = FileAsset
     parser_classes = (MultiPartParser, FormParser)
 
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
     def post(self, request, slug, project_id, issue_id):
         serializer = IssueAttachmentSerializer(data=request.data)
+        workspace = Workspace.objects.get(slug=slug)
         if serializer.is_valid():
-            serializer.save(project_id=project_id, issue_id=issue_id)
+            serializer.save(
+                project_id=project_id,
+                issue_id=issue_id,
+                workspace_id=workspace.id,
+                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            )
             issue_activity.delay(
                 type="attachment.activity.created",
                 requested_data=None,
@@ -45,9 +55,9 @@ class IssueAttachmentEndpoint(BaseAPIView):
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
-    @allow_permission([ROLE.ADMIN], creator=True, model=IssueAttachment)
+    @allow_permission([ROLE.ADMIN], creator=True, model=FileAsset)
     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(
@@ -72,8 +82,182 @@ class IssueAttachmentEndpoint(BaseAPIView):
         ]
     )
     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)
         return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class IssueAttachmentV2Endpoint(BaseAPIView):
+
+    serializer_class = IssueAttachmentSerializer
+    model = FileAsset
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def post(self, request, slug, project_id, issue_id):
+        name = request.data.get("name")
+        type = request.data.get("type", False)
+        size = int(request.data.get("size", settings.FILE_SIZE_LIMIT))
+
+        if not type or type not in settings.ATTACHMENT_MIME_TYPES:
+            return Response(
+                {
+                    "error": "Invalid file type.",
+                    "status": False,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the workspace
+        workspace = Workspace.objects.get(slug=slug)
+
+        # asset key
+        asset_key = f"{workspace.id}/{uuid.uuid4().hex}-{name}"
+
+        # Get the size limit
+        size_limit = min(size, settings.FILE_SIZE_LIMIT)
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={
+                "name": name,
+                "type": type,
+                "size": size_limit,
+            },
+            asset=asset_key,
+            size=size_limit,
+            workspace_id=workspace.id,
+            created_by=request.user,
+            issue_id=issue_id,
+            project_id=project_id,
+            entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+        )
+
+        # 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),
+                "attachment": IssueAttachmentSerializer(asset).data,
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    @allow_permission([ROLE.ADMIN], creator=True, model=FileAsset)
+    def delete(self, request, slug, project_id, issue_id, pk):
+        issue_attachment = FileAsset.objects.get(
+            pk=pk, workspace__slug=slug, project_id=project_id
+        )
+        issue_attachment.is_deleted = True
+        issue_attachment.deleted_at = timezone.now()
+        issue_attachment.save()
+
+        issue_activity.delay(
+            type="attachment.activity.deleted",
+            requested_data=None,
+            actor_id=str(self.request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission(
+        [
+            ROLE.ADMIN,
+            ROLE.MEMBER,
+            ROLE.GUEST,
+        ]
+    )
+    def get(self, request, slug, project_id, issue_id, pk=None):
+        if pk:
+            # Get the asset
+            asset = FileAsset.objects.get(
+                id=pk, workspace__slug=slug, project_id=project_id
+            )
+
+            # Check if the asset is uploaded
+            if not asset.is_uploaded:
+                return Response(
+                    {
+                        "error": "The asset is not uploaded.",
+                        "status": False,
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            storage = S3Storage(request=request)
+            presigned_url = storage.generate_presigned_url(
+                object_name=asset.asset.name,
+                disposition="attachment",
+                filename=asset.attributes.get("name"),
+            )
+            return HttpResponseRedirect(presigned_url)
+
+        # Get all the attachments
+        issue_attachments = FileAsset.objects.filter(
+            issue_id=issue_id,
+            entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            workspace__slug=slug,
+            project_id=project_id,
+            is_uploaded=True,
+        )
+        # Serialize the attachments
+        serializer = IssueAttachmentSerializer(issue_attachments, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(
+        [
+            ROLE.ADMIN,
+            ROLE.MEMBER,
+            ROLE.GUEST,
+        ]
+    )
+    def patch(self, request, slug, project_id, issue_id, pk):
+        issue_attachment = FileAsset.objects.get(
+            pk=pk, workspace__slug=slug, project_id=project_id
+        )
+        serializer = IssueAttachmentSerializer(issue_attachment)
+
+        # Send this activity only if the attachment is not uploaded before
+        if not issue_attachment.is_uploaded:
+            issue_activity.delay(
+                type="attachment.activity.created",
+                requested_data=None,
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id", None)),
+                project_id=str(self.kwargs.get("project_id", None)),
+                current_instance=json.dumps(
+                    serializer.data,
+                    cls=DjangoJSONEncoder,
+                ),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+
+            # Update the attachment
+            issue_attachment.is_uploaded = True
+
+        # Get the storage metadata
+        if issue_attachment.storage_metadata is None:
+            storage = S3Storage(request=request)
+            issue_attachment.storage_metadata = storage.get_object_metadata(
+                issue_attachment.asset.name
+            )
+        issue_attachment.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)

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

@@ -35,7 +35,7 @@ from plane.app.serializers import (
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.db.models import (
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     IssueUserProperty,
     IssueReaction,
@@ -91,8 +91,9 @@ class IssueListEndpoint(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"))
@@ -214,8 +215,9 @@ class IssueViewSet(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"))
@@ -500,12 +502,6 @@ class IssueViewSet(BaseViewSet):
                     ),
                 )
             )
-            .prefetch_related(
-                Prefetch(
-                    "issue_attachment",
-                    queryset=IssueAttachment.objects.select_related("issue"),
-                )
-            )
             .prefetch_related(
                 Prefetch(
                     "issue_link",
@@ -760,8 +756,9 @@ class IssuePaginatedViewSet(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"))
@@ -791,7 +788,7 @@ class IssuePaginatedViewSet(BaseViewSet):
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
     def list(self, request, slug, project_id):
         cursor = request.GET.get("cursor", None)
-        is_description_required = request.GET.get("description", False)
+        is_description_required = request.GET.get("description", "false")
         updated_at = request.GET.get("updated_at__gt", None)
 
         # required fields
@@ -824,7 +821,7 @@ class IssuePaginatedViewSet(BaseViewSet):
             "sub_issues_count",
         ]
 
-        if is_description_required:
+        if str(is_description_required).lower() == "true":
             required_fields.append("description_html")
 
         # querying issues

apiserver/plane/app/views/issue/relation.py

@@ -24,7 +24,7 @@ from plane.db.models import (
     Project,
     IssueRelation,
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
 )
 from plane.bgtasks.issue_activities_task import issue_activity
@@ -91,8 +91,9 @@ class IssueRelationViewSet(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"))

apiserver/plane/app/views/issue/sub_issue.py

@@ -28,7 +28,7 @@ from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import (
     Issue,
     IssueLink,
-    IssueAttachment,
+    FileAsset,
 )
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.utils.user_timezone_converter import user_timezone_converter
@@ -56,8 +56,9 @@ class SubIssuesEndpoint(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"))

apiserver/plane/app/views/module/archive.py

@@ -14,9 +14,12 @@ from django.db.models import (
     Value,
     Sum,
     FloatField,
+    Case,
+    When,
 )
-from django.db.models.functions import Coalesce, Cast
+from django.db.models.functions import Coalesce, Cast, Concat
 from django.utils import timezone
+from django.db import models
 
 # Third party imports
 from rest_framework import status
@@ -364,12 +367,31 @@ class ModuleArchiveUnarchiveEndpoint(BaseAPIView):
                     .annotate(last_name=F("assignees__last_name"))
                     .annotate(assignee_id=F("assignees__id"))
                     .annotate(display_name=F("assignees__display_name"))
-                    .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(),
+                        )
+                    )
                     .values(
                         "first_name",
                         "last_name",
                         "assignee_id",
-                        "avatar",
+                        "avatar_url",
                         "display_name",
                     )
                     .annotate(
@@ -437,7 +459,9 @@ class ModuleArchiveUnarchiveEndpoint(BaseAPIView):
                     )
                     .order_by("label_name")
                 )
-                data["estimate_distribution"]["assignees"] = assignee_distribution
+                data["estimate_distribution"][
+                    "assignees"
+                ] = assignee_distribution
                 data["estimate_distribution"]["labels"] = label_distribution
 
                 if modules and modules.start_date and modules.target_date:
@@ -461,12 +485,31 @@ class ModuleArchiveUnarchiveEndpoint(BaseAPIView):
                 .annotate(last_name=F("assignees__last_name"))
                 .annotate(assignee_id=F("assignees__id"))
                 .annotate(display_name=F("assignees__display_name"))
-                .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(),
+                    )
+                )
                 .values(
                     "first_name",
                     "last_name",
                     "assignee_id",
-                    "avatar",
+                    "avatar_url",
                     "display_name",
                 )
                 .annotate(

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

@@ -18,8 +18,11 @@ from django.db.models import (
     Value,
     Sum,
     FloatField,
+    Case,
+    When,
 )
-from django.db.models.functions import Coalesce, Cast
+from django.db import models
+from django.db.models.functions import Coalesce, Cast, Concat
 from django.core.serializers.json import DjangoJSONEncoder
 from django.utils import timezone
 
@@ -481,12 +484,31 @@ class ModuleViewSet(BaseViewSet):
                 .annotate(last_name=F("assignees__last_name"))
                 .annotate(assignee_id=F("assignees__id"))
                 .annotate(display_name=F("assignees__display_name"))
-                .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(),
+                    )
+                )
                 .values(
                     "first_name",
                     "last_name",
                     "assignee_id",
-                    "avatar",
+                    "avatar_url",
                     "display_name",
                 )
                 .annotate(
@@ -578,12 +600,31 @@ class ModuleViewSet(BaseViewSet):
             .annotate(last_name=F("assignees__last_name"))
             .annotate(assignee_id=F("assignees__id"))
             .annotate(display_name=F("assignees__display_name"))
-            .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(),
+                )
+            )
             .values(
                 "first_name",
                 "last_name",
                 "assignee_id",
-                "avatar",
+                "avatar_url",
                 "display_name",
             )
             .annotate(

apiserver/plane/app/views/module/issue.py

@@ -24,7 +24,7 @@ from plane.app.serializers import (
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.db.models import (
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     ModuleIssue,
     Project,
@@ -73,8 +73,9 @@ class ModuleIssueViewSet(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"))

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

@@ -372,11 +372,11 @@ class UserNotificationPreferenceEndpoint(BaseAPIView):
 
     # request the object
     def get(self, request):
-        user_notification_preference = UserNotificationPreference.objects.get(
-            user=request.user
+        user_notification_preference = (
+            UserNotificationPreference.objects.filter(user=request.user)
         )
         serializer = UserNotificationPreferenceSerializer(
-            user_notification_preference
+            user_notification_preference, many=True
         )
         return Response(serializer.data, status=status.HTTP_200_OK)
 

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

@@ -18,7 +18,7 @@ from django.db.models.functions import Coalesce
 from rest_framework import status
 from rest_framework.response import Response
 
-
+# Module imports
 from plane.app.permissions import allow_permission, ROLE
 from plane.app.serializers import (
     PageLogSerializer,
@@ -35,10 +35,7 @@ from plane.db.models import (
     Project,
 )
 from plane.utils.error_codes import ERROR_CODES
-
-# Module imports
 from ..base import BaseAPIView, BaseViewSet
-
 from plane.bgtasks.page_transaction_task import page_transaction
 from plane.bgtasks.page_version_task import page_version
 from plane.bgtasks.recent_visited_task import recent_visited_task

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

@@ -53,6 +53,7 @@ from plane.db.models import (
 from plane.utils.cache import cache_response
 from plane.bgtasks.webhook_task import model_activity
 from plane.bgtasks.recent_visited_task import recent_visited_task
+from plane.utils.exception_logger import log_exception
 
 
 class ProjectViewSet(BaseViewSet):
@@ -720,18 +721,22 @@ class ProjectPublicCoverImagesEndpoint(BaseAPIView):
             "Prefix": "static/project-cover/",
         }
 
-        response = s3.list_objects_v2(**params)
-        # Extracting file keys from the response
-        if "Contents" in response:
-            for content in response["Contents"]:
-                if not content["Key"].endswith(
-                    "/"
-                ):  # This line ensures we're only getting files, not "sub-folders"
-                    files.append(
-                        f"https://{settings.AWS_STORAGE_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
-                    )
+        try:
+            response = s3.list_objects_v2(**params)
+            # Extracting file keys from the response
+            if "Contents" in response:
+                for content in response["Contents"]:
+                    if not content["Key"].endswith(
+                        "/"
+                    ):  # This line ensures we're only getting files, not "sub-folders"
+                        files.append(
+                            f"https://{settings.AWS_STORAGE_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
+                        )
 
-        return Response(files, status=status.HTTP_200_OK)
+            return Response(files, status=status.HTTP_200_OK)
+        except Exception as e:
+            log_exception(e)
+            return Response([], status=status.HTTP_200_OK)
 
 
 class DeployBoardViewSet(BaseViewSet):

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

@@ -29,7 +29,7 @@ from plane.app.serializers import (
 )
 from plane.db.models import (
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     IssueView,
     Workspace,
@@ -213,8 +213,9 @@ class WorkspaceViewIssuesViewSet(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"))

apiserver/plane/app/views/workspace/cycle.py

@@ -43,6 +43,7 @@ class WorkspaceCyclesEndpoint(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,
                     ),
                 )
             )
@@ -53,6 +54,7 @@ class WorkspaceCyclesEndpoint(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,
                     ),
                 )
             )
@@ -63,6 +65,7 @@ class WorkspaceCyclesEndpoint(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,
                     ),
                 )
             )
@@ -73,6 +76,7 @@ class WorkspaceCyclesEndpoint(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,
                     ),
                 )
             )
@@ -83,6 +87,7 @@ class WorkspaceCyclesEndpoint(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,
                     ),
                 )
             )

apiserver/plane/app/views/workspace/draft.py

@@ -44,18 +44,11 @@ from plane.utils.issue_filters import issue_filters
 
 
 class WorkspaceDraftIssueViewSet(BaseViewSet):
-
     model = DraftIssue
 
-    @method_decorator(gzip_page)
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
-    )
-    def list(self, request, slug):
-        filters = issue_filters(request.query_params, "GET")
-        issues = (
-            DraftIssue.objects.filter(workspace__slug=slug)
-            .filter(created_by=request.user)
+    def get_queryset(self):
+        return (
+            DraftIssue.objects.filter(workspace__slug=self.kwargs.get("slug"))
             .select_related("workspace", "project", "state", "parent")
             .prefetch_related(
                 "assignees", "labels", "draft_issue_module__module"
@@ -91,6 +84,17 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
                     Value([], output_field=ArrayField(UUIDField())),
                 ),
             )
+        ).distinct()
+
+    @method_decorator(gzip_page)
+    @allow_permission(
+        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
+    )
+    def list(self, request, slug):
+        filters = issue_filters(request.query_params, "GET")
+        issues = (
+            self.get_queryset()
+            .filter(created_by=request.user)
             .order_by("-created_at")
         )
 
@@ -120,7 +124,36 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
         )
         if serializer.is_valid():
             serializer.save()
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
+            issue = (
+                self.get_queryset()
+                .filter(pk=serializer.data.get("id"))
+                .values(
+                    "id",
+                    "name",
+                    "state_id",
+                    "sort_order",
+                    "completed_at",
+                    "estimate_point",
+                    "priority",
+                    "start_date",
+                    "target_date",
+                    "project_id",
+                    "parent_id",
+                    "cycle_id",
+                    "module_ids",
+                    "label_ids",
+                    "assignee_ids",
+                    "created_at",
+                    "updated_at",
+                    "created_by",
+                    "updated_by",
+                    "type_id",
+                    "description_html",
+                )
+                .first()
+            )
+
+            return Response(issue, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     @allow_permission(
@@ -131,45 +164,7 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
     )
     def partial_update(self, request, slug, pk):
         issue = (
-            DraftIssue.objects.filter(workspace__slug=slug)
-            .filter(pk=pk)
-            .filter(created_by=request.user)
-            .select_related("workspace", "project", "state", "parent")
-            .prefetch_related(
-                "assignees", "labels", "draft_issue_module__module"
-            )
-            .annotate(cycle_id=F("draft_issue_cycle__cycle_id"))
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=~Q(labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=~Q(assignees__id__isnull=True)
-                        & Q(assignees__member_project__is_active=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "draft_issue_module__module_id",
-                        distinct=True,
-                        filter=~Q(draft_issue_module__module_id__isnull=True)
-                        & Q(
-                            draft_issue_module__module__archived_at__isnull=True
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-            .first()
+            self.get_queryset().filter(pk=pk, created_by=request.user).first()
         )
 
         if not issue:
@@ -202,46 +197,8 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
     )
     def retrieve(self, request, slug, pk=None):
         issue = (
-            DraftIssue.objects.filter(workspace__slug=slug)
-            .filter(pk=pk)
-            .filter(created_by=request.user)
-            .select_related("workspace", "project", "state", "parent")
-            .prefetch_related(
-                "assignees", "labels", "draft_issue_module__module"
-            )
-            .annotate(cycle_id=F("draft_issue_cycle__cycle_id"))
-            .filter(pk=pk)
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=~Q(labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=~Q(assignees__id__isnull=True)
-                        & Q(assignees__member_project__is_active=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "draft_issue_module__module_id",
-                        distinct=True,
-                        filter=~Q(draft_issue_module__module_id__isnull=True)
-                        & Q(
-                            draft_issue_module__module__archived_at__isnull=True
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-        ).first()
+            self.get_queryset().filter(pk=pk, created_by=request.user).first()
+        )
 
         if not issue:
             return Response(
@@ -255,7 +212,7 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
     @allow_permission(
         allowed_roles=[ROLE.ADMIN],
         creator=True,
-        model=Issue,
+        model=DraftIssue,
         level="WORKSPACE",
     )
     def destroy(self, request, slug, pk=None):
@@ -268,42 +225,7 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
         level="WORKSPACE",
     )
     def create_draft_to_issue(self, request, slug, draft_id):
-        draft_issue = (
-            DraftIssue.objects.filter(workspace__slug=slug, pk=draft_id)
-            .annotate(cycle_id=F("draft_issue_cycle__cycle_id"))
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=~Q(labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=~Q(assignees__id__isnull=True)
-                        & Q(assignees__member_project__is_active=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "draft_issue_module__module_id",
-                        distinct=True,
-                        filter=~Q(draft_issue_module__module_id__isnull=True)
-                        & Q(
-                            draft_issue_module__module__archived_at__isnull=True
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-            .select_related("project", "workspace")
-            .first()
-        )
+        draft_issue = self.get_queryset().filter(pk=draft_id).first()
 
         if not draft_issue.project_id:
             return Response(
@@ -357,7 +279,7 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
                         {
                             "updated_cycle_issues": None,
                             "created_cycle_issues": serializers.serialize(
-                                "json", created_records
+                                "json", [created_records]
                             ),
                         }
                     ),

apiserver/plane/app/views/workspace/user.py

@@ -40,7 +40,7 @@ from plane.db.models import (
     CycleIssue,
     Issue,
     IssueActivity,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     IssueSubscriber,
     Project,
@@ -128,8 +128,9 @@ class WorkspaceUserProfileIssuesEndpoint(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"))
@@ -359,8 +360,8 @@ class WorkspaceUserProfileEndpoint(BaseAPIView):
                     "email": user_data.email,
                     "first_name": user_data.first_name,
                     "last_name": user_data.last_name,
-                    "avatar": user_data.avatar,
-                    "cover_image": user_data.cover_image,
+                    "avatar_url": user_data.avatar_url,
+                    "cover_image_url": user_data.cover_image_url,
                     "date_joined": user_data.date_joined,
                     "user_timezone": user_data.user_timezone,
                     "display_name": user_data.display_name,

apiserver/plane/bgtasks/analytic_plot_export.py

@@ -10,6 +10,9 @@ from celery import shared_task
 from django.core.mail import EmailMultiAlternatives, get_connection
 from django.template.loader import render_to_string
 from django.utils.html import strip_tags
+from django.db.models import Q, Case, Value, When
+from django.db import models
+from django.db.models.functions import Concat
 
 # Module imports
 from plane.db.models import Issue
@@ -84,12 +87,37 @@ def get_assignee_details(slug, filters):
     """Fetch assignee details if required."""
     return (
         Issue.issue_objects.filter(
-            workspace__slug=slug, **filters, assignees__avatar__isnull=False
+            Q(
+                Q(assignees__avatar__isnull=False)
+                | Q(assignees__avatar_asset__isnull=False)
+            ),
+            workspace__slug=slug,
+            **filters,
+        )
+        .annotate(
+            assignees__avatar_url=Case(
+                # If `avatar_asset` exists, use it to generate the asset URL
+                When(
+                    assignees__avatar_asset__isnull=False,
+                    then=Concat(
+                        Value("/api/assets/v2/static/"),
+                        "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                        Value("/"),
+                    ),
+                ),
+                # If `avatar_asset` is None, fall back to using `avatar` field directly
+                When(
+                    assignees__avatar_asset__isnull=True,
+                    then="assignees__avatar",
+                ),
+                default=Value(None),
+                output_field=models.CharField(),
+            )
         )
         .distinct("assignees__id")
         .order_by("assignees__id")
         .values(
-            "assignees__avatar",
+            "assignees__avatar_url",
             "assignees__display_name",
             "assignees__first_name",
             "assignees__last_name",

apiserver/plane/bgtasks/deletion_task.py

@@ -21,8 +21,8 @@ def soft_delete_related_objects(
             try:
                 # Check if the field has CASCADE on delete
                 if (
-                    hasattr(field.remote_field, "on_delete")
-                    and field.remote_field.on_delete == models.CASCADE
+                    not hasattr(field.remote_field, "on_delete")
+                    or field.remote_field.on_delete == models.CASCADE
                 ):
                     if field.one_to_many:
                         related_objects = getattr(instance, field.name).all()

apiserver/plane/bgtasks/email_notification_task.py

@@ -224,7 +224,7 @@ def send_email_notification(
                         {
                             "actor_comments": comment,
                             "actor_detail": {
-                                "avatar_url": actor.avatar,
+                                "avatar_url": f"{base_api}{actor.avatar_url}",
                                 "first_name": actor.first_name,
                                 "last_name": actor.last_name,
                             },
@@ -241,7 +241,7 @@ def send_email_notification(
                         {
                             "actor_comments": mention,
                             "actor_detail": {
-                                "avatar_url": actor.avatar,
+                                "avatar_url": f"{base_api}{actor.avatar_url}",
                                 "first_name": actor.first_name,
                                 "last_name": actor.last_name,
                             },
@@ -257,7 +257,7 @@ def send_email_notification(
                     template_data.append(
                         {
                             "actor_detail": {
-                                "avatar_url": actor.avatar,
+                                "avatar_url": f"{base_api}{actor.avatar_url}",
                                 "first_name": actor.first_name,
                                 "last_name": actor.last_name,
                             },

apiserver/plane/bgtasks/export_task.py

@@ -105,7 +105,6 @@ def upload_to_s3(zip_file, workspace_id, token_id, slug):
             ExpiresIn=expires_in,
         )
     else:
-
         # If endpoint url is present, use it
         if settings.AWS_S3_ENDPOINT_URL:
             s3 = boto3.client(
@@ -129,7 +128,7 @@ def upload_to_s3(zip_file, workspace_id, token_id, slug):
             zip_file,
             settings.AWS_STORAGE_BUCKET_NAME,
             file_name,
-            ExtraArgs={"ACL": "public-read", "ContentType": "application/zip"},
+            ExtraArgs={"ContentType": "application/zip"},
         )
 
         # Generate presigned url for the uploaded file

apiserver/plane/bgtasks/file_asset_task.py

@@ -1,4 +1,5 @@
 # Python imports
+import os
 from datetime import timedelta
 
 # Django imports
@@ -13,16 +14,14 @@ from plane.db.models import FileAsset
 
 
 @shared_task
-def delete_file_asset():
-    # file assets to delete
-    file_assets_to_delete = FileAsset.objects.filter(
-        Q(is_deleted=True)
-        & Q(updated_at__lte=timezone.now() - timedelta(days=7))
-    )
-
-    # Delete the file from storage and the file object from the database
-    for file_asset in file_assets_to_delete:
-        # Delete the file from storage
-        file_asset.asset.delete(save=False)
-        # Delete the file object
-        file_asset.delete()
+def delete_unuploaded_file_asset():
+    """This task deletes unuploaded file assets older than a certain number of days."""
+    FileAsset.objects.filter(
+        Q(
+            created_at__lt=timezone.now()
+            - timedelta(
+                days=int(os.environ.get("UNUPLOADED_ASSET_DELETE_DAYS", "7"))
+            )
+        )
+        & Q(is_uploaded=False)
+    ).delete()

apiserver/plane/celery.py

@@ -25,7 +25,7 @@ app.conf.beat_schedule = {
         "schedule": crontab(hour=0, minute=0),
     },
     "check-every-day-to-delete-file-asset": {
-        "task": "plane.bgtasks.file_asset_task.delete_file_asset",
+        "task": "plane.bgtasks.file_asset_task.delete_unuploaded_file_asset",
         "schedule": crontab(hour=0, minute=0),
     },
     "check-every-five-minutes-to-send-email-notifications": {

apiserver/plane/db/management/commands/create_bucket.py

@@ -1,67 +1,45 @@
 # Python imports
+import os
 import boto3
-import json
 from botocore.exceptions import ClientError
 
 # Django imports
 from django.core.management import BaseCommand
-from django.conf import settings
 
 
 class Command(BaseCommand):
     help = "Create the default bucket for the instance"
 
-    def set_bucket_public_policy(self, s3_client, bucket_name):
-        public_policy = {
-            "Version": "2012-10-17",
-            "Statement": [
-                {
-                    "Effect": "Allow",
-                    "Principal": "*",
-                    "Action": ["s3:GetObject"],
-                    "Resource": [f"arn:aws:s3:::{bucket_name}/*"],
-                }
-            ],
-        }
-
-        try:
-            s3_client.put_bucket_policy(
-                Bucket=bucket_name, Policy=json.dumps(public_policy)
-            )
-            self.stdout.write(
-                self.style.SUCCESS(
-                    f"Public read access policy set for bucket '{bucket_name}'."
-                )
-            )
-        except ClientError as e:
-            self.stdout.write(
-                self.style.ERROR(
-                    f"Error setting public read access policy: {e}"
-                )
-            )
-
     def handle(self, *args, **options):
         # Create a session using the credentials from Django settings
         try:
-            session = boto3.session.Session(
-                aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
-                aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
+            s3_client = boto3.client(
+                "s3",
+                endpoint_url=os.environ.get(
+                    "AWS_S3_ENDPOINT_URL"
+                ),  # MinIO endpoint
+                aws_access_key_id=os.environ.get(
+                    "AWS_ACCESS_KEY_ID"
+                ),  # MinIO access key
+                aws_secret_access_key=os.environ.get(
+                    "AWS_SECRET_ACCESS_KEY"
+                ),  # MinIO secret key
+                region_name=os.environ.get("AWS_REGION"),  # MinIO region
+                config=boto3.session.Config(signature_version="s3v4"),
             )
-            # Create an S3 client using the session
-            s3_client = session.client(
-                "s3", endpoint_url=settings.AWS_S3_ENDPOINT_URL
-            )
-            bucket_name = settings.AWS_STORAGE_BUCKET_NAME
-
+            # Get the bucket name from the environment
+            bucket_name = os.environ.get("AWS_S3_BUCKET_NAME")
             self.stdout.write(self.style.NOTICE("Checking bucket..."))
-
             # Check if the bucket exists
             s3_client.head_bucket(Bucket=bucket_name)
-
-            self.set_bucket_public_policy(s3_client, bucket_name)
+            # If the bucket exists, print a success message
+            self.stdout.write(
+                self.style.SUCCESS(f"Bucket '{bucket_name}' exists.")
+            )
+            return
         except ClientError as e:
             error_code = int(e.response["Error"]["Code"])
-            bucket_name = settings.AWS_STORAGE_BUCKET_NAME
+            bucket_name = os.environ.get("AWS_S3_BUCKET_NAME")
             if error_code == 404:
                 # Bucket does not exist, create it
                 self.stdout.write(
@@ -76,13 +54,16 @@ class Command(BaseCommand):
                             f"Bucket '{bucket_name}' created successfully."
                         )
                     )
-                    self.set_bucket_public_policy(s3_client, bucket_name)
+
+                # Handle the exception if the bucket creation fails
                 except ClientError as create_error:
                     self.stdout.write(
                         self.style.ERROR(
                             f"Failed to create bucket: {create_error}"
                         )
                     )
+
+            # Handle the exception if access to the bucket is forbidden
             elif error_code == 403:
                 # Access to the bucket is forbidden
                 self.stdout.write(

apiserver/plane/db/management/commands/update_bucket.py

@@ -0,0 +1,209 @@
+# Python imports
+import os
+import boto3
+from botocore.exceptions import ClientError
+import json
+
+# Django imports
+from django.core.management import BaseCommand
+
+
+class Command(BaseCommand):
+    help = "Create the default bucket for the instance"
+
+    def get_s3_client(self):
+        s3_client = boto3.client(
+            "s3",
+            endpoint_url=os.environ.get(
+                "AWS_S3_ENDPOINT_URL"
+            ),  # MinIO endpoint
+            aws_access_key_id=os.environ.get(
+                "AWS_ACCESS_KEY_ID"
+            ),  # MinIO access key
+            aws_secret_access_key=os.environ.get(
+                "AWS_SECRET_ACCESS_KEY"
+            ),  # MinIO secret key
+            region_name=os.environ.get("AWS_REGION"),  # MinIO region
+            config=boto3.session.Config(signature_version="s3v4"),
+        )
+        return s3_client
+
+    # Check if the access key has the required permissions
+    def check_s3_permissions(self, bucket_name):
+        s3_client = self.get_s3_client()
+        permissions = {
+            "s3:GetObject": False,
+            "s3:ListBucket": False,
+            "s3:PutBucketPolicy": False,
+            "s3:PutObject": False,
+        }
+
+        # 1. Test s3:ListBucket (attempt to list the bucket contents)
+        try:
+            s3_client.list_objects_v2(Bucket=bucket_name)
+            permissions["s3:ListBucket"] = True
+        except ClientError as e:
+            if e.response["Error"]["Code"] == "AccessDenied":
+                self.stdout.write("ListBucket permission denied.")
+            else:
+                self.stdout.write(f"Error in ListBucket: {e}")
+
+        # 2. Test s3:GetObject (attempt to get a specific object)
+        try:
+            response = s3_client.list_objects_v2(Bucket=bucket_name)
+            if "Contents" in response:
+                test_object_key = response["Contents"][0]["Key"]
+                s3_client.get_object(Bucket=bucket_name, Key=test_object_key)
+                permissions["s3:GetObject"] = True
+        except ClientError as e:
+            if e.response["Error"]["Code"] == "AccessDenied":
+                self.stdout.write("GetObject permission denied.")
+            else:
+                self.stdout.write(f"Error in GetObject: {e}")
+
+        # 3. Test s3:PutObject (attempt to upload an object)
+        try:
+            s3_client.put_object(
+                Bucket=bucket_name,
+                Key="test_permission_check.txt",
+                Body=b"Test",
+            )
+            self.stdout.write("PutObject permission granted.")
+            permissions["s3:PutObject"] = True
+            # Clean up
+        except ClientError as e:
+            if e.response["Error"]["Code"] == "AccessDenied":
+                self.stdout.write("PutObject permission denied.")
+            else:
+                self.stdout.write(f"Error in PutObject: {e}")
+
+        # Clean up
+        try:
+            s3_client.delete_object(
+                Bucket=bucket_name, Key="test_permission_check.txt"
+            )
+        except ClientError:
+            self.stdout.write("Coudn't delete test object")
+
+        # 4. Test s3:PutBucketPolicy (attempt to put a bucket policy)
+        try:
+            policy = {
+                "Version": "2012-10-17",
+                "Statement": [
+                    {
+                        "Effect": "Allow",
+                        "Principal": "*",
+                        "Action": "s3:GetObject",
+                        "Resource": f"arn:aws:s3:::{bucket_name}/*",
+                    }
+                ],
+            }
+            s3_client.put_bucket_policy(
+                Bucket=bucket_name, Policy=json.dumps(policy)
+            )
+            permissions["s3:PutBucketPolicy"] = True
+        except ClientError as e:
+            if e.response["Error"]["Code"] == "AccessDenied":
+                self.stdout.write("PutBucketPolicy permission denied.")
+            else:
+                self.stdout.write(f"Error in PutBucketPolicy: {e}")
+
+        return permissions
+
+    def generate_bucket_policy(self, bucket_name):
+        s3_client = self.get_s3_client()
+        response = s3_client.list_objects_v2(Bucket=bucket_name)
+        public_object_resource = []
+        if "Contents" in response:
+            for obj in response["Contents"]:
+                object_key = obj["Key"]
+                public_object_resource.append(
+                    f"arn:aws:s3:::{bucket_name}/{object_key}"
+                )
+        bucket_policy = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Effect": "Allow",
+                    "Principal": "*",
+                    "Action": "s3:GetObject",
+                    "Resource": public_object_resource,
+                }
+            ],
+        }
+        return bucket_policy
+
+    def make_objects_public(self, bucket_name):
+        # Initialize S3 client
+        s3_client = self.get_s3_client()
+        # Get the bucket policy
+        bucket_policy = self.generate_bucket_policy(bucket_name)
+        # Apply the policy to the bucket
+        s3_client.put_bucket_policy(
+            Bucket=bucket_name, Policy=json.dumps(bucket_policy)
+        )
+        # Print a success message
+        self.stdout.write(
+            "Bucket is private, but existing objects remain public."
+        )
+        return
+
+    def handle(self, *args, **options):
+        # Create a session using the credentials from Django settings
+        try:
+            # Check if the bucket exists
+            s3_client = self.get_s3_client()
+            # Get the bucket name from the environment
+            bucket_name = os.environ.get("AWS_S3_BUCKET_NAME")
+            self.stdout.write(self.style.NOTICE("Checking bucket..."))
+            # Check if the bucket exists
+            s3_client.head_bucket(Bucket=bucket_name)
+
+            # If the bucket exists, print a success message
+            self.stdout.write(
+                self.style.SUCCESS(f"Bucket '{bucket_name}' exists.")
+            )
+
+            # Check the permissions of the access key
+            permissions = self.check_s3_permissions(bucket_name)
+
+            if all(permissions.values()):
+                self.stdout.write(
+                    self.style.SUCCESS(
+                        "Access key has the required permissions."
+                    )
+                )
+                # Making the existing objects public
+                self.make_objects_public(bucket_name)
+
+            # If the access key does not have PutBucketPolicy permission
+            # write the bucket policy to a file
+            if (
+                all(
+                    {
+                        k: v
+                        for k, v in permissions.items()
+                        if k != "s3:PutBucketPolicy"
+                    }.values()
+                )
+                and not permissions["s3:PutBucketPolicy"]
+            ):
+                self.stdout.write(
+                    self.style.WARNING(
+                        "Access key does not have PutBucketPolicy permission."
+                    )
+                )
+                # Writing to a file
+                with open("permissions.json", "w") as f:
+                    f.write(
+                        json.dumps(self.generate_bucket_policy(bucket_name))
+                    )
+                self.stdout.write(
+                    self.style.WARNING(
+                        "Permissions have been written to permissions.json."
+                    )
+                )
+                return
+        except Exception as ex:
+            # Handle any other exception
+            self.stdout.write(self.style.ERROR(f"An error occurred: {ex}"))

apiserver/plane/db/migrations/0078_fileasset_comment_fileasset_entity_type_and_more.py

@@ -0,0 +1,179 @@
+# Generated by Django 4.2.15 on 2024-10-09 06:19
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import plane.db.models.asset
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        (
+            "db",
+            "0077_draftissue_cycle_user_timezone_project_user_timezone_and_more",
+        ),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="fileasset",
+            name="comment",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="assets",
+                to="db.issuecomment",
+            ),
+        ),
+        migrations.AddField(
+            model_name="fileasset",
+            name="entity_type",
+            field=models.CharField(
+                blank=True,
+                choices=[
+                    ("ISSUE_ATTACHMENT", "Issue Attachment"),
+                    ("ISSUE_DESCRIPTION", "Issue Description"),
+                    ("COMMENT_DESCRIPTION", "Comment Description"),
+                    ("PAGE_DESCRIPTION", "Page Description"),
+                    ("USER_COVER", "User Cover"),
+                    ("USER_AVATAR", "User Avatar"),
+                    ("WORKSPACE_LOGO", "Workspace Logo"),
+                    ("PROJECT_COVER", "Project Cover"),
+                ],
+                max_length=255,
+                null=True,
+            ),
+        ),
+        migrations.AddField(
+            model_name="fileasset",
+            name="external_id",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name="fileasset",
+            name="external_source",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name="fileasset",
+            name="is_uploaded",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="fileasset",
+            name="issue",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="assets",
+                to="db.issue",
+            ),
+        ),
+        migrations.AddField(
+            model_name="fileasset",
+            name="page",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="assets",
+                to="db.page",
+            ),
+        ),
+        migrations.AddField(
+            model_name="fileasset",
+            name="project",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="assets",
+                to="db.project",
+            ),
+        ),
+        migrations.AddField(
+            model_name="fileasset",
+            name="size",
+            field=models.FloatField(default=0),
+        ),
+        migrations.AddField(
+            model_name="fileasset",
+            name="storage_metadata",
+            field=models.JSONField(blank=True, default=dict, null=True),
+        ),
+        migrations.AddField(
+            model_name="fileasset",
+            name="user",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="assets",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+        migrations.AddField(
+            model_name="project",
+            name="cover_image_asset",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="project_cover_image",
+                to="db.fileasset",
+            ),
+        ),
+        migrations.AddField(
+            model_name="user",
+            name="avatar_asset",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="user_avatar",
+                to="db.fileasset",
+            ),
+        ),
+        migrations.AddField(
+            model_name="user",
+            name="cover_image_asset",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="user_cover_image",
+                to="db.fileasset",
+            ),
+        ),
+        migrations.AddField(
+            model_name="workspace",
+            name="logo_asset",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="workspace_logo",
+                to="db.fileasset",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="fileasset",
+            name="asset",
+            field=models.FileField(
+                max_length=800, upload_to=plane.db.models.asset.get_upload_path
+            ),
+        ),
+        migrations.AlterField(
+            model_name="integration",
+            name="avatar_url",
+            field=models.TextField(blank=True, null=True),
+        ),
+        migrations.AlterField(
+            model_name="project",
+            name="cover_image",
+            field=models.TextField(blank=True, null=True),
+        ),
+        migrations.AlterField(
+            model_name="workspace",
+            name="logo",
+            field=models.TextField(blank=True, null=True, verbose_name="Logo"),
+        ),
+    ]

apiserver/plane/db/migrations/0079_auto_20241009_0619.py

@@ -0,0 +1,64 @@
+# Generated by Django 4.2.15 on 2024-10-09 06:19
+
+from django.db import migrations
+
+
+def move_attachment_to_fileasset(apps, schema_editor):
+    FileAsset = apps.get_model("db", "FileAsset")
+    IssueAttachment = apps.get_model("db", "IssueAttachment")
+
+    bulk_issue_attachment = []
+    for issue_attachment in IssueAttachment.objects.values(
+        "issue_id",
+        "project_id",
+        "workspace_id",
+        "asset",
+        "attributes",
+        "external_source",
+        "external_id",
+        "deleted_at",
+        "created_by_id",
+        "updated_by_id",
+    ):
+        bulk_issue_attachment.append(
+            FileAsset(
+                issue_id=issue_attachment["issue_id"],
+                entity_type="ISSUE_ATTACHMENT",
+                project_id=issue_attachment["project_id"],
+                workspace_id=issue_attachment["workspace_id"],
+                attributes=issue_attachment["attributes"],
+                asset=issue_attachment["asset"],
+                external_source=issue_attachment["external_source"],
+                external_id=issue_attachment["external_id"],
+                deleted_at=issue_attachment["deleted_at"],
+                created_by_id=issue_attachment["created_by_id"],
+                updated_by_id=issue_attachment["updated_by_id"],
+                size=issue_attachment["attributes"].get("size", 0),
+            )
+        )
+
+    FileAsset.objects.bulk_create(bulk_issue_attachment, batch_size=1000)
+
+
+def mark_existing_file_uploads(apps, schema_editor):
+    FileAsset = apps.get_model("db", "FileAsset")
+    # Mark all existing file uploads as uploaded
+    FileAsset.objects.update(is_uploaded=True)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("db", "0078_fileasset_comment_fileasset_entity_type_and_more"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            move_attachment_to_fileasset,
+            reverse_code=migrations.RunPython.noop,
+        ),
+        migrations.RunPython(
+            mark_existing_file_uploads,
+            reverse_code=migrations.RunPython.noop,
+        ),
+    ]

apiserver/plane/db/migrations/0080_fileasset_draft_issue_alter_fileasset_entity_type.py

@@ -0,0 +1,45 @@
+# Generated by Django 4.2.15 on 2024-10-12 18:45
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("db", "0079_auto_20241009_0619"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="fileasset",
+            name="draft_issue",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="assets",
+                to="db.draftissue",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="fileasset",
+            name="entity_type",
+            field=models.CharField(
+                blank=True,
+                choices=[
+                    ("ISSUE_ATTACHMENT", "Issue Attachment"),
+                    ("ISSUE_DESCRIPTION", "Issue Description"),
+                    ("COMMENT_DESCRIPTION", "Comment Description"),
+                    ("PAGE_DESCRIPTION", "Page Description"),
+                    ("USER_COVER", "User Cover"),
+                    ("USER_AVATAR", "User Avatar"),
+                    ("WORKSPACE_LOGO", "Workspace Logo"),
+                    ("PROJECT_COVER", "Project Cover"),
+                    ("DRAFT_ISSUE_ATTACHMENT", "Draft Issue Attachment"),
+                    ("DRAFT_ISSUE_DESCRIPTION", "Draft Issue Description"),
+                ],
+                max_length=255,
+                null=True,
+            ),
+        ),
+    ]

apiserver/plane/db/migrations/0081_remove_globalview_created_by_and_more.py

@@ -0,0 +1,187 @@
+# Generated by Django 4.2.16 on 2024-10-15 11:31
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("db", "0080_fileasset_draft_issue_alter_fileasset_entity_type"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="globalview",
+            name="created_by",
+        ),
+        migrations.RemoveField(
+            model_name="globalview",
+            name="updated_by",
+        ),
+        migrations.RemoveField(
+            model_name="globalview",
+            name="workspace",
+        ),
+        migrations.AlterUniqueTogether(
+            name="issueviewfavorite",
+            unique_together=None,
+        ),
+        migrations.RemoveField(
+            model_name="issueviewfavorite",
+            name="created_by",
+        ),
+        migrations.RemoveField(
+            model_name="issueviewfavorite",
+            name="project",
+        ),
+        migrations.RemoveField(
+            model_name="issueviewfavorite",
+            name="updated_by",
+        ),
+        migrations.RemoveField(
+            model_name="issueviewfavorite",
+            name="user",
+        ),
+        migrations.RemoveField(
+            model_name="issueviewfavorite",
+            name="view",
+        ),
+        migrations.RemoveField(
+            model_name="issueviewfavorite",
+            name="workspace",
+        ),
+        migrations.AlterUniqueTogether(
+            name="modulefavorite",
+            unique_together=None,
+        ),
+        migrations.RemoveField(
+            model_name="modulefavorite",
+            name="created_by",
+        ),
+        migrations.RemoveField(
+            model_name="modulefavorite",
+            name="module",
+        ),
+        migrations.RemoveField(
+            model_name="modulefavorite",
+            name="project",
+        ),
+        migrations.RemoveField(
+            model_name="modulefavorite",
+            name="updated_by",
+        ),
+        migrations.RemoveField(
+            model_name="modulefavorite",
+            name="user",
+        ),
+        migrations.RemoveField(
+            model_name="modulefavorite",
+            name="workspace",
+        ),
+        migrations.RemoveField(
+            model_name="pageblock",
+            name="created_by",
+        ),
+        migrations.RemoveField(
+            model_name="pageblock",
+            name="issue",
+        ),
+        migrations.RemoveField(
+            model_name="pageblock",
+            name="page",
+        ),
+        migrations.RemoveField(
+            model_name="pageblock",
+            name="project",
+        ),
+        migrations.RemoveField(
+            model_name="pageblock",
+            name="updated_by",
+        ),
+        migrations.RemoveField(
+            model_name="pageblock",
+            name="workspace",
+        ),
+        migrations.AlterUniqueTogether(
+            name="pagefavorite",
+            unique_together=None,
+        ),
+        migrations.RemoveField(
+            model_name="pagefavorite",
+            name="created_by",
+        ),
+        migrations.RemoveField(
+            model_name="pagefavorite",
+            name="page",
+        ),
+        migrations.RemoveField(
+            model_name="pagefavorite",
+            name="project",
+        ),
+        migrations.RemoveField(
+            model_name="pagefavorite",
+            name="updated_by",
+        ),
+        migrations.RemoveField(
+            model_name="pagefavorite",
+            name="user",
+        ),
+        migrations.RemoveField(
+            model_name="pagefavorite",
+            name="workspace",
+        ),
+        migrations.AlterUniqueTogether(
+            name="projectfavorite",
+            unique_together=None,
+        ),
+        migrations.RemoveField(
+            model_name="projectfavorite",
+            name="created_by",
+        ),
+        migrations.RemoveField(
+            model_name="projectfavorite",
+            name="project",
+        ),
+        migrations.RemoveField(
+            model_name="projectfavorite",
+            name="updated_by",
+        ),
+        migrations.RemoveField(
+            model_name="projectfavorite",
+            name="user",
+        ),
+        migrations.RemoveField(
+            model_name="projectfavorite",
+            name="workspace",
+        ),
+        migrations.AddField(
+            model_name="issuetype",
+            name="external_id",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name="issuetype",
+            name="external_source",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.DeleteModel(
+            name="CycleFavorite",
+        ),
+        migrations.DeleteModel(
+            name="GlobalView",
+        ),
+        migrations.DeleteModel(
+            name="IssueViewFavorite",
+        ),
+        migrations.DeleteModel(
+            name="ModuleFavorite",
+        ),
+        migrations.DeleteModel(
+            name="PageBlock",
+        ),
+        migrations.DeleteModel(
+            name="PageFavorite",
+        ),
+        migrations.DeleteModel(
+            name="ProjectFavorite",
+        ),
+    ]

apiserver/plane/db/migrations/0082_deployboard_is_disabled_and_more.py

@@ -0,0 +1,130 @@
+# Generated by Django 4.2.15 on 2024-10-16 10:56
+
+from django.db import migrations, models
+
+
+def create_in_app_user_notification_preference(apps, schema_editor):
+
+    UserNotificationPreferences = apps.get_model(
+        "db", "UserNotificationPreference"
+    )
+
+    UserNotificationPreferences.objects.bulk_create(
+        [
+            UserNotificationPreferences(
+                user_id=user_notification_preference,
+                type="IN_APP",
+                property_change=True,
+                state_change=True,
+                comment=True,
+                mention=True,
+                issue_completed=True,
+                priority_change=True,
+                assignee_change=True,
+                start_target_date_change=True,
+                module_change=True,
+                cycle_change=True,
+                reactions=True,
+            )
+            for user_notification_preference in UserNotificationPreferences.objects.values_list(
+                "user_id", flat=True
+            )
+        ],
+        batch_size=2000,
+    )
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("db", "0081_remove_globalview_created_by_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="deployboard",
+            name="is_disabled",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="usernotificationpreference",
+            name="assignee_change",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="usernotificationpreference",
+            name="cycle_change",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="usernotificationpreference",
+            name="module_change",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="usernotificationpreference",
+            name="priority_change",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="usernotificationpreference",
+            name="reactions",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="usernotificationpreference",
+            name="start_target_date_change",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="usernotificationpreference",
+            name="type",
+            field=models.CharField(
+                choices=[("EMAIL", "Email"), ("IN_APP", "In App")],
+                default="EMAIL",
+                max_length=30,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="deployboard",
+            name="entity_name",
+            field=models.CharField(
+                choices=[
+                    ("project", "Project"),
+                    ("issue", "Issue"),
+                    ("module", "Module"),
+                    ("cycle", "Task"),
+                    ("page", "Page"),
+                    ("view", "View"),
+                    ("inbox", "Inbox"),
+                ],
+                max_length=30,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="usernotificationpreference",
+            name="comment",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AlterField(
+            model_name="usernotificationpreference",
+            name="issue_completed",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AlterField(
+            model_name="usernotificationpreference",
+            name="mention",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AlterField(
+            model_name="usernotificationpreference",
+            name="property_change",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AlterField(
+            model_name="usernotificationpreference",
+            name="state_change",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.RunPython(create_in_app_user_notification_preference),
+    ]

apiserver/plane/db/models/__init__.py

@@ -2,7 +2,7 @@ from .analytic import AnalyticView
 from .api import APIActivityLog, APIToken
 from .asset import FileAsset
 from .base import BaseModel
-from .cycle import Cycle, CycleFavorite, CycleIssue, CycleUserProperties
+from .cycle import Cycle, CycleIssue, CycleUserProperties
 from .dashboard import Dashboard, DashboardWidget, Widget
 from .deploy_board import DeployBoard
 from .draft import DraftIssue, DraftIssueAssignee, DraftIssueLabel, DraftIssueModule, DraftIssueCycle
@@ -24,7 +24,6 @@ from .issue import (
     Issue,
     IssueActivity,
     IssueAssignee,
-    IssueAttachment,
     IssueBlocker,
     IssueComment,
     IssueLabel,
@@ -40,7 +39,6 @@ from .issue import (
 )
 from .module import (
     Module,
-    ModuleFavorite,
     ModuleIssue,
     ModuleLink,
     ModuleMember,
@@ -53,7 +51,6 @@ from .notification import (
 )
 from .page import (
     Page,
-    PageFavorite,
     PageLabel,
     PageLog,
     ProjectPage,
@@ -62,7 +59,6 @@ from .page import (
 from .project import (
     Project,
     ProjectBaseModel,
-    ProjectFavorite,
     ProjectIdentifier,
     ProjectMember,
     ProjectMemberInvite,
@@ -73,7 +69,7 @@ from .session import Session
 from .social_connection import SocialLoginConnection
 from .state import State
 from .user import Account, Profile, User
-from .view import IssueView, IssueViewFavorite
+from .view import IssueView
 from .webhook import Webhook, WebhookLog
 from .workspace import (
     Team,
@@ -88,7 +84,7 @@ from .workspace import (
 
 from .importer import Importer
 
-from .page import Page, PageLog, PageFavorite, PageLabel
+from .page import Page, PageLog, PageLabel
 
 from .estimate import Estimate, EstimatePoint
 

apiserver/plane/db/models/asset.py

@@ -5,14 +5,13 @@ from uuid import uuid4
 from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.db import models
-from django.core.validators import FileExtensionValidator
 
 # Module import
 from .base import BaseModel
 
 
 def get_upload_path(instance, filename):
-    filename = filename[:50]
+
     if instance.workspace_id is not None:
         return f"{instance.workspace.id}/{uuid4().hex}-{filename}"
     return f"user-{uuid4().hex}-{filename}"
@@ -28,13 +27,28 @@ class FileAsset(BaseModel):
     A file asset.
     """
 
+    class EntityTypeContext(models.TextChoices):
+        ISSUE_ATTACHMENT = "ISSUE_ATTACHMENT"
+        ISSUE_DESCRIPTION = "ISSUE_DESCRIPTION"
+        COMMENT_DESCRIPTION = "COMMENT_DESCRIPTION"
+        PAGE_DESCRIPTION = "PAGE_DESCRIPTION"
+        USER_COVER = "USER_COVER"
+        USER_AVATAR = "USER_AVATAR"
+        WORKSPACE_LOGO = "WORKSPACE_LOGO"
+        PROJECT_COVER = "PROJECT_COVER"
+        DRAFT_ISSUE_ATTACHMENT = "DRAFT_ISSUE_ATTACHMENT"
+        DRAFT_ISSUE_DESCRIPTION = "DRAFT_ISSUE_DESCRIPTION"
+
     attributes = models.JSONField(default=dict)
     asset = models.FileField(
         upload_to=get_upload_path,
-        validators=[
-            FileExtensionValidator(allowed_extensions=["jpg", "jpeg", "png"]),
-            file_size,
-        ],
+        max_length=800,
+    )
+    user = models.ForeignKey(
+        "db.User",
+        on_delete=models.CASCADE,
+        null=True,
+        related_name="assets",
     )
     workspace = models.ForeignKey(
         "db.Workspace",
@@ -42,8 +56,49 @@ class FileAsset(BaseModel):
         null=True,
         related_name="assets",
     )
+    draft_issue = models.ForeignKey(
+        "db.DraftIssue",
+        on_delete=models.CASCADE,
+        null=True,
+        related_name="assets",
+    )
+    project = models.ForeignKey(
+        "db.Project",
+        on_delete=models.CASCADE,
+        null=True,
+        related_name="assets",
+    )
+    issue = models.ForeignKey(
+        "db.Issue",
+        on_delete=models.CASCADE,
+        null=True,
+        related_name="assets",
+    )
+    comment = models.ForeignKey(
+        "db.IssueComment",
+        on_delete=models.CASCADE,
+        null=True,
+        related_name="assets",
+    )
+    page = models.ForeignKey(
+        "db.Page",
+        on_delete=models.CASCADE,
+        null=True,
+        related_name="assets",
+    )
+    entity_type = models.CharField(
+        max_length=255,
+        choices=EntityTypeContext.choices,
+        null=True,
+        blank=True,
+    )
     is_deleted = models.BooleanField(default=False)
     is_archived = models.BooleanField(default=False)
+    external_id = models.CharField(max_length=255, null=True, blank=True)
+    external_source = models.CharField(max_length=255, null=True, blank=True)
+    size = models.FloatField(default=0)
+    is_uploaded = models.BooleanField(default=False)
+    storage_metadata = models.JSONField(default=dict, null=True, blank=True)
 
     class Meta:
         verbose_name = "File Asset"
@@ -53,3 +108,26 @@ class FileAsset(BaseModel):
 
     def __str__(self):
         return str(self.asset)
+
+    @property
+    def asset_url(self):
+        if (
+            self.entity_type == self.EntityTypeContext.WORKSPACE_LOGO
+            or self.entity_type == self.EntityTypeContext.USER_AVATAR
+            or self.entity_type == self.EntityTypeContext.USER_COVER
+            or self.entity_type == self.EntityTypeContext.PROJECT_COVER
+        ):
+            return f"/api/assets/v2/static/{self.id}/"
+
+        if self.entity_type == self.EntityTypeContext.ISSUE_ATTACHMENT:
+            return f"/api/assets/v2/workspaces/{self.workspace.slug}/projects/{self.project_id}/issues/{self.issue_id}/attachments/{self.id}/"
+
+        if self.entity_type in [
+            self.EntityTypeContext.ISSUE_DESCRIPTION,
+            self.EntityTypeContext.COMMENT_DESCRIPTION,
+            self.EntityTypeContext.PAGE_DESCRIPTION,
+            self.EntityTypeContext.DRAFT_ISSUE_DESCRIPTION,
+        ]:
+            return f"/api/assets/v2/workspaces/{self.workspace.slug}/projects/{self.project_id}/{self.id}/"
+
+        return None

apiserver/plane/db/models/cycle.py

@@ -127,33 +127,6 @@ class CycleIssue(ProjectBaseModel):
         return f"{self.cycle}"
 
 
-# DEPRECATED TODO: - Remove in next release
-class CycleFavorite(ProjectBaseModel):
-    """_summary_
-    CycleFavorite (model): To store all the cycle favorite of the user
-    """
-
-    user = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.CASCADE,
-        related_name="cycle_favorites",
-    )
-    cycle = models.ForeignKey(
-        "db.Cycle", on_delete=models.CASCADE, related_name="cycle_favorites"
-    )
-
-    class Meta:
-        unique_together = ["cycle", "user"]
-        verbose_name = "Cycle Favorite"
-        verbose_name_plural = "Cycle Favorites"
-        db_table = "cycle_favorites"
-        ordering = ("-created_at",)
-
-    def __str__(self):
-        """Return user and the cycle"""
-        return f"{self.user.email} <{self.cycle.name}>"
-
-
 class CycleUserProperties(ProjectBaseModel):
     cycle = models.ForeignKey(
         "db.Cycle",

apiserver/plane/db/models/deploy_board.py

@@ -20,6 +20,7 @@ class DeployBoard(WorkspaceBaseModel):
         ("cycle", "Task"),
         ("page", "Page"),
         ("view", "View"),
+        ("inbox", "Inbox"),
     )
 
     entity_identifier = models.UUIDField(null=True)
@@ -41,6 +42,7 @@ class DeployBoard(WorkspaceBaseModel):
     is_votes_enabled = models.BooleanField(default=False)
     view_props = models.JSONField(default=dict)
     is_activity_enabled = models.BooleanField(default=True)
+    is_disabled = models.BooleanField(default=False)
 
     def __str__(self):
         """Return name of the deploy board"""

apiserver/plane/db/models/integration/base.py

@@ -29,7 +29,7 @@ class Integration(AuditModel):
     redirect_url = models.TextField(blank=True)
     metadata = models.JSONField(default=dict)
     verified = models.BooleanField(default=False)
-    avatar_url = models.URLField(blank=True, null=True)
+    avatar_url = models.TextField(blank=True, null=True)
 
     def __str__(self):
         """Return provider of the integration"""

apiserver/plane/db/models/issue_type.py

@@ -19,6 +19,8 @@ class IssueType(BaseModel):
     is_default = models.BooleanField(default=False)
     is_active = models.BooleanField(default=True)
     level = models.PositiveIntegerField(default=0)
+    external_source = models.CharField(max_length=255, null=True, blank=True)
+    external_id = models.CharField(max_length=255, blank=True, null=True)
 
     class Meta:
         verbose_name = "Issue Type"

apiserver/plane/db/models/module.py

@@ -100,9 +100,9 @@ class Module(ProjectBaseModel):
         unique_together = ["name", "project", "deleted_at"]
         constraints = [
             models.UniqueConstraint(
-                fields=['name', 'project'],
+                fields=["name", "project"],
                 condition=Q(deleted_at__isnull=True),
-                name='module_unique_name_project_when_deleted_at_null'
+                name="module_unique_name_project_when_deleted_at_null",
             )
         ]
         verbose_name = "Module"
@@ -191,33 +191,6 @@ class ModuleLink(ProjectBaseModel):
         return f"{self.module.name} {self.url}"
 
 
-# DEPRECATED TODO: - Remove in next release
-class ModuleFavorite(ProjectBaseModel):
-    """_summary_
-    ModuleFavorite (model): To store all the module favorite of the user
-    """
-
-    user = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.CASCADE,
-        related_name="module_favorites",
-    )
-    module = models.ForeignKey(
-        "db.Module", on_delete=models.CASCADE, related_name="module_favorites"
-    )
-
-    class Meta:
-        unique_together = ["module", "user"]
-        verbose_name = "Module Favorite"
-        verbose_name_plural = "Module Favorites"
-        db_table = "module_favorites"
-        ordering = ("-created_at",)
-
-    def __str__(self):
-        """Return user and the module"""
-        return f"{self.user.email} <{self.module.name}>"
-
-
 class ModuleUserProperties(ProjectBaseModel):
     module = models.ForeignKey(
         "db.Module",

apiserver/plane/db/models/notification.py

@@ -6,6 +6,10 @@ from django.db import models
 from .base import BaseModel
 
 
+class PreferenceTypeEnum(models.TextChoices):
+    EMAIL = "EMAIL", "Email"
+    IN_APP = "IN_APP", "In App"
+
 
 class Notification(BaseModel):
     workspace = models.ForeignKey(
@@ -89,13 +93,24 @@ class UserNotificationPreference(BaseModel):
         related_name="project_notification_preferences",
         null=True,
     )
+    type = models.CharField(
+        max_length=30,
+        choices=PreferenceTypeEnum.choices,
+        default=PreferenceTypeEnum.EMAIL,
+    )
 
     # preference fields
-    property_change = models.BooleanField(default=True)
-    state_change = models.BooleanField(default=True)
-    comment = models.BooleanField(default=True)
-    mention = models.BooleanField(default=True)
-    issue_completed = models.BooleanField(default=True)
+    property_change = models.BooleanField(default=False)
+    state_change = models.BooleanField(default=False)
+    comment = models.BooleanField(default=False)
+    mention = models.BooleanField(default=False)
+    issue_completed = models.BooleanField(default=False)
+    priority_change = models.BooleanField(default=False)
+    assignee_change = models.BooleanField(default=False)
+    start_target_date_change = models.BooleanField(default=False)
+    module_change = models.BooleanField(default=False)
+    cycle_change = models.BooleanField(default=False)
+    reactions = models.BooleanField(default=False)
 
     class Meta:
         verbose_name = "UserNotificationPreference"

apiserver/plane/db/models/page.py

@@ -119,86 +119,6 @@ class PageLog(BaseModel):
         return f"{self.page.name} {self.entity_name}"
 
 
-# DEPRECATED TODO: - Remove in next release
-class PageBlock(ProjectBaseModel):
-    page = models.ForeignKey(
-        "db.Page", on_delete=models.CASCADE, related_name="blocks"
-    )
-    name = models.CharField(max_length=255)
-    description = models.JSONField(default=dict, blank=True)
-    description_html = models.TextField(blank=True, default="<p></p>")
-    description_stripped = models.TextField(blank=True, null=True)
-    issue = models.ForeignKey(
-        "db.Issue", on_delete=models.SET_NULL, related_name="blocks", null=True
-    )
-    completed_at = models.DateTimeField(null=True)
-    sort_order = models.FloatField(default=65535)
-    sync = models.BooleanField(default=True)
-
-    def save(self, *args, **kwargs):
-        if self._state.adding:
-            largest_sort_order = PageBlock.objects.filter(
-                project=self.project, page=self.page
-            ).aggregate(largest=models.Max("sort_order"))["largest"]
-            if largest_sort_order is not None:
-                self.sort_order = largest_sort_order + 10000
-
-        # Strip the html tags using html parser
-        self.description_stripped = (
-            None
-            if (self.description_html == "" or self.description_html is None)
-            else strip_tags(self.description_html)
-        )
-
-        if self.completed_at and self.issue:
-            try:
-                from plane.db.models import Issue, State
-
-                completed_state = State.objects.filter(
-                    group="completed", project=self.project
-                ).first()
-                if completed_state is not None:
-                    Issue.objects.update(
-                        pk=self.issue_id, state=completed_state
-                    )
-            except ImportError:
-                pass
-        super(PageBlock, self).save(*args, **kwargs)
-
-    class Meta:
-        verbose_name = "Page Block"
-        verbose_name_plural = "Page Blocks"
-        db_table = "page_blocks"
-        ordering = ("-created_at",)
-
-    def __str__(self):
-        """Return page and page block"""
-        return f"{self.page.name} <{self.name}>"
-
-
-# DEPRECATED TODO: - Remove in next release
-class PageFavorite(ProjectBaseModel):
-    user = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.CASCADE,
-        related_name="page_favorites",
-    )
-    page = models.ForeignKey(
-        "db.Page", on_delete=models.CASCADE, related_name="page_favorites"
-    )
-
-    class Meta:
-        unique_together = ["page", "user"]
-        verbose_name = "Page Favorite"
-        verbose_name_plural = "Page Favorites"
-        db_table = "page_favorites"
-        ordering = ("-created_at",)
-
-    def __str__(self):
-        """Return user and the page"""
-        return f"{self.user.email} <{self.page.name}>"
-
-
 class PageLabel(BaseModel):
     label = models.ForeignKey(
         "db.Label", on_delete=models.CASCADE, related_name="page_labels"

apiserver/plane/db/models/project.py

@@ -99,7 +99,14 @@ class Project(BaseModel):
     is_time_tracking_enabled = models.BooleanField(default=False)
     is_issue_type_enabled = models.BooleanField(default=False)
     guest_view_all_features = models.BooleanField(default=False)
-    cover_image = models.URLField(blank=True, null=True, max_length=800)
+    cover_image = models.TextField(blank=True, null=True)
+    cover_image_asset = models.ForeignKey(
+        "db.FileAsset",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="project_cover_image",
+    )
     estimate = models.ForeignKey(
         "db.Estimate",
         on_delete=models.SET_NULL,
@@ -126,6 +133,18 @@ class Project(BaseModel):
         max_length=255, default="UTC", choices=TIMEZONE_CHOICES
     )
 
+    @property
+    def cover_image_url(self):
+        # Return cover image url
+        if self.cover_image_asset:
+            return self.cover_image_asset.asset_url
+
+        # Return cover image url
+        if self.cover_image:
+            return self.cover_image
+
+        return None
+
     def __str__(self):
         """Return name of the project"""
         return f"{self.name} <{self.workspace.name}>"
@@ -162,7 +181,9 @@ class ProjectBaseModel(BaseModel):
         Project, on_delete=models.CASCADE, related_name="project_%(class)s"
     )
     workspace = models.ForeignKey(
-        "db.Workspace", models.CASCADE, related_name="workspace_%(class)s"
+        "db.Workspace",
+        on_delete=models.CASCADE,
+        related_name="workspace_%(class)s",
     )
 
     class Meta:
@@ -266,26 +287,6 @@ class ProjectIdentifier(AuditModel):
         ordering = ("-created_at",)
 
 
-# DEPRECATED TODO: - Remove in next release
-class ProjectFavorite(ProjectBaseModel):
-    user = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.CASCADE,
-        related_name="project_favorites",
-    )
-
-    class Meta:
-        unique_together = ["project", "user"]
-        verbose_name = "Project Favorite"
-        verbose_name_plural = "Project Favorites"
-        db_table = "project_favorites"
-        ordering = ("-created_at",)
-
-    def __str__(self):
-        """Return user of the project"""
-        return f"{self.user.email} <{self.project.name}>"
-
-
 def get_anchor():
     return uuid4().hex
 

apiserver/plane/db/models/user.py

@@ -17,6 +17,7 @@ from django.dispatch import receiver
 from django.utils import timezone
 
 # Module imports
+from plane.db.models import FileAsset
 from ..mixins import TimeAuditModel
 
 
@@ -48,8 +49,24 @@ class User(AbstractBaseUser, PermissionsMixin):
     display_name = models.CharField(max_length=255, default="")
     first_name = models.CharField(max_length=255, blank=True)
     last_name = models.CharField(max_length=255, blank=True)
+    # avatar
     avatar = models.TextField(blank=True)
+    avatar_asset = models.ForeignKey(
+        FileAsset,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="user_avatar",
+    )
+    # cover image
     cover_image = models.URLField(blank=True, null=True, max_length=800)
+    cover_image_asset = models.ForeignKey(
+        FileAsset,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="user_cover_image",
+    )
 
     # tracking metrics
     date_joined = models.DateTimeField(
@@ -111,6 +128,28 @@ class User(AbstractBaseUser, PermissionsMixin):
     def __str__(self):
         return f"{self.username} <{self.email}>"
 
+    @property
+    def avatar_url(self):
+        # Return the logo asset url if it exists
+        if self.avatar_asset:
+            return self.avatar_asset.asset_url
+
+        # Return the logo url if it exists
+        if self.avatar:
+            return self.avatar
+        return None
+
+    @property
+    def cover_image_url(self):
+        # Return the logo asset url if it exists
+        if self.cover_image_asset:
+            return self.cover_image_asset.asset_url
+
+        # Return the logo url if it exists
+        if self.cover_image:
+            return self.cover_image
+        return None
+
     def save(self, *args, **kwargs):
         self.email = self.email.lower().strip()
         self.mobile_number = self.mobile_number
@@ -182,7 +221,11 @@ class Account(TimeAuditModel):
     )
     provider_account_id = models.CharField(max_length=255)
     provider = models.CharField(
-        choices=(("google", "Google"), ("github", "Github"), ("gitlab", "GitLab")),
+        choices=(
+            ("google", "Google"),
+            ("github", "Github"),
+            ("gitlab", "GitLab"),
+        ),
     )
     access_token = models.TextField()
     access_token_expired_at = models.DateTimeField(null=True)
@@ -209,9 +252,20 @@ def create_user_notification(sender, instance, created, **kwargs):
 
         UserNotificationPreference.objects.create(
             user=instance,
-            property_change=False,
-            state_change=False,
-            comment=False,
-            mention=False,
-            issue_completed=False,
+            type="EMAIL",
+        )
+        UserNotificationPreference.objects.create(
+            user=instance,
+            type="IN_APP",
+            property_change=True,
+            state_change=True,
+            comment=True,
+            mention=True,
+            issue_completed=True,
+            priority_change=True,
+            assignee_change=True,
+            start_target_date_change=True,
+            module_change=True,
+            cycle_change=True,
+            reactions=True,
         )

apiserver/plane/db/models/view.py

@@ -52,41 +52,6 @@ def get_default_display_properties():
         "updated_on": True,
     }
 
-# DEPRECATED TODO: - Remove in next release
-class GlobalView(BaseModel):
-    workspace = models.ForeignKey(
-        "db.Workspace", on_delete=models.CASCADE, related_name="global_views"
-    )
-    name = models.CharField(max_length=255, verbose_name="View Name")
-    description = models.TextField(verbose_name="View Description", blank=True)
-    query = models.JSONField(verbose_name="View Query")
-    access = models.PositiveSmallIntegerField(
-        default=1, choices=((0, "Private"), (1, "Public"))
-    )
-    query_data = models.JSONField(default=dict)
-    sort_order = models.FloatField(default=65535)
-    logo_props = models.JSONField(default=dict)
-
-    class Meta:
-        verbose_name = "Global View"
-        verbose_name_plural = "Global Views"
-        db_table = "global_views"
-        ordering = ("-created_at",)
-
-    def save(self, *args, **kwargs):
-        if self._state.adding:
-            largest_sort_order = GlobalView.objects.filter(
-                workspace=self.workspace
-            ).aggregate(largest=models.Max("sort_order"))["largest"]
-            if largest_sort_order is not None:
-                self.sort_order = largest_sort_order + 10000
-
-        super(GlobalView, self).save(*args, **kwargs)
-
-    def __str__(self):
-        """Return name of the View"""
-        return f"{self.name} <{self.workspace.name}>"
-
 
 class IssueView(WorkspaceBaseModel):
     name = models.CharField(max_length=255, verbose_name="View Name")
@@ -109,7 +74,6 @@ class IssueView(WorkspaceBaseModel):
     )
     is_locked = models.BooleanField(default=False)
 
-
     class Meta:
         verbose_name = "Issue View"
         verbose_name_plural = "Issue Views"
@@ -139,26 +103,3 @@ class IssueView(WorkspaceBaseModel):
     def __str__(self):
         """Return name of the View"""
         return f"{self.name} <{self.project.name}>"
-
-
-# DEPRECATED TODO: - Remove in next release
-class IssueViewFavorite(ProjectBaseModel):
-    user = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.CASCADE,
-        related_name="user_view_favorites",
-    )
-    view = models.ForeignKey(
-        "db.IssueView", on_delete=models.CASCADE, related_name="view_favorites"
-    )
-
-    class Meta:
-        unique_together = ["view", "user"]
-        verbose_name = "View Favorite"
-        verbose_name_plural = "View Favorites"
-        db_table = "view_favorites"
-        ordering = ("-created_at",)
-
-    def __str__(self):
-        """Return user and the view"""
-        return f"{self.user.email} <{self.view.name}>"

apiserver/plane/db/models/workspace.py

@@ -118,7 +118,14 @@ def slug_validator(value):
 
 class Workspace(BaseModel):
     name = models.CharField(max_length=80, verbose_name="Workspace Name")
-    logo = models.URLField(verbose_name="Logo", blank=True, null=True)
+    logo = models.TextField(verbose_name="Logo", blank=True, null=True)
+    logo_asset = models.ForeignKey(
+        "db.FileAsset",
+        on_delete=models.SET_NULL,
+        related_name="workspace_logo",
+        blank=True,
+        null=True,
+    )
     owner = models.ForeignKey(
         settings.AUTH_USER_MODEL,
         on_delete=models.CASCADE,
@@ -138,6 +145,17 @@ class Workspace(BaseModel):
         """Return name of the Workspace"""
         return self.name
 
+    @property
+    def logo_url(self):
+        # Return the logo asset url if it exists
+        if self.logo_asset:
+            return self.logo_asset.asset_url
+
+        # Return the logo url if it exists
+        if self.logo:
+            return self.logo
+        return None
+
     class Meta:
         verbose_name = "Workspace"
         verbose_name_plural = "Workspaces"

apiserver/plane/license/api/serializers/admin.py

@@ -11,6 +11,7 @@ class InstanceAdminMeSerializer(BaseSerializer):
         fields = [
             "id",
             "avatar",
+            "avatar_url",
             "cover_image",
             "date_joined",
             "display_name",

apiserver/plane/settings/common.py

@@ -72,7 +72,6 @@ INSTALLED_APPS = [
     "rest_framework",
     "corsheaders",
     "django_celery_beat",
-    "storages",
 ]
 
 # Middlewares
@@ -259,7 +258,7 @@ STORAGES = {
     },
 }
 STORAGES["default"] = {
-    "BACKEND": "storages.backends.s3boto3.S3Boto3Storage",
+    "BACKEND": "plane.settings.storage.S3Storage",
 }
 AWS_ACCESS_KEY_ID = os.environ.get("AWS_ACCESS_KEY_ID", "access-key")
 AWS_SECRET_ACCESS_KEY = os.environ.get("AWS_SECRET_ACCESS_KEY", "secret-key")
@@ -384,3 +383,61 @@ SPACE_BASE_URL = os.environ.get("SPACE_BASE_URL", None)
 APP_BASE_URL = os.environ.get("APP_BASE_URL")
 
 HARD_DELETE_AFTER_DAYS = int(os.environ.get("HARD_DELETE_AFTER_DAYS", 60))
+
+ATTACHMENT_MIME_TYPES = [
+    # Images
+    "image/jpeg",
+    "image/png",
+    "image/gif",
+    "image/svg+xml",
+    "image/webp",
+    "image/tiff",
+    "image/bmp",
+    # Documents
+    "application/pdf",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.ms-excel",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "text/plain",
+    "application/rtf",
+    # Audio
+    "audio/mpeg",
+    "audio/wav",
+    "audio/ogg",
+    "audio/midi",
+    "audio/x-midi",
+    "audio/aac",
+    "audio/flac",
+    "audio/x-m4a",
+    # Video
+    "video/mp4",
+    "video/mpeg",
+    "video/ogg",
+    "video/webm",
+    "video/quicktime",
+    "video/x-msvideo",
+    "video/x-ms-wmv",
+    # Archives
+    "application/zip",
+    "application/x-rar-compressed",
+    "application/x-tar",
+    "application/gzip",
+    # 3D Models
+    "model/gltf-binary",
+    "model/gltf+json",
+    "application/octet-stream",  # for .obj files, but be cautious
+    # Fonts
+    "font/ttf",
+    "font/otf",
+    "font/woff",
+    "font/woff2",
+    # Other
+    "text/css",
+    "text/javascript",
+    "application/json",
+    "text/xml",
+    "application/xml",
+]

apiserver/plane/settings/storage.py

@@ -0,0 +1,154 @@
+# Python imports
+import os
+
+# Third party imports
+import boto3
+from botocore.exceptions import ClientError
+from urllib.parse import quote
+
+# Module imports
+from plane.utils.exception_logger import log_exception
+from storages.backends.s3boto3 import S3Boto3Storage
+
+
+class S3Storage(S3Boto3Storage):
+
+    def url(self, name, parameters=None, expire=None, http_method=None):
+        return name
+
+    """S3 storage class to generate presigned URLs for S3 objects"""
+
+    def __init__(self, request=None):
+        # Get the AWS credentials and bucket name from the environment
+        self.aws_access_key_id = os.environ.get("AWS_ACCESS_KEY_ID")
+        # Use the AWS_SECRET_ACCESS_KEY environment variable for the secret key
+        self.aws_secret_access_key = os.environ.get("AWS_SECRET_ACCESS_KEY")
+        # Use the AWS_S3_BUCKET_NAME environment variable for the bucket name
+        self.aws_storage_bucket_name = os.environ.get("AWS_S3_BUCKET_NAME")
+        # Use the AWS_REGION environment variable for the region
+        self.aws_region = os.environ.get("AWS_REGION")
+        # Use the AWS_S3_ENDPOINT_URL environment variable for the endpoint URL
+        self.aws_s3_endpoint_url = os.environ.get(
+            "AWS_S3_ENDPOINT_URL"
+        ) or os.environ.get("MINIO_ENDPOINT_URL")
+
+        if os.environ.get("USE_MINIO") == "1":
+            # Create an S3 client for MinIO
+            self.s3_client = boto3.client(
+                "s3",
+                aws_access_key_id=self.aws_access_key_id,
+                aws_secret_access_key=self.aws_secret_access_key,
+                region_name=self.aws_region,
+                endpoint_url=f"{request.scheme}://{request.get_host()}",
+                config=boto3.session.Config(signature_version="s3v4"),
+            )
+        else:
+            # Create an S3 client
+            self.s3_client = boto3.client(
+                "s3",
+                aws_access_key_id=self.aws_access_key_id,
+                aws_secret_access_key=self.aws_secret_access_key,
+                region_name=self.aws_region,
+                endpoint_url=self.aws_s3_endpoint_url,
+                config=boto3.session.Config(signature_version="s3v4"),
+            )
+
+    def generate_presigned_post(
+        self, object_name, file_type, file_size, expiration=3600
+    ):
+        """Generate a presigned URL to upload an S3 object"""
+        fields = {
+            "Content-Type": file_type,
+        }
+
+        conditions = [
+            {"bucket": self.aws_storage_bucket_name},
+            ["content-length-range", 1, file_size],
+            {"Content-Type": file_type},
+        ]
+
+        # Add condition for the object name (key)
+        if object_name.startswith("${filename}"):
+            conditions.append(
+                ["starts-with", "$key", object_name[: -len("${filename}")]]
+            )
+        else:
+            fields["key"] = object_name
+            conditions.append({"key": object_name})
+
+        # Generate the presigned POST URL
+        try:
+            # Generate a presigned URL for the S3 object
+            response = self.s3_client.generate_presigned_post(
+                Bucket=self.aws_storage_bucket_name,
+                Key=object_name,
+                Fields=fields,
+                Conditions=conditions,
+                ExpiresIn=expiration,
+            )
+        # Handle errors
+        except ClientError as e:
+            print(f"Error generating presigned POST URL: {e}")
+            return None
+
+        return response
+
+    def _get_content_disposition(self, disposition, filename=None):
+        """Helper method to generate Content-Disposition header value"""
+        if filename:
+            # Encode the filename to handle special characters
+            encoded_filename = quote(filename)
+            return f"{disposition}; filename*=UTF-8''{encoded_filename}"
+        return disposition
+
+    def generate_presigned_url(
+        self,
+        object_name,
+        expiration=3600,
+        http_method="GET",
+        disposition="inline",
+        filename=None,
+    ):
+        content_disposition = self._get_content_disposition(
+            disposition, filename
+        )
+        """Generate a presigned URL to share an S3 object"""
+        try:
+            response = self.s3_client.generate_presigned_url(
+                "get_object",
+                Params={
+                    "Bucket": self.aws_storage_bucket_name,
+                    "Key": str(object_name),
+                    "ResponseContentDisposition": content_disposition,
+                },
+                ExpiresIn=expiration,
+                HttpMethod=http_method,
+            )
+        except ClientError as e:
+            log_exception(e)
+            return None
+
+        # The response contains the presigned URL
+        return response
+
+    def get_object_metadata(self, object_name):
+        """Get the metadata for an S3 object"""
+        try:
+            response = self.s3_client.head_object(
+                Bucket=self.aws_storage_bucket_name, Key=object_name
+            )
+        except ClientError as e:
+            log_exception(e)
+            return None
+
+        return {
+            "ContentType": response.get("ContentType"),
+            "ContentLength": response.get("ContentLength"),
+            "LastModified": (
+                response.get("LastModified").isoformat()
+                if response.get("LastModified")
+                else None
+            ),
+            "ETag": response.get("ETag"),
+            "Metadata": response.get("Metadata", {}),
+        }

apiserver/plane/space/serializer/issue.py

@@ -22,7 +22,7 @@ from plane.db.models import (
     CycleIssue,
     ModuleIssue,
     IssueLink,
-    IssueAttachment,
+    FileAsset,
     IssueReaction,
     CommentReaction,
     IssueVote,
@@ -174,7 +174,7 @@ class IssueLinkSerializer(BaseSerializer):
 
 class IssueAttachmentSerializer(BaseSerializer):
     class Meta:
-        model = IssueAttachment
+        model = FileAsset
         fields = "__all__"
         read_only_fields = [
             "created_by",

apiserver/plane/space/serializer/user.py

@@ -13,6 +13,7 @@ class UserLiteSerializer(BaseSerializer):
             "first_name",
             "last_name",
             "avatar",
+            "avatar_url",
             "is_bot",
             "display_name",
         ]

apiserver/plane/space/urls/__init__.py

@@ -1,10 +1,12 @@
 from .inbox import urlpatterns as inbox_urls
 from .issue import urlpatterns as issue_urls
 from .project import urlpatterns as project_urls
+from .asset import urlpatterns as asset_urls
 
 
 urlpatterns = [
     *inbox_urls,
     *issue_urls,
     *project_urls,
+    *asset_urls,
 ]

apiserver/plane/space/urls/asset.py

@@ -0,0 +1,32 @@
+# Django imports
+from django.urls import path
+
+# Module imports
+from plane.space.views import (
+    EntityAssetEndpoint,
+    AssetRestoreEndpoint,
+    EntityBulkAssetEndpoint,
+)
+
+urlpatterns = [
+    path(
+        "assets/v2/anchor/<str:anchor>/",
+        EntityAssetEndpoint.as_view(),
+        name="entity-asset",
+    ),
+    path(
+        "assets/v2/anchor/<str:anchor>/<uuid:pk>/",
+        EntityAssetEndpoint.as_view(),
+        name="entity-asset",
+    ),
+    path(
+        "assets/v2/anchor/<str:anchor>/restore/<uuid:pk>/",
+        AssetRestoreEndpoint.as_view(),
+        name="asset-restore",
+    ),
+    path(
+        "assets/v2/anchor/<str:anchor>/<uuid:entity_id>/bulk/",
+        EntityBulkAssetEndpoint.as_view(),
+        name="entity-bulk-asset",
+    ),
+]

apiserver/plane/space/utils/grouper.py

@@ -1,8 +1,17 @@
 # Django imports
 from django.contrib.postgres.aggregates import ArrayAgg
 from django.contrib.postgres.fields import ArrayField
-from django.db.models import Q, UUIDField, Value, F, Case, When, JSONField
-from django.db.models.functions import Coalesce, JSONObject
+from django.db.models import (
+    Q,
+    UUIDField,
+    Value,
+    F,
+    Case,
+    When,
+    JSONField,
+    CharField,
+)
+from django.db.models.functions import Coalesce, JSONObject, Concat
 
 # Module imports
 from plane.db.models import (
@@ -16,6 +25,7 @@ from plane.db.models import (
     WorkspaceMember,
 )
 
+
 def issue_queryset_grouper(queryset, group_by, sub_group_by):
 
     FIELD_MAPPER = {
@@ -98,18 +108,26 @@ def issue_on_results(issues, group_by, sub_group_by):
                             first_name=F("votes__actor__first_name"),
                             last_name=F("votes__actor__last_name"),
                             avatar=F("votes__actor__avatar"),
+                            avatar_url=Case(
+                                When(
+                                    votes__actor__avatar_asset__isnull=False,
+                                    then=Concat(
+                                        Value("/api/assets/v2/static/"),
+                                        F("votes__actor__avatar_asset"),
+                                        Value("/"),
+                                    ),
+                                ),
+                                default=F("votes__actor__avatar"),
+                                output_field=CharField(),
+                            ),
                             display_name=F("votes__actor__display_name"),
-                        )
+                        ),
                     ),
                 ),
                 default=None,
                 output_field=JSONField(),
             ),
-            filter=Case(
-                When(votes__isnull=False, then=True),
-                default=False,
-                output_field=JSONField(),
-            ),
+            filter=Q(votes__isnull=False),
             distinct=True,
         ),
         reaction_items=ArrayAgg(
@@ -123,18 +141,30 @@ def issue_on_results(issues, group_by, sub_group_by):
                             first_name=F("issue_reactions__actor__first_name"),
                             last_name=F("issue_reactions__actor__last_name"),
                             avatar=F("issue_reactions__actor__avatar"),
-                            display_name=F("issue_reactions__actor__display_name"),
+                            avatar_url=Case(
+                                When(
+                                    issue_reactions__actor__avatar_asset__isnull=False,
+                                    then=Concat(
+                                        Value("/api/assets/v2/static/"),
+                                        F(
+                                            "issue_reactions__actor__avatar_asset"
+                                        ),
+                                        Value("/"),
+                                    ),
+                                ),
+                                default=F("issue_reactions__actor__avatar"),
+                                output_field=CharField(),
+                            ),
+                            display_name=F(
+                                "issue_reactions__actor__display_name"
+                            ),
                         ),
                     ),
                 ),
                 default=None,
                 output_field=JSONField(),
             ),
-            filter=Case(
-                When(issue_reactions__isnull=False, then=True),
-                default=False,
-                output_field=JSONField(),
-            ),
+            filter=Q(issue_reactions__isnull=False),
             distinct=True,
         ),
     ).values(*required_fields, "vote_items", "reaction_items")

apiserver/plane/space/views/__init__.py

@@ -23,3 +23,9 @@ from .module import ProjectModulesEndpoint
 from .state import ProjectStatesEndpoint
 
 from .label import ProjectLabelsEndpoint
+
+from .asset import (
+    EntityAssetEndpoint,
+    AssetRestoreEndpoint,
+    EntityBulkAssetEndpoint,
+)

apiserver/plane/space/views/asset.py

@@ -0,0 +1,280 @@
+# 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.permissions import AllowAny, IsAuthenticated
+from rest_framework.response import Response
+
+# Module imports
+from .base import BaseAPIView
+from plane.db.models import DeployBoard, FileAsset
+from plane.settings.storage import S3Storage
+
+
+class EntityAssetEndpoint(BaseAPIView):
+
+    def get_permissions(self):
+        if self.request.method == "GET":
+            permission_classes = [
+                AllowAny,
+            ]
+        else:
+            permission_classes = [
+                IsAuthenticated,
+            ]
+        return [permission() for permission in permission_classes]
+
+    def get(self, request, anchor, pk):
+        # Get the deploy board
+        deploy_board = DeployBoard.objects.filter(anchor=anchor).first()
+        # Check if the project is published
+        if not deploy_board:
+            return Response(
+                {"error": "Requested resource could not be found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # get the asset id
+        asset = FileAsset.objects.get(
+            workspace_id=deploy_board.workspace_id,
+            pk=pk,
+            entity_type__in=[
+                FileAsset.EntityTypeContext.ISSUE_DESCRIPTION,
+                FileAsset.EntityTypeContext.COMMENT_DESCRIPTION,
+            ],
+        )
+
+        # 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)
+
+    def post(self, request, anchor):
+        # Get the deploy board
+        deploy_board = DeployBoard.objects.filter(
+            anchor=anchor, entity_name="project"
+        ).first()
+        # Check if the project is published
+        if not deploy_board:
+            return Response(
+                {"error": "Project is not published"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Get the asset
+        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"]
+        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"{deploy_board.workspace_id}/{uuid.uuid4().hex}-{name}"
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={
+                "name": name,
+                "type": type,
+                "size": size,
+            },
+            asset=asset_key,
+            size=size,
+            workspace=deploy_board.workspace,
+            created_by=request.user,
+            entity_type=entity_type,
+            project_id=deploy_board.project_id,
+            comment_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,
+        )
+        # 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, anchor, pk):
+        # Get the deploy board
+        deploy_board = DeployBoard.objects.filter(
+            anchor=anchor, entity_name="project"
+        ).first()
+        # Check if the project is published
+        if not deploy_board:
+            return Response(
+                {"error": "Project is not published"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # get the asset id
+        asset = FileAsset.objects.get(id=pk, workspace=deploy_board.workspace)
+        storage = S3Storage(request=request)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if asset.storage_metadata is None:
+            asset.storage_metadata = storage.get_object_metadata(
+                object_name=asset.asset.name
+            )
+
+        # update the attributes
+        asset.attributes = request.data.get("attributes", asset.attributes)
+        # save the asset
+        asset.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def delete(self, request, anchor, pk):
+        # Get the deploy board
+        deploy_board = DeployBoard.objects.filter(
+            anchor=anchor, entity_name="project"
+        ).first()
+        # Check if the project is published
+        if not deploy_board:
+            return Response(
+                {"error": "Project is not published"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        # Get the asset
+        asset = FileAsset.objects.get(
+            id=pk,
+            workspace=deploy_board.workspace,
+            project_id=deploy_board.project_id,
+        )
+        # Check deleted assets
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        # Save the asset
+        asset.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class AssetRestoreEndpoint(BaseAPIView):
+    """Endpoint to restore a deleted assets."""
+
+    def post(self, request, anchor, asset_id):
+        # Get the deploy board
+        deploy_board = DeployBoard.objects.filter(
+            anchor=anchor, entity_name="project"
+        ).first()
+        # Check if the project is published
+        if not deploy_board:
+            return Response(
+                {"error": "Project is not published"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Get the asset
+        asset = FileAsset.all_objects.get(
+            id=asset_id, workspace=deploy_board.workspace
+        )
+        asset.is_deleted = False
+        asset.deleted_at = None
+        asset.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class EntityBulkAssetEndpoint(BaseAPIView):
+    """Endpoint to bulk update assets."""
+
+    def post(self, request, anchor, entity_id):
+        # Get the deploy board
+        deploy_board = DeployBoard.objects.filter(
+            anchor=anchor, entity_name="project"
+        ).first()
+        # Check if the project is published
+        if not deploy_board:
+            return Response(
+                {"error": "Project is not published"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        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=deploy_board.workspace,
+            project_id=deploy_board.project_id,
+        )
+
+        asset = assets.first()
+
+        # Check if the asset is uploaded
+        if not asset:
+            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
+            == FileAsset.EntityTypeContext.COMMENT_DESCRIPTION
+        ):
+            # update the attributes
+            assets.update(
+                comment_id=entity_id,
+            )
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/space/views/inbox.py

@@ -17,7 +17,7 @@ from plane.db.models import (
     Issue,
     State,
     IssueLink,
-    IssueAttachment,
+    FileAsset,
     DeployBoard,
 )
 from plane.app.serializers import (
@@ -95,8 +95,9 @@ class InboxIssuePublicViewSet(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"))

apiserver/plane/space/views/issue.py

@@ -19,7 +19,9 @@ from django.db.models import (
     Value,
     OuterRef,
     Func,
+    CharField,
 )
+from django.db.models.functions import Concat
 
 # Third Party imports
 from rest_framework.response import Response
@@ -59,7 +61,7 @@ from plane.db.models import (
     DeployBoard,
     IssueVote,
     ProjectPublicMember,
-    IssueAttachment,
+    FileAsset,
 )
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.utils.issue_filters import issue_filters
@@ -112,8 +114,9 @@ class ProjectIssuesPublicEndpoint(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"))
@@ -746,6 +749,26 @@ class IssueRetrievePublicEndpoint(BaseAPIView):
                                     first_name=F("votes__actor__first_name"),
                                     last_name=F("votes__actor__last_name"),
                                     avatar=F("votes__actor__avatar"),
+                                    avatar_url=Case(
+                                        When(
+                                            votes__actor__avatar_asset__isnull=False,
+                                            then=Concat(
+                                                Value(
+                                                    "/api/assets/v2/static/"
+                                                ),
+                                                F(
+                                                    "votes__actor__avatar_asset"
+                                                ),
+                                                Value("/"),
+                                            ),
+                                        ),
+                                        When(
+                                            votes__actor__avatar_asset__isnull=True,
+                                            then=F("votes__actor__avatar"),
+                                        ),
+                                        default=Value(None),
+                                        output_field=CharField(),
+                                    ),
                                     display_name=F(
                                         "votes__actor__display_name"
                                     ),
@@ -777,6 +800,26 @@ class IssueRetrievePublicEndpoint(BaseAPIView):
                                         "issue_reactions__actor__last_name"
                                     ),
                                     avatar=F("issue_reactions__actor__avatar"),
+                                    avatar_url=Case(
+                                        When(
+                                            votes__actor__avatar_asset__isnull=False,
+                                            then=Concat(
+                                                Value(
+                                                    "/api/assets/v2/static/"
+                                                ),
+                                                F(
+                                                    "votes__actor__avatar_asset"
+                                                ),
+                                                Value("/"),
+                                            ),
+                                        ),
+                                        When(
+                                            votes__actor__avatar_asset__isnull=True,
+                                            then=F("votes__actor__avatar"),
+                                        ),
+                                        default=Value(None),
+                                        output_field=CharField(),
+                                    ),
                                     display_name=F(
                                         "issue_reactions__actor__display_name"
                                     ),

apiserver/plane/utils/analytics_plot.py

@@ -138,7 +138,7 @@ def burndown_plot(
         estimate__type="points",
     ).exists()
     if estimate_type and plot_type == "points" and cycle_id:
-        issue_estimates = Issue.objects.filter(
+        issue_estimates = Issue.issue_objects.filter(
             workspace__slug=slug,
             project_id=project_id,
             issue_cycle__cycle_id=cycle_id,
@@ -149,7 +149,7 @@ def burndown_plot(
         total_estimate_points = sum(issue_estimates)
 
     if estimate_type and plot_type == "points" and module_id:
-        issue_estimates = Issue.objects.filter(
+        issue_estimates = Issue.issue_objects.filter(
             workspace__slug=slug,
             project_id=project_id,
             issue_module__module_id=module_id,

apiserver/plane/utils/paginator.py

@@ -150,7 +150,6 @@ class OffsetPaginator:
             raise BadPaginationError("Pagination offset cannot be negative")
 
         results = queryset[offset:stop]
-
         if cursor.value != limit:
             results = results[-(limit + 1) :]
 
@@ -761,7 +760,6 @@ class BasePaginator:
     ):
         """Paginate the request"""
         per_page = self.get_per_page(request, default_per_page, max_per_page)
-
         # Convert the cursor value to integer and float from string
         input_cursor = None
         try:

packages/editor/package.json

@@ -42,8 +42,6 @@
     "@tiptap/extension-blockquote": "^2.1.13",
     "@tiptap/extension-character-count": "^2.6.5",
     "@tiptap/extension-collaboration": "^2.3.2",
-    "@tiptap/extension-color": "^2.7.1",
-    "@tiptap/extension-highlight": "^2.7.1",
     "@tiptap/extension-image": "^2.1.13",
     "@tiptap/extension-list-item": "^2.1.13",
     "@tiptap/extension-mention": "^2.1.13",

packages/editor/src/core/components/editors/document/collaborative-read-only-editor.tsx

@@ -18,6 +18,7 @@ const CollaborativeDocumentReadOnlyEditor = (props: ICollaborativeDocumentReadOn
     displayConfig = DEFAULT_DISPLAY_CONFIG,
     editorClassName = "",
     embedHandler,
+    fileHandler,
     forwardedRef,
     handleEditorReady,
     id,
@@ -38,6 +39,7 @@ const CollaborativeDocumentReadOnlyEditor = (props: ICollaborativeDocumentReadOn
   const { editor, hasServerConnectionFailed, hasServerSynced } = useReadOnlyCollaborativeEditor({
     editorClassName,
     extensions,
+    fileHandler,
     forwardedRef,
     handleEditorReady,
     id,

packages/editor/src/core/components/editors/document/read-only-editor.tsx

@@ -10,7 +10,7 @@ import { getEditorClassNames } from "@/helpers/common";
 // hooks
 import { useReadOnlyEditor } from "@/hooks/use-read-only-editor";
 // types
-import { EditorReadOnlyRefApi, IMentionHighlight, TDisplayConfig } from "@/types";
+import { EditorReadOnlyRefApi, IMentionHighlight, TDisplayConfig, TFileHandler } from "@/types";
 
 interface IDocumentReadOnlyEditor {
   id: string;
@@ -19,6 +19,7 @@ interface IDocumentReadOnlyEditor {
   displayConfig?: TDisplayConfig;
   editorClassName?: string;
   embedHandler: any;
+  fileHandler: Pick<TFileHandler, "getAssetSrc">;
   tabIndex?: number;
   handleEditorReady?: (value: boolean) => void;
   mentionHandler: {
@@ -33,6 +34,7 @@ const DocumentReadOnlyEditor = (props: IDocumentReadOnlyEditor) => {
     displayConfig = DEFAULT_DISPLAY_CONFIG,
     editorClassName = "",
     embedHandler,
+    fileHandler,
     id,
     forwardedRef,
     handleEditorReady,
@@ -51,6 +53,7 @@ const DocumentReadOnlyEditor = (props: IDocumentReadOnlyEditor) => {
   const editor = useReadOnlyEditor({
     editorClassName,
     extensions,
+    fileHandler,
     forwardedRef,
     handleEditorReady,
     initialValue,

packages/editor/src/core/components/editors/read-only-editor-wrapper.tsx

@@ -14,14 +14,16 @@ export const ReadOnlyEditorWrapper = (props: IReadOnlyEditorProps) => {
     containerClassName,
     displayConfig = DEFAULT_DISPLAY_CONFIG,
     editorClassName = "",
+    fileHandler,
+    forwardedRef,
     id,
     initialValue,
-    forwardedRef,
     mentionHandler,
   } = props;
 
   const editor = useReadOnlyEditor({
     editorClassName,
+    fileHandler,
     forwardedRef,
     initialValue,
     mentionHandler,

packages/editor/src/core/components/menus/bubble-menu/color-selector.tsx

@@ -16,12 +16,8 @@ type Props = {
 export const BubbleMenuColorSelector: FC<Props> = (props) => {
   const { editor, isOpen, setIsOpen } = props;
 
-  const activeTextColor = COLORS_LIST.find((c) => editor.getAttributes("textStyle").color === c.textColor);
-  const activeBackgroundColor = COLORS_LIST.find((c) =>
-    editor.isActive("highlight", {
-      color: c.backgroundColor,
-    })
-  );
+  const activeTextColor = COLORS_LIST.find((c) => editor.getAttributes("textStyle").color === c.key);
+  const activeBackgroundColor = COLORS_LIST.find((c) => editor.getAttributes("textStyle").backgroundColor === c.key);
 
   return (
     <div className="relative h-full">
@@ -41,25 +37,17 @@ export const BubbleMenuColorSelector: FC<Props> = (props) => {
               "bg-custom-background-100": !activeBackgroundColor,
             }
           )}
-          style={
-            activeBackgroundColor
-              ? {
-                  backgroundColor: activeBackgroundColor.backgroundColor,
-                }
-              : {}
-          }
+          style={{
+            backgroundColor: activeBackgroundColor ? activeBackgroundColor.backgroundColor : "transparent",
+          }}
         >
           <ALargeSmall
             className={cn("size-3.5", {
               "text-custom-text-100": !activeTextColor,
             })}
-            style={
-              activeTextColor
-                ? {
-                    color: activeTextColor.textColor,
-                  }
-                : {}
-            }
+            style={{
+              color: activeTextColor ? activeTextColor.textColor : "inherit",
+            }}
           />
         </span>
       </button>
@@ -70,13 +58,13 @@ export const BubbleMenuColorSelector: FC<Props> = (props) => {
             <div className="flex items-center gap-2">
               {COLORS_LIST.map((color) => (
                 <button
-                  key={color.textColor}
+                  key={color.key}
                   type="button"
                   className="flex-shrink-0 size-6 rounded border-[0.5px] border-custom-border-400 hover:opacity-60 transition-opacity"
                   style={{
                     backgroundColor: color.textColor,
                   }}
-                  onClick={() => TextColorItem(editor).command(color.textColor)}
+                  onClick={() => TextColorItem(editor).command(color.key)}
                 />
               ))}
               <button
@@ -93,13 +81,13 @@ export const BubbleMenuColorSelector: FC<Props> = (props) => {
             <div className="flex items-center gap-2">
               {COLORS_LIST.map((color) => (
                 <button
-                  key={color.backgroundColor}
+                  key={color.key}
                   type="button"
                   className="flex-shrink-0 size-6 rounded border-[0.5px] border-custom-border-400 hover:opacity-60 transition-opacity"
                   style={{
                     backgroundColor: color.backgroundColor,
                   }}
-                  onClick={() => BackgroundColorItem(editor).command(color.backgroundColor)}
+                  onClick={() => BackgroundColorItem(editor).command(color.key)}
                 />
               ))}
               <button

packages/editor/src/core/components/menus/menu-items.ts

@@ -219,7 +219,7 @@ export const TextColorItem = (editor: Editor): EditorMenuItem => ({
 export const BackgroundColorItem = (editor: Editor): EditorMenuItem => ({
   key: "background-color",
   name: "Background color",
-  isActive: (color) => editor.isActive("highlight", { color }),
+  isActive: (color) => editor.getAttributes("textStyle").backgroundColor === color,
   command: (color: string) => toggleBackgroundColor(color, editor),
   icon: Palette,
 });

packages/editor/src/core/constants/common.ts

@@ -1,51 +1,61 @@
 export const COLORS_LIST: {
-  backgroundColor: string;
-  textColor: string;
+  key: string;
   label: string;
+  textColor: string;
+  backgroundColor: string;
 }[] = [
-  // {
-  //   backgroundColor: "#1c202426",
-  //   textColor: "#1c2024",
-  //   label: "Black",
-  // },
   {
-    backgroundColor: "#5c5e6326",
-    textColor: "#5c5e63",
+    key: "gray",
     label: "Gray",
+    textColor: "var(--editor-colors-gray-text)",
+    backgroundColor: "var(--editor-colors-gray-background)",
   },
   {
-    backgroundColor: "#ff5b5926",
-    textColor: "#ff5b59",
+    key: "peach",
     label: "Peach",
+    textColor: "var(--editor-colors-peach-text)",
+    backgroundColor: "var(--editor-colors-peach-background)",
   },
   {
-    backgroundColor: "#f6538526",
-    textColor: "#f65385",
+    key: "pink",
     label: "Pink",
+    textColor: "var(--editor-colors-pink-text)",
+    backgroundColor: "var(--editor-colors-pink-background)",
   },
   {
-    backgroundColor: "#fd903826",
-    textColor: "#fd9038",
+    key: "orange",
     label: "Orange",
+    textColor: "var(--editor-colors-orange-text)",
+    backgroundColor: "var(--editor-colors-orange-background)",
   },
   {
-    backgroundColor: "#0fc27b26",
-    textColor: "#0fc27b",
+    key: "green",
     label: "Green",
+    textColor: "var(--editor-colors-green-text)",
+    backgroundColor: "var(--editor-colors-green-background)",
   },
   {
-    backgroundColor: "#17bee926",
-    textColor: "#17bee9",
+    key: "light-blue",
     label: "Light blue",
+    textColor: "var(--editor-colors-light-blue-text)",
+    backgroundColor: "var(--editor-colors-light-blue-background)",
   },
   {
-    backgroundColor: "#266df026",
-    textColor: "#266df0",
+    key: "dark-blue",
     label: "Dark blue",
+    textColor: "var(--editor-colors-dark-blue-text)",
+    backgroundColor: "var(--editor-colors-dark-blue-background)",
   },
   {
-    backgroundColor: "#9162f926",
-    textColor: "#9162f9",
+    key: "purple",
     label: "Purple",
+    textColor: "var(--editor-colors-purple-text)",
+    backgroundColor: "var(--editor-colors-purple-background)",
   },
+  // {
+  //   key: "pink-blue-gradient",
+  //   label: "Pink blue gradient",
+  //   textColor: "var(--editor-colors-pink-blue-gradient-text)",
+  //   backgroundColor: "var(--editor-colors-pink-blue-gradient-background)",
+  // },
 ];

packages/editor/src/core/extensions/core-without-props.ts

@@ -1,5 +1,3 @@
-import { Color } from "@tiptap/extension-color";
-import Highlight from "@tiptap/extension-highlight";
 import TaskItem from "@tiptap/extension-task-item";
 import TaskList from "@tiptap/extension-task-list";
 import TextStyle from "@tiptap/extension-text-style";
@@ -18,6 +16,8 @@ import { IssueWidgetWithoutProps } from "./issue-embed/issue-embed-without-props
 import { CustomMentionWithoutProps } from "./mentions/mentions-without-props";
 import { CustomQuoteExtension } from "./quote";
 import { TableHeader, TableCell, TableRow, Table } from "./table";
+import { CustomTextColorExtension } from "./custom-text-color";
+import { CustomBackgroundColorExtension } from "./custom-background-color";
 
 export const CoreEditorExtensionsWithoutProps = [
   StarterKit.configure({
@@ -85,10 +85,8 @@ export const CoreEditorExtensionsWithoutProps = [
   TableCell,
   TableRow,
   CustomMentionWithoutProps(),
-  Color,
-  Highlight.configure({
-    multicolor: true,
-  }),
+  CustomTextColorExtension,
+  CustomBackgroundColorExtension,
 ];
 
 export const DocumentEditorExtensionsWithoutProps = [IssueWidgetWithoutProps()];

packages/editor/src/core/extensions/custom-background-color.ts

@@ -0,0 +1,78 @@
+import { Extension } from "@tiptap/core";
+// constants
+import { COLORS_LIST } from "@/constants/common";
+
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    backgroundColor: {
+      /**
+       * Set the background color
+       * @param color The color to set
+       * @example editor.commands.setBackgroundColor('red')
+       */
+      setBackgroundColor: (color: string) => ReturnType;
+
+      /**
+       * Unset the background color
+       * @example editor.commands.unsetBackgroundColor()
+       */
+      unsetBackgroundColor: () => ReturnType;
+    };
+  }
+}
+
+export const CustomBackgroundColorExtension = Extension.create({
+  name: "customBackgroundColor",
+
+  addOptions() {
+    return {
+      types: ["textStyle"],
+    };
+  },
+
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          backgroundColor: {
+            default: null,
+            parseHTML: (element: HTMLElement) => element.getAttribute("data-background-color"),
+            renderHTML: (attributes: { backgroundColor: string }) => {
+              const { backgroundColor } = attributes;
+              if (!backgroundColor) {
+                return {};
+              }
+
+              let elementAttributes: Record<string, string> = {
+                "data-background-color": backgroundColor,
+              };
+
+              if (!COLORS_LIST.find((c) => c.key === backgroundColor)) {
+                elementAttributes = {
+                  ...elementAttributes,
+                  style: `background-color: ${backgroundColor}`,
+                };
+              }
+
+              return elementAttributes;
+            },
+          },
+        },
+      },
+    ];
+  },
+
+  addCommands() {
+    return {
+      setBackgroundColor:
+        (backgroundColor: string) =>
+        ({ chain }) =>
+          chain().setMark("textStyle", { backgroundColor }).run(),
+      unsetBackgroundColor:
+        () =>
+        ({ chain }) =>
+          chain().setMark("textStyle", { backgroundColor: null }).run(),
+    };
+  },
+});

packages/editor/src/core/extensions/custom-image/components/image-block.tsx

@@ -42,6 +42,7 @@ type CustomImageBlockProps = CustomImageNodeViewProps & {
   setFailedToLoadImage: (isError: boolean) => void;
   editorContainer: HTMLDivElement | null;
   setEditorContainer: (editorContainer: HTMLDivElement | null) => void;
+  src: string;
 };
 
 export const CustomImageBlock: React.FC<CustomImageBlockProps> = (props) => {
@@ -55,9 +56,10 @@ export const CustomImageBlock: React.FC<CustomImageBlockProps> = (props) => {
     getPos,
     editor,
     editorContainer,
+    src: remoteImageSrc,
     setEditorContainer,
   } = props;
-  const { src: remoteImageSrc, width, height, aspectRatio } = node.attrs;
+  const { width, height, aspectRatio } = node.attrs;
   // states
   const [size, setSize] = useState<Size>({
     width: ensurePixelString(width, "35%"),
@@ -206,7 +208,7 @@ export const CustomImageBlock: React.FC<CustomImageBlockProps> = (props) => {
   // show the image resizer only if the editor is editable, the remote image's (post upload) src is set and the initial resize is complete (but not while we're showing the preview imageFromFileSystem)
   const showImageResizer = editor.isEditable && remoteImageSrc && initialResizeComplete;
   // show the preview image from the file system if the remote image's src is not set
-  const displayedImageSrc = remoteImageSrc ?? imageFromFileSystem;
+  const displayedImageSrc = remoteImageSrc || imageFromFileSystem;
 
   return (
     <div

packages/editor/src/core/extensions/custom-image/components/image-node.tsx

@@ -54,6 +54,8 @@ export const CustomImageNode = (props: CustomImageNodeViewProps) => {
             imageFromFileSystem={imageFromFileSystem}
             editorContainer={editorContainer}
             editor={editor}
+            // @ts-expect-error function not expected here, but will still work
+            src={editor?.commands?.getImageSource?.(node.attrs.src)}
             getPos={getPos}
             node={node}
             setEditorContainer={setEditorContainer}
@@ -67,6 +69,7 @@ export const CustomImageNode = (props: CustomImageNodeViewProps) => {
             failedToLoadImage={failedToLoadImage}
             getPos={getPos}
             loadImageFromFileSystem={setImageFromFileSystem}
+            maxFileSize={editor.storage.imageComponent.maxFileSize}
             node={node}
             setIsUploaded={setIsUploaded}
             selected={selected}

packages/editor/src/core/extensions/custom-image/components/image-uploader.tsx

@@ -10,33 +10,34 @@ import { useUploader, useDropZone, uploadFirstImageAndInsertRemaining } from "@/
 import { getImageComponentImageFileMap, ImageAttributes } from "@/extensions/custom-image";
 
 export const CustomImageUploader = (props: {
-  failedToLoadImage: boolean;
   editor: Editor;
-  selected: boolean;
+  failedToLoadImage: boolean;
+  getPos: () => number;
   loadImageFromFileSystem: (file: string) => void;
-  setIsUploaded: (isUploaded: boolean) => void;
+  maxFileSize: number;
   node: ProsemirrorNode & {
     attrs: ImageAttributes;
   };
+  selected: boolean;
+  setIsUploaded: (isUploaded: boolean) => void;
   updateAttributes: (attrs: Record<string, any>) => void;
-  getPos: () => number;
 }) => {
   const {
-    selected,
-    failedToLoadImage,
     editor,
+    failedToLoadImage,
+    getPos,
     loadImageFromFileSystem,
+    maxFileSize,
     node,
+    selected,
     setIsUploaded,
     updateAttributes,
-    getPos,
   } = props;
-  // ref
+  // refs
   const fileInputRef = useRef<HTMLInputElement>(null);
-
   const hasTriggeredFilePickerRef = useRef(false);
+  // derived values
   const imageEntityId = node.attrs.id;
-
   const imageComponentImageFileMap = useMemo(() => getImageComponentImageFileMap(editor), [editor]);
 
   const onUpload = useCallback(
@@ -71,11 +72,17 @@ export const CustomImageUploader = (props: {
     [imageComponentImageFileMap, imageEntityId, updateAttributes, getPos]
   );
   // hooks
-  const { uploading: isImageBeingUploaded, uploadFile } = useUploader({ onUpload, editor, loadImageFromFileSystem });
-  const { draggedInside, onDrop, onDragEnter, onDragLeave } = useDropZone({
-    uploader: uploadFile,
+  const { uploading: isImageBeingUploaded, uploadFile } = useUploader({
     editor,
+    loadImageFromFileSystem,
+    maxFileSize,
+    onUpload,
+  });
+  const { draggedInside, onDrop, onDragEnter, onDragLeave } = useDropZone({
+    editor,
+    maxFileSize,
     pos: getPos(),
+    uploader: uploadFile,
   });
 
   // the meta data of the image component
@@ -102,11 +109,17 @@ export const CustomImageUploader = (props: {
   const onFileChange = useCallback(
     async (e: ChangeEvent<HTMLInputElement>) => {
       e.preventDefault();
-      const fileList = e.target.files;
-      if (!fileList) {
+      const filesList = e.target.files;
+      if (!filesList) {
         return;
       }
-      await uploadFirstImageAndInsertRemaining(editor, fileList, getPos(), uploadFile);
+      await uploadFirstImageAndInsertRemaining({
+        editor,
+        filesList,
+        maxFileSize,
+        pos: getPos(),
+        uploader: uploadFile,
+      });
     },
     [uploadFile, editor, getPos]
   );

packages/editor/src/core/extensions/custom-image/custom-image.ts

@@ -22,6 +22,7 @@ declare module "@tiptap/core" {
     imageComponent: {
       insertImageComponent: ({ file, pos, event }: InsertImageComponentProps) => ReturnType;
       uploadImage: (file: File) => () => Promise<string> | undefined;
+      getImageSource?: (path: string) => () => string;
     };
   }
 }
@@ -36,7 +37,13 @@ export interface UploadImageExtensionStorage {
 export type UploadEntity = ({ event: "insert" } | { event: "drop"; file: File }) & { hasOpenedFileInputOnce?: boolean };
 
 export const CustomImageExtension = (props: TFileHandler) => {
-  const { upload, delete: deleteImage, restore: restoreImage } = props;
+  const {
+    getAssetSrc,
+    upload,
+    delete: deleteImage,
+    restore: restoreImage,
+    validation: { maxFileSize },
+  } = props;
 
   return Image.extend<Record<string, unknown>, UploadImageExtensionStorage>({
     name: "imageComponent",
@@ -87,8 +94,7 @@ export const CustomImageExtension = (props: TFileHandler) => {
       });
       imageSources.forEach(async (src) => {
         try {
-          const assetUrlWithWorkspaceId = new URL(src).pathname.substring(1);
-          await restoreImage(assetUrlWithWorkspaceId);
+          await restoreImage(src);
         } catch (error) {
           console.error("Error restoring image: ", error);
         }
@@ -114,6 +120,7 @@ export const CustomImageExtension = (props: TFileHandler) => {
         fileMap: new Map(),
         deletedImageSet: new Map<string, boolean>(),
         uploadInProgress: false,
+        maxFileSize,
       };
     },
 
@@ -123,7 +130,13 @@ export const CustomImageExtension = (props: TFileHandler) => {
           (props: { file?: File; pos?: number; event: "insert" | "drop" }) =>
           ({ commands }) => {
             // Early return if there's an invalid file being dropped
-            if (props?.file && !isFileValid(props.file)) {
+            if (
+              props?.file &&
+              !isFileValid({
+                file: props.file,
+                maxFileSize,
+              })
+            ) {
               return false;
             }
 
@@ -166,6 +179,7 @@ export const CustomImageExtension = (props: TFileHandler) => {
           const fileUrl = await upload(file);
           return fileUrl;
         },
+        getImageSource: (path: string) => () => getAssetSrc(path),
       };
     },
 

packages/editor/src/core/extensions/custom-image/read-only-custom-image.ts

@@ -3,9 +3,13 @@ import { Image } from "@tiptap/extension-image";
 import { ReactNodeViewRenderer } from "@tiptap/react";
 // components
 import { CustomImageNode, UploadImageExtensionStorage } from "@/extensions/custom-image";
+// types
+import { TFileHandler } from "@/types";
 
-export const CustomReadOnlyImageExtension = () =>
-  Image.extend<Record<string, unknown>, UploadImageExtensionStorage>({
+export const CustomReadOnlyImageExtension = (props: Pick<TFileHandler, "getAssetSrc">) => {
+  const { getAssetSrc } = props;
+
+  return Image.extend<Record<string, unknown>, UploadImageExtensionStorage>({
     name: "imageComponent",
     selectable: false,
     group: "block",
@@ -51,7 +55,14 @@ export const CustomReadOnlyImageExtension = () =>
       };
     },
 
+    addCommands() {
+      return {
+        getImageSource: (path: string) => () => getAssetSrc(path),
+      };
+    },
+
     addNodeView() {
       return ReactNodeViewRenderer(CustomImageNode);
     },
   });
+};

packages/editor/src/core/extensions/custom-text-color.ts

@@ -0,0 +1,78 @@
+import { Extension } from "@tiptap/core";
+// constants
+import { COLORS_LIST } from "@/constants/common";
+
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    color: {
+      /**
+       * Set the text color
+       * @param color The color to set
+       * @example editor.commands.setColor('red')
+       */
+      setTextColor: (color: string) => ReturnType;
+
+      /**
+       * Unset the text color
+       * @example editor.commands.unsetColor()
+       */
+      unsetTextColor: () => ReturnType;
+    };
+  }
+}
+
+export const CustomTextColorExtension = Extension.create({
+  name: "customTextColor",
+
+  addOptions() {
+    return {
+      types: ["textStyle"],
+    };
+  },
+
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          color: {
+            default: null,
+            parseHTML: (element: HTMLElement) => element.getAttribute("data-text-color"),
+            renderHTML: (attributes: { color: string }) => {
+              const { color } = attributes;
+              if (!color) {
+                return {};
+              }
+
+              let elementAttributes: Record<string, string> = {
+                "data-text-color": color,
+              };
+
+              if (!COLORS_LIST.find((c) => c.key === color)) {
+                elementAttributes = {
+                  ...elementAttributes,
+                  style: `color: ${color}`,
+                };
+              }
+
+              return elementAttributes;
+            },
+          },
+        },
+      },
+    ];
+  },
+
+  addCommands() {
+    return {
+      setTextColor:
+        (color: string) =>
+        ({ chain }) =>
+          chain().setMark("textStyle", { color }).run(),
+      unsetTextColor:
+        () =>
+        ({ chain }) =>
+          chain().setMark("textStyle", { color: null }).run(),
+    };
+  },
+});

packages/editor/src/core/extensions/extensions.tsx

@@ -1,6 +1,4 @@
 import CharacterCount from "@tiptap/extension-character-count";
-import { Color } from "@tiptap/extension-color";
-import Highlight from "@tiptap/extension-highlight";
 import Placeholder from "@tiptap/extension-placeholder";
 import TaskItem from "@tiptap/extension-task-item";
 import TaskList from "@tiptap/extension-task-list";
@@ -10,6 +8,7 @@ import StarterKit from "@tiptap/starter-kit";
 import { Markdown } from "tiptap-markdown";
 // extensions
 import {
+  CustomBackgroundColorExtension,
   CustomCodeBlockExtension,
   CustomCodeInlineExtension,
   CustomCodeMarkPlugin,
@@ -19,6 +18,7 @@ import {
   CustomLinkExtension,
   CustomMention,
   CustomQuoteExtension,
+  CustomTextColorExtension,
   CustomTypographyExtension,
   DropHandlerExtension,
   ImageExtension,
@@ -31,16 +31,11 @@ import {
 // helpers
 import { isValidHttpUrl } from "@/helpers/common";
 // types
-import { DeleteImage, IMentionHighlight, IMentionSuggestion, RestoreImage, UploadImage } from "@/types";
+import { IMentionHighlight, IMentionSuggestion, TFileHandler } from "@/types";
 
 type TArguments = {
   enableHistory: boolean;
-  fileConfig: {
-    deleteFile: DeleteImage;
-    restoreFile: RestoreImage;
-    cancelUploadImage?: () => void;
-    uploadFile: UploadImage;
-  };
+  fileHandler: TFileHandler;
   mentionConfig: {
     mentionSuggestions?: () => Promise<IMentionSuggestion[]>;
     mentionHighlights?: () => Promise<IMentionHighlight[]>;
@@ -49,127 +44,118 @@ type TArguments = {
   tabIndex?: number;
 };
 
-export const CoreEditorExtensions = ({
-  enableHistory,
-  fileConfig: { deleteFile, restoreFile, cancelUploadImage, uploadFile },
-  mentionConfig,
-  placeholder,
-  tabIndex,
-}: TArguments) => [
-  StarterKit.configure({
-    bulletList: {
-      HTMLAttributes: {
-        class: "list-disc pl-7 space-y-2",
+export const CoreEditorExtensions = (args: TArguments) => {
+  const { enableHistory, fileHandler, mentionConfig, placeholder, tabIndex } = args;
+
+  return [
+    StarterKit.configure({
+      bulletList: {
+        HTMLAttributes: {
+          class: "list-disc pl-7 space-y-2",
+        },
       },
-    },
-    orderedList: {
-      HTMLAttributes: {
-        class: "list-decimal pl-7 space-y-2",
+      orderedList: {
+        HTMLAttributes: {
+          class: "list-decimal pl-7 space-y-2",
+        },
       },
-    },
-    listItem: {
-      HTMLAttributes: {
-        class: "not-prose space-y-2",
+      listItem: {
+        HTMLAttributes: {
+          class: "not-prose space-y-2",
+        },
       },
-    },
-    code: false,
-    codeBlock: false,
-    horizontalRule: false,
-    blockquote: false,
-    dropcursor: {
-      class: "text-custom-text-300",
-    },
-    ...(enableHistory ? {} : { history: false }),
-  }),
-  CustomQuoteExtension,
-  DropHandlerExtension(),
-  CustomHorizontalRule.configure({
-    HTMLAttributes: {
-      class: "my-4 border-custom-border-400",
-    },
-  }),
-  CustomKeymap,
-  ListKeymap({ tabIndex }),
-  CustomLinkExtension.configure({
-    openOnClick: true,
-    autolink: true,
-    linkOnPaste: true,
-    protocols: ["http", "https"],
-    validate: (url: string) => isValidHttpUrl(url),
-    HTMLAttributes: {
-      class:
-        "text-custom-primary-300 underline underline-offset-[3px] hover:text-custom-primary-500 transition-colors cursor-pointer",
-    },
-  }),
-  CustomTypographyExtension,
-  ImageExtension(deleteFile, restoreFile, cancelUploadImage).configure({
-    HTMLAttributes: {
-      class: "rounded-md",
-    },
-  }),
-  CustomImageExtension({
-    delete: deleteFile,
-    restore: restoreFile,
-    upload: uploadFile,
-    cancel: cancelUploadImage ?? (() => {}),
-  }),
-  TiptapUnderline,
-  TextStyle,
-  TaskList.configure({
-    HTMLAttributes: {
-      class: "not-prose pl-2 space-y-2",
-    },
-  }),
-  TaskItem.configure({
-    HTMLAttributes: {
-      class: "relative",
-    },
-    nested: true,
-  }),
-  CustomCodeBlockExtension.configure({
-    HTMLAttributes: {
-      class: "",
-    },
-  }),
-  CustomCodeMarkPlugin,
-  CustomCodeInlineExtension,
-  Markdown.configure({
-    html: true,
-    transformPastedText: true,
-    breaks: true,
-  }),
-  Table,
-  TableHeader,
-  TableCell,
-  TableRow,
-  CustomMention({
-    mentionSuggestions: mentionConfig.mentionSuggestions,
-    mentionHighlights: mentionConfig.mentionHighlights,
-    readonly: false,
-  }),
-  Placeholder.configure({
-    placeholder: ({ editor, node }) => {
-      if (node.type.name === "heading") return `Heading ${node.attrs.level}`;
+      code: false,
+      codeBlock: false,
+      horizontalRule: false,
+      blockquote: false,
+      dropcursor: {
+        class: "text-custom-text-300",
+      },
+      ...(enableHistory ? {} : { history: false }),
+    }),
+    CustomQuoteExtension,
+    DropHandlerExtension(),
+    CustomHorizontalRule.configure({
+      HTMLAttributes: {
+        class: "my-4 border-custom-border-400",
+      },
+    }),
+    CustomKeymap,
+    ListKeymap({ tabIndex }),
+    CustomLinkExtension.configure({
+      openOnClick: true,
+      autolink: true,
+      linkOnPaste: true,
+      protocols: ["http", "https"],
+      validate: (url: string) => isValidHttpUrl(url),
+      HTMLAttributes: {
+        class:
+          "text-custom-primary-300 underline underline-offset-[3px] hover:text-custom-primary-500 transition-colors cursor-pointer",
+      },
+    }),
+    CustomTypographyExtension,
+    ImageExtension(fileHandler).configure({
+      HTMLAttributes: {
+        class: "rounded-md",
+      },
+    }),
+    CustomImageExtension(fileHandler),
+    TiptapUnderline,
+    TextStyle,
+    TaskList.configure({
+      HTMLAttributes: {
+        class: "not-prose pl-2 space-y-2",
+      },
+    }),
+    TaskItem.configure({
+      HTMLAttributes: {
+        class: "relative",
+      },
+      nested: true,
+    }),
+    CustomCodeBlockExtension.configure({
+      HTMLAttributes: {
+        class: "",
+      },
+    }),
+    CustomCodeMarkPlugin,
+    CustomCodeInlineExtension,
+    Markdown.configure({
+      html: true,
+      transformPastedText: true,
+      breaks: true,
+    }),
+    Table,
+    TableHeader,
+    TableCell,
+    TableRow,
+    CustomMention({
+      mentionSuggestions: mentionConfig.mentionSuggestions,
+      mentionHighlights: mentionConfig.mentionHighlights,
+      readonly: false,
+    }),
+    Placeholder.configure({
+      placeholder: ({ editor, node }) => {
+        if (node.type.name === "heading") return `Heading ${node.attrs.level}`;
 
-      if (editor.storage.imageComponent.uploadInProgress) return "";
+        if (editor.storage.imageComponent.uploadInProgress) return "";
 
-      const shouldHidePlaceholder =
-        editor.isActive("table") || editor.isActive("codeBlock") || editor.isActive("image");
+        const shouldHidePlaceholder =
+          editor.isActive("table") || editor.isActive("codeBlock") || editor.isActive("image");
 
-      if (shouldHidePlaceholder) return "";
+        if (shouldHidePlaceholder) return "";
 
-      if (placeholder) {
-        if (typeof placeholder === "string") return placeholder;
-        else return placeholder(editor.isFocused, editor.getHTML());
-      }
+        if (placeholder) {
+          if (typeof placeholder === "string") return placeholder;
+          else return placeholder(editor.isFocused, editor.getHTML());
+        }
 
-      return "Press '/' for commands...";
-    },
-    includeChildren: true,
-  }),
-  CharacterCount,
-  Color,
-  Highlight.configure({
-    multicolor: true,
-  }),
-];
+        return "Press '/' for commands...";
+      },
+      includeChildren: true,
+    }),
+    CharacterCount,
+    CustomTextColorExtension,
+    CustomBackgroundColorExtension,
+  ];
+};