fix: install script container availability check

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

CONTRIBUTING.md

@@ -4,7 +4,7 @@ Thank you for showing an interest in contributing to Plane! All kinds of contrib
 
 ## Submitting an issue
 
-Before submitting a new issue, please search the [issues](https://github.com/makeplane/plane/issues) tab. Maybe an issue or discussion already exists and might inform you of workarounds. Otherwise, you can give new information.
+Before submitting a new issue, please search the [issues](https://github.com/makeplane/plane/issues) tab. Maybe an issue or discussion already exists and might inform you of workarounds. Otherwise, you can give new informplaneation.
 
 While we want to fix all the [issues](https://github.com/makeplane/plane/issues), before fixing a bug we need to be able to reproduce and confirm it. Please provide us with a minimal reproduction scenario using a repository or [Gist](https://gist.github.com/). Having a live, reproducible scenario gives us the information without asking questions back & forth with additional questions like:
 

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.22.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.22.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().date())
+                | 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().date()
+        ):
             if "sort_order" in request_data:
                 # Can only change sort order
                 request_data = {
@@ -537,7 +537,7 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
         cycle = Cycle.objects.get(
             pk=cycle_id, project_id=project_id, workspace__slug=slug
         )
-        if cycle.end_date >= timezone.now():
+        if cycle.end_date >= timezone.now().date():
             return Response(
                 {"error": "Only completed cycles can be archived"},
                 status=status.HTTP_400_BAD_REQUEST,
@@ -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"],
@@ -1189,7 +1146,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
 
         if (
             new_cycle.end_date is not None
-            and new_cycle.end_date < timezone.now()
+            and new_cycle.end_date < timezone.now().date()
         ):
             return Response(
                 {

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/__init__.py

@@ -124,9 +124,3 @@ from .webhook import WebhookSerializer, WebhookLogSerializer
 from .dashboard import DashboardSerializer, WidgetSerializer
 
 from .favorite import UserFavoriteSerializer
-
-from .draft import (
-    DraftIssueCreateSerializer,
-    DraftIssueSerializer,
-    DraftIssueDetailSerializer,
-)

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

@@ -1,292 +0,0 @@
-# Django imports
-from django.utils import timezone
-
-# Third Party imports
-from rest_framework import serializers
-
-# Module imports
-from .base import BaseSerializer
-from plane.db.models import (
-    User,
-    Issue,
-    Label,
-    State,
-    DraftIssue,
-    DraftIssueAssignee,
-    DraftIssueLabel,
-    DraftIssueCycle,
-    DraftIssueModule,
-)
-
-
-class DraftIssueCreateSerializer(BaseSerializer):
-    # ids
-    state_id = serializers.PrimaryKeyRelatedField(
-        source="state",
-        queryset=State.objects.all(),
-        required=False,
-        allow_null=True,
-    )
-    parent_id = serializers.PrimaryKeyRelatedField(
-        source="parent",
-        queryset=Issue.objects.all(),
-        required=False,
-        allow_null=True,
-    )
-    label_ids = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
-        write_only=True,
-        required=False,
-    )
-    assignee_ids = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
-        write_only=True,
-        required=False,
-    )
-
-    class Meta:
-        model = DraftIssue
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-    def to_representation(self, instance):
-        data = super().to_representation(instance)
-        assignee_ids = self.initial_data.get("assignee_ids")
-        data["assignee_ids"] = assignee_ids if assignee_ids else []
-        label_ids = self.initial_data.get("label_ids")
-        data["label_ids"] = label_ids if label_ids else []
-        return data
-
-    def validate(self, data):
-        if (
-            data.get("start_date", None) is not None
-            and data.get("target_date", None) is not None
-            and data.get("start_date", None) > data.get("target_date", None)
-        ):
-            raise serializers.ValidationError(
-                "Start date cannot exceed target date"
-            )
-        return data
-
-    def create(self, validated_data):
-        assignees = validated_data.pop("assignee_ids", None)
-        labels = validated_data.pop("label_ids", None)
-        modules = validated_data.pop("module_ids", None)
-        cycle_id = self.initial_data.get("cycle_id", None)
-        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
-        created_by_id = issue.created_by_id
-        updated_by_id = issue.updated_by_id
-
-        if assignees is not None and len(assignees):
-            DraftIssueAssignee.objects.bulk_create(
-                [
-                    DraftIssueAssignee(
-                        assignee=user,
-                        draft_issue=issue,
-                        workspace_id=workspace_id,
-                        project_id=project_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for user in assignees
-                ],
-                batch_size=10,
-            )
-
-        if labels is not None and len(labels):
-            DraftIssueLabel.objects.bulk_create(
-                [
-                    DraftIssueLabel(
-                        label=label,
-                        draft_issue=issue,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for label in labels
-                ],
-                batch_size=10,
-            )
-
-        if cycle_id is not None:
-            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,
-            )
-
-        if modules is not None and len(modules):
-            DraftIssueModule.objects.bulk_create(
-                [
-                    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,
-                    )
-                    for module_id in modules
-                ],
-                batch_size=10,
-            )
-
-        return issue
-
-    def update(self, instance, validated_data):
-        assignees = validated_data.pop("assignee_ids", None)
-        labels = validated_data.pop("label_ids", None)
-        cycle_id = self.context.get("cycle_id", None)
-        modules = self.initial_data.get("module_ids", None)
-
-        # Related models
-        workspace_id = instance.workspace_id
-        project_id = instance.project_id
-
-        created_by_id = instance.created_by_id
-        updated_by_id = instance.updated_by_id
-
-        if assignees is not None:
-            DraftIssueAssignee.objects.filter(draft_issue=instance).delete()
-            DraftIssueAssignee.objects.bulk_create(
-                [
-                    DraftIssueAssignee(
-                        assignee=user,
-                        draft_issue=instance,
-                        workspace_id=workspace_id,
-                        project_id=project_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for user in assignees
-                ],
-                batch_size=10,
-            )
-
-        if labels is not None:
-            DraftIssueLabel.objects.filter(draft_issue=instance).delete()
-            DraftIssueLabel.objects.bulk_create(
-                [
-                    DraftIssueLabel(
-                        label=label,
-                        draft_issue=instance,
-                        workspace_id=workspace_id,
-                        project_id=project_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for label in labels
-                ],
-                batch_size=10,
-            )
-
-        if cycle_id != "not_provided":
-            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,
-                )
-
-        if modules is not None:
-            DraftIssueModule.objects.filter(draft_issue=instance).delete()
-            DraftIssueModule.objects.bulk_create(
-                [
-                    DraftIssueModule(
-                        module_id=module_id,
-                        draft_issue=instance,
-                        workspace_id=workspace_id,
-                        project_id=project_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for module_id in modules
-                ],
-                batch_size=10,
-            )
-
-        # Time updation occurs even when other related models are updated
-        instance.updated_at = timezone.now()
-        return super().update(instance, validated_data)
-
-
-class DraftIssueSerializer(BaseSerializer):
-    # ids
-    cycle_id = serializers.PrimaryKeyRelatedField(read_only=True)
-    module_ids = serializers.ListField(
-        child=serializers.UUIDField(),
-        required=False,
-    )
-
-    # Many to many
-    label_ids = serializers.ListField(
-        child=serializers.UUIDField(),
-        required=False,
-    )
-    assignee_ids = serializers.ListField(
-        child=serializers.UUIDField(),
-        required=False,
-    )
-
-    class Meta:
-        model = DraftIssue
-        fields = [
-            "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",
-        ]
-        read_only_fields = fields
-
-
-class DraftIssueDetailSerializer(DraftIssueSerializer):
-    description_html = serializers.CharField()
-
-    class Meta(DraftIssueSerializer.Meta):
-        fields = DraftIssueSerializer.Meta.fields + [
-            "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

@@ -11,6 +11,7 @@ from plane.app.views import (
     IssueActivityEndpoint,
     IssueArchiveViewSet,
     IssueCommentViewSet,
+    IssueDraftViewSet,
     IssueListEndpoint,
     IssueReactionViewSet,
     IssueRelationViewSet,
@@ -21,7 +22,6 @@ from plane.app.views import (
     BulkArchiveIssuesEndpoint,
     DeletedIssuesListViewSet,
     IssuePaginatedViewSet,
-    IssueAttachmentV2Endpoint,
 )
 
 urlpatterns = [
@@ -42,7 +42,7 @@ urlpatterns = [
     ),
     # updated v2 paginated issues
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/v2/issues/",
+        "workspaces/<str:slug>/v2/issues/",
         IssuePaginatedViewSet.as_view({"get": "list"}),
         name="project-issues-paginated",
     ),
@@ -133,18 +133,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(),
@@ -302,6 +290,28 @@ urlpatterns = [
         name="issue-relation",
     ),
     ## End Issue Relation
+    ## Issue Drafts
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-drafts/",
+        IssueDraftViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-draft",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-drafts/<uuid:pk>/",
+        IssueDraftViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-draft",
+    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/deleted-issues/",
         DeletedIssuesListViewSet.as_view(),

apiserver/plane/app/urls/workspace.py

@@ -27,7 +27,6 @@ from plane.app.views import (
     WorkspaceCyclesEndpoint,
     WorkspaceFavoriteEndpoint,
     WorkspaceFavoriteGroupEndpoint,
-    WorkspaceDraftIssueViewSet,
 )
 
 
@@ -255,30 +254,4 @@ urlpatterns = [
         WorkspaceFavoriteGroupEndpoint.as_view(),
         name="workspace-user-favorites-groups",
     ),
-    path(
-        "workspaces/<str:slug>/draft-issues/",
-        WorkspaceDraftIssueViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
-        name="workspace-draft-issues",
-    ),
-    path(
-        "workspaces/<str:slug>/draft-issues/<uuid:pk>/",
-        WorkspaceDraftIssueViewSet.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="workspace-drafts-issues",
-    ),
-    path(
-        "workspaces/<str:slug>/draft-to-issue/<uuid:draft_id>/",
-        WorkspaceDraftIssueViewSet.as_view({"post": "create_draft_to_issue"}),
-        name="workspace-drafts-issues",
-    ),
 ]

apiserver/plane/app/views/__init__.py

@@ -40,8 +40,6 @@ from .workspace.base import (
     ExportWorkspaceUserActivityEndpoint,
 )
 
-from .workspace.draft import WorkspaceDraftIssueViewSet
-
 from .workspace.favorite import (
     WorkspaceFavoriteEndpoint,
     WorkspaceFavoriteGroupEndpoint,
@@ -110,19 +108,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 +126,6 @@ from .issue.archive import IssueArchiveViewSet, BulkArchiveIssuesEndpoint
 
 from .issue.attachment import (
     IssueAttachmentEndpoint,
-    # V2
-    IssueAttachmentV2Endpoint,
 )
 
 from .issue.comment import (
@@ -149,6 +133,8 @@ from .issue.comment import (
     CommentReactionViewSet,
 )
 
+from .issue.draft import IssueDraftViewSet
+
 from .issue.label import (
     LabelViewSet,
     BulkCreateIssueLabelsEndpoint,

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(
@@ -624,7 +604,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
             pk=cycle_id, project_id=project_id, workspace__slug=slug
         )
 
-        if cycle.end_date >= timezone.now():
+        if cycle.end_date >= timezone.now().date():
             return Response(
                 {"error": "Only completed cycles can be archived"},
                 status=status.HTTP_400_BAD_REQUEST,

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().date()
+        ):
             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"],
@@ -968,7 +925,7 @@ class TransferCycleIssueEndpoint(BaseAPIView):
 
         if (
             new_cycle.end_date is not None
-            and new_cycle.end_date < timezone.now()
+            and new_cycle.end_date < timezone.now().date()
         ):
             return Response(
                 {
@@ -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().date()
+        ):
             return Response(
                 {
                     "error": "The Cycle has already been completed so no new issues can be added"

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

@@ -36,10 +36,12 @@ from plane.db.models import (
     DashboardWidget,
     Issue,
     IssueActivity,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
     IssueRelation,
     Project,
+    ProjectMember,
+    User,
     Widget,
     WorkspaceMember,
 )
@@ -56,8 +58,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 +85,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 +110,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 +136,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 +197,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 +360,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/estimate/base.py

@@ -1,9 +1,5 @@
 import random
 import string
-import json
-
-# Django imports
-from django.utils import timezone
 
 # Third party imports
 from rest_framework.response import Response
@@ -23,7 +19,6 @@ from plane.app.serializers import (
     EstimateReadSerializer,
 )
 from plane.utils.cache import invalidate_cache
-from plane.bgtasks.issue_activities_task import issue_activity
 
 
 def generate_random_name(length=10):
@@ -254,66 +249,11 @@ class EstimatePointEndpoint(BaseViewSet):
         )
         # update all the issues with the new estimate
         if new_estimate_id:
-            issues = Issue.objects.filter(
+            _ = Issue.objects.filter(
                 project_id=project_id,
                 workspace__slug=slug,
                 estimate_point_id=estimate_point_id,
-            )
-            for issue in issues:
-                issue_activity.delay(
-                    type="issue.activity.updated",
-                    requested_data=json.dumps(
-                        {
-                            "estimate_point": (
-                                str(new_estimate_id)
-                                if new_estimate_id
-                                else None
-                            ),
-                        }
-                    ),
-                    actor_id=str(request.user.id),
-                    issue_id=issue.id,
-                    project_id=str(project_id),
-                    current_instance=json.dumps(
-                        {
-                            "estimate_point": (
-                                str(issue.estimate_point_id)
-                                if issue.estimate_point_id
-                                else None
-                            ),
-                        }
-                    ),
-                    epoch=int(timezone.now().timestamp()),
-                )
-                issues.update(estimate_point_id=new_estimate_id)
-        else:
-            issues = Issue.objects.filter(
-                project_id=project_id,
-                workspace__slug=slug,
-                estimate_point_id=estimate_point_id,
-            )
-            for issue in issues:
-                issue_activity.delay(
-                    type="issue.activity.updated",
-                    requested_data=json.dumps(
-                        {
-                            "estimate_point": None,
-                        }
-                    ),
-                    actor_id=str(request.user.id),
-                    issue_id=issue.id,
-                    project_id=str(project_id),
-                    current_instance=json.dumps(
-                        {
-                            "estimate_point": (
-                                str(issue.estimate_point_id)
-                                if issue.estimate_point_id
-                                else None
-                            ),
-                        }
-                    ),
-                    epoch=int(timezone.now().timestamp()),
-                )
+            ).update(estimate_point_id=new_estimate_id)
 
         # delete the estimate point
         old_estimate_point = EstimatePoint.objects.filter(

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",
@@ -737,12 +741,17 @@ class DeletedIssuesListViewSet(BaseAPIView):
 class IssuePaginatedViewSet(BaseViewSet):
     def get_queryset(self):
         workspace_slug = self.kwargs.get("slug")
-        project_id = self.kwargs.get("project_id")
+
+        # getting the project_id from the request params
+        project_id = self.request.GET.get("project_id", None)
 
         issue_queryset = Issue.issue_objects.filter(
-            workspace__slug=workspace_slug, project_id=project_id
+            workspace__slug=workspace_slug
         )
 
+        if project_id:
+            issue_queryset = issue_queryset.filter(project_id=project_id)
+
         return (
             issue_queryset.select_related(
                 "workspace", "project", "state", "parent"
@@ -755,6 +764,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")
@@ -776,8 +793,8 @@ class IssuePaginatedViewSet(BaseViewSet):
 
         return paginated_data
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def list(self, request, slug, project_id):
+    def list(self, request, slug):
+        project_id = self.request.GET.get("project_id", None)
         cursor = request.GET.get("cursor", None)
         is_description_required = request.GET.get("description", False)
         updated_at = request.GET.get("updated_at__gt", None)
@@ -816,26 +833,14 @@ class IssuePaginatedViewSet(BaseViewSet):
             required_fields.append("description_html")
 
         # querying issues
-        base_queryset = Issue.issue_objects.filter(
-            workspace__slug=slug, project_id=project_id
-        )
+        base_queryset = Issue.issue_objects.filter(workspace__slug=slug)
+
+        if project_id:
+            base_queryset = base_queryset.filter(project_id=project_id)
 
         base_queryset = base_queryset.order_by("updated_at")
         queryset = self.get_queryset().order_by("updated_at")
 
-        # validation for guest user
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-        project_member = ProjectMember.objects.filter(
-            workspace__slug=slug,
-            project_id=project_id,
-            member=request.user,
-            role=5,
-            is_active=True,
-        )
-        if project_member.exists() and not project.guest_view_all_features:
-            base_queryset = base_queryset.filter(created_by=request.user)
-            queryset = queryset.filter(created_by=request.user)
-
         # filtering issues by greater then updated_at given by the user
         if updated_at:
             base_queryset = base_queryset.filter(updated_at__gt=updated_at)

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

@@ -0,0 +1,410 @@
+# Python imports
+import json
+
+# Django imports
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.core.serializers.json import DjangoJSONEncoder
+from django.db.models import (
+    Exists,
+    F,
+    Func,
+    OuterRef,
+    Prefetch,
+    Q,
+    UUIDField,
+    Value,
+)
+from django.db.models.functions import Coalesce
+from django.utils import timezone
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+
+# Third Party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.permissions import ProjectEntityPermission
+from plane.app.serializers import (
+    IssueCreateSerializer,
+    IssueDetailSerializer,
+    IssueFlatSerializer,
+    IssueSerializer,
+)
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.db.models import (
+    Issue,
+    IssueAttachment,
+    IssueLink,
+    IssueReaction,
+    IssueSubscriber,
+    Project,
+    ProjectMember,
+)
+from plane.utils.grouper import (
+    issue_group_values,
+    issue_on_results,
+    issue_queryset_grouper,
+)
+from plane.utils.issue_filters import issue_filters
+from plane.utils.order_queryset import order_issue_queryset
+from plane.utils.paginator import (
+    GroupedOffsetPaginator,
+    SubGroupedOffsetPaginator,
+)
+from .. import BaseViewSet
+
+
+class IssueDraftViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+    serializer_class = IssueFlatSerializer
+    model = Issue
+
+    def get_queryset(self):
+        return (
+            Issue.objects.filter(project_id=self.kwargs.get("project_id"))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(is_draft=True)
+            .filter(deleted_at__isnull=True)
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module")
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+        ).distinct()
+
+    @method_decorator(gzip_page)
+    def list(self, request, slug, project_id):
+        filters = issue_filters(request.query_params, "GET")
+
+        order_by_param = request.GET.get("order_by", "-created_at")
+
+        issue_queryset = self.get_queryset().filter(**filters)
+        # Issue queryset
+        issue_queryset, order_by_param = order_issue_queryset(
+            issue_queryset=issue_queryset,
+            order_by_param=order_by_param,
+        )
+
+        # Group by
+        group_by = request.GET.get("group_by", False)
+        sub_group_by = request.GET.get("sub_group_by", False)
+
+        # issue queryset
+        issue_queryset = issue_queryset_grouper(
+            queryset=issue_queryset,
+            group_by=group_by,
+            sub_group_by=sub_group_by,
+        )
+
+        if group_by:
+            # Check group and sub group value paginate
+            if sub_group_by:
+                if group_by == sub_group_by:
+                    return Response(
+                        {
+                            "error": "Group by and sub group by cannot have same parameters"
+                        },
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+                else:
+                    # group and sub group pagination
+                    return self.paginate(
+                        request=request,
+                        order_by=order_by_param,
+                        queryset=issue_queryset,
+                        on_results=lambda issues: issue_on_results(
+                            group_by=group_by,
+                            issues=issues,
+                            sub_group_by=sub_group_by,
+                        ),
+                        paginator_cls=SubGroupedOffsetPaginator,
+                        group_by_fields=issue_group_values(
+                            field=group_by,
+                            slug=slug,
+                            project_id=project_id,
+                            filters=filters,
+                        ),
+                        sub_group_by_fields=issue_group_values(
+                            field=sub_group_by,
+                            slug=slug,
+                            project_id=project_id,
+                            filters=filters,
+                        ),
+                        group_by_field_name=group_by,
+                        sub_group_by_field_name=sub_group_by,
+                        count_filter=Q(
+                            Q(issue_inbox__status=1)
+                            | Q(issue_inbox__status=-1)
+                            | Q(issue_inbox__status=2)
+                            | Q(issue_inbox__isnull=True),
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+            # Group Paginate
+            else:
+                # Group paginate
+                return self.paginate(
+                    request=request,
+                    order_by=order_by_param,
+                    queryset=issue_queryset,
+                    on_results=lambda issues: issue_on_results(
+                        group_by=group_by,
+                        issues=issues,
+                        sub_group_by=sub_group_by,
+                    ),
+                    paginator_cls=GroupedOffsetPaginator,
+                    group_by_fields=issue_group_values(
+                        field=group_by,
+                        slug=slug,
+                        project_id=project_id,
+                        filters=filters,
+                    ),
+                    group_by_field_name=group_by,
+                    count_filter=Q(
+                        Q(issue_inbox__status=1)
+                        | Q(issue_inbox__status=-1)
+                        | Q(issue_inbox__status=2)
+                        | Q(issue_inbox__isnull=True),
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+        else:
+            # List Paginate
+            return self.paginate(
+                order_by=order_by_param,
+                request=request,
+                queryset=issue_queryset,
+                on_results=lambda issues: issue_on_results(
+                    group_by=group_by, issues=issues, sub_group_by=sub_group_by
+                ),
+            )
+
+    def create(self, request, slug, project_id):
+        project = Project.objects.get(pk=project_id)
+
+        serializer = IssueCreateSerializer(
+            data=request.data,
+            context={
+                "project_id": project_id,
+                "workspace_id": project.workspace_id,
+                "default_assignee_id": project.default_assignee_id,
+            },
+        )
+
+        if serializer.is_valid():
+            serializer.save(is_draft=True)
+
+            # Track the issue
+            issue_activity.delay(
+                type="issue_draft.activity.created",
+                requested_data=json.dumps(
+                    self.request.data, cls=DjangoJSONEncoder
+                ),
+                actor_id=str(request.user.id),
+                issue_id=str(serializer.data.get("id", None)),
+                project_id=str(project_id),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+
+            issue = (
+                issue_queryset_grouper(
+                    queryset=self.get_queryset().filter(
+                        pk=serializer.data["id"]
+                    ),
+                    group_by=None,
+                    sub_group_by=None,
+                )
+                .values(
+                    "id",
+                    "name",
+                    "state_id",
+                    "sort_order",
+                    "completed_at",
+                    "estimate_point",
+                    "priority",
+                    "start_date",
+                    "target_date",
+                    "sequence_id",
+                    "project_id",
+                    "parent_id",
+                    "cycle_id",
+                    "module_ids",
+                    "label_ids",
+                    "assignee_ids",
+                    "sub_issues_count",
+                    "created_at",
+                    "updated_at",
+                    "created_by",
+                    "updated_by",
+                    "attachment_count",
+                    "link_count",
+                    "is_draft",
+                    "archived_at",
+                )
+                .first()
+            )
+            return Response(issue, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def partial_update(self, request, slug, project_id, pk):
+        issue = self.get_queryset().filter(pk=pk).first()
+
+        if not issue:
+            return Response(
+                {"error": "Issue does not exist"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        serializer = IssueCreateSerializer(
+            issue, data=request.data, partial=True
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+            issue_activity.delay(
+                type="issue_draft.activity.updated",
+                requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("pk", None)),
+                project_id=str(self.kwargs.get("project_id", None)),
+                current_instance=json.dumps(
+                    IssueSerializer(issue).data,
+                    cls=DjangoJSONEncoder,
+                ),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def retrieve(self, request, slug, project_id, pk=None):
+        issue = (
+            self.get_queryset()
+            .filter(pk=pk)
+            .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(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=~Q(issue_module__module_id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_reactions",
+                    queryset=IssueReaction.objects.select_related(
+                        "issue", "actor"
+                    ),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_attachment",
+                    queryset=IssueAttachment.objects.select_related("issue"),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_link",
+                    queryset=IssueLink.objects.select_related("created_by"),
+                )
+            )
+            .annotate(
+                is_subscribed=Exists(
+                    IssueSubscriber.objects.filter(
+                        workspace__slug=slug,
+                        project_id=project_id,
+                        issue_id=OuterRef("pk"),
+                        subscriber=request.user,
+                    )
+                )
+            )
+        ).first()
+
+        if not issue:
+            return Response(
+                {"error": "The required object does not exist."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        serializer = IssueDetailSerializer(issue, expand=self.expand)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def destroy(self, request, slug, project_id, pk=None):
+        issue = Issue.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
+        if issue.created_by_id != request.user.id and (
+            not ProjectMember.objects.filter(
+                workspace__slug=slug,
+                member=request.user,
+                role=20,
+                project_id=project_id,
+                is_active=True,
+            ).exists()
+        ):
+            return Response(
+                {"error": "Only admin or creator can delete the issue"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+        issue.delete()
+        issue_activity.delay(
+            type="issue_draft.activity.deleted",
+            requested_data=json.dumps({"issue_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(pk),
+            project_id=str(project_id),
+            current_instance={},
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)

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):
@@ -414,20 +413,9 @@ class ProjectViewSet(BaseViewSet):
                 status=status.HTTP_410_GONE,
             )
 
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
     def partial_update(self, request, slug, pk=None):
         try:
-            if not ProjectMember.objects.filter(
-                member=request.user,
-                workspace__slug=slug,
-                project_id=pk,
-                role=20,
-                is_active=True,
-            ).exists():
-                return Response(
-                    {"error": "You don't have the required permissions."},
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-
             workspace = Workspace.objects.get(slug=slug)
 
             project = Project.objects.get(pk=pk)
@@ -509,44 +497,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 +671,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,334 +0,0 @@
-# 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 (
-    F,
-    Q,
-    UUIDField,
-    Value,
-)
-from django.db.models.functions import Coalesce
-from django.utils.decorators import method_decorator
-from django.views.decorators.gzip import gzip_page
-
-# Third Party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from plane.app.permissions import allow_permission, ROLE
-from plane.app.serializers import (
-    IssueCreateSerializer,
-    DraftIssueCreateSerializer,
-    DraftIssueSerializer,
-    DraftIssueDetailSerializer,
-)
-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"))
-            .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())),
-                ),
-            )
-        ).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,
-        )
-
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
-    )
-    def create(self, request, slug):
-        workspace = Workspace.objects.get(slug=slug)
-
-        serializer = DraftIssueCreateSerializer(
-            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.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER],
-        creator=True,
-        model=Issue,
-        level="WORKSPACE",
-    )
-    def partial_update(self, request, slug, pk):
-        issue = (
-            self.get_queryset().filter(pk=pk, created_by=request.user).first()
-        )
-
-        if not issue:
-            return Response(
-                {"error": "Issue not found"},
-                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"),
-            },
-        )
-
-        if serializer.is_valid():
-            serializer.save()
-
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN],
-        creator=True,
-        model=Issue,
-        level="WORKSPACE",
-    )
-    def retrieve(self, request, slug, pk=None):
-        issue = (
-            self.get_queryset().filter(pk=pk, created_by=request.user).first()
-        )
-
-        if not issue:
-            return Response(
-                {"error": "The required object does not exist."},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-
-        serializer = DraftIssueDetailSerializer(issue)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    @allow_permission(
-        allowed_roles=[ROLE.ADMIN],
-        creator=True,
-        model=DraftIssue,
-        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/member.py

@@ -74,6 +74,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
 
         # Get all active workspace members
         workspace_members = self.get_queryset()
+
         if workspace_member.role > 5:
             serializer = WorkspaceMemberAdminSerializer(
                 workspace_members,

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,
@@ -505,7 +504,7 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
 
         upcoming_cycles = CycleIssue.objects.filter(
             workspace__slug=slug,
-            cycle__start_date__gt=timezone.now(),
+            cycle__start_date__gt=timezone.now().date(),
             issue__assignees__in=[
                 user_id,
             ],
@@ -513,8 +512,8 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
 
         present_cycle = CycleIssue.objects.filter(
             workspace__slug=slug,
-            cycle__start_date__lt=timezone.now(),
-            cycle__end_date__gt=timezone.now(),
+            cycle__start_date__lt=timezone.now().date(),
+            cycle__end_date__gt=timezone.now().date(),
             issue__assignees__in=[
                 user_id,
             ],

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/deletion_task.py

@@ -2,7 +2,6 @@
 from django.utils import timezone
 from django.apps import apps
 from django.conf import settings
-from django.db import models
 from django.core.exceptions import ObjectDoesNotExist
 
 # Third party imports
@@ -19,25 +18,17 @@ def soft_delete_related_objects(
     for field in related_fields:
         if field.one_to_many or field.one_to_one:
             try:
-                # Check if the field has CASCADE on delete
-                if (
-                    hasattr(field.remote_field, "on_delete")
-                    and field.remote_field.on_delete == models.CASCADE
-                ):
-                    if field.one_to_many:
-                        related_objects = getattr(instance, field.name).all()
-                    elif field.one_to_one:
-                        related_object = getattr(instance, field.name)
-                        related_objects = (
-                            [related_object]
-                            if related_object is not None
-                            else []
-                        )
-
-                    for obj in related_objects:
-                        if obj:
-                            obj.deleted_at = timezone.now()
-                            obj.save(using=using)
+                if field.one_to_many:
+                    related_objects = getattr(instance, field.name).all()
+                elif field.one_to_one:
+                    related_object = getattr(instance, field.name)
+                    related_objects = (
+                        [related_object] if related_object is not None else []
+                    )
+                for obj in related_objects:
+                    if obj:
+                        obj.deleted_at = timezone.now()
+                        obj.save(using=using)
             except ObjectDoesNotExist:
                 pass
 
@@ -163,7 +154,8 @@ def hard_delete():
         if hasattr(model, "deleted_at"):
             # Get all instances where 'deleted_at' is greater than 30 days ago
             _ = model.all_objects.filter(
-                deleted_at__lt=timezone.now() - timezone.timedelta(days=days)
+                deleted_at__lt=timezone.now()
+                - timezone.timedelta(days=days)
             ).delete()
 
     return

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/bgtasks/issue_activities_task.py

@@ -465,7 +465,7 @@ def track_estimate_points(
             IssueActivity(
                 issue_id=issue_id,
                 actor_id=actor_id,
-                verb="removed" if new_estimate is None else "updated",
+                verb="updated",
                 old_identifier=(
                     current_instance.get("estimate_point")
                     if current_instance.get("estimate_point") is not None
@@ -1700,12 +1700,16 @@ def issue_activity(
                     event=(
                         "issue_comment"
                         if activity.field == "comment"
-                        else "inbox_issue" if inbox else "issue"
+                        else "inbox_issue"
+                        if inbox
+                        else "issue"
                     ),
                     event_id=(
                         activity.issue_comment_id
                         if activity.field == "comment"
-                        else inbox if inbox else activity.issue_id
+                        else inbox
+                        if inbox
+                        else activity.issue_id
                     ),
                     verb=activity.verb,
                     field=(

apiserver/plane/bgtasks/issue_automation_task.py

@@ -42,12 +42,14 @@ def archive_old_issues():
                 ),
                 Q(issue_cycle__isnull=True)
                 | (
-                    Q(issue_cycle__cycle__end_date__lt=timezone.now())
+                    Q(issue_cycle__cycle__end_date__lt=timezone.now().date())
                     & Q(issue_cycle__isnull=False)
                 ),
                 Q(issue_module__isnull=True)
                 | (
-                    Q(issue_module__module__target_date__lt=timezone.now())
+                    Q(
+                        issue_module__module__target_date__lt=timezone.now().date()
+                    )
                     & Q(issue_module__isnull=False)
                 ),
             ).filter(
@@ -120,12 +122,14 @@ def close_old_issues():
                 ),
                 Q(issue_cycle__isnull=True)
                 | (
-                    Q(issue_cycle__cycle__end_date__lt=timezone.now())
+                    Q(issue_cycle__cycle__end_date__lt=timezone.now().date())
                     & Q(issue_cycle__isnull=False)
                 ),
                 Q(issue_module__isnull=True)
                 | (
-                    Q(issue_module__module__target_date__lt=timezone.now())
+                    Q(
+                        issue_module__module__target_date__lt=timezone.now().date()
+                    )
                     & Q(issue_module__isnull=False)
                 ),
             ).filter(

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

@@ -5,7 +5,6 @@ from .base import BaseModel
 from .cycle import Cycle, CycleFavorite, CycleIssue, CycleUserProperties
 from .dashboard import Dashboard, DashboardWidget, Widget
 from .deploy_board import DeployBoard
-from .draft import DraftIssue, DraftIssueAssignee, DraftIssueLabel, DraftIssueModule, DraftIssueCycle
 from .estimate import Estimate, EstimatePoint
 from .exporter import ExporterHistory
 from .importer import Importer
@@ -24,6 +23,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/cycle.py

@@ -1,6 +1,3 @@
-# Python imports
-import pytz
-
 # Django imports
 from django.conf import settings
 from django.db import models
@@ -58,12 +55,10 @@ class Cycle(ProjectBaseModel):
     description = models.TextField(
         verbose_name="Cycle Description", blank=True
     )
-    start_date = models.DateTimeField(
+    start_date = models.DateField(
         verbose_name="Start Date", blank=True, null=True
     )
-    end_date = models.DateTimeField(
-        verbose_name="End Date", blank=True, null=True
-    )
+    end_date = models.DateField(verbose_name="End Date", blank=True, null=True)
     owned_by = models.ForeignKey(
         settings.AUTH_USER_MODEL,
         on_delete=models.CASCADE,
@@ -76,12 +71,6 @@ class Cycle(ProjectBaseModel):
     progress_snapshot = models.JSONField(default=dict)
     archived_at = models.DateTimeField(null=True)
     logo_props = models.JSONField(default=dict)
-    # timezone
-    TIMEZONE_CHOICES = tuple(zip(pytz.all_timezones, pytz.all_timezones))
-    timezone = models.CharField(
-        max_length=255, default="UTC", choices=TIMEZONE_CHOICES
-    )
-    version = models.IntegerField(default=1)
 
     class Meta:
         verbose_name = "Cycle"

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/draft.py

@@ -1,253 +0,0 @@
-# Django imports
-from django.conf import settings
-from django.db import models
-from django.utils import timezone
-
-# Module imports
-from plane.utils.html_processor import strip_tags
-
-from .workspace import WorkspaceBaseModel
-
-
-class DraftIssue(WorkspaceBaseModel):
-    PRIORITY_CHOICES = (
-        ("urgent", "Urgent"),
-        ("high", "High"),
-        ("medium", "Medium"),
-        ("low", "Low"),
-        ("none", "None"),
-    )
-    parent = models.ForeignKey(
-        "db.Issue",
-        on_delete=models.CASCADE,
-        null=True,
-        blank=True,
-        related_name="draft_parent_issue",
-    )
-    state = models.ForeignKey(
-        "db.State",
-        on_delete=models.CASCADE,
-        null=True,
-        blank=True,
-        related_name="state_draft_issue",
-    )
-    estimate_point = models.ForeignKey(
-        "db.EstimatePoint",
-        on_delete=models.SET_NULL,
-        related_name="draft_issue_estimates",
-        null=True,
-        blank=True,
-    )
-    name = models.CharField(
-        max_length=255, verbose_name="Issue Name", blank=True, null=True
-    )
-    description = models.JSONField(blank=True, default=dict)
-    description_html = models.TextField(blank=True, default="<p></p>")
-    description_stripped = models.TextField(blank=True, null=True)
-    description_binary = models.BinaryField(null=True)
-    priority = models.CharField(
-        max_length=30,
-        choices=PRIORITY_CHOICES,
-        verbose_name="Issue Priority",
-        default="none",
-    )
-    start_date = models.DateField(null=True, blank=True)
-    target_date = models.DateField(null=True, blank=True)
-    assignees = models.ManyToManyField(
-        settings.AUTH_USER_MODEL,
-        blank=True,
-        related_name="draft_assignee",
-        through="DraftIssueAssignee",
-        through_fields=("draft_issue", "assignee"),
-    )
-    labels = models.ManyToManyField(
-        "db.Label",
-        blank=True,
-        related_name="draft_labels",
-        through="DraftIssueLabel",
-    )
-    sort_order = models.FloatField(default=65535)
-    completed_at = models.DateTimeField(null=True)
-    external_source = models.CharField(max_length=255, null=True, blank=True)
-    external_id = models.CharField(max_length=255, blank=True, null=True)
-    type = models.ForeignKey(
-        "db.IssueType",
-        on_delete=models.SET_NULL,
-        related_name="draft_issue_type",
-        null=True,
-        blank=True,
-    )
-
-    class Meta:
-        verbose_name = "DraftIssue"
-        verbose_name_plural = "DraftIssues"
-        db_table = "draft_issues"
-        ordering = ("-created_at",)
-
-    def save(self, *args, **kwargs):
-        if self.state is None:
-            try:
-                from plane.db.models import State
-
-                default_state = State.objects.filter(
-                    ~models.Q(is_triage=True),
-                    project=self.project,
-                    default=True,
-                ).first()
-                if default_state is None:
-                    random_state = State.objects.filter(
-                        ~models.Q(is_triage=True), project=self.project
-                    ).first()
-                    self.state = random_state
-                else:
-                    self.state = default_state
-            except ImportError:
-                pass
-        else:
-            try:
-                from plane.db.models import State
-
-                if self.state.group == "completed":
-                    self.completed_at = timezone.now()
-                else:
-                    self.completed_at = None
-            except ImportError:
-                pass
-
-        if self._state.adding:
-            # Strip the html tags using html parser
-            self.description_stripped = (
-                None
-                if (
-                    self.description_html == ""
-                    or self.description_html is None
-                )
-                else strip_tags(self.description_html)
-            )
-            largest_sort_order = DraftIssue.objects.filter(
-                project=self.project, state=self.state
-            ).aggregate(largest=models.Max("sort_order"))["largest"]
-            if largest_sort_order is not None:
-                self.sort_order = largest_sort_order + 10000
-
-            super(DraftIssue, self).save(*args, **kwargs)
-
-        else:
-            # Strip the html tags using html parser
-            self.description_stripped = (
-                None
-                if (
-                    self.description_html == ""
-                    or self.description_html is None
-                )
-                else strip_tags(self.description_html)
-            )
-            super(DraftIssue, self).save(*args, **kwargs)
-
-    def __str__(self):
-        """Return name of the draft issue"""
-        return f"{self.name} <{self.project.name}>"
-
-
-class DraftIssueAssignee(WorkspaceBaseModel):
-    draft_issue = models.ForeignKey(
-        DraftIssue,
-        on_delete=models.CASCADE,
-        related_name="draft_issue_assignee",
-    )
-    assignee = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.CASCADE,
-        related_name="draft_issue_assignee",
-    )
-
-    class Meta:
-        unique_together = ["draft_issue", "assignee", "deleted_at"]
-        constraints = [
-            models.UniqueConstraint(
-                fields=["draft_issue", "assignee"],
-                condition=models.Q(deleted_at__isnull=True),
-                name="draft_issue_assignee_unique_issue_assignee_when_deleted_at_null",
-            )
-        ]
-        verbose_name = "Draft Issue Assignee"
-        verbose_name_plural = "Draft Issue Assignees"
-        db_table = "draft_issue_assignees"
-        ordering = ("-created_at",)
-
-    def __str__(self):
-        return f"{self.draft_issue.name} {self.assignee.email}"
-
-
-class DraftIssueLabel(WorkspaceBaseModel):
-    draft_issue = models.ForeignKey(
-        "db.DraftIssue",
-        on_delete=models.CASCADE,
-        related_name="draft_label_issue",
-    )
-    label = models.ForeignKey(
-        "db.Label", on_delete=models.CASCADE, related_name="draft_label_issue"
-    )
-
-    class Meta:
-        verbose_name = "Draft Issue Label"
-        verbose_name_plural = "Draft Issue Labels"
-        db_table = "draft_issue_labels"
-        ordering = ("-created_at",)
-
-    def __str__(self):
-        return f"{self.draft_issue.name} {self.label.name}"
-
-
-class DraftIssueModule(WorkspaceBaseModel):
-    module = models.ForeignKey(
-        "db.Module",
-        on_delete=models.CASCADE,
-        related_name="draft_issue_module",
-    )
-    draft_issue = models.ForeignKey(
-        "db.DraftIssue",
-        on_delete=models.CASCADE,
-        related_name="draft_issue_module",
-    )
-
-    class Meta:
-        unique_together = ["draft_issue", "module", "deleted_at"]
-        constraints = [
-            models.UniqueConstraint(
-                fields=["draft_issue", "module"],
-                condition=models.Q(deleted_at__isnull=True),
-                name="module_draft_issue_unique_issue_module_when_deleted_at_null",
-            )
-        ]
-        verbose_name = "Draft Issue Module"
-        verbose_name_plural = "Draft Issue Modules"
-        db_table = "draft_issue_modules"
-        ordering = ("-created_at",)
-
-    def __str__(self):
-        return f"{self.module.name} {self.draft_issue.name}"
-
-
-class DraftIssueCycle(WorkspaceBaseModel):
-    """
-    Draft Issue Cycles
-    """
-
-    draft_issue = models.OneToOneField(
-        "db.DraftIssue",
-        on_delete=models.CASCADE,
-        related_name="draft_issue_cycle",
-    )
-    cycle = models.ForeignKey(
-        "db.Cycle", on_delete=models.CASCADE, related_name="draft_issue_cycle"
-    )
-
-    class Meta:
-        verbose_name = "Draft Issue Cycle"
-        verbose_name_plural = "Draft Issue Cycles"
-        db_table = "draft_issue_cycles"
-        ordering = ("-created_at",)
-
-    def __str__(self):
-        return f"{self.cycle}"

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

@@ -1,5 +1,4 @@
 # Python imports
-import pytz
 from uuid import uuid4
 
 # Django imports
@@ -8,7 +7,7 @@ from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import models
 from django.db.models import Q
 
-# Module imports
+# Modeule imports
 from plane.db.mixins import AuditModel
 
 # Module imports
@@ -99,14 +98,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,
@@ -127,23 +119,6 @@ class Project(BaseModel):
         related_name="default_state",
     )
     archived_at = models.DateTimeField(null=True)
-    # timezone
-    TIMEZONE_CHOICES = tuple(zip(pytz.all_timezones, pytz.all_timezones))
-    timezone = models.CharField(
-        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"""

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/license/bgtasks/tracer.py

@@ -1,97 +0,0 @@
-# Third party imports
-from celery import shared_task
-from opentelemetry import trace
-
-# Module imports
-from plane.license.models import Instance
-from plane.db.models import (
-    User,
-    Workspace,
-    Project,
-    Issue,
-    Module,
-    Cycle,
-    CycleIssue,
-    ModuleIssue,
-    Page,
-    WorkspaceMember,
-)
-
-
-@shared_task
-def instance_traces():
-    # Get the tracer
-    tracer = trace.get_tracer(__name__)
-
-    # Check if the instance is registered
-    instance = Instance.objects.first()
-
-    # If instance is None then return
-    if instance is None:
-        return
-
-    if instance.is_telemetry_enabled:
-        # Instance details
-        with tracer.start_as_current_span("instance_details") as span:
-            # Count of all models
-            workspace_count = Workspace.objects.count()
-            user_count = User.objects.count()
-            project_count = Project.objects.count()
-            issue_count = Issue.objects.count()
-            module_count = Module.objects.count()
-            cycle_count = Cycle.objects.count()
-            cycle_issue_count = CycleIssue.objects.count()
-            module_issue_count = ModuleIssue.objects.count()
-            page_count = Page.objects.count()
-
-            # Set span attributes
-            span.set_attribute("instance_id", instance.instance_id)
-            span.set_attribute("instance_name", instance.instance_name)
-            span.set_attribute("current_version", instance.current_version)
-            span.set_attribute("latest_version", instance.latest_version)
-            span.set_attribute(
-                "is_telemetry_enabled", instance.is_telemetry_enabled
-            )
-            span.set_attribute("user_count", user_count)
-            span.set_attribute("workspace_count", workspace_count)
-            span.set_attribute("project_count", project_count)
-            span.set_attribute("issue_count", issue_count)
-            span.set_attribute("module_count", module_count)
-            span.set_attribute("cycle_count", cycle_count)
-            span.set_attribute("cycle_issue_count", cycle_issue_count)
-            span.set_attribute("module_issue_count", module_issue_count)
-            span.set_attribute("page_count", page_count)
-
-        # Workspace details
-        for workspace in Workspace.objects.all():
-            # Count of all models
-            project_count = Project.objects.filter(workspace=workspace).count()
-            issue_count = Issue.objects.filter(workspace=workspace).count()
-            module_count = Module.objects.filter(workspace=workspace).count()
-            cycle_count = Cycle.objects.filter(workspace=workspace).count()
-            cycle_issue_count = CycleIssue.objects.filter(
-                workspace=workspace
-            ).count()
-            module_issue_count = ModuleIssue.objects.filter(
-                workspace=workspace
-            ).count()
-            page_count = Page.objects.filter(workspace=workspace).count()
-            member_count = WorkspaceMember.objects.filter(
-                workspace=workspace
-            ).count()
-
-            # Set span attributes
-            with tracer.start_as_current_span("workspace_details") as span:
-                span.set_attribute("instance_id", instance.instance_id)
-                span.set_attribute("workspace_id", str(workspace.id))
-                span.set_attribute("workspace_slug", workspace.slug)
-                span.set_attribute("project_count", project_count)
-                span.set_attribute("issue_count", issue_count)
-                span.set_attribute("module_count", module_count)
-                span.set_attribute("cycle_count", cycle_count)
-                span.set_attribute("cycle_issue_count", cycle_issue_count)
-                span.set_attribute("module_issue_count", module_issue_count)
-                span.set_attribute("page_count", page_count)
-                span.set_attribute("member_count", member_count)
-
-    return

apiserver/plane/license/management/commands/register_instance.py

@@ -9,10 +9,7 @@ from django.conf import settings
 
 # Module imports
 from plane.license.models import Instance
-from plane.db.models import (
-    User,
-)
-from plane.license.bgtasks.tracer import instance_traces
+from plane.db.models import User
 
 
 class Command(BaseCommand):
@@ -24,24 +21,16 @@ class Command(BaseCommand):
             "machine_signature", type=str, help="Machine signature"
         )
 
-    def read_package_json(self):
-        with open("package.json", "r") as file:
-            # Load JSON content from the file
-            data = json.load(file)
-
-        payload = {
-            "instance_key": settings.INSTANCE_KEY,
-            "version": data.get("version", 0.1),
-            "user_count": User.objects.filter(is_bot=False).count(),
-        }
-        return payload
-
     def handle(self, *args, **options):
         # Check if the instance is registered
         instance = Instance.objects.first()
 
         # If instance is None then register this instance
         if instance is None:
+            with open("package.json", "r") as file:
+                # Load JSON content from the file
+                data = json.load(file)
+
             machine_signature = options.get(
                 "machine_signature", "machine-signature"
             )
@@ -49,7 +38,12 @@ class Command(BaseCommand):
             if not machine_signature:
                 raise CommandError("Machine signature is required")
 
-            payload = self.read_package_json()
+            payload = {
+                "instance_key": settings.INSTANCE_KEY,
+                "version": data.get("version", 0.1),
+                "machine_signature": machine_signature,
+                "user_count": User.objects.filter(is_bot=False).count(),
+            }
 
             instance = Instance.objects.create(
                 instance_name="Plane Community Edition",
@@ -66,15 +60,4 @@ class Command(BaseCommand):
             self.stdout.write(
                 self.style.SUCCESS("Instance already registered")
             )
-            payload = self.read_package_json()
-            # Update the instance details
-            instance.last_checked_at = timezone.now()
-            instance.user_count = payload.get("user_count", 0)
-            instance.current_version = payload.get("version")
-            instance.latest_version = payload.get("version")
-            instance.save()
-
-        # Call the instance traces task
-        instance_traces.delay()
-
-        return
+            return

apiserver/plane/settings/common.py

@@ -16,17 +16,6 @@ from sentry_sdk.integrations.django import DjangoIntegration
 from sentry_sdk.integrations.redis import RedisIntegration
 from corsheaders.defaults import default_headers
 
-# OpenTelemetry
-from opentelemetry import trace
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
-    OTLPSpanExporter,
-)
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.instrumentation.django import DjangoInstrumentor
-
-
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
 # Secret Key
@@ -35,19 +24,6 @@ SECRET_KEY = os.environ.get("SECRET_KEY", get_random_secret_key())
 # SECURITY WARNING: don't run with debug turned on in production!
 DEBUG = int(os.environ.get("DEBUG", "0"))
 
-# Initialize Django instrumentation
-DjangoInstrumentor().instrument()
-# Configure the tracer provider
-service_name = os.environ.get("SERVICE_NAME", "plane-ce-api")
-resource = Resource.create({"service.name": service_name})
-trace.set_tracer_provider(TracerProvider(resource=resource))
-# Configure the OTLP exporter
-otel_endpoint = os.environ.get("OTLP_ENDPOINT", "https://telemetry.plane.so")
-otlp_exporter = OTLPSpanExporter(endpoint=otel_endpoint)
-span_processor = BatchSpanProcessor(otlp_exporter)
-trace.get_tracer_provider().add_span_processor(span_processor)
-
-
 # Allowed Hosts
 ALLOWED_HOSTS = ["*"]
 
@@ -72,6 +48,7 @@ INSTALLED_APPS = [
     "rest_framework",
     "corsheaders",
     "django_celery_beat",
+    "storages",
 ]
 
 # Middlewares
@@ -258,7 +235,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")
@@ -302,7 +279,6 @@ CELERY_IMPORTS = (
     "plane.bgtasks.file_asset_task",
     "plane.bgtasks.email_notification_task",
     "plane.bgtasks.api_logs_task",
-    "plane.license.bgtasks.tracer",
     # management tasks
     "plane.bgtasks.dummy_data_task",
 )
@@ -383,61 +359,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

@@ -163,7 +163,7 @@ def burndown_plot(
         if queryset.end_date and queryset.start_date:
             # Get all dates between the two dates
             date_range = [
-                (queryset.start_date + timedelta(days=x)).date()
+                queryset.start_date + timedelta(days=x)
                 for x in range(
                     (queryset.end_date - queryset.start_date).days + 1
                 )
@@ -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)
             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 
@@ -62,8 +62,3 @@ zxcvbn==4.4.28
 pytz==2024.1
 # jwt
 PyJWT==2.8.0
-# OpenTelemetry
-opentelemetry-api==1.27.0
-opentelemetry-sdk==1.27.0
-opentelemetry-instrumentation-django==0.48b0
-opentelemetry-exporter-otlp==1.27.0

deploy/selfhost/install.sh

@@ -280,7 +280,7 @@ function download() {
 function startServices() {
     /bin/bash -c "$COMPOSE_CMD -f $DOCKER_FILE_PATH --env-file=$DOCKER_ENV_PATH up -d --pull if_not_present --quiet-pull"
 
-    local migrator_container_id=$(docker container ls -aq -f "name=$SERVICE_FOLDER-migrator")
+    local migrator_container_id=$(docker ps --format "{{.ID}} {{.Names}}" | grep -E "${SERVICE_FOLDER}(-migrator|_migrator)" | awk '{print $1}')
     if [ -n "$migrator_container_id" ]; then
         local idx=0
         while docker inspect --format='{{.State.Status}}' $migrator_container_id | grep -q "running"; do
@@ -308,7 +308,7 @@ function startServices() {
         fi
     fi
 
-    local api_container_id=$(docker container ls -q -f "name=$SERVICE_FOLDER-api")
+    local api_container_id=$(docker ps --format "{{.ID}} {{.Names}}" | grep -E "${SERVICE_FOLDER}(-api|_api)" | awk '{print $1}')
     local idx2=0
     while ! docker logs $api_container_id 2>&1 | grep -m 1 -i "Application startup complete" | grep -q ".";
     do

live/package.json

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

live/src/ce/lib/authentication.ts

@@ -0,0 +1,15 @@
+import { ConnectionConfiguration } from "@hocuspocus/server";
+// types
+import { TDocumentTypes } from "@/core/types/common.js";
+
+type TArgs = {
+  connection: ConnectionConfiguration
+  cookie: string;
+  documentType: TDocumentTypes | undefined;
+  params: URLSearchParams;
+}
+
+export const authenticateUser = async (args: TArgs): Promise<void> => {
+  const { documentType } = args;
+  throw Error(`Authentication failed: Invalid document type ${documentType} provided.`);
+}

live/src/core/hocuspocus-server.ts

@@ -12,11 +12,15 @@ export const getHocusPocusServer = async () => {
     name: serverName,
     onAuthenticate: async ({
       requestHeaders,
+      requestParameters,
+      connection,
       // user id used as token for authentication
       token,
     }) => {
       // request headers
       const cookie = requestHeaders.cookie?.toString();
+      // params
+      const params = requestParameters;
 
       if (!cookie) {
         throw Error("Credentials not provided");
@@ -24,7 +28,9 @@ export const getHocusPocusServer = async () => {
 
       try {
         await handleAuthentication({
+          connection,
           cookie,
+          params,
           token,
         });
       } catch (error) {
@@ -32,6 +38,6 @@ export const getHocusPocusServer = async () => {
       }
     },
     extensions,
-    debounce: 10000,
+    debounce: 10000
   });
 };

live/src/core/lib/authentication.ts

@@ -1,17 +1,28 @@
+import { ConnectionConfiguration } from "@hocuspocus/server";
 // services
 import { UserService } from "@/core/services/user.service.js";
+// types
+import { TDocumentTypes } from "@/core/types/common.js";
+// plane live lib
+import { authenticateUser } from "@/plane-live/lib/authentication.js";
 // core helpers
 import { manualLogger } from "@/core/helpers/logger.js";
 
 const userService = new UserService();
 
 type Props = {
+  connection: ConnectionConfiguration;
   cookie: string;
+  params: URLSearchParams;
   token: string;
 };
 
 export const handleAuthentication = async (props: Props) => {
-  const { cookie, token } = props;
+  const { connection, cookie, params, token } = props;
+  // params
+  const documentType = params.get("documentType")?.toString() as
+    | TDocumentTypes
+    | undefined;
   // fetch current user info
   let response;
   try {
@@ -24,6 +35,40 @@ export const handleAuthentication = async (props: Props) => {
     throw Error("Authentication failed: Token doesn't match the current user.");
   }
 
+  if (documentType === "project_page") {
+    // params
+    const workspaceSlug = params.get("workspaceSlug")?.toString();
+    const projectId = params.get("projectId")?.toString();
+    if (!workspaceSlug || !projectId) {
+      throw Error(
+        "Authentication failed: Incomplete query params. Either workspaceSlug or projectId is missing."
+      );
+    }
+    // fetch current user's project membership info
+    try {
+      const projectMembershipInfo = await userService.getUserProjectMembership(
+        workspaceSlug,
+        projectId,
+        cookie
+      );
+      const projectRole = projectMembershipInfo.role;
+      // make the connection read only for roles lower than a member
+      if (projectRole < 15) {
+        connection.readOnly = true;
+      }
+    } catch (error) {
+      manualLogger.error("Failed to fetch project membership info:", error);
+      throw error;
+    }
+  } else {
+    await authenticateUser({
+      connection,
+      cookie,
+      documentType,
+      params,
+    });
+  }
+
   return {
     user: {
       id: response.id,

live/src/core/services/user.service.ts

@@ -1,5 +1,5 @@
 // types
-import type { IUser } from "@plane/types";
+import type { IProjectMember, IUser } from "@plane/types";
 // services
 import { API_BASE_URL, APIService } from "@/core/services/api.service.js";
 
@@ -25,4 +25,37 @@ export class UserService extends APIService {
         throw error;
       });
   }
+
+  async getUserWorkspaceMembership(
+    workspaceSlug: string,
+    cookie: string
+  ): Promise<IProjectMember> {
+    return this.get(`/api/workspaces/${workspaceSlug}/workspace-members/me/`,
+      {
+        headers: {
+          Cookie: cookie,
+        },
+      })
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response;
+      });
+  }
+
+  async getUserProjectMembership(
+    workspaceSlug: string,
+    projectId: string,
+    cookie: string
+  ): Promise<IProjectMember> {
+    return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/project-members/me/`,
+      {
+        headers: {
+          Cookie: cookie,
+        },
+      })
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response;
+      });
+  }
 }

package.json

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