fix: playwright setup

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

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

.github/workflows/build-branch.yml

@@ -1,45 +1,29 @@
-name: Branch Build CE
+name: Branch Build
 
 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
+  push:
+    branches:
+      - master
+      - preview
+  release:
+    types: [released, prereleased]
 
 env:
-  TARGET_BRANCH: ${{ github.ref_name }}
+  TARGET_BRANCH: ${{ github.ref_name || github.event.release.target_commitish }}
   ARM64_BUILD: ${{ github.event.inputs.arm64 }}
-  BUILD_TYPE: ${{ github.event.inputs.build_type }}
-  RELEASE_VERSION: ${{ github.event.inputs.releaseVersion }}
-  IS_PRERELEASE: ${{ github.event.inputs.isPrerelease }}
+  IS_PRERELEASE: ${{ github.event.release.prerelease }}
 
 jobs:
   branch_build_setup:
     name: Build Setup
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     outputs:
       gh_branch_name: ${{ steps.set_env_variables.outputs.TARGET_BRANCH }}
       gh_buildx_driver: ${{ steps.set_env_variables.outputs.BUILDX_DRIVER }}
@@ -52,24 +36,13 @@ 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 }}
-
-      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 }}
+      flat_branch_name: ${{ steps.set_env_variables.outputs.FLAT_BRANCH_NAME }}
 
     steps:
       - id: set_env_variables
         name: Set Environment Variables
         run: |
-          if [ "${{ env.ARM64_BUILD }}" == "true" ] || ([ "${{ env.BUILD_TYPE }}" == "Release" ] && [ "${{ env.IS_PRERELEASE }}" != "true" ]); then
+          if [ "${{ env.TARGET_BRANCH }}" == "master" ] || [ "${{ env.ARM64_BUILD }}" == "true" ] || ([ "${{ github.event_name }}" == "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
@@ -80,43 +53,9 @@ jobs:
             echo "BUILDX_PLATFORMS=linux/amd64" >> $GITHUB_OUTPUT
             echo "BUILDX_ENDPOINT=" >> $GITHUB_OUTPUT
           fi
-          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
+          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
 
       - id: checkout_files
         name: Checkout Files
@@ -134,24 +73,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/**
@@ -160,224 +99,338 @@ jobs:
               - 'tsconfig.json'
               - 'turbo.json'
 
-  branch_build_push_admin:
-    if: ${{ needs.branch_build_setup.outputs.build_admin == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
-    name: Build-Push Admin Docker Image
-    runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
-    steps:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
-      - name: Admin 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_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' }}
+    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:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
-      - name: Web Build and Push
-        uses: ./.github/actions/buildpush-action
+      - 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:
-          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 }}
+          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' }}
+    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
+        uses: actions/checkout@v4
+
+      - name: Build and Push Frontend to Docker Container Registry
+        uses: docker/build-push-action@v5.1.0
+        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 }}
 
   branch_build_push_space:
-    if: ${{ needs.branch_build_setup.outputs.build_space == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    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' }}
     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:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
-      - name: Space 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_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 }}
+      - 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
 
-  branch_build_push_live:
-    if: ${{ needs.branch_build_setup.outputs.build_live == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
-    name: Build-Push Live Collaboration Docker Image
-    runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
-    steps:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
-      - name: Live Build and Push
-        uses: ./.github/actions/buildpush-action
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
         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_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 }}
+          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 Space to Docker Hub
+        uses: docker/build-push-action@v5.1.0
+        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' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    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:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
-      - name: Backend Build and Push
-        uses: ./.github/actions/buildpush-action
+      - 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:
-          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 }}
+          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 }}
+
+  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' }}
+    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
+        uses: actions/checkout@v4
+
+      - name: Build and Push Live Server to Docker Hub
+        uses: docker/build-push-action@v5.1.0
+        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 }}
 
   branch_build_push_proxy:
-    if: ${{ needs.branch_build_setup.outputs.build_proxy == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    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' }}
     name: Build-Push Proxy Docker Image
     runs-on: ubuntu-20.04
     needs: [branch_build_setup]
-    steps:
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
-      - name: Proxy 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_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 }}
-
-  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: Update Assets
-        run: |
-          cp ./deploy/selfhost/install.sh deploy/selfhost/setup.sh
-
-      - name: Attach Assets
-        id: attach_assets
-        uses: actions/upload-artifact@v4
-        with:
-          name: selfhost-assets
-          retention-days: 2
-          path: |
-            ${{ github.workspace }}/deploy/selfhost/setup.sh
-            ${{ github.workspace }}/deploy/selfhost/restore.sh
-            ${{ github.workspace }}/deploy/selfhost/docker-compose.yml
-            ${{ github.workspace }}/deploy/selfhost/variables.env
- 
-  publish_release:
-    if: ${{ needs.branch_build_setup.outputs.build_type == 'Release' }}
-    name: Build Release
-    runs-on: ubuntu-20.04
-    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 }}
+      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: Checkout
+      - 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
+        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: 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:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
+      - name: Build and Push Plane-Proxy to Docker Hub
+        uses: docker/build-push-action@v5.1.0
         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
+          context: ./nginx
+          file: ./nginx/Dockerfile
+          platforms: ${{ env.BUILDX_PLATFORMS }}
+          tags: ${{ env.PROXY_TAG }}
+          push: true
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}

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

@@ -5,13 +5,11 @@ 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";
-// helpers
-import { API_BASE_URL, cn } from "@/helpers/common.helper";
-import { getFileURL } from "@/helpers/file.helper";
 // hooks
+import { API_BASE_URL, cn } from "@/helpers/common.helper";
 import { useTheme, useUser } from "@/hooks/store";
+// helpers
 // services
 import { AuthService } from "@/services/auth.service";
 
@@ -124,7 +122,7 @@ export const SidebarDropdown = observer(() => {
           <Menu.Button className="grid place-items-center outline-none">
             <Avatar
               name={currentUser.display_name}
-              src={getFileURL(currentUser.avatar_url)}
+              src={currentUser.avatar ?? undefined}
               size={24}
               shape="square"
               className="!text-base"

admin/helpers/file.helper.ts

@@ -1,14 +0,0 @@
-// 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

@@ -1,21 +0,0 @@
-/**
- * @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

@@ -1,6 +1,6 @@
 {
   "name": "admin",
-  "version": "0.23.1",
+  "version": "0.23.0",
   "private": true,
   "scripts": {
     "dev": "turbo run develop",
@@ -22,6 +22,7 @@
     "@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",
@@ -40,6 +41,7 @@
   "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/package.json

@@ -1,4 +1,4 @@
 {
   "name": "plane-api",
-  "version": "0.23.1"
+  "version": "0.23.0"
 }

apiserver/plane/api/serializers/__init__.py

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

apiserver/plane/api/serializers/project.py

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

apiserver/plane/api/serializers/user.py

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

apiserver/plane/api/views/cycle.py

@@ -13,12 +13,8 @@ from django.db.models import (
     Q,
     Sum,
     FloatField,
-    Case,
-    When,
-    Value,
 )
-from django.db.models.functions import Cast, Concat
-from django.db import models
+from django.db.models.functions import Cast
 
 # Third party imports
 from rest_framework import status
@@ -36,7 +32,7 @@ from plane.db.models import (
     CycleIssue,
     Issue,
     Project,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
     ProjectMember,
     UserFavorite,
@@ -211,7 +207,8 @@ class CycleAPIEndpoint(BaseAPIView):
         # Incomplete Cycles
         if cycle_view == "incomplete":
             queryset = queryset.filter(
-                Q(end_date__gte=timezone.now()) | Q(end_date__isnull=True),
+                Q(end_date__gte=timezone.now())
+                | Q(end_date__isnull=True),
             )
             return self.paginate(
                 request=request,
@@ -312,7 +309,10 @@ class CycleAPIEndpoint(BaseAPIView):
 
         request_data = request.data
 
-        if cycle.end_date is not None and cycle.end_date < timezone.now():
+        if (
+            cycle.end_date is not None
+            and cycle.end_date < timezone.now()
+        ):
             if "sort_order" in request_data:
                 # Can only change sort order
                 request_data = {
@@ -645,9 +645,8 @@ class CycleIssueAPIEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -888,27 +887,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                 .annotate(display_name=F("assignees__display_name"))
                 .annotate(assignee_id=F("assignees__id"))
                 .annotate(avatar=F("assignees__avatar"))
-                .annotate(
-                    avatar_url=Case(
-                        # If `avatar_asset` exists, use it to generate the asset URL
-                        When(
-                            assignees__avatar_asset__isnull=False,
-                            then=Concat(
-                                Value("/api/assets/v2/static/"),
-                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                                Value("/"),
-                            ),
-                        ),
-                        # If `avatar_asset` is None, fall back to using `avatar` field directly
-                        When(
-                            assignees__avatar_asset__isnull=True,
-                            then="assignees__avatar",
-                        ),
-                        default=Value(None),
-                        output_field=models.CharField(),
-                    )
-                )
-                .values("display_name", "assignee_id", "avatar", "avatar_url")
+                .values("display_name", "assignee_id", "avatar")
                 .annotate(
                     total_estimates=Sum(
                         Cast("estimate_point__value", FloatField())
@@ -945,8 +924,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                         if item["assignee_id"]
                         else None
                     ),
-                    "avatar": item.get("avatar", None),
-                    "avatar_url": item.get("avatar_url", None),
+                    "avatar": item["avatar"],
                     "total_estimates": item["total_estimates"],
                     "completed_estimates": item["completed_estimates"],
                     "pending_estimates": item["pending_estimates"],
@@ -1024,27 +1002,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
             .annotate(display_name=F("assignees__display_name"))
             .annotate(assignee_id=F("assignees__id"))
             .annotate(avatar=F("assignees__avatar"))
-            .annotate(
-                avatar_url=Case(
-                    # If `avatar_asset` exists, use it to generate the asset URL
-                    When(
-                        assignees__avatar_asset__isnull=False,
-                        then=Concat(
-                            Value("/api/assets/v2/static/"),
-                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                            Value("/"),
-                        ),
-                    ),
-                    # If `avatar_asset` is None, fall back to using `avatar` field directly
-                    When(
-                        assignees__avatar_asset__isnull=True,
-                        then="assignees__avatar",
-                    ),
-                    default=Value(None),
-                    output_field=models.CharField(),
-                )
-            )
-            .values("display_name", "assignee_id", "avatar_url")
+            .values("display_name", "assignee_id", "avatar")
             .annotate(
                 total_issues=Count(
                     "id",
@@ -1083,8 +1041,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                 "assignee_id": (
                     str(item["assignee_id"]) if item["assignee_id"] else None
                 ),
-                "avatar": item.get("avatar", None),
-                "avatar_url": item.get("avatar_url", None),
+                "avatar": item["avatar"],
                 "total_issues": item["total_issues"],
                 "completed_issues": item["completed_issues"],
                 "pending_issues": item["pending_issues"],

apiserver/plane/api/views/inbox.py

@@ -285,7 +285,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                 )
 
         # Only project admins and members can edit inbox issue attributes
-        if project_member.role > 15:
+        if project_member.role > 5:
             serializer = InboxIssueSerializer(
                 inbox_issue, data=request.data, partial=True
             )

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,
-    FileAsset,
+    IssueAttachment,
     IssueComment,
     IssueLink,
     Label,
@@ -210,9 +210,8 @@ class IssueAPIEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -1063,7 +1062,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
     permission_classes = [
         ProjectEntityPermission,
     ]
-    model = FileAsset
+    model = IssueAttachment
     parser_classes = (MultiPartParser, FormParser)
 
     def post(self, request, slug, project_id, issue_id):
@@ -1071,7 +1070,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
         if (
             request.data.get("external_id")
             and request.data.get("external_source")
-            and FileAsset.objects.filter(
+            and IssueAttachment.objects.filter(
                 project_id=project_id,
                 workspace__slug=slug,
                 issue_id=issue_id,
@@ -1079,7 +1078,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
                 external_id=request.data.get("external_id"),
             ).exists()
         ):
-            issue_attachment = FileAsset.objects.filter(
+            issue_attachment = IssueAttachment.objects.filter(
                 workspace__slug=slug,
                 project_id=project_id,
                 external_id=request.data.get("external_id"),
@@ -1113,7 +1112,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 = FileAsset.objects.get(pk=pk)
+        issue_attachment = IssueAttachment.objects.get(pk=pk)
         issue_attachment.asset.delete(save=False)
         issue_attachment.delete()
         issue_activity.delay(
@@ -1131,7 +1130,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
     def get(self, request, slug, project_id, issue_id):
-        issue_attachments = FileAsset.objects.filter(
+        issue_attachments = IssueAttachment.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,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
     Module,
     ModuleIssue,
@@ -393,9 +393,8 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))

apiserver/plane/app/serializers/base.py

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

@@ -49,6 +49,7 @@ class DraftIssueCreateSerializer(BaseSerializer):
         fields = "__all__"
         read_only_fields = [
             "workspace",
+            "project",
             "created_by",
             "updated_by",
             "created_at",
@@ -82,13 +83,11 @@ class DraftIssueCreateSerializer(BaseSerializer):
         modules = self.initial_data.get("module_ids", None)
 
         workspace_id = self.context["workspace_id"]
-        project_id = self.context["project_id"]
 
         # Create Issue
         issue = DraftIssue.objects.create(
             **validated_data,
             workspace_id=workspace_id,
-            project_id=project_id,
         )
 
         # Issue Audit Users
@@ -100,9 +99,8 @@ class DraftIssueCreateSerializer(BaseSerializer):
                 [
                     DraftIssueAssignee(
                         assignee=user,
-                        draft_issue=issue,
+                        issue=issue,
                         workspace_id=workspace_id,
-                        project_id=project_id,
                         created_by_id=created_by_id,
                         updated_by_id=updated_by_id,
                     )
@@ -116,8 +114,7 @@ class DraftIssueCreateSerializer(BaseSerializer):
                 [
                     DraftIssueLabel(
                         label=label,
-                        draft_issue=issue,
-                        project_id=project_id,
+                        issue=issue,
                         workspace_id=workspace_id,
                         created_by_id=created_by_id,
                         updated_by_id=updated_by_id,
@@ -131,7 +128,6 @@ class DraftIssueCreateSerializer(BaseSerializer):
             DraftIssueCycle.objects.create(
                 cycle_id=cycle_id,
                 draft_issue=issue,
-                project_id=project_id,
                 workspace_id=workspace_id,
                 created_by_id=created_by_id,
                 updated_by_id=updated_by_id,
@@ -143,7 +139,6 @@ class DraftIssueCreateSerializer(BaseSerializer):
                     DraftIssueModule(
                         module_id=module_id,
                         draft_issue=issue,
-                        project_id=project_id,
                         workspace_id=workspace_id,
                         created_by_id=created_by_id,
                         updated_by_id=updated_by_id,
@@ -158,25 +153,22 @@ class DraftIssueCreateSerializer(BaseSerializer):
     def update(self, instance, validated_data):
         assignees = validated_data.pop("assignee_ids", None)
         labels = validated_data.pop("label_ids", None)
-        cycle_id = self.context.get("cycle_id", None)
+        cycle_id = self.initial_data.get("cycle_id", None)
         modules = self.initial_data.get("module_ids", None)
 
         # Related models
         workspace_id = instance.workspace_id
-        project_id = instance.project_id
-
         created_by_id = instance.created_by_id
         updated_by_id = instance.updated_by_id
 
         if assignees is not None:
-            DraftIssueAssignee.objects.filter(draft_issue=instance).delete()
+            DraftIssueAssignee.objects.filter(issue=instance).delete()
             DraftIssueAssignee.objects.bulk_create(
                 [
                     DraftIssueAssignee(
                         assignee=user,
-                        draft_issue=instance,
+                        issue=instance,
                         workspace_id=workspace_id,
-                        project_id=project_id,
                         created_by_id=created_by_id,
                         updated_by_id=updated_by_id,
                     )
@@ -186,14 +178,13 @@ class DraftIssueCreateSerializer(BaseSerializer):
             )
 
         if labels is not None:
-            DraftIssueLabel.objects.filter(draft_issue=instance).delete()
+            DraftIssueLabel.objects.filter(issue=instance).delete()
             DraftIssueLabel.objects.bulk_create(
                 [
                     DraftIssueLabel(
                         label=label,
-                        draft_issue=instance,
+                        issue=instance,
                         workspace_id=workspace_id,
-                        project_id=project_id,
                         created_by_id=created_by_id,
                         updated_by_id=updated_by_id,
                     )
@@ -202,31 +193,28 @@ class DraftIssueCreateSerializer(BaseSerializer):
                 batch_size=10,
             )
 
-        if cycle_id != "not_provided":
+        if cycle_id is not None:
             DraftIssueCycle.objects.filter(draft_issue=instance).delete()
-            if cycle_id is not None:
-                DraftIssueCycle.objects.create(
-                    cycle_id=cycle_id,
-                    draft_issue=instance,
-                    workspace_id=workspace_id,
-                    project_id=project_id,
-                    created_by_id=created_by_id,
-                    updated_by_id=updated_by_id,
-                )
+            DraftIssueCycle.objects.create(
+                cycle_id=cycle_id,
+                draft_issue=instance,
+                workspace_id=workspace_id,
+                created_by_id=created_by_id,
+                updated_by_id=updated_by_id,
+            )
 
         if modules is not None:
             DraftIssueModule.objects.filter(draft_issue=instance).delete()
             DraftIssueModule.objects.bulk_create(
                 [
                     DraftIssueModule(
-                        module_id=module_id,
+                        module=module,
                         draft_issue=instance,
                         workspace_id=workspace_id,
-                        project_id=project_id,
                         created_by_id=created_by_id,
                         updated_by_id=updated_by_id,
                     )
-                    for module_id in modules
+                    for module in modules
                 ],
                 batch_size=10,
             )
@@ -276,8 +264,6 @@ 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,
-    FileAsset,
+    IssueAttachment,
     IssueReaction,
     CommentReaction,
     IssueVote,
@@ -498,11 +498,8 @@ class IssueLinkLiteSerializer(BaseSerializer):
 
 
 class IssueAttachmentSerializer(BaseSerializer):
-
-    asset_url = serializers.CharField(read_only=True)
-
     class Meta:
-        model = FileAsset
+        model = IssueAttachment
         fields = "__all__"
         read_only_fields = [
             "created_by",
@@ -517,15 +514,14 @@ class IssueAttachmentSerializer(BaseSerializer):
 
 class IssueAttachmentLiteSerializer(DynamicBaseSerializer):
     class Meta:
-        model = FileAsset
+        model = IssueAttachment
         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,7 +95,6 @@ class ProjectLiteSerializer(BaseSerializer):
             "identifier",
             "name",
             "cover_image",
-            "cover_image_url",
             "logo_props",
             "description",
         ]
@@ -118,7 +117,6 @@ 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)
@@ -130,7 +128,6 @@ 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,15 +56,12 @@ 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",
@@ -159,7 +156,6 @@ class UserLiteSerializer(BaseSerializer):
             "first_name",
             "last_name",
             "avatar",
-            "avatar_url",
             "is_bot",
             "display_name",
         ]
@@ -177,7 +173,6 @@ class UserAdminLiteSerializer(BaseSerializer):
             "first_name",
             "last_name",
             "avatar",
-            "avatar_url",
             "is_bot",
             "display_name",
             "email",

apiserver/plane/app/serializers/workspace.py

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

apiserver/plane/app/urls/asset.py

@@ -5,13 +5,6 @@ from plane.app.views import (
     FileAssetEndpoint,
     UserAssetsEndpoint,
     FileAssetViewSet,
-    # V2 Endpoints
-    WorkspaceFileAssetEndpoint,
-    UserAssetsV2Endpoint,
-    StaticFileAssetEndpoint,
-    AssetRestoreEndpoint,
-    ProjectAssetEndpoint,
-    ProjectBulkAssetEndpoint,
 )
 
 
@@ -45,49 +38,4 @@ 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,7 +21,6 @@ from plane.app.views import (
     BulkArchiveIssuesEndpoint,
     DeletedIssuesListViewSet,
     IssuePaginatedViewSet,
-    IssueAttachmentV2Endpoint,
 )
 
 urlpatterns = [
@@ -133,18 +132,6 @@ 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/urls/workspace.py

@@ -276,9 +276,4 @@ urlpatterns = [
         ),
         name="workspace-drafts-issues",
     ),
-    path(
-        "workspaces/<str:slug>/draft-to-issue/<uuid:draft_id>/",
-        WorkspaceDraftIssueViewSet.as_view({"post": "create_draft_to_issue"}),
-        name="workspace-drafts-issues",
-    ),
 ]

apiserver/plane/app/views/__init__.py

@@ -110,19 +110,7 @@ from .cycle.archive import (
     CycleArchiveUnarchiveEndpoint,
 )
 
-from .asset.base import (
-    FileAssetEndpoint,
-    UserAssetsEndpoint,
-    FileAssetViewSet,
-)
-from .asset.v2 import (
-    WorkspaceFileAssetEndpoint,
-    UserAssetsV2Endpoint,
-    StaticFileAssetEndpoint,
-    AssetRestoreEndpoint,
-    ProjectAssetEndpoint,
-    ProjectBulkAssetEndpoint,
-)
+from .asset.base import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
 from .issue.base import (
     IssueListEndpoint,
     IssueViewSet,
@@ -140,8 +128,6 @@ 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,10 +1,7 @@
 # Django imports
-from django.db.models import Count, F, Sum, Q
+from django.db.models import Count, F, Sum
 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
@@ -121,37 +118,14 @@ 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,
-                )
-                .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(),
-                    )
+                    assignees__avatar__isnull=False,
                 )
                 .order_by("assignees__id")
                 .distinct("assignees__id")
                 .values(
-                    "assignees__avatar_url",
+                    "assignees__avatar",
                     "assignees__display_name",
                     "assignees__first_name",
                     "assignees__last_name",
@@ -381,6 +355,7 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
         user_details = [
             "created_by__first_name",
             "created_by__last_name",
+            "created_by__avatar",
             "created_by__display_name",
             "created_by__id",
         ]
@@ -389,32 +364,13 @@ 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",
         ]
@@ -423,26 +379,6 @@ 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]
         )
@@ -451,26 +387,6 @@ 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

@@ -1,811 +0,0 @@
-# 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,7 +1,6 @@
 # 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,
@@ -19,7 +18,7 @@ from django.db.models import (
     Sum,
     FloatField,
 )
-from django.db.models.functions import Coalesce, Cast, Concat
+from django.db.models.functions import Coalesce, Cast
 from django.utils import timezone
 
 # Third party imports
@@ -140,7 +139,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                 Prefetch(
                     "issue_cycle__issue__assignees",
                     queryset=User.objects.only(
-                        "avatar_asset", "first_name", "id"
+                        "avatar", "first_name", "id"
                     ).distinct(),
                 )
             )
@@ -401,27 +400,8 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                     )
                     .annotate(display_name=F("assignees__display_name"))
                     .annotate(assignee_id=F("assignees__id"))
-                    .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(avatar=F("assignees__avatar"))
+                    .values("display_name", "assignee_id", "avatar")
                     .annotate(
                         total_estimates=Sum(
                             Cast("estimate_point__value", FloatField())
@@ -514,13 +494,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_url=F("assignees__avatar_url"))
+                .annotate(avatar=F("assignees__avatar"))
                 .annotate(display_name=F("assignees__display_name"))
                 .values(
                     "first_name",
                     "last_name",
                     "assignee_id",
-                    "avatar_url",
+                    "avatar",
                     "display_name",
                 )
                 .annotate(

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

@@ -20,8 +20,7 @@ from django.db.models import (
     Sum,
     FloatField,
 )
-from django.db import models
-from django.db.models.functions import Coalesce, Cast, Concat
+from django.db.models.functions import Coalesce, Cast
 from django.utils import timezone
 from django.core.serializers.json import DjangoJSONEncoder
 
@@ -82,7 +81,7 @@ class CycleViewSet(BaseViewSet):
                 Prefetch(
                     "issue_cycle__issue__assignees",
                     queryset=User.objects.only(
-                        "avatar_asset", "first_name", "id"
+                        "avatar", "first_name", "id"
                     ).distinct(),
                 )
             )
@@ -188,7 +187,6 @@ class CycleViewSet(BaseViewSet):
                 "completed_issues",
                 "assignee_ids",
                 "status",
-                "version",
                 "created_by",
             )
 
@@ -218,7 +216,6 @@ class CycleViewSet(BaseViewSet):
             "completed_issues",
             "assignee_ids",
             "status",
-            "version",
             "created_by",
         )
         return Response(data, status=status.HTTP_200_OK)
@@ -258,7 +255,6 @@ class CycleViewSet(BaseViewSet):
                         "external_id",
                         "progress_snapshot",
                         "logo_props",
-                        "version",
                         # meta fields
                         "is_favorite",
                         "total_issues",
@@ -310,7 +306,10 @@ class CycleViewSet(BaseViewSet):
 
         request_data = request.data
 
-        if cycle.end_date is not None and cycle.end_date < timezone.now():
+        if (
+            cycle.end_date is not None
+            and cycle.end_date < timezone.now()
+        ):
             if "sort_order" in request_data:
                 # Can only change sort order for a completed cycle``
                 request_data = {
@@ -348,7 +347,6 @@ class CycleViewSet(BaseViewSet):
                 "external_id",
                 "progress_snapshot",
                 "logo_props",
-                "version",
                 # meta fields
                 "is_favorite",
                 "total_issues",
@@ -414,7 +412,6 @@ class CycleViewSet(BaseViewSet):
                 "progress_snapshot",
                 "sub_issues",
                 "logo_props",
-                "version",
                 # meta fields
                 "is_favorite",
                 "total_issues",
@@ -668,27 +665,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                 )
                 .annotate(display_name=F("assignees__display_name"))
                 .annotate(assignee_id=F("assignees__id"))
-                .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(avatar=F("assignees__avatar"))
+                .values("display_name", "assignee_id", "avatar")
                 .annotate(
                     total_estimates=Sum(
                         Cast("estimate_point__value", FloatField())
@@ -725,8 +703,7 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                         if item["assignee_id"]
                         else None
                     ),
-                    "avatar": item.get("avatar"),
-                    "avatar_url": item.get("avatar_url"),
+                    "avatar": item["avatar"],
                     "total_estimates": item["total_estimates"],
                     "completed_estimates": item["completed_estimates"],
                     "pending_estimates": item["pending_estimates"],
@@ -803,27 +780,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
             )
             .annotate(display_name=F("assignees__display_name"))
             .annotate(assignee_id=F("assignees__id"))
-            .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(avatar=F("assignees__avatar"))
+            .values("display_name", "assignee_id", "avatar")
             .annotate(
                 total_issues=Count(
                     "id",
@@ -862,8 +820,7 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                 "assignee_id": (
                     str(item["assignee_id"]) if item["assignee_id"] else None
                 ),
-                "avatar": item.get("avatar"),
-                "avatar_url": item.get("avatar_url"),
+                "avatar": item["avatar"],
                 "total_issues": item["total_issues"],
                 "completed_issues": item["completed_issues"],
                 "pending_issues": item["pending_issues"],
@@ -1191,7 +1148,6 @@ class CycleProgressEndpoint(BaseAPIView):
             status=status.HTTP_200_OK,
         )
 
-
 class CycleAnalyticsEndpoint(BaseAPIView):
 
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
@@ -1242,27 +1198,8 @@ class CycleAnalyticsEndpoint(BaseAPIView):
                 )
                 .annotate(display_name=F("assignees__display_name"))
                 .annotate(assignee_id=F("assignees__id"))
-                .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(avatar=F("assignees__avatar"))
+                .values("display_name", "assignee_id", "avatar")
                 .annotate(
                     total_estimates=Sum(
                         Cast("estimate_point__value", FloatField())
@@ -1345,27 +1282,8 @@ class CycleAnalyticsEndpoint(BaseAPIView):
                 )
                 .annotate(display_name=F("assignees__display_name"))
                 .annotate(assignee_id=F("assignees__id"))
-                .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(avatar=F("assignees__avatar"))
+                .values("display_name", "assignee_id", "avatar")
                 .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,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
 )
 from plane.utils.grouper import (
@@ -110,9 +110,8 @@ class CycleIssueViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -247,7 +246,10 @@ 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,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
     IssueRelation,
     Project,
@@ -56,8 +56,7 @@ 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,
@@ -84,8 +83,7 @@ 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,
@@ -110,8 +108,7 @@ 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,
@@ -137,8 +134,7 @@ 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,
@@ -199,9 +195,8 @@ def dashboard_assigned_issues(self, request, slug):
             .values("count")
         )
         .annotate(
-            attachment_count=FileAsset.objects.filter(
-                issue_id=OuterRef("id"),
-                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            attachment_count=IssueAttachment.objects.filter(
+                issue=OuterRef("id")
             )
             .order_by()
             .annotate(count=Func(F("id"), function="Count"))
@@ -363,9 +358,8 @@ def dashboard_created_issues(self, request, slug):
             .values("count")
         )
         .annotate(
-            attachment_count=FileAsset.objects.filter(
-                issue_id=OuterRef("id"),
-                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            attachment_count=IssueAttachment.objects.filter(
+                issue=OuterRef("id")
             )
             .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,
-    FileAsset,
+    IssueAttachment,
     Project,
     ProjectMember,
 )
@@ -120,9 +120,8 @@ class InboxIssueViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -324,7 +323,7 @@ class InboxIssueViewSet(BaseViewSet):
                 serializer.errors, status=status.HTTP_400_BAD_REQUEST
             )
 
-    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=Issue)
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
     def partial_update(self, request, slug, project_id, pk):
         inbox_id = Inbox.objects.filter(
             workspace__slug=slug, project_id=project_id
@@ -419,7 +418,7 @@ class InboxIssueViewSet(BaseViewSet):
                 )
 
         # Only project admins and members can edit inbox issue attributes
-        if project_member.role > 15:
+        if project_member.role > 5:
             serializer = InboxIssueSerializer(
                 inbox_issue, data=request.data, partial=True
             )

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,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
     IssueSubscriber,
     IssueReaction,
@@ -79,9 +79,8 @@ class IssueArchiveViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -237,6 +236,12 @@ 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,12 +1,9 @@
 # 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
@@ -16,28 +13,21 @@ from rest_framework.parsers import MultiPartParser, FormParser
 # Module imports
 from .. import BaseAPIView
 from plane.app.serializers import IssueAttachmentSerializer
-from plane.db.models import FileAsset, Workspace
+from plane.db.models import IssueAttachment
 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 = FileAsset
+    model = IssueAttachment
     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,
-                workspace_id=workspace.id,
-                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
-            )
+            serializer.save(project_id=project_id, issue_id=issue_id)
             issue_activity.delay(
                 type="attachment.activity.created",
                 requested_data=None,
@@ -55,9 +45,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=FileAsset)
+    @allow_permission([ROLE.ADMIN], creator=True, model=IssueAttachment)
     def delete(self, request, slug, project_id, issue_id, pk):
-        issue_attachment = FileAsset.objects.get(pk=pk)
+        issue_attachment = IssueAttachment.objects.get(pk=pk)
         issue_attachment.asset.delete(save=False)
         issue_attachment.delete()
         issue_activity.delay(
@@ -82,182 +72,8 @@ class IssueAttachmentEndpoint(BaseAPIView):
         ]
     )
     def get(self, request, slug, project_id, issue_id):
-        issue_attachments = FileAsset.objects.filter(
+        issue_attachments = IssueAttachment.objects.filter(
             issue_id=issue_id, workspace__slug=slug, project_id=project_id
         )
         serializer = IssueAttachmentSerializer(issue_attachments, many=True)
         return Response(serializer.data, status=status.HTTP_200_OK)
-
-
-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,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
     IssueUserProperty,
     IssueReaction,
@@ -91,9 +91,8 @@ class IssueListEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -215,9 +214,8 @@ class IssueViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -502,6 +500,12 @@ class IssueViewSet(BaseViewSet):
                     ),
                 )
             )
+            .prefetch_related(
+                Prefetch(
+                    "issue_attachment",
+                    queryset=IssueAttachment.objects.select_related("issue"),
+                )
+            )
             .prefetch_related(
                 Prefetch(
                     "issue_link",
@@ -755,6 +759,14 @@ class IssuePaginatedViewSet(BaseViewSet):
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
             )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
             .annotate(
                 sub_issues_count=Issue.issue_objects.filter(
                     parent=OuterRef("id")

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

@@ -24,7 +24,7 @@ from plane.db.models import (
     Project,
     IssueRelation,
     Issue,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
 )
 from plane.bgtasks.issue_activities_task import issue_activity
@@ -91,9 +91,8 @@ class IssueRelationViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .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,
-    FileAsset,
+    IssueAttachment,
 )
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.utils.user_timezone_converter import user_timezone_converter
@@ -56,9 +56,8 @@ class SubIssuesEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))

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

@@ -14,12 +14,9 @@ from django.db.models import (
     Value,
     Sum,
     FloatField,
-    Case,
-    When,
 )
-from django.db.models.functions import Coalesce, Cast, Concat
+from django.db.models.functions import Coalesce, Cast
 from django.utils import timezone
-from django.db import models
 
 # Third party imports
 from rest_framework import status
@@ -367,31 +364,12 @@ 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_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(avatar=F("assignees__avatar"))
                     .values(
                         "first_name",
                         "last_name",
                         "assignee_id",
-                        "avatar_url",
+                        "avatar",
                         "display_name",
                     )
                     .annotate(
@@ -459,9 +437,7 @@ 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:
@@ -485,31 +461,12 @@ 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_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(avatar=F("assignees__avatar"))
                 .values(
                     "first_name",
                     "last_name",
                     "assignee_id",
-                    "avatar_url",
+                    "avatar",
                     "display_name",
                 )
                 .annotate(

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

@@ -18,11 +18,8 @@ from django.db.models import (
     Value,
     Sum,
     FloatField,
-    Case,
-    When,
 )
-from django.db import models
-from django.db.models.functions import Coalesce, Cast, Concat
+from django.db.models.functions import Coalesce, Cast
 from django.core.serializers.json import DjangoJSONEncoder
 from django.utils import timezone
 
@@ -33,7 +30,6 @@ from rest_framework.response import Response
 # Module imports
 from plane.app.permissions import (
     ProjectEntityPermission,
-    ProjectLitePermission,
     allow_permission,
     ROLE,
 )
@@ -321,12 +317,13 @@ class ModuleViewSet(BaseViewSet):
             .order_by("-is_favorite", "-created_at")
         )
 
-    @allow_permission(
+    allow_permission(
         [
             ROLE.ADMIN,
             ROLE.MEMBER,
         ]
     )
+
     def create(self, request, slug, project_id):
         project = Project.objects.get(workspace__slug=slug, pk=project_id)
         serializer = ModuleWriteSerializer(
@@ -389,7 +386,8 @@ class ModuleViewSet(BaseViewSet):
             return Response(module, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+
     def list(self, request, slug, project_id):
         queryset = self.get_queryset().filter(archived_at__isnull=True)
         if self.fields:
@@ -437,7 +435,13 @@ class ModuleViewSet(BaseViewSet):
             )
         return Response(modules, status=status.HTTP_200_OK)
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    allow_permission(
+        [
+            ROLE.ADMIN,
+            ROLE.MEMBER,
+        ]
+    )
+
     def retrieve(self, request, slug, project_id, pk):
         queryset = (
             self.get_queryset()
@@ -484,31 +488,12 @@ 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_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(avatar=F("assignees__avatar"))
                 .values(
                     "first_name",
                     "last_name",
                     "assignee_id",
-                    "avatar_url",
+                    "avatar",
                     "display_name",
                 )
                 .annotate(
@@ -600,31 +585,12 @@ 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_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(avatar=F("assignees__avatar"))
             .values(
                 "first_name",
                 "last_name",
                 "assignee_id",
-                "avatar_url",
+                "avatar",
                 "display_name",
             )
             .annotate(
@@ -706,13 +672,7 @@ class ModuleViewSet(BaseViewSet):
             "labels": label_distribution,
             "completion_chart": {},
         }
-
-        if (
-            modules
-            and modules.start_date
-            and modules.target_date
-            and modules.total_issues > 0
-        ):
+        if modules and modules.start_date and modules.target_date:
             data["distribution"]["completion_chart"] = burndown_plot(
                 queryset=modules,
                 slug=slug,
@@ -878,9 +838,6 @@ class ModuleLinkViewSet(BaseViewSet):
 
 class ModuleFavoriteViewSet(BaseViewSet):
     model = UserFavorite
-    permission_classes = [
-        ProjectLitePermission,
-    ]
 
     def get_queryset(self):
         return self.filter_queryset(

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,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
     ModuleIssue,
     Project,
@@ -73,9 +73,8 @@ class ModuleIssueViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))

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,7 +35,10 @@ 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,7 +53,6 @@ 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):
@@ -509,44 +508,6 @@ class ProjectViewSet(BaseViewSet):
                 status=status.HTTP_410_GONE,
             )
 
-    def destroy(self, request, slug, pk):
-        if (
-            WorkspaceMember.objects.filter(
-                member=request.user,
-                workspace__slug=slug,
-                is_active=True,
-                role=20,
-            ).exists()
-            or ProjectMember.objects.filter(
-                member=request.user,
-                workspace__slug=slug,
-                project_id=pk,
-                role=20,
-                is_active=True,
-            ).exists()
-        ):
-            project = Project.objects.get(pk=pk)
-            project.delete()
-
-            # Delete the project members
-            DeployBoard.objects.filter(
-                project_id=pk,
-                workspace__slug=slug,
-            ).delete()
-
-            # Delete the user favorite
-            UserFavorite.objects.filter(
-                project_id=pk,
-                workspace__slug=slug,
-            ).delete()
-
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        else:
-            return Response(
-                {"error": "You don't have the required permissions."},
-                status=status.HTTP_403_FORBIDDEN,
-            )
-
 
 class ProjectArchiveUnarchiveEndpoint(BaseAPIView):
 
@@ -721,22 +682,18 @@ class ProjectPublicCoverImagesEndpoint(BaseAPIView):
             "Prefix": "static/project-cover/",
         }
 
-        try:
-            response = s3.list_objects_v2(**params)
-            # Extracting file keys from the response
-            if "Contents" in response:
-                for content in response["Contents"]:
-                    if not content["Key"].endswith(
-                        "/"
-                    ):  # This line ensures we're only getting files, not "sub-folders"
-                        files.append(
-                            f"https://{settings.AWS_STORAGE_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
-                        )
+        response = s3.list_objects_v2(**params)
+        # Extracting file keys from the response
+        if "Contents" in response:
+            for content in response["Contents"]:
+                if not content["Key"].endswith(
+                    "/"
+                ):  # This line ensures we're only getting files, not "sub-folders"
+                    files.append(
+                        f"https://{settings.AWS_STORAGE_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
+                    )
 
-            return Response(files, status=status.HTTP_200_OK)
-        except Exception as e:
-            log_exception(e)
-            return Response([], status=status.HTTP_200_OK)
+        return Response(files, 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,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
     IssueView,
     Workspace,
@@ -213,9 +213,8 @@ class WorkspaceViewIssuesViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -432,7 +431,8 @@ class IssueViewViewSet(BaseViewSet):
             .distinct()
         )
 
-    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+
     def list(self, request, slug, project_id):
         queryset = self.get_queryset()
         project = Project.objects.get(id=project_id)
@@ -457,7 +457,8 @@ class IssueViewViewSet(BaseViewSet):
         ).data
         return Response(views, status=status.HTTP_200_OK)
 
-    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+
     def retrieve(self, request, slug, project_id, pk):
         issue_view = (
             self.get_queryset().filter(pk=pk, project_id=project_id).first()
@@ -497,7 +498,8 @@ class IssueViewViewSet(BaseViewSet):
             status=status.HTTP_200_OK,
         )
 
-    @allow_permission(allowed_roles=[], creator=True, model=IssueView)
+    allow_permission(allowed_roles=[], creator=True, model=IssueView)
+
     def partial_update(self, request, slug, project_id, pk):
         with transaction.atomic():
             issue_view = IssueView.objects.select_for_update().get(
@@ -530,7 +532,8 @@ class IssueViewViewSet(BaseViewSet):
                 serializer.errors, status=status.HTTP_400_BAD_REQUEST
             )
 
-    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=IssueView)
+    allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=IssueView)
+
     def destroy(self, request, slug, project_id, pk):
         project_view = IssueView.objects.get(
             pk=pk,
@@ -575,7 +578,8 @@ class IssueViewFavoriteViewSet(BaseViewSet):
             .select_related("view")
         )
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+
     def create(self, request, slug, project_id):
         _ = UserFavorite.objects.create(
             user=request.user,
@@ -585,7 +589,8 @@ class IssueViewFavoriteViewSet(BaseViewSet):
         )
         return Response(status=status.HTTP_204_NO_CONTENT)
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+
     def destroy(self, request, slug, project_id, view_id):
         view_favorite = UserFavorite.objects.get(
             project=project_id,

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

@@ -1,10 +1,4 @@
-# Python imports
-import json
-
 # Django imports
-from django.utils import timezone
-from django.core import serializers
-from django.core.serializers.json import DjangoJSONEncoder
 from django.contrib.postgres.aggregates import ArrayAgg
 from django.contrib.postgres.fields import ArrayField
 from django.db.models import (
@@ -32,23 +26,23 @@ from plane.app.serializers import (
 from plane.db.models import (
     Issue,
     DraftIssue,
-    CycleIssue,
-    ModuleIssue,
-    DraftIssueModule,
-    DraftIssueCycle,
     Workspace,
 )
 from .. import BaseViewSet
-from plane.bgtasks.issue_activities_task import issue_activity
-from plane.utils.issue_filters import issue_filters
 
 
 class WorkspaceDraftIssueViewSet(BaseViewSet):
+
     model = DraftIssue
 
-    def get_queryset(self):
-        return (
-            DraftIssue.objects.filter(workspace__slug=self.kwargs.get("slug"))
+    @method_decorator(gzip_page)
+    @allow_permission(
+        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
+    )
+    def list(self, request, slug):
+        issues = (
+            DraftIssue.objects.filter(workspace__slug=slug)
+            .filter(created_by=request.user)
             .select_related("workspace", "project", "state", "parent")
             .prefetch_related(
                 "assignees", "labels", "draft_issue_module__module"
@@ -84,30 +78,11 @@ 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")
         )
 
-        issues = issues.filter(**filters)
-        # List Paginate
-        return self.paginate(
-            request=request,
-            queryset=(issues),
-            on_results=lambda issues: DraftIssueSerializer(
-                issues,
-                many=True,
-            ).data,
-        )
+        serializer = DraftIssueSerializer(issues, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
     @allow_permission(
         allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
@@ -119,41 +94,11 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
             data=request.data,
             context={
                 "workspace_id": workspace.id,
-                "project_id": request.data.get("project_id", None),
             },
         )
         if serializer.is_valid():
             serializer.save()
-            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.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     @allow_permission(
@@ -164,7 +109,45 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
     )
     def partial_update(self, request, slug, pk):
         issue = (
-            self.get_queryset().filter(pk=pk, created_by=request.user).first()
+            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()
         )
 
         if not issue:
@@ -173,14 +156,8 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
                 status=status.HTTP_404_NOT_FOUND,
             )
 
-        serializer = DraftIssueCreateSerializer(
-            issue,
-            data=request.data,
-            partial=True,
-            context={
-                "project_id": request.data.get("project_id", None),
-                "cycle_id": request.data.get("cycle_id", "not_provided"),
-            },
+        serializer = IssueCreateSerializer(
+            issue, data=request.data, partial=True
         )
 
         if serializer.is_valid():
@@ -197,8 +174,46 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
     )
     def retrieve(self, request, slug, pk=None):
         issue = (
-            self.get_queryset().filter(pk=pk, created_by=request.user).first()
-        )
+            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()
 
         if not issue:
             return Response(
@@ -212,123 +227,10 @@ class WorkspaceDraftIssueViewSet(BaseViewSet):
     @allow_permission(
         allowed_roles=[ROLE.ADMIN],
         creator=True,
-        model=DraftIssue,
+        model=Issue,
         level="WORKSPACE",
     )
     def destroy(self, request, slug, pk=None):
         draft_issue = DraftIssue.objects.get(workspace__slug=slug, pk=pk)
         draft_issue.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
-
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER],
-        level="WORKSPACE",
-    )
-    def create_draft_to_issue(self, request, slug, draft_id):
-        draft_issue = self.get_queryset().filter(pk=draft_id).first()
-
-        if not draft_issue.project_id:
-            return Response(
-                {"error": "Project is required to create an issue."},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        serializer = IssueCreateSerializer(
-            data=request.data,
-            context={
-                "project_id": draft_issue.project_id,
-                "workspace_id": draft_issue.project.workspace_id,
-                "default_assignee_id": draft_issue.project.default_assignee_id,
-            },
-        )
-
-        if serializer.is_valid():
-            serializer.save()
-
-            issue_activity.delay(
-                type="issue.activity.created",
-                requested_data=json.dumps(
-                    self.request.data, cls=DjangoJSONEncoder
-                ),
-                actor_id=str(request.user.id),
-                issue_id=str(serializer.data.get("id", None)),
-                project_id=str(draft_issue.project_id),
-                current_instance=None,
-                epoch=int(timezone.now().timestamp()),
-                notification=True,
-                origin=request.META.get("HTTP_ORIGIN"),
-            )
-
-            if draft_issue.cycle_id:
-                created_records = CycleIssue.objects.create(
-                    cycle_id=draft_issue.cycle_id,
-                    issue_id=serializer.data.get("id", None),
-                    project_id=draft_issue.project_id,
-                    workspace_id=draft_issue.workspace_id,
-                    created_by_id=draft_issue.created_by_id,
-                    updated_by_id=draft_issue.updated_by_id,
-                )
-                # Capture Issue Activity
-                issue_activity.delay(
-                    type="cycle.activity.created",
-                    requested_data=None,
-                    actor_id=str(self.request.user.id),
-                    issue_id=None,
-                    project_id=str(self.kwargs.get("project_id", None)),
-                    current_instance=json.dumps(
-                        {
-                            "updated_cycle_issues": None,
-                            "created_cycle_issues": serializers.serialize(
-                                "json", created_records
-                            ),
-                        }
-                    ),
-                    epoch=int(timezone.now().timestamp()),
-                    notification=True,
-                    origin=request.META.get("HTTP_ORIGIN"),
-                )
-
-            if draft_issue.module_ids:
-                # bulk create the module
-                ModuleIssue.objects.bulk_create(
-                    [
-                        ModuleIssue(
-                            module_id=module,
-                            issue_id=serializer.data.get("id", None),
-                            workspace_id=draft_issue.workspace_id,
-                            project_id=draft_issue.project_id,
-                            created_by_id=draft_issue.created_by_id,
-                            updated_by_id=draft_issue.updated_by_id,
-                        )
-                        for module in draft_issue.module_ids
-                    ],
-                    batch_size=10,
-                )
-                # Bulk Update the activity
-                _ = [
-                    issue_activity.delay(
-                        type="module.activity.created",
-                        requested_data=json.dumps({"module_id": str(module)}),
-                        actor_id=str(request.user.id),
-                        issue_id=serializer.data.get("id", None),
-                        project_id=draft_issue.project_id,
-                        current_instance=None,
-                        epoch=int(timezone.now().timestamp()),
-                        notification=True,
-                        origin=request.META.get("HTTP_ORIGIN"),
-                    )
-                    for module in draft_issue.module_ids
-                ]
-
-            # delete the draft issue
-            draft_issue.delete()
-
-            # delete the draft issue module
-            DraftIssueModule.objects.filter(draft_issue=draft_issue).delete()
-
-            # delete the draft issue cycle
-            DraftIssueCycle.objects.filter(draft_issue=draft_issue).delete()
-
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

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

@@ -40,7 +40,7 @@ from plane.db.models import (
     CycleIssue,
     Issue,
     IssueActivity,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
     IssueSubscriber,
     Project,
@@ -128,9 +128,8 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -360,8 +359,8 @@ class WorkspaceUserProfileEndpoint(BaseAPIView):
                     "email": user_data.email,
                     "first_name": user_data.first_name,
                     "last_name": user_data.last_name,
-                    "avatar_url": user_data.avatar_url,
-                    "cover_image_url": user_data.cover_image_url,
+                    "avatar": user_data.avatar,
+                    "cover_image": user_data.cover_image,
                     "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,9 +10,6 @@ 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
@@ -87,37 +84,12 @@ def get_assignee_details(slug, filters):
     """Fetch assignee details if required."""
     return (
         Issue.issue_objects.filter(
-            Q(
-                Q(assignees__avatar__isnull=False)
-                | Q(assignees__avatar_asset__isnull=False)
-            ),
-            workspace__slug=slug,
-            **filters,
-        )
-        .annotate(
-            assignees__avatar_url=Case(
-                # If `avatar_asset` exists, use it to generate the asset URL
-                When(
-                    assignees__avatar_asset__isnull=False,
-                    then=Concat(
-                        Value("/api/assets/v2/static/"),
-                        "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                        Value("/"),
-                    ),
-                ),
-                # If `avatar_asset` is None, fall back to using `avatar` field directly
-                When(
-                    assignees__avatar_asset__isnull=True,
-                    then="assignees__avatar",
-                ),
-                default=Value(None),
-                output_field=models.CharField(),
-            )
+            workspace__slug=slug, **filters, assignees__avatar__isnull=False
         )
         .distinct("assignees__id")
         .order_by("assignees__id")
         .values(
-            "assignees__avatar_url",
+            "assignees__avatar",
             "assignees__display_name",
             "assignees__first_name",
             "assignees__last_name",

apiserver/plane/bgtasks/email_notification_task.py

@@ -224,7 +224,7 @@ def send_email_notification(
                         {
                             "actor_comments": comment,
                             "actor_detail": {
-                                "avatar_url": f"{base_api}{actor.avatar_url}",
+                                "avatar_url": actor.avatar,
                                 "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": f"{base_api}{actor.avatar_url}",
+                                "avatar_url": actor.avatar,
                                 "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": f"{base_api}{actor.avatar_url}",
+                                "avatar_url": actor.avatar,
                                 "first_name": actor.first_name,
                                 "last_name": actor.last_name,
                             },

apiserver/plane/bgtasks/export_task.py

@@ -105,6 +105,7 @@ 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(
@@ -128,7 +129,7 @@ def upload_to_s3(zip_file, workspace_id, token_id, slug):
             zip_file,
             settings.AWS_STORAGE_BUCKET_NAME,
             file_name,
-            ExtraArgs={"ContentType": "application/zip"},
+            ExtraArgs={"ACL": "public-read", "ContentType": "application/zip"},
         )
 
         # Generate presigned url for the uploaded file

apiserver/plane/bgtasks/file_asset_task.py

@@ -1,5 +1,4 @@
 # Python imports
-import os
 from datetime import timedelta
 
 # Django imports
@@ -14,14 +13,16 @@ from plane.db.models import FileAsset
 
 
 @shared_task
-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()
+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()

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_unuploaded_file_asset",
+        "task": "plane.bgtasks.file_asset_task.delete_file_asset",
         "schedule": crontab(hour=0, minute=0),
     },
     "check-every-five-minutes-to-send-email-notifications": {
@@ -40,10 +40,6 @@ app.conf.beat_schedule = {
         "task": "plane.bgtasks.deletion_task.hard_delete",
         "schedule": crontab(hour=0, minute=0),
     },
-    "run-every-6-hours-for-instance-trace": {
-        "task": "plane.license.bgtasks.tracer.instance_traces",
-        "schedule": crontab(hour="*/6"),
-    },
 }
 
 # Load task modules from all registered Django app configs.

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

@@ -1,45 +1,67 @@
 # 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:
-            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"),
+            session = boto3.session.Session(
+                aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
+                aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
             )
-            # Get the bucket name from the environment
-            bucket_name = os.environ.get("AWS_S3_BUCKET_NAME")
+            # 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
+
             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.")
-            )
-            return
+
+            self.set_bucket_public_policy(s3_client, bucket_name)
         except ClientError as e:
             error_code = int(e.response["Error"]["Code"])
-            bucket_name = os.environ.get("AWS_S3_BUCKET_NAME")
+            bucket_name = settings.AWS_STORAGE_BUCKET_NAME
             if error_code == 404:
                 # Bucket does not exist, create it
                 self.stdout.write(
@@ -54,16 +76,13 @@ class Command(BaseCommand):
                             f"Bucket '{bucket_name}' created successfully."
                         )
                     )
-
-                # Handle the exception if the bucket creation fails
+                    self.set_bucket_public_policy(s3_client, bucket_name)
                 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

@@ -1,209 +0,0 @@
-# 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

@@ -1,179 +0,0 @@
-# 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

@@ -1,64 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-# 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_issuetype_external_id_issuetype_external_source.py

@@ -1,179 +0,0 @@
-# Generated by Django 4.2.16 on 2024-10-14 07:59
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("db", "0080_fileasset_draft_issue_alter_fileasset_entity_type"),
-    ]
-
-    operations = [
-        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.RenameField(
-            model_name="usernotificationpreference",
-            old_name="property_change",
-            new_name="email_property_change",
-        ),
-        migrations.AlterField(
-            model_name="usernotificationpreference",
-            name="email_property_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.RenameField(
-            model_name="usernotificationpreference",
-            old_name="state_change",
-            new_name="email_state_change",
-        ),
-        migrations.AlterField(
-            model_name="usernotificationpreference",
-            name="email_state_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.RenameField(
-            model_name="usernotificationpreference",
-            old_name="comment",
-            new_name="email_comment",
-        ),
-        migrations.AlterField(
-            model_name="usernotificationpreference",
-            name="email_comment",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.RenameField(
-            model_name="usernotificationpreference",
-            old_name="mention",
-            new_name="email_mention",
-        ),
-        migrations.AlterField(
-            model_name="usernotificationpreference",
-            name="email_mention",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.RenameField(
-            model_name="usernotificationpreference",
-            old_name="issue_completed",
-            new_name="email_issue_completed",
-        ),
-        migrations.AlterField(
-            model_name="usernotificationpreference",
-            name="email_issue_completed",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="deployboard",
-            name="is_disabled",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="email_assignee_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="email_cycle_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="email_module_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="email_priority_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="email_reactions",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="email_start_target_date_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="in_app_assignee_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="in_app_comment",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="in_app_cycle_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="in_app_issue_completed",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="in_app_mention",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="in_app_module_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="in_app_priority_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="in_app_property_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="in_app_reactions",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="in_app_start_target_date_change",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="usernotificationpreference",
-            name="in_app_state_change",
-            field=models.BooleanField(default=False),
-        ),
-        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,
-            ),
-        ),
-    ]

apiserver/plane/db/models/__init__.py

@@ -24,6 +24,7 @@ from .issue import (
     Issue,
     IssueActivity,
     IssueAssignee,
+    IssueAttachment,
     IssueBlocker,
     IssueComment,
     IssueLabel,

apiserver/plane/db/models/asset.py

@@ -5,13 +5,14 @@ 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}"
@@ -27,28 +28,13 @@ 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,
-        max_length=800,
-    )
-    user = models.ForeignKey(
-        "db.User",
-        on_delete=models.CASCADE,
-        null=True,
-        related_name="assets",
+        validators=[
+            FileExtensionValidator(allowed_extensions=["jpg", "jpeg", "png"]),
+            file_size,
+        ],
     )
     workspace = models.ForeignKey(
         "db.Workspace",
@@ -56,49 +42,8 @@ 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"
@@ -108,26 +53,3 @@ 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/deploy_board.py

@@ -20,7 +20,6 @@ class DeployBoard(WorkspaceBaseModel):
         ("cycle", "Task"),
         ("page", "Page"),
         ("view", "View"),
-        ("inbox", "Inbox"),
     )
 
     entity_identifier = models.UUIDField(null=True)
@@ -42,7 +41,6 @@ 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.TextField(blank=True, null=True)
+    avatar_url = models.URLField(blank=True, null=True)
 
     def __str__(self):
         """Return provider of the integration"""

apiserver/plane/db/models/issue_type.py

@@ -19,8 +19,6 @@ 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/notification.py

@@ -6,6 +6,7 @@ from django.db import models
 from .base import BaseModel
 
 
+
 class Notification(BaseModel):
     workspace = models.ForeignKey(
         "db.Workspace", related_name="notifications", on_delete=models.CASCADE
@@ -89,31 +90,12 @@ class UserNotificationPreference(BaseModel):
         null=True,
     )
 
-    # email preference fields
-    email_property_change = models.BooleanField(default=False)
-    email_state_change = models.BooleanField(default=False)
-    email_priority_change = models.BooleanField(default=False)
-    email_assignee_change = models.BooleanField(default=False)
-    email_start_target_date_change = models.BooleanField(default=False)
-    email_module_change = models.BooleanField(default=False)
-    email_cycle_change = models.BooleanField(default=False)
-    email_reactions = models.BooleanField(default=False)
-    email_comment = models.BooleanField(default=False)
-    email_mention = models.BooleanField(default=False)
-    email_issue_completed = models.BooleanField(default=False)
-
-    # in app preference fields
-    in_app_property_change = models.BooleanField(default=False)
-    in_app_state_change = models.BooleanField(default=False)
-    in_app_priority_change = models.BooleanField(default=False)
-    in_app_assignee_change = models.BooleanField(default=False)
-    in_app_start_target_date_change = models.BooleanField(default=False)
-    in_app_module_change = models.BooleanField(default=False)
-    in_app_cycle_change = models.BooleanField(default=False)
-    in_app_reactions = models.BooleanField(default=False)
-    in_app_comment = models.BooleanField(default=False)
-    in_app_mention = models.BooleanField(default=False)
-    in_app_issue_completed = models.BooleanField(default=False)
+    # 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)
 
     class Meta:
         verbose_name = "UserNotificationPreference"

apiserver/plane/db/models/project.py

@@ -99,14 +99,7 @@ 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.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",
-    )
+    cover_image = models.URLField(blank=True, null=True, max_length=800)
     estimate = models.ForeignKey(
         "db.Estimate",
         on_delete=models.SET_NULL,
@@ -133,18 +126,6 @@ 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}>"

apiserver/plane/db/models/user.py

@@ -17,7 +17,6 @@ from django.dispatch import receiver
 from django.utils import timezone
 
 # Module imports
-from plane.db.models import FileAsset
 from ..mixins import TimeAuditModel
 
 
@@ -49,24 +48,8 @@ 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(
@@ -128,28 +111,6 @@ 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
@@ -221,11 +182,7 @@ 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)
@@ -252,4 +209,9 @@ 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,
         )

apiserver/plane/db/models/workspace.py

@@ -118,14 +118,7 @@ def slug_validator(value):
 
 class Workspace(BaseModel):
     name = models.CharField(max_length=80, verbose_name="Workspace Name")
-    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,
-    )
+    logo = models.URLField(verbose_name="Logo", blank=True, null=True)
     owner = models.ForeignKey(
         settings.AUTH_USER_MODEL,
         on_delete=models.CASCADE,
@@ -145,17 +138,6 @@ 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,7 +11,6 @@ class InstanceAdminMeSerializer(BaseSerializer):
         fields = [
             "id",
             "avatar",
-            "avatar_url",
             "cover_image",
             "date_joined",
             "display_name",

apiserver/plane/settings/common.py

@@ -72,6 +72,7 @@ INSTALLED_APPS = [
     "rest_framework",
     "corsheaders",
     "django_celery_beat",
+    "storages",
 ]
 
 # Middlewares
@@ -258,7 +259,7 @@ STORAGES = {
     },
 }
 STORAGES["default"] = {
-    "BACKEND": "plane.settings.storage.S3Storage",
+    "BACKEND": "storages.backends.s3boto3.S3Boto3Storage",
 }
 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")
@@ -383,61 +384,3 @@ 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

@@ -1,154 +0,0 @@
-# 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,
-    FileAsset,
+    IssueAttachment,
     IssueReaction,
     CommentReaction,
     IssueVote,
@@ -174,7 +174,7 @@ class IssueLinkSerializer(BaseSerializer):
 
 class IssueAttachmentSerializer(BaseSerializer):
     class Meta:
-        model = FileAsset
+        model = IssueAttachment
         fields = "__all__"
         read_only_fields = [
             "created_by",

apiserver/plane/space/serializer/user.py

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

apiserver/plane/space/urls/__init__.py

@@ -1,12 +1,10 @@
 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

@@ -1,32 +0,0 @@
-# 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,17 +1,8 @@
 # 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,
-    CharField,
-)
-from django.db.models.functions import Coalesce, JSONObject, Concat
+from django.db.models import Q, UUIDField, Value, F, Case, When, JSONField
+from django.db.models.functions import Coalesce, JSONObject
 
 # Module imports
 from plane.db.models import (
@@ -25,7 +16,6 @@ from plane.db.models import (
     WorkspaceMember,
 )
 
-
 def issue_queryset_grouper(queryset, group_by, sub_group_by):
 
     FIELD_MAPPER = {
@@ -108,26 +98,18 @@ 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=Q(votes__isnull=False),
+            filter=Case(
+                When(votes__isnull=False, then=True),
+                default=False,
+                output_field=JSONField(),
+            ),
             distinct=True,
         ),
         reaction_items=ArrayAgg(
@@ -141,30 +123,18 @@ 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"),
-                            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"
-                            ),
+                            display_name=F("issue_reactions__actor__display_name"),
                         ),
                     ),
                 ),
                 default=None,
                 output_field=JSONField(),
             ),
-            filter=Q(issue_reactions__isnull=False),
+            filter=Case(
+                When(issue_reactions__isnull=False, then=True),
+                default=False,
+                output_field=JSONField(),
+            ),
             distinct=True,
         ),
     ).values(*required_fields, "vote_items", "reaction_items")

apiserver/plane/space/views/__init__.py

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

apiserver/plane/space/views/asset.py

@@ -1,280 +0,0 @@
-# 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,
-    FileAsset,
+    IssueAttachment,
     DeployBoard,
 )
 from plane.app.serializers import (
@@ -95,9 +95,8 @@ class InboxIssuePublicViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))

apiserver/plane/space/views/issue.py

@@ -19,9 +19,7 @@ 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
@@ -61,7 +59,7 @@ from plane.db.models import (
     DeployBoard,
     IssueVote,
     ProjectPublicMember,
-    FileAsset,
+    IssueAttachment,
 )
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.utils.issue_filters import issue_filters
@@ -114,9 +112,8 @@ class ProjectIssuesPublicEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -749,26 +746,6 @@ 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"
                                     ),
@@ -800,26 +777,6 @@ 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

@@ -203,7 +203,7 @@ def burndown_plot(
     if module_id:
         # Get all dates between the two dates
         date_range = [
-            (queryset.start_date + timedelta(days=x))
+            (queryset.start_date + timedelta(days=x)).date()
             for x in range(
                 (queryset.target_date - queryset.start_date).days + 1
             )

apiserver/plane/utils/paginator.py

@@ -150,6 +150,7 @@ class OffsetPaginator:
             raise BadPaginationError("Pagination offset cannot be negative")
 
         results = queryset[offset:stop]
+
         if cursor.value != limit:
             results = results[-(limit + 1) :]
 
@@ -185,6 +186,7 @@ class OffsetPaginator:
 
 
 class GroupedOffsetPaginator(OffsetPaginator):
+
     # Field mappers - list m2m fields here
     FIELD_MAPPER = {
         "labels__id": "label_ids",
@@ -682,7 +684,7 @@ class SubGroupedOffsetPaginator(OffsetPaginator):
                     # for multi groups
                     result[
                         self.FIELD_MAPPER.get(self.sub_group_by_field_name)
-                    ] = [] if "None" in sub_group_ids else sub_group_ids
+                    ] = ([] if "None" in sub_group_ids else sub_group_ids)
                 # If a result belongs to multiple groups, add it to each group
                 processed_results[str(group_value)]["results"][
                     str(sub_group_value)
@@ -759,6 +761,7 @@ 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:

apiserver/requirements/base.txt

@@ -1,7 +1,7 @@
 # base requirements
 
 # django
-Django==4.2.16
+Django==4.2.15
 # rest framework
 djangorestframework==3.15.2
 # postgres 

live/package.json

@@ -1,6 +1,6 @@
 {
   "name": "live",
-  "version": "0.23.1",
+  "version": "0.23.0",
   "description": "",
   "main": "./src/server.ts",
   "private": true,

package.json

@@ -1,6 +1,6 @@
 {
   "repository": "https://github.com/makeplane/plane.git",
-  "version": "0.23.1",
+  "version": "0.23.0",
   "license": "AGPL-3.0",
   "private": true,
   "workspaces": [

packages/constants/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plane/constants",
-  "version": "0.23.1",
+  "version": "0.23.0",
   "private": true,
   "main": "./index.ts"
 }

packages/editor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plane/editor",
-  "version": "0.23.1",
+  "version": "0.23.0",
   "description": "Core Editor that powers Plane",
   "private": true,
   "main": "./dist/index.mjs",
@@ -48,7 +48,7 @@
     "@tiptap/extension-placeholder": "^2.3.0",
     "@tiptap/extension-task-item": "^2.1.13",
     "@tiptap/extension-task-list": "^2.1.13",
-    "@tiptap/extension-text-style": "^2.7.1",
+    "@tiptap/extension-text-style": "^2.1.13",
     "@tiptap/extension-underline": "^2.1.13",
     "@tiptap/pm": "^2.1.13",
     "@tiptap/react": "^2.1.13",

packages/editor/src/ce/extensions/document-extensions.tsx

@@ -1,6 +1,6 @@
 import { HocuspocusProvider } from "@hocuspocus/provider";
 import { Extensions } from "@tiptap/core";
-import { SlashCommands } from "@/extensions";
+import { SlashCommand } from "@/extensions";
 // plane editor types
 import { TIssueEmbedConfig } from "@/plane-editor/types";
 // types
@@ -14,7 +14,7 @@ type Props = {
 };
 
 export const DocumentEditorAdditionalExtensions = (_props: Props) => {
-  const extensions: Extensions = [SlashCommands()];
+  const extensions: Extensions = [SlashCommand()];
 
   return extensions;
 };

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

@@ -18,7 +18,6 @@ const CollaborativeDocumentReadOnlyEditor = (props: ICollaborativeDocumentReadOn
     displayConfig = DEFAULT_DISPLAY_CONFIG,
     editorClassName = "",
     embedHandler,
-    fileHandler,
     forwardedRef,
     handleEditorReady,
     id,
@@ -39,7 +38,6 @@ 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, TFileHandler } from "@/types";
+import { EditorReadOnlyRefApi, IMentionHighlight, TDisplayConfig } from "@/types";
 
 interface IDocumentReadOnlyEditor {
   id: string;
@@ -19,7 +19,6 @@ interface IDocumentReadOnlyEditor {
   displayConfig?: TDisplayConfig;
   editorClassName?: string;
   embedHandler: any;
-  fileHandler: Pick<TFileHandler, "getAssetSrc">;
   tabIndex?: number;
   handleEditorReady?: (value: boolean) => void;
   mentionHandler: {
@@ -34,7 +33,6 @@ const DocumentReadOnlyEditor = (props: IDocumentReadOnlyEditor) => {
     displayConfig = DEFAULT_DISPLAY_CONFIG,
     editorClassName = "",
     embedHandler,
-    fileHandler,
     id,
     forwardedRef,
     handleEditorReady,
@@ -53,7 +51,6 @@ 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,16 +14,14 @@ 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/editors/rich-text/editor.tsx

@@ -3,7 +3,7 @@ import { forwardRef, useCallback } from "react";
 import { EditorWrapper } from "@/components/editors";
 import { EditorBubbleMenu } from "@/components/menus";
 // extensions
-import { SideMenuExtension, SlashCommands } from "@/extensions";
+import { SideMenuExtension, SlashCommand } from "@/extensions";
 // types
 import { EditorRefApi, IRichTextEditor } from "@/types";
 
@@ -11,7 +11,7 @@ const RichTextEditor = (props: IRichTextEditor) => {
   const { dragDropEnabled } = props;
 
   const getExtensions = useCallback(() => {
-    const extensions = [SlashCommands()];
+    const extensions = [SlashCommand()];
 
     extensions.push(
       SideMenuExtension({

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

@@ -1,106 +0,0 @@
-import { Dispatch, FC, SetStateAction } from "react";
-import { Editor } from "@tiptap/react";
-import { ALargeSmall, Ban } from "lucide-react";
-// constants
-import { COLORS_LIST } from "@/constants/common";
-// helpers
-import { cn } from "@/helpers/common";
-import { BackgroundColorItem, TextColorItem } from "../menu-items";
-
-type Props = {
-  editor: Editor;
-  isOpen: boolean;
-  setIsOpen: Dispatch<SetStateAction<boolean>>;
-};
-
-export const BubbleMenuColorSelector: FC<Props> = (props) => {
-  const { editor, isOpen, setIsOpen } = props;
-
-  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">
-      <button
-        type="button"
-        onClick={(e) => {
-          setIsOpen(!isOpen);
-          e.stopPropagation();
-        }}
-        className="flex items-center gap-1 h-full whitespace-nowrap px-3 text-sm font-medium text-custom-text-300 hover:bg-custom-background-80 active:bg-custom-background-80 rounded transition-colors"
-      >
-        <span>Color</span>
-        <span
-          className={cn(
-            "flex-shrink-0 size-6 grid place-items-center rounded border-[0.5px] border-custom-border-300",
-            {
-              "bg-custom-background-100": !activeBackgroundColor,
-            }
-          )}
-          style={{
-            backgroundColor: activeBackgroundColor ? activeBackgroundColor.backgroundColor : "transparent",
-          }}
-        >
-          <ALargeSmall
-            className={cn("size-3.5", {
-              "text-custom-text-100": !activeTextColor,
-            })}
-            style={{
-              color: activeTextColor ? activeTextColor.textColor : "inherit",
-            }}
-          />
-        </span>
-      </button>
-      {isOpen && (
-        <section className="fixed top-full z-[99999] mt-1 rounded-md border-[0.5px] border-custom-border-300 bg-custom-background-100 p-2 space-y-2 shadow-custom-shadow-rg animate-in fade-in slide-in-from-top-1">
-          <div className="space-y-1.5">
-            <p className="text-xs text-custom-text-300 font-semibold">Text colors</p>
-            <div className="flex items-center gap-2">
-              {COLORS_LIST.map((color) => (
-                <button
-                  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.key)}
-                />
-              ))}
-              <button
-                type="button"
-                className="flex-shrink-0 size-6 grid place-items-center rounded text-custom-text-300 border-[0.5px] border-custom-border-400 hover:bg-custom-background-80 transition-colors"
-                onClick={() => TextColorItem(editor).command(undefined)}
-              >
-                <Ban className="size-4" />
-              </button>
-            </div>
-          </div>
-          <div className="space-y-1.5">
-            <p className="text-xs text-custom-text-300 font-semibold">Background colors</p>
-            <div className="flex items-center gap-2">
-              {COLORS_LIST.map((color) => (
-                <button
-                  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.key)}
-                />
-              ))}
-              <button
-                type="button"
-                className="flex-shrink-0 size-6 grid place-items-center rounded text-custom-text-300 border-[0.5px] border-custom-border-400 hover:bg-custom-background-80 transition-colors"
-                onClick={() => BackgroundColorItem(editor).command(undefined)}
-              >
-                <Ban className="size-4" />
-              </button>
-            </div>
-          </div>
-        </section>
-      )}
-    </div>
-  );
-};

packages/editor/src/core/components/menus/bubble-menu/index.ts

@@ -1,4 +1,3 @@
-export * from "./color-selector";
 export * from "./link-selector";
 export * from "./node-selector";
 export * from "./root";

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

@@ -1,6 +1,6 @@
 import { Dispatch, FC, SetStateAction, useCallback, useEffect, useRef } from "react";
 import { Editor } from "@tiptap/core";
-import { Check, Link, Trash } from "lucide-react";
+import { Check, Trash } from "lucide-react";
 // helpers
 import { cn, isValidHttpUrl } from "@/helpers/common";
 import { setLinkEditor, unsetLinkEditor } from "@/helpers/editor-commands";
@@ -11,9 +11,7 @@ type Props = {
   setIsOpen: Dispatch<SetStateAction<boolean>>;
 };
 
-export const BubbleMenuLinkSelector: FC<Props> = (props) => {
-  const { editor, isOpen, setIsOpen } = props;
-  // refs
+export const BubbleMenuLinkSelector: FC<Props> = ({ editor, isOpen, setIsOpen }) => {
   const inputRef = useRef<HTMLInputElement>(null);
 
   const onLinkSubmit = useCallback(() => {
@@ -30,23 +28,26 @@ export const BubbleMenuLinkSelector: FC<Props> = (props) => {
   });
 
   return (
-    <div className="relative h-full">
+    <div className="relative">
       <button
         type="button"
         className={cn(
-          "h-full flex items-center gap-1 px-3 text-sm font-medium text-custom-text-300 hover:bg-custom-background-80 active:bg-custom-background-80 rounded transition-colors",
-          {
-            "bg-custom-background-80": isOpen,
-            "text-custom-text-100": editor.isActive("link"),
-          }
+          "flex h-full items-center space-x-2 px-3 py-1.5 text-sm font-medium text-custom-text-300 hover:bg-custom-background-100 active:bg-custom-background-100",
+          { "bg-custom-background-100": isOpen }
         )}
         onClick={(e) => {
           setIsOpen(!isOpen);
           e.stopPropagation();
         }}
       >
-        <span>Link</span>
-        <Link className="flex-shrink-0 size-3" />
+        <p className="text-base">↗</p>
+        <p
+          className={cn("underline underline-offset-4", {
+            "text-custom-text-100": editor.isActive("link"),
+          })}
+        >
+          Link
+        </p>
       </button>
       {isOpen && (
         <div

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

@@ -15,7 +15,7 @@ import {
   HeadingFourItem,
   HeadingFiveItem,
   HeadingSixItem,
-  EditorMenuItem,
+  BubbleMenuItem,
 } from "@/components/menus";
 // helpers
 import { cn } from "@/helpers/common";
@@ -26,10 +26,8 @@ type Props = {
   setIsOpen: Dispatch<SetStateAction<boolean>>;
 };
 
-export const BubbleMenuNodeSelector: FC<Props> = (props) => {
-  const { editor, isOpen, setIsOpen } = props;
-
-  const items: EditorMenuItem[] = [
+export const BubbleMenuNodeSelector: FC<Props> = ({ editor, isOpen, setIsOpen }) => {
+  const items: BubbleMenuItem[] = [
     TextItem(editor),
     HeadingOneItem(editor),
     HeadingTwoItem(editor),
@@ -44,7 +42,7 @@ export const BubbleMenuNodeSelector: FC<Props> = (props) => {
     CodeItem(editor),
   ];
 
-  const activeItem = items.filter((item) => item.isActive("")).pop() ?? {
+  const activeItem = items.filter((item) => item.isActive()).pop() ?? {
     name: "Multiple",
   };
 
@@ -56,11 +54,12 @@ export const BubbleMenuNodeSelector: FC<Props> = (props) => {
           setIsOpen(!isOpen);
           e.stopPropagation();
         }}
-        className="flex items-center gap-1 h-full whitespace-nowrap px-3 text-sm font-medium text-custom-text-300 hover:bg-custom-background-80 active:bg-custom-background-80 rounded transition-colors"
+        className="flex h-full items-center gap-1 whitespace-nowrap p-2 text-sm font-medium text-custom-text-300 hover:bg-custom-primary-100/5 active:bg-custom-primary-100/5"
       >
         <span>{activeItem?.name}</span>
-        <ChevronDown className="flex-shrink-0 size-3" />
+        <ChevronDown className="h-4 w-4" />
       </button>
+
       {isOpen && (
         <section className="fixed top-full z-[99999] mt-1 flex w-48 flex-col overflow-hidden rounded-md border-[0.5px] border-custom-border-300 bg-custom-background-100 px-2 py-2.5 shadow-custom-shadow-rg animate-in fade-in slide-in-from-top-1">
           {items.map((item) => (

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

@@ -1,13 +1,12 @@
 import { FC, useEffect, useState } from "react";
 import { BubbleMenu, BubbleMenuProps, isNodeSelection } from "@tiptap/react";
+import { LucideIcon } from "lucide-react";
 // components
 import {
   BoldItem,
-  BubbleMenuColorSelector,
   BubbleMenuLinkSelector,
   BubbleMenuNodeSelector,
   CodeItem,
-  EditorMenuItem,
   ItalicItem,
   StrikeThroughItem,
   UnderLineItem,
@@ -17,23 +16,34 @@ import { isCellSelection } from "@/extensions/table/table/utilities/is-cell-sele
 // helpers
 import { cn } from "@/helpers/common";
 
+export interface BubbleMenuItem {
+  key: string;
+  name: string;
+  isActive: () => boolean;
+  command: () => void;
+  icon: LucideIcon;
+}
+
 type EditorBubbleMenuProps = Omit<BubbleMenuProps, "children">;
 
 export const EditorBubbleMenu: FC<EditorBubbleMenuProps> = (props: any) => {
-  // states
-  const [isNodeSelectorOpen, setIsNodeSelectorOpen] = useState(false);
-  const [isLinkSelectorOpen, setIsLinkSelectorOpen] = useState(false);
-  const [isColorSelectorOpen, setIsColorSelectorOpen] = useState(false);
-  const [isSelecting, setIsSelecting] = useState(false);
-
-  const items: EditorMenuItem[] = props.editor.isActive("code")
-    ? [CodeItem(props.editor)]
-    : [BoldItem(props.editor), ItalicItem(props.editor), UnderLineItem(props.editor), StrikeThroughItem(props.editor)];
+  const items: BubbleMenuItem[] = [
+    ...(props.editor.isActive("code")
+      ? []
+      : [
+          BoldItem(props.editor),
+          ItalicItem(props.editor),
+          UnderLineItem(props.editor),
+          StrikeThroughItem(props.editor),
+        ]),
+    CodeItem(props.editor),
+  ];
 
   const bubbleMenuProps: EditorBubbleMenuProps = {
     ...props,
     shouldShow: ({ state, editor }) => {
       const { selection } = state;
+
       const { empty } = selection;
 
       if (
@@ -53,11 +63,15 @@ export const EditorBubbleMenu: FC<EditorBubbleMenuProps> = (props: any) => {
       onHidden: () => {
         setIsNodeSelectorOpen(false);
         setIsLinkSelectorOpen(false);
-        setIsColorSelectorOpen(false);
       },
     },
   };
 
+  const [isNodeSelectorOpen, setIsNodeSelectorOpen] = useState(false);
+  const [isLinkSelectorOpen, setIsLinkSelectorOpen] = useState(false);
+
+  const [isSelecting, setIsSelecting] = useState(false);
+
   useEffect(() => {
     function handleMouseDown() {
       function handleMouseMove() {
@@ -88,66 +102,51 @@ export const EditorBubbleMenu: FC<EditorBubbleMenuProps> = (props: any) => {
   return (
     <BubbleMenu
       {...bubbleMenuProps}
-      className="flex py-2 divide-x divide-custom-border-200 rounded-lg border border-custom-border-200 bg-custom-background-100 shadow-custom-shadow-rg"
+      className="flex w-fit divide-x divide-custom-border-300 rounded border border-custom-border-300 bg-custom-background-100 shadow-xl"
     >
-      {!isSelecting && (
+      {isSelecting ? null : (
         <>
-          <div className="px-2">
-            {!props.editor.isActive("table") && (
-              <BubbleMenuNodeSelector
-                editor={props.editor!}
-                isOpen={isNodeSelectorOpen}
-                setIsOpen={() => {
-                  setIsNodeSelectorOpen((prev) => !prev);
-                  setIsLinkSelectorOpen(false);
-                  setIsColorSelectorOpen(false);
-                }}
-              />
-            )}
-          </div>
-          <div className="px-2">
-            {!props.editor.isActive("code") && (
-              <BubbleMenuLinkSelector
-                editor={props.editor}
-                isOpen={isLinkSelectorOpen}
-                setIsOpen={() => {
-                  setIsLinkSelectorOpen((prev) => !prev);
-                  setIsNodeSelectorOpen(false);
-                  setIsColorSelectorOpen(false);
-                }}
-              />
-            )}
-          </div>
-          <div className="px-2">
-            {!props.editor.isActive("code") && (
-              <BubbleMenuColorSelector
-                editor={props.editor}
-                isOpen={isColorSelectorOpen}
-                setIsOpen={() => {
-                  setIsColorSelectorOpen((prev) => !prev);
-                  setIsNodeSelectorOpen(false);
-                  setIsLinkSelectorOpen(false);
-                }}
-              />
-            )}
-          </div>
-          <div className="flex gap-0.5 px-2">
+          {!props.editor.isActive("table") && (
+            <BubbleMenuNodeSelector
+              editor={props.editor!}
+              isOpen={isNodeSelectorOpen}
+              setIsOpen={() => {
+                setIsNodeSelectorOpen(!isNodeSelectorOpen);
+                setIsLinkSelectorOpen(false);
+              }}
+            />
+          )}
+          {!props.editor.isActive("code") && (
+            <BubbleMenuLinkSelector
+              editor={props.editor}
+              isOpen={isLinkSelectorOpen}
+              setIsOpen={() => {
+                setIsLinkSelectorOpen(!isLinkSelectorOpen);
+                setIsNodeSelectorOpen(false);
+              }}
+            />
+          )}
+          <div className="flex">
             {items.map((item) => (
               <button
-                key={item.key}
+                key={item.name}
                 type="button"
                 onClick={(e) => {
                   item.command();
                   e.stopPropagation();
                 }}
                 className={cn(
-                  "size-7 grid place-items-center rounded text-custom-text-300 hover:bg-custom-background-80 active:bg-custom-background-80 transition-colors",
+                  "p-2 text-custom-text-300 transition-colors hover:bg-custom-primary-100/5 active:bg-custom-primary-100/5",
                   {
-                    "bg-custom-background-80 text-custom-text-100": item.isActive(""),
+                    "bg-custom-primary-100/5 text-custom-text-100": item.isActive(),
                   }
                 )}
               >
-                <item.icon className="size-4" />
+                <item.icon
+                  className={cn("h-4 w-4", {
+                    "text-custom-text-100": item.isActive(),
+                  })}
+                />
               </button>
             ))}
           </div>

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

@@ -20,14 +20,12 @@ import {
   Heading6,
   CaseSensitive,
   LucideIcon,
-  Palette,
 } from "lucide-react";
 // helpers
 import {
   insertImage,
   insertTableCommand,
   setText,
-  toggleBackgroundColor,
   toggleBlockquote,
   toggleBold,
   toggleBulletList,
@@ -42,26 +40,18 @@ import {
   toggleOrderedList,
   toggleStrike,
   toggleTaskList,
-  toggleTextColor,
   toggleUnderline,
 } from "@/helpers/editor-commands";
 // types
-import { TColorEditorCommands, TNonColorEditorCommands } from "@/types";
+import { TEditorCommands } from "@/types";
 
-export type EditorMenuItem = {
+export interface EditorMenuItem {
+  key: TEditorCommands;
   name: string;
-  command: (...args: any) => void;
+  isActive: () => boolean;
+  command: () => void;
   icon: LucideIcon;
-} & (
-  | {
-      key: TNonColorEditorCommands;
-      isActive: () => boolean;
-    }
-  | {
-      key: TColorEditorCommands;
-      isActive: (color: string | undefined) => boolean;
-    }
-);
+}
 
 export const TextItem = (editor: Editor): EditorMenuItem => ({
   key: "text",
@@ -208,25 +198,10 @@ export const ImageItem = (editor: Editor) =>
     icon: ImageIcon,
   }) as const;
 
-export const TextColorItem = (editor: Editor): EditorMenuItem => ({
-  key: "text-color",
-  name: "Color",
-  isActive: (color) => editor.getAttributes("textStyle").color === color,
-  command: (color: string) => toggleTextColor(color, editor),
-  icon: Palette,
-});
-
-export const BackgroundColorItem = (editor: Editor): EditorMenuItem => ({
-  key: "background-color",
-  name: "Background color",
-  isActive: (color) => editor.getAttributes("textStyle").backgroundColor === color,
-  command: (color: string) => toggleBackgroundColor(color, editor),
-  icon: Palette,
-});
-
-export const getEditorMenuItems = (editor: Editor | null): EditorMenuItem[] => {
-  if (!editor) return [];
-
+export function getEditorMenuItems(editor: Editor | null) {
+  if (!editor) {
+    return [];
+  }
   return [
     TextItem(editor),
     HeadingOneItem(editor),
@@ -246,7 +221,5 @@ export const getEditorMenuItems = (editor: Editor | null): EditorMenuItem[] => {
     QuoteItem(editor),
     TableItem(editor),
     ImageItem(editor),
-    TextColorItem(editor),
-    BackgroundColorItem(editor),
   ];
-};
+}

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

@@ -1,61 +0,0 @@
-export const COLORS_LIST: {
-  key: string;
-  label: string;
-  textColor: string;
-  backgroundColor: string;
-}[] = [
-  {
-    key: "gray",
-    label: "Gray",
-    textColor: "var(--editor-colors-gray-text)",
-    backgroundColor: "var(--editor-colors-gray-background)",
-  },
-  {
-    key: "peach",
-    label: "Peach",
-    textColor: "var(--editor-colors-peach-text)",
-    backgroundColor: "var(--editor-colors-peach-background)",
-  },
-  {
-    key: "pink",
-    label: "Pink",
-    textColor: "var(--editor-colors-pink-text)",
-    backgroundColor: "var(--editor-colors-pink-background)",
-  },
-  {
-    key: "orange",
-    label: "Orange",
-    textColor: "var(--editor-colors-orange-text)",
-    backgroundColor: "var(--editor-colors-orange-background)",
-  },
-  {
-    key: "green",
-    label: "Green",
-    textColor: "var(--editor-colors-green-text)",
-    backgroundColor: "var(--editor-colors-green-background)",
-  },
-  {
-    key: "light-blue",
-    label: "Light blue",
-    textColor: "var(--editor-colors-light-blue-text)",
-    backgroundColor: "var(--editor-colors-light-blue-background)",
-  },
-  {
-    key: "dark-blue",
-    label: "Dark blue",
-    textColor: "var(--editor-colors-dark-blue-text)",
-    backgroundColor: "var(--editor-colors-dark-blue-background)",
-  },
-  {
-    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

@@ -16,8 +16,6 @@ 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,8 +83,6 @@ export const CoreEditorExtensionsWithoutProps = [
   TableCell,
   TableRow,
   CustomMentionWithoutProps(),
-  CustomTextColorExtension,
-  CustomBackgroundColorExtension,
 ];
 
 export const DocumentEditorExtensionsWithoutProps = [IssueWidgetWithoutProps()];

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

@@ -1,78 +0,0 @@
-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,7 +42,6 @@ type CustomImageBlockProps = CustomImageNodeViewProps & {
   setFailedToLoadImage: (isError: boolean) => void;
   editorContainer: HTMLDivElement | null;
   setEditorContainer: (editorContainer: HTMLDivElement | null) => void;
-  src: string;
 };
 
 export const CustomImageBlock: React.FC<CustomImageBlockProps> = (props) => {
@@ -56,10 +55,9 @@ export const CustomImageBlock: React.FC<CustomImageBlockProps> = (props) => {
     getPos,
     editor,
     editorContainer,
-    src: remoteImageSrc,
     setEditorContainer,
   } = props;
-  const { width, height, aspectRatio } = node.attrs;
+  const { src: remoteImageSrc, width, height, aspectRatio } = node.attrs;
   // states
   const [size, setSize] = useState<Size>({
     width: ensurePixelString(width, "35%"),
@@ -208,7 +206,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,8 +54,6 @@ 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}
@@ -69,7 +67,6 @@ export const CustomImageNode = (props: CustomImageNodeViewProps) => {
             failedToLoadImage={failedToLoadImage}
             getPos={getPos}
             loadImageFromFileSystem={setImageFromFileSystem}
-            maxFileSize={editor.storage.imageComponent.maxFileSize}
             node={node}
             setIsUploaded={setIsUploaded}
             selected={selected}