chore: squashed migration

* fix: workspace level issue creation

* dev: add draft issue support, fix your work tab and cache invalidation for workspace level logos

* chore: issue description

---------

Co-authored-by: Aaryan Khandelwal <aaryankhandu123@gmail.com>

.eslintrc-staged.js

@@ -1,59 +0,0 @@
-/**
- * Adds three new lint plugins over the existing configuration:
- * This is used to lint staged files only.
- * We should remove this file once the entire codebase follows these rules.
- */
-module.exports = {
-  root: true,
-  extends: [
-    "custom",
-  ],
-  parser: "@typescript-eslint/parser",
-  settings: {
-    "import/resolver": {
-      typescript: {},
-      node: {
-        moduleDirectory: ["node_modules", "."],
-      },
-    },
-  },
-  rules: {
-    "import/order": [
-      "error",
-      {
-        groups: ["builtin", "external", "internal", "parent", "sibling"],
-        pathGroups: [
-          {
-            pattern: "react",
-            group: "external",
-            position: "before",
-          },
-          {
-            pattern: "lucide-react",
-            group: "external",
-            position: "after",
-          },
-          {
-            pattern: "@headlessui/**",
-            group: "external",
-            position: "after",
-          },
-          {
-            pattern: "@plane/**",
-            group: "external",
-            position: "after",
-          },
-          {
-            pattern: "@/**",
-            group: "internal",
-          },
-        ],
-        pathGroupsExcludedImportTypes: ["builtin", "internal", "react"],
-        alphabetize: {
-          order: "asc",
-          caseInsensitive: true,
-        },
-      },
-    ],
-  },
-};

.eslintrc.js

@@ -1,10 +0,0 @@
-module.exports = {
-  root: true,
-  // This tells ESLint to load the config from the package `eslint-config-custom`
-  extends: ["custom"],
-  settings: {
-    next: {
-      rootDir: ["web/", "space/", "admin/"],
-    },
-  },
-};

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

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

.github/workflows/build-branch.yml

@@ -1,29 +1,45 @@
-name: Branch Build
+name: Branch Build CE
 
 on:
   workflow_dispatch:
     inputs:
+      build_type:
+        description: "Type of build to run"
+        required: true
+        type: choice
+        default: "Build"
+        options:
+          - "Build"
+          - "Release"
+      releaseVersion:
+        description: "Release Version"
+        type: string
+        default: v0.0.0
+      isPrerelease:
+        description: "Is Pre-release"
+        type: boolean
+        default: false
+        required: true
       arm64:
         description: "Build for ARM64 architecture"
         required: false
         default: false
         type: boolean
-  push:
-    branches:
-      - master
-      - preview
-  release:
-    types: [released, prereleased]
+  # push:
+  #   branches:
+  #     - master
 
 env:
-  TARGET_BRANCH: ${{ github.ref_name || github.event.release.target_commitish }}
+  TARGET_BRANCH: ${{ github.ref_name }}
   ARM64_BUILD: ${{ github.event.inputs.arm64 }}
-  IS_PRERELEASE: ${{ github.event.release.prerelease }}
+  BUILD_TYPE: ${{ github.event.inputs.build_type }}
+  RELEASE_VERSION: ${{ github.event.inputs.releaseVersion }}
+  IS_PRERELEASE: ${{ github.event.inputs.isPrerelease }}
 
 jobs:
   branch_build_setup:
     name: Build Setup
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
     outputs:
       gh_branch_name: ${{ steps.set_env_variables.outputs.TARGET_BRANCH }}
       gh_buildx_driver: ${{ steps.set_env_variables.outputs.BUILDX_DRIVER }}
@@ -36,13 +52,24 @@ jobs:
       build_space: ${{ steps.changed_files.outputs.space_any_changed }}
       build_web: ${{ steps.changed_files.outputs.web_any_changed }}
       build_live: ${{ steps.changed_files.outputs.live_any_changed }}
-      flat_branch_name: ${{ steps.set_env_variables.outputs.FLAT_BRANCH_NAME }}
+
+      dh_img_web: ${{ steps.set_env_variables.outputs.DH_IMG_WEB }}
+      dh_img_space: ${{ steps.set_env_variables.outputs.DH_IMG_SPACE }}
+      dh_img_admin: ${{ steps.set_env_variables.outputs.DH_IMG_ADMIN }}
+      dh_img_live: ${{ steps.set_env_variables.outputs.DH_IMG_LIVE }}
+      dh_img_backend: ${{ steps.set_env_variables.outputs.DH_IMG_BACKEND }}
+      dh_img_proxy: ${{ steps.set_env_variables.outputs.DH_IMG_PROXY }}
+
+      build_type: ${{steps.set_env_variables.outputs.BUILD_TYPE}}
+      build_release: ${{ steps.set_env_variables.outputs.BUILD_RELEASE }}
+      build_prerelease: ${{ steps.set_env_variables.outputs.BUILD_PRERELEASE }}
+      release_version: ${{ steps.set_env_variables.outputs.RELEASE_VERSION }}
 
     steps:
       - id: set_env_variables
         name: Set Environment Variables
         run: |
-          if [ "${{ env.TARGET_BRANCH }}" == "master" ] || [ "${{ env.ARM64_BUILD }}" == "true" ] || ([ "${{ github.event_name }}" == "release" ] && [ "${{ env.IS_PRERELEASE }}" != "true" ]); then
+          if [ "${{ env.ARM64_BUILD }}" == "true" ] || ([ "${{ env.BUILD_TYPE }}" == "Release" ] && [ "${{ env.IS_PRERELEASE }}" != "true" ]); then
             echo "BUILDX_DRIVER=cloud" >> $GITHUB_OUTPUT
             echo "BUILDX_VERSION=lab:latest" >> $GITHUB_OUTPUT
             echo "BUILDX_PLATFORMS=linux/amd64,linux/arm64" >> $GITHUB_OUTPUT
@@ -53,9 +80,43 @@ jobs:
             echo "BUILDX_PLATFORMS=linux/amd64" >> $GITHUB_OUTPUT
             echo "BUILDX_ENDPOINT=" >> $GITHUB_OUTPUT
           fi
-          echo "TARGET_BRANCH=${{ env.TARGET_BRANCH }}" >> $GITHUB_OUTPUT
-          flat_branch_name=$(echo ${{ env.TARGET_BRANCH }} | sed 's/[^a-zA-Z0-9\._]/-/g')
-          echo "FLAT_BRANCH_NAME=${flat_branch_name}" >> $GITHUB_OUTPUT
+          BR_NAME=$( echo "${{ env.TARGET_BRANCH }}" |sed 's/[^a-zA-Z0-9.-]//g')
+          echo "TARGET_BRANCH=$BR_NAME" >> $GITHUB_OUTPUT
+
+          echo "DH_IMG_WEB=plane-frontend" >> $GITHUB_OUTPUT
+          echo "DH_IMG_SPACE=plane-space" >> $GITHUB_OUTPUT
+          echo "DH_IMG_ADMIN=plane-admin" >> $GITHUB_OUTPUT
+          echo "DH_IMG_LIVE=plane-live" >> $GITHUB_OUTPUT
+          echo "DH_IMG_BACKEND=plane-backend" >> $GITHUB_OUTPUT
+          echo "DH_IMG_PROXY=plane-proxy" >> $GITHUB_OUTPUT
+
+          echo "BUILD_TYPE=${{env.BUILD_TYPE}}" >> $GITHUB_OUTPUT
+          BUILD_RELEASE=false
+          BUILD_PRERELEASE=false
+          RELVERSION="latest"
+
+          if [ "${{ env.BUILD_TYPE }}" == "Release" ]; then
+            FLAT_RELEASE_VERSION=$(echo "${{ env.RELEASE_VERSION }}" | sed 's/[^a-zA-Z0-9.-]//g')
+            echo "FLAT_RELEASE_VERSION=${FLAT_RELEASE_VERSION}" >> $GITHUB_OUTPUT
+
+            semver_regex="^v([0-9]+)\.([0-9]+)\.([0-9]+)(-[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*)?$"
+            if [[ ! $FLAT_RELEASE_VERSION =~ $semver_regex ]]; then
+              echo "Invalid Release Version Format : $FLAT_RELEASE_VERSION"
+              echo "Please provide a valid SemVer version"
+              echo "e.g. v1.2.3 or v1.2.3-alpha-1"
+              echo "Exiting the build process"
+              exit 1  # Exit with status 1 to fail the step
+            fi
+            BUILD_RELEASE=true
+            RELVERSION=$FLAT_RELEASE_VERSION
+
+            if [ "${{ env.IS_PRERELEASE }}" == "true" ]; then
+              BUILD_PRERELEASE=true
+            fi
+          fi
+          echo "BUILD_RELEASE=${BUILD_RELEASE}" >> $GITHUB_OUTPUT
+          echo "BUILD_PRERELEASE=${BUILD_PRERELEASE}" >> $GITHUB_OUTPUT
+          echo "RELEASE_VERSION=${RELVERSION}" >> $GITHUB_OUTPUT
 
       - id: checkout_files
         name: Checkout Files
@@ -73,24 +134,24 @@ jobs:
             admin:
               - admin/**
               - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
+              - "package.json"
+              - "yarn.lock"
+              - "tsconfig.json"
+              - "turbo.json"
             space:
               - space/**
               - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
+              - "package.json"
+              - "yarn.lock"
+              - "tsconfig.json"
+              - "turbo.json"
             web:
               - web/**
               - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
+              - "package.json"
+              - "yarn.lock"
+              - "tsconfig.json"
+              - "turbo.json"
             live:
               - live/**
               - packages/**
@@ -99,338 +160,224 @@ jobs:
               - 'tsconfig.json'
               - 'turbo.json'
 
-  branch_build_push_web:
-    if: ${{ needs.branch_build_setup.outputs.build_web == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
-    name: Build-Push Web Docker Image
-    runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
-    env:
-      FRONTEND_TAG: makeplane/plane-frontend:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
-    steps:
-      - name: Set Frontend Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-frontend:${{ github.event.release.tag_name }}
-            if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-frontend:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-frontend:latest
-          else
-            TAG=${{ env.FRONTEND_TAG }}
-          fi
-          echo "FRONTEND_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
-        uses: actions/checkout@v4
-
-      - name: Build and Push Frontend to Docker Container Registry
-        uses: docker/build-push-action@v5.1.0
-        with:
-          context: .
-          file: ./web/Dockerfile.web
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          tags: ${{ env.FRONTEND_TAG }}
-          push: true
-        env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
-
   branch_build_push_admin:
-    if: ${{ needs.branch_build_setup.outputs.build_admin== 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    if: ${{ needs.branch_build_setup.outputs.build_admin == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     name: Build-Push Admin Docker Image
     runs-on: ubuntu-20.04
     needs: [branch_build_setup]
-    env:
-      ADMIN_TAG: makeplane/plane-admin:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
     steps:
-      - name: Set Admin Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-admin:${{ github.event.release.tag_name }}
-            if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-admin:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-admin:latest
-          else
-            TAG=${{ env.ADMIN_TAG }}
-          fi
-          echo "ADMIN_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
+      - id: checkout_files
+        name: Checkout Files
         uses: actions/checkout@v4
-
-      - name: Build and Push Frontend to Docker Container Registry
-        uses: docker/build-push-action@v5.1.0
+      - name: Admin Build and Push
+        uses: ./.github/actions/buildpush-action
         with:
-          context: .
-          file: ./admin/Dockerfile.admin
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          tags: ${{ env.ADMIN_TAG }}
-          push: true
-        env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_admin }}
+          build-context: .
+          dockerfile-path: ./admin/Dockerfile.admin
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  branch_build_push_web:
+    if: ${{ needs.branch_build_setup.outputs.build_web == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    name: Build-Push Web Docker Image
+    runs-on: ubuntu-20.04
+    needs: [branch_build_setup]
+    steps:
+      - id: checkout_files
+        name: Checkout Files
+        uses: actions/checkout@v4
+      - name: Web Build and Push
+        uses: ./.github/actions/buildpush-action
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_web }}
+          build-context: .
+          dockerfile-path: ./web/Dockerfile.web
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
 
   branch_build_push_space:
-    if: ${{ needs.branch_build_setup.outputs.build_space == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    if: ${{ needs.branch_build_setup.outputs.build_space == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     name: Build-Push Space Docker Image
     runs-on: ubuntu-20.04
     needs: [branch_build_setup]
-    env:
-      SPACE_TAG: makeplane/plane-space:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
     steps:
-      - name: Set Space Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-space:${{ github.event.release.tag_name }}
-            if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-space:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-space:latest
-          else
-            TAG=${{ env.SPACE_TAG }}
-          fi
-          echo "SPACE_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
+      - id: checkout_files
+        name: Checkout Files
         uses: actions/checkout@v4
-
-      - name: Build and Push Space to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+      - name: Space Build and Push
+        uses: ./.github/actions/buildpush-action
         with:
-          context: .
-          file: ./space/Dockerfile.space
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          tags: ${{ env.SPACE_TAG }}
-          push: true
-        env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
-
-  branch_build_push_apiserver:
-    if: ${{ needs.branch_build_setup.outputs.build_apiserver == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
-    name: Build-Push API Server Docker Image
-    runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
-    env:
-      BACKEND_TAG: makeplane/plane-backend:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
-    steps:
-      - name: Set Backend Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-backend:${{ github.event.release.tag_name }}
-            if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-backend:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-backend:latest
-          else
-            TAG=${{ env.BACKEND_TAG }}
-          fi
-          echo "BACKEND_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
-        uses: actions/checkout@v4
-
-      - name: Build and Push Backend to Docker Hub
-        uses: docker/build-push-action@v5.1.0
-        with:
-          context: ./apiserver
-          file: ./apiserver/Dockerfile.api
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          push: true
-          tags: ${{ env.BACKEND_TAG }}
-        env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_space }}
+          build-context: .
+          dockerfile-path: ./space/Dockerfile.space
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
 
   branch_build_push_live:
-    if: ${{ needs.branch_build_setup.outputs.build_live == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    if: ${{ needs.branch_build_setup.outputs.build_live == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     name: Build-Push Live Collaboration Docker Image
     runs-on: ubuntu-20.04
     needs: [branch_build_setup]
-    env:
-      LIVE_TAG: makeplane/plane-live:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
     steps:
-      - name: Set Live Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-live:${{ github.event.release.tag_name }}
-            if [ "${{ github.event.release.prerelease }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-live:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-live:latest
-          else
-            TAG=${{ env.LIVE_TAG }}
-          fi
-          echo "LIVE_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
+      - id: checkout_files
+        name: Checkout Files
         uses: actions/checkout@v4
-
-      - name: Build and Push Live Server to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+      - name: Live Build and Push
+        uses: ./.github/actions/buildpush-action
         with:
-          context: .
-          file: ./live/Dockerfile.live
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          tags: ${{ env.LIVE_TAG }}
-          push: true
-        env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_live }}
+          build-context: .
+          dockerfile-path: ./live/Dockerfile.live
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  branch_build_push_apiserver:
+    if: ${{ needs.branch_build_setup.outputs.build_apiserver == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    name: Build-Push API Server Docker Image
+    runs-on: ubuntu-20.04
+    needs: [branch_build_setup]
+    steps:
+      - id: checkout_files
+        name: Checkout Files
+        uses: actions/checkout@v4
+      - name: Backend Build and Push
+        uses: ./.github/actions/buildpush-action
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_backend }}
+          build-context: ./apiserver
+          dockerfile-path: ./apiserver/Dockerfile.api
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
 
   branch_build_push_proxy:
-    if: ${{ needs.branch_build_setup.outputs.build_proxy == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    if: ${{ needs.branch_build_setup.outputs.build_proxy == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     name: Build-Push Proxy Docker Image
     runs-on: ubuntu-20.04
     needs: [branch_build_setup]
-    env:
-      PROXY_TAG: makeplane/plane-proxy:${{ needs.branch_build_setup.outputs.flat_branch_name }}
-      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
-      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
-      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
-      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
-      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
     steps:
-      - name: Set Proxy Docker Tag
-        run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=makeplane/plane-proxy:${{ github.event.release.tag_name }}
-            if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
-              TAG=${TAG},makeplane/plane-proxy:stable
-            fi
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=makeplane/plane-proxy:latest
-          else
-            TAG=${{ env.PROXY_TAG }}
-          fi
-          echo "PROXY_TAG=${TAG}" >> $GITHUB_ENV
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
+      - id: checkout_files
+        name: Checkout Files
+        uses: actions/checkout@v4
+      - name: Proxy Build and Push
+        uses: ./.github/actions/buildpush-action
         with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          docker-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          docker-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_proxy }}
+          build-context: ./nginx
+          dockerfile-path: ./nginx/Dockerfile
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
+  attach_assets_to_build:
+    if: ${{ needs.branch_build_setup.outputs.build_type == 'Build' }}
+    name: Attach Assets to Build
+    runs-on: ubuntu-20.04
+    needs: [ branch_build_setup ]
+    steps:
+      - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Build and Push Plane-Proxy to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+      - name: Update Assets
+        run: |
+          cp ./deploy/selfhost/install.sh deploy/selfhost/setup.sh
+
+      - name: Attach Assets
+        id: attach_assets
+        uses: actions/upload-artifact@v4
         with:
-          context: ./nginx
-          file: ./nginx/Dockerfile
-          platforms: ${{ env.BUILDX_PLATFORMS }}
-          tags: ${{ env.PROXY_TAG }}
-          push: true
+          name: selfhost-assets
+          retention-days: 2
+          path: |
+            ${{ github.workspace }}/deploy/selfhost/setup.sh
+            ${{ github.workspace }}/deploy/selfhost/restore.sh
+            ${{ github.workspace }}/deploy/selfhost/docker-compose.yml
+            ${{ github.workspace }}/deploy/selfhost/variables.env
+ 
+  publish_release:
+    if: ${{ needs.branch_build_setup.outputs.build_type == 'Release' }}
+    name: Build Release
+    runs-on: ubuntu-20.04
+    needs:
+      [
+        branch_build_setup,
+        branch_build_push_admin,
+        branch_build_push_web,
+        branch_build_push_space,
+        branch_build_push_live,
+        branch_build_push_apiserver,
+        branch_build_push_proxy
+      ]
+    env:
+      REL_VERSION: ${{ needs.branch_build_setup.outputs.release_version }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Update Assets
+        run: |
+          cp ./deploy/selfhost/install.sh deploy/selfhost/setup.sh
+
+      - name: Create Release
+        id: create_release
+        uses: softprops/action-gh-release@v2.0.8
         env:
-          DOCKER_BUILDKIT: 1
-          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
+        with:
+          tag_name: ${{ env.REL_VERSION }}
+          name: ${{ env.REL_VERSION }}
+          draft: false
+          prerelease: ${{ env.IS_PRERELEASE }}
+          generate_release_notes: true
+          files: |
+            ${{ github.workspace }}/deploy/selfhost/setup.sh
+            ${{ github.workspace }}/deploy/selfhost/restore.sh
+            ${{ github.workspace }}/deploy/selfhost/docker-compose.yml
+            ${{ github.workspace }}/deploy/selfhost/variables.env

.lintstagedrc.json

@@ -1,3 +0,0 @@
-{
-  "*.{ts,tsx,js,jsx}": ["eslint -c ./.eslintrc-staged.js", "prettier --check"]
-}

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 informplaneation.
+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.
 
 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:
 

SECURITY.md

@@ -1,44 +1,39 @@
-# Security Policy
+# Security policy
+This document outlines the security protocols and vulnerability reporting guidelines for the Plane project. Ensuring the security of our systems is a top priority, and while we work diligently to maintain robust protection, vulnerabilities may still occur. We highly value the community’s role in identifying and reporting security concerns to uphold the integrity of our systems and safeguard our users.
 
-This document outlines security procedures and vulnerabilities reporting for the Plane project.
+## Reporting a vulnerability
+If you have identified a security vulnerability, submit your findings to [security@plane.so](mailto:security@plane.so). 
+Ensure your report includes all relevant information needed for us to reproduce and assess the issue. Include the IP address or URL of the affected system.
 
-At Plane, we safeguarding the security of our systems with top priority. Despite our efforts, vulnerabilities may still exist. We greatly appreciate your assistance in identifying and reporting any such vulnerabilities to help us maintain the integrity of our systems and protect our clients.
+To ensure a responsible and effective disclosure process, please adhere to the following:
 
-To report a security vulnerability, please email us directly at security@plane.so with a detailed description of the vulnerability and steps to reproduce it. Please refrain from disclosing the vulnerability publicly until we have had an opportunity to review and address it.
+- Maintain confidentiality and refrain from publicly disclosing the vulnerability until we have had the opportunity to investigate and address the issue.
+- Refrain from running automated vulnerability scans on our infrastructure or dashboard without prior consent. Contact us to set up a sandbox environment if necessary.
+- Do not exploit any discovered vulnerabilities for malicious purposes, such as accessing or altering user data.
+- Do not engage in physical security attacks, social engineering, distributed denial of service (DDoS) attacks, spam campaigns, or attacks on third-party applications as part of your vulnerability testing.
 
-## Out of Scope Vulnerabilities
+## Out of scope
+While we appreciate all efforts to assist in improving our security, please note that the following types of vulnerabilities are considered out of scope:
 
-We appreciate your help in identifying vulnerabilities. However, please note that the following types of vulnerabilities are considered out of scope:
+- Vulnerabilities requiring man-in-the-middle (MITM) attacks or physical access to a user’s device.
+- Content spoofing or text injection issues without a clear attack vector or the ability to modify HTML/CSS.
+- Issues related to email spoofing.
+- Missing DNSSEC, CAA, or CSP headers.
+- Absence of secure or HTTP-only flags on non-sensitive cookies.
 
-- Attacks requiring MITM or physical access to a user's device.
-- Content spoofing and text injection issues without demonstrating an attack vector or ability to modify HTML/CSS.
-- Email spoofing.
-- Missing DNSSEC, CAA, CSP headers.
-- Lack of Secure or HTTP only flag on non-sensitive cookies.
+## Our commitment
 
-## Reporting Process
+At Plane, we are committed to maintaining transparent and collaborative communication throughout the vulnerability resolution process. Here's what you can expect from us:
 
-If you discover a vulnerability, please adhere to the following reporting process:
+- **Response Time** <br/>
+We will acknowledge receipt of your vulnerability report within three business days and provide an estimated timeline for resolution.
+- **Legal Protection** <br/>
+We will not initiate legal action against you for reporting vulnerabilities, provided you adhere to the reporting guidelines.
+- **Confidentiality** <br/>
+Your report will be treated with confidentiality. We will not disclose your personal information to third parties without your consent.
+- **Recognition** <br/>
+With your permission, we are happy to publicly acknowledge your contribution to improving our security once the issue is resolved.
+- **Timely Resolution** <br/>
+We are committed to working closely with you throughout the resolution process, providing timely updates as necessary. Our goal is to address all reported vulnerabilities swiftly, and we will actively engage with you to coordinate a responsible disclosure once the issue is fully resolved.
 
-1. Email your findings to security@plane.so.
-2. Refrain from running automated scanners on our infrastructure or dashboard without prior consent. Contact us to set up a sandbox environment if necessary.
-3. Do not exploit the vulnerability for malicious purposes, such as downloading excessive data or altering user data.
-4. Maintain confidentiality and refrain from disclosing the vulnerability until it has been resolved.
-5. Avoid using physical security attacks, social engineering, distributed denial of service, spam, or third-party applications.
-
-When reporting a vulnerability, please provide sufficient information to allow us to reproduce and address the issue promptly. Include the IP address or URL of the affected system, along with a detailed description of the vulnerability.
-
-## Our Commitment
-
-We are committed to promptly addressing reported vulnerabilities and maintaining open communication throughout the resolution process. Here's what you can expect from us:
-
-- **Response Time:** We will acknowledge receipt of your report within three business days and provide an expected resolution date.
-- **Legal Protection:** We will not pursue legal action against you for reporting vulnerabilities, provided you adhere to the reporting guidelines.
-- **Confidentiality:** Your report will be treated with strict confidentiality. We will not disclose your personal information to third parties without your consent.
-- **Progress Updates:** We will keep you informed of our progress in resolving the reported vulnerability.
-- **Recognition:** With your permission, we will publicly acknowledge you as the discoverer of the vulnerability.
-- **Timely Resolution:** We strive to resolve all reported vulnerabilities promptly and will actively participate in the publication process once the issue is resolved.
-
-We appreciate your cooperation in helping us maintain the security of our systems and protecting our clients. Thank you for your contributions to our security efforts.
-
-reference: https://supabase.com/.well-known/security.txt
+We appreciate your help in ensuring the security of our platform. Your contributions are crucial to protecting our users and maintaining a secure environment. Thank you for working with us to keep Plane safe.

admin/.eslintrc.js

@@ -1,52 +1,8 @@
 module.exports = {
   root: true,
-  extends: ["custom"],
+  extends: ["@plane/eslint-config/next.js"],
   parser: "@typescript-eslint/parser",
-  settings: {
-    "import/resolver": {
-      typescript: {},
-      node: {
-        moduleDirectory: ["node_modules", "."],
-      },
-    },
+  parserOptions: {
+    project: true,
   },
-  rules: {
-    "import/order": [
-      "error",
-      {
-        groups: ["builtin", "external", "internal", "parent", "sibling",],
-        pathGroups: [
-          {
-            pattern: "react",
-            group: "external",
-            position: "before",
-          },
-          {
-            pattern: "lucide-react",
-            group: "external",
-            position: "after",
-          },
-          {
-            pattern: "@headlessui/**",
-            group: "external",
-            position: "after",
-          },
-          {
-            pattern: "@plane/**",
-            group: "external",
-            position: "after",
-          },
-          {
-            pattern: "@/**",
-            group: "internal",
-          }
-        ],
-        pathGroupsExcludedImportTypes: ["builtin", "internal", "react"],
-        alphabetize: {
-          order: "asc",
-          caseInsensitive: true,
-        },
-      },
-    ],
-  },
-}
+};

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

@@ -9,9 +9,7 @@ import { HelpSection, SidebarMenu, SidebarDropdown } from "@/components/admin-si
 // hooks
 import { useTheme } from "@/hooks/store";
 
-export interface IInstanceSidebar {}
-
-export const InstanceSidebar: FC<IInstanceSidebar> = observer(() => {
+export const InstanceSidebar: FC = observer(() => {
   // store
   const { isSidebarCollapsed, toggleSidebar } = useTheme();
 

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

@@ -5,11 +5,13 @@ import { observer } from "mobx-react";
 import { useTheme as useNextTheme } from "next-themes";
 import { LogOut, UserCog2, Palette } from "lucide-react";
 import { Menu, Transition } from "@headlessui/react";
+// plane ui
 import { Avatar } from "@plane/ui";
-// hooks
-import { API_BASE_URL, cn } from "@/helpers/common.helper";
-import { useTheme, useUser } from "@/hooks/store";
 // helpers
+import { API_BASE_URL, cn } from "@/helpers/common.helper";
+import { getFileURL } from "@/helpers/file.helper";
+// hooks
+import { useTheme, useUser } from "@/hooks/store";
 // services
 import { AuthService } from "@/services/auth.service";
 
@@ -122,7 +124,7 @@ export const SidebarDropdown = observer(() => {
           <Menu.Button className="grid place-items-center outline-none">
             <Avatar
               name={currentUser.display_name}
-              src={currentUser.avatar ?? undefined}
+              src={getFileURL(currentUser.avatar_url)}
               size={24}
               shape="square"
               className="!text-base"

admin/core/components/instance/instance-failure-view.tsx

@@ -7,11 +7,7 @@ import { Button } from "@plane/ui";
 import InstanceFailureDarkImage from "@/public/instance/instance-failure-dark.svg";
 import InstanceFailureImage from "@/public/instance/instance-failure.svg";
 
-type InstanceFailureViewProps = {
-  // mutate: () => void;
-};
-
-export const InstanceFailureView: FC<InstanceFailureViewProps> = () => {
+export const InstanceFailureView: FC = () => {
   const { resolvedTheme } = useTheme();
 
   const instanceImage = resolvedTheme === "dark" ? InstanceFailureDarkImage : InstanceFailureImage;

admin/core/services/auth.service.ts

@@ -1,5 +1,5 @@
 // helpers
-import { API_BASE_URL } from "helpers/common.helper";
+import { API_BASE_URL } from "@/helpers/common.helper";
 // services
 import { APIService } from "@/services/api.service";
 

admin/core/services/user.service.ts

@@ -1,7 +1,7 @@
-// helpers
-import { API_BASE_URL } from "helpers/common.helper";
 // types
 import type { IUser } from "@plane/types";
+// helpers
+import { API_BASE_URL } from "@/helpers/common.helper";
 // services
 import { APIService } from "@/services/api.service";
 

admin/helpers/file.helper.ts

@@ -0,0 +1,14 @@
+// helpers
+import { API_BASE_URL } from "@/helpers/common.helper";
+
+/**
+ * @description combine the file path with the base URL
+ * @param {string} path
+ * @returns {string} final URL with the base URL
+ */
+export const getFileURL = (path: string): string | undefined => {
+  if (!path) return undefined;
+  const isValidURL = path.startsWith("http");
+  if (isValidURL) return path;
+  return `${API_BASE_URL}${path}`;
+};

admin/helpers/string.helper.ts

@@ -0,0 +1,21 @@
+/**
+ * @description
+ * This function test whether a URL is valid or not.
+ *
+ * It accepts URLs with or without the protocol.
+ * @param {string} url
+ * @returns {boolean}
+ * @example
+ * checkURLValidity("https://example.com") => true
+ * checkURLValidity("example.com") => true
+ * checkURLValidity("example") => false
+ */
+export const checkURLValidity = (url: string): boolean => {
+  if (!url) return false;
+
+  // regex to support complex query parameters and fragments
+  const urlPattern =
+    /^(https?:\/\/)?((([a-z\d-]+\.)*[a-z\d-]+\.[a-z]{2,6})|(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}))(:\d+)?(\/[\w.-]*)*(\?[^#\s]*)?(#[\w-]*)?$/i;
+
+  return urlPattern.test(url);
+};

admin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "admin",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "private": true,
   "scripts": {
     "dev": "turbo run develop",
@@ -8,7 +8,8 @@
     "build": "next build",
     "preview": "next build && next start",
     "start": "next start",
-    "lint": "next lint"
+    "lint": "eslint . --ext .ts,.tsx",
+    "lint:errors": "eslint . --ext .ts,.tsx --quiet"
   },
   "dependencies": {
     "@headlessui/react": "^1.7.19",
@@ -16,16 +17,16 @@
     "@plane/helpers": "*",
     "@plane/types": "*",
     "@plane/ui": "*",
+    "@sentry/nextjs": "^8.32.0",
     "@tailwindcss/typography": "^0.5.9",
     "@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",
     "mobx-react": "^9.1.1",
-    "next": "^14.2.3",
+    "next": "^14.2.12",
     "next-themes": "^0.2.1",
     "postcss": "^8.4.38",
     "react": "^18.3.1",
@@ -37,15 +38,14 @@
     "zxcvbn": "^4.4.2"
   },
   "devDependencies": {
-    "@types/js-cookie": "^3.0.6",
+    "@plane/eslint-config": "*",
+    "@plane/typescript-config": "*",
     "@types/node": "18.16.1",
     "@types/react": "^18.2.48",
     "@types/react-dom": "^18.2.18",
     "@types/uuid": "^9.0.8",
     "@types/zxcvbn": "^4.4.4",
-    "eslint-config-custom": "*",
     "tailwind-config-custom": "*",
-    "tsconfig": "*",
-    "typescript": "5.4.5"
+    "typescript": "5.3.3"
   }
 }

admin/tsconfig.json

@@ -1,21 +1,15 @@
 {
-  "extends": "tsconfig/nextjs.json",
-  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
-  "exclude": ["node_modules"],
+  "extends": "@plane/typescript-config/nextjs.json",
   "compilerOptions": {
+    "plugins": [{ "name": "next" }],
     "baseUrl": ".",
-    "jsx": "preserve",
-    "esModuleInterop": true,
     "paths": {
       "@/*": ["core/*"],
       "@/helpers/*": ["helpers/*"],
       "@/public/*": ["public/*"],
       "@/plane-admin/*": ["ce/*"]
-    },
-    "plugins": [
-      {
-        "name": "next"
-      }
-    ]
-  }
+    }
+  },
+  "include": ["next-env.d.ts", "next.config.js", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
 }

apiserver/package.json

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

apiserver/plane/api/serializers/__init__.py

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

apiserver/plane/api/serializers/issue.py

@@ -11,7 +11,7 @@ from plane.db.models import (
     IssueType,
     IssueActivity,
     IssueAssignee,
-    IssueAttachment,
+    FileAsset,
     IssueComment,
     IssueLabel,
     IssueLink,
@@ -31,6 +31,7 @@ from .user import UserLiteSerializer
 from django.core.exceptions import ValidationError
 from django.core.validators import URLValidator
 
+
 class IssueSerializer(BaseSerializer):
     assignees = serializers.ListField(
         child=serializers.PrimaryKeyRelatedField(
@@ -315,7 +316,7 @@ class IssueLinkSerializer(BaseSerializer):
             "created_at",
             "updated_at",
         ]
-    
+
     def validate_url(self, value):
         # Check URL format
         validate_url = URLValidator()
@@ -359,7 +360,7 @@ class IssueLinkSerializer(BaseSerializer):
 
 class IssueAttachmentSerializer(BaseSerializer):
     class Meta:
-        model = IssueAttachment
+        model = FileAsset
         fields = "__all__"
         read_only_fields = [
             "id",

apiserver/plane/api/serializers/project.py

@@ -19,6 +19,7 @@ class ProjectSerializer(BaseSerializer):
     sort_order = serializers.FloatField(read_only=True)
     member_role = serializers.IntegerField(read_only=True)
     is_deployed = serializers.BooleanField(read_only=True)
+    cover_image_url = serializers.CharField(read_only=True)
 
     class Meta:
         model = Project
@@ -32,6 +33,7 @@ class ProjectSerializer(BaseSerializer):
             "created_by",
             "updated_by",
             "deleted_at",
+            "cover_image_url",
         ]
 
     def validate(self, data):
@@ -87,6 +89,8 @@ class ProjectSerializer(BaseSerializer):
 
 
 class ProjectLiteSerializer(BaseSerializer):
+    cover_image_url = serializers.CharField(read_only=True)
+
     class Meta:
         model = Project
         fields = [
@@ -97,5 +101,6 @@ class ProjectLiteSerializer(BaseSerializer):
             "icon_prop",
             "emoji",
             "description",
+            "cover_image_url",
         ]
         read_only_fields = fields

apiserver/plane/api/serializers/user.py

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

apiserver/plane/api/views/cycle.py

@@ -13,8 +13,12 @@ from django.db.models import (
     Q,
     Sum,
     FloatField,
+    Case,
+    When,
+    Value,
 )
-from django.db.models.functions import Cast
+from django.db.models.functions import Cast, Concat
+from django.db import models
 
 # Third party imports
 from rest_framework import status
@@ -32,7 +36,7 @@ from plane.db.models import (
     CycleIssue,
     Issue,
     Project,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     ProjectMember,
     UserFavorite,
@@ -207,8 +211,7 @@ class CycleAPIEndpoint(BaseAPIView):
         # Incomplete Cycles
         if cycle_view == "incomplete":
             queryset = queryset.filter(
-                Q(end_date__gte=timezone.now().date())
-                | Q(end_date__isnull=True),
+                Q(end_date__gte=timezone.now()) | Q(end_date__isnull=True),
             )
             return self.paginate(
                 request=request,
@@ -309,10 +312,7 @@ class CycleAPIEndpoint(BaseAPIView):
 
         request_data = request.data
 
-        if (
-            cycle.end_date is not None
-            and cycle.end_date < timezone.now().date()
-        ):
+        if cycle.end_date is not None and cycle.end_date < timezone.now():
             if "sort_order" in request_data:
                 # Can only change sort order
                 request_data = {
@@ -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().date():
+        if cycle.end_date >= timezone.now():
             return Response(
                 {"error": "Only completed cycles can be archived"},
                 status=status.HTTP_400_BAD_REQUEST,
@@ -645,8 +645,9 @@ class CycleIssueAPIEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -887,7 +888,27 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                 .annotate(display_name=F("assignees__display_name"))
                 .annotate(assignee_id=F("assignees__id"))
                 .annotate(avatar=F("assignees__avatar"))
-                .values("display_name", "assignee_id", "avatar")
+                .annotate(
+                    avatar_url=Case(
+                        # If `avatar_asset` exists, use it to generate the asset URL
+                        When(
+                            assignees__avatar_asset__isnull=False,
+                            then=Concat(
+                                Value("/api/assets/v2/static/"),
+                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                Value("/"),
+                            ),
+                        ),
+                        # If `avatar_asset` is None, fall back to using `avatar` field directly
+                        When(
+                            assignees__avatar_asset__isnull=True,
+                            then="assignees__avatar",
+                        ),
+                        default=Value(None),
+                        output_field=models.CharField(),
+                    )
+                )
+                .values("display_name", "assignee_id", "avatar", "avatar_url")
                 .annotate(
                     total_estimates=Sum(
                         Cast("estimate_point__value", FloatField())
@@ -924,7 +945,8 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                         if item["assignee_id"]
                         else None
                     ),
-                    "avatar": item["avatar"],
+                    "avatar": item.get("avatar", None),
+                    "avatar_url": item.get("avatar_url", None),
                     "total_estimates": item["total_estimates"],
                     "completed_estimates": item["completed_estimates"],
                     "pending_estimates": item["pending_estimates"],
@@ -1002,7 +1024,27 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
             .annotate(display_name=F("assignees__display_name"))
             .annotate(assignee_id=F("assignees__id"))
             .annotate(avatar=F("assignees__avatar"))
-            .values("display_name", "assignee_id", "avatar")
+            .annotate(
+                avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        assignees__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(
+                        assignees__avatar_asset__isnull=True,
+                        then="assignees__avatar",
+                    ),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
+            .values("display_name", "assignee_id", "avatar_url")
             .annotate(
                 total_issues=Count(
                     "id",
@@ -1041,7 +1083,8 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                 "assignee_id": (
                     str(item["assignee_id"]) if item["assignee_id"] else None
                 ),
-                "avatar": item["avatar"],
+                "avatar": item.get("avatar", None),
+                "avatar_url": item.get("avatar_url", None),
                 "total_issues": item["total_issues"],
                 "completed_issues": item["completed_issues"],
                 "pending_issues": item["pending_issues"],
@@ -1146,7 +1189,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
 
         if (
             new_cycle.end_date is not None
-            and new_cycle.end_date < timezone.now().date()
+            and new_cycle.end_date < timezone.now()
         ):
             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 > 5:
+        if project_member.role > 15:
             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,
-    IssueAttachment,
+    FileAsset,
     IssueComment,
     IssueLink,
     Label,
@@ -210,8 +210,9 @@ class IssueAPIEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -1062,7 +1063,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
     permission_classes = [
         ProjectEntityPermission,
     ]
-    model = IssueAttachment
+    model = FileAsset
     parser_classes = (MultiPartParser, FormParser)
 
     def post(self, request, slug, project_id, issue_id):
@@ -1070,7 +1071,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
         if (
             request.data.get("external_id")
             and request.data.get("external_source")
-            and IssueAttachment.objects.filter(
+            and FileAsset.objects.filter(
                 project_id=project_id,
                 workspace__slug=slug,
                 issue_id=issue_id,
@@ -1078,7 +1079,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
                 external_id=request.data.get("external_id"),
             ).exists()
         ):
-            issue_attachment = IssueAttachment.objects.filter(
+            issue_attachment = FileAsset.objects.filter(
                 workspace__slug=slug,
                 project_id=project_id,
                 external_id=request.data.get("external_id"),
@@ -1112,7 +1113,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def delete(self, request, slug, project_id, issue_id, pk):
-        issue_attachment = IssueAttachment.objects.get(pk=pk)
+        issue_attachment = FileAsset.objects.get(pk=pk)
         issue_attachment.asset.delete(save=False)
         issue_attachment.delete()
         issue_activity.delay(
@@ -1130,7 +1131,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
     def get(self, request, slug, project_id, issue_id):
-        issue_attachments = IssueAttachment.objects.filter(
+        issue_attachments = FileAsset.objects.filter(
             issue_id=issue_id, workspace__slug=slug, project_id=project_id
         )
         serializer = IssueAttachmentSerializer(issue_attachments, many=True)

apiserver/plane/api/views/module.py

@@ -21,7 +21,7 @@ from plane.app.permissions import ProjectEntityPermission
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.db.models import (
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     Module,
     ModuleIssue,
@@ -393,8 +393,9 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))

apiserver/plane/api/views/project.py

@@ -301,11 +301,16 @@ class ProjectAPIEndpoint(BaseAPIView):
             if serializer.is_valid():
                 serializer.save()
                 if serializer.data["inbox_view"]:
-                    Inbox.objects.get_or_create(
-                        name=f"{project.name} Inbox",
+                    inbox = Inbox.objects.filter(
                         project=project,
                         is_default=True,
-                    )
+                    ).first()
+                    if not inbox:
+                        Inbox.objects.create(
+                            name=f"{project.name} Inbox",
+                            project=project,
+                            is_default=True,
+                        )
 
                     # Create the triage state in Backlog group
                     State.objects.get_or_create(

apiserver/plane/app/serializers/__init__.py

@@ -124,3 +124,9 @@ 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,48 +49,46 @@ class DynamicBaseSerializer(BaseSerializer):
                 allowed.append(list(item.keys())[0])
 
         for field in allowed:
-            if field not in self.fields:
-                from . import (
-                    WorkspaceLiteSerializer,
-                    ProjectLiteSerializer,
-                    UserLiteSerializer,
-                    StateLiteSerializer,
-                    IssueSerializer,
-                    LabelSerializer,
-                    CycleIssueSerializer,
-                    IssueLiteSerializer,
-                    IssueRelationSerializer,
-                    InboxIssueLiteSerializer,
-                    IssueReactionLiteSerializer,
-                    IssueAttachmentLiteSerializer,
-                    IssueLinkLiteSerializer,
-                )
+            from . import (
+                WorkspaceLiteSerializer,
+                ProjectLiteSerializer,
+                UserLiteSerializer,
+                StateLiteSerializer,
+                IssueSerializer,
+                LabelSerializer,
+                CycleIssueSerializer,
+                IssueLiteSerializer,
+                IssueRelationSerializer,
+                InboxIssueLiteSerializer,
+                IssueReactionLiteSerializer,
+                IssueLinkLiteSerializer,
+            )
 
-                # Expansion mapper
-                expansion = {
-                    "user": UserLiteSerializer,
-                    "workspace": WorkspaceLiteSerializer,
-                    "project": ProjectLiteSerializer,
-                    "default_assignee": UserLiteSerializer,
-                    "project_lead": UserLiteSerializer,
-                    "state": StateLiteSerializer,
-                    "created_by": UserLiteSerializer,
-                    "issue": IssueSerializer,
-                    "actor": UserLiteSerializer,
-                    "owned_by": UserLiteSerializer,
-                    "members": UserLiteSerializer,
-                    "assignees": UserLiteSerializer,
-                    "labels": LabelSerializer,
-                    "issue_cycle": CycleIssueSerializer,
-                    "parent": IssueLiteSerializer,
-                    "issue_relation": IssueRelationSerializer,
-                    "issue_inbox": InboxIssueLiteSerializer,
-                    "issue_reactions": IssueReactionLiteSerializer,
-                    "issue_attachment": IssueAttachmentLiteSerializer,
-                    "issue_link": IssueLinkLiteSerializer,
-                    "sub_issues": IssueLiteSerializer,
-                }
+            # Expansion mapper
+            expansion = {
+                "user": UserLiteSerializer,
+                "workspace": WorkspaceLiteSerializer,
+                "project": ProjectLiteSerializer,
+                "default_assignee": UserLiteSerializer,
+                "project_lead": UserLiteSerializer,
+                "state": StateLiteSerializer,
+                "created_by": UserLiteSerializer,
+                "issue": IssueSerializer,
+                "actor": UserLiteSerializer,
+                "owned_by": UserLiteSerializer,
+                "members": UserLiteSerializer,
+                "assignees": UserLiteSerializer,
+                "labels": LabelSerializer,
+                "issue_cycle": CycleIssueSerializer,
+                "parent": IssueLiteSerializer,
+                "issue_relation": IssueRelationSerializer,
+                "issue_inbox": InboxIssueLiteSerializer,
+                "issue_reactions": IssueReactionLiteSerializer,
+                "issue_link": IssueLinkLiteSerializer,
+                "sub_issues": IssueLiteSerializer,
+            }
 
+            if field not in self.fields and field in expansion:
                 self.fields[field] = expansion[field](
                     many=(
                         True
@@ -178,4 +176,29 @@ class DynamicBaseSerializer(BaseSerializer):
                             instance, f"{expand}_id", None
                         )
 
+            # Check if issue_attachments is in fields or expand
+            if (
+                "issue_attachments" in self.fields
+                or "issue_attachments" in self.expand
+            ):
+                # Import the model here to avoid circular imports
+                from plane.db.models import FileAsset
+
+                issue_id = getattr(instance, "id", None)
+
+                if issue_id:
+                    # Fetch related issue_attachments
+                    issue_attachments = FileAsset.objects.filter(
+                        issue_id=issue_id,
+                        entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                    )
+                    # Serialize issue_attachments and add them to the response
+                    response["issue_attachments"] = (
+                        IssueAttachmentLiteSerializer(
+                            issue_attachments, many=True
+                        ).data
+                    )
+                else:
+                    response["issue_attachments"] = []
+
         return response

apiserver/plane/app/serializers/draft.py

@@ -0,0 +1,292 @@
+# 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,
-    IssueAttachment,
+    FileAsset,
     IssueReaction,
     CommentReaction,
     IssueVote,
@@ -498,8 +498,11 @@ class IssueLinkLiteSerializer(BaseSerializer):
 
 
 class IssueAttachmentSerializer(BaseSerializer):
+
+    asset_url = serializers.CharField(read_only=True)
+
     class Meta:
-        model = IssueAttachment
+        model = FileAsset
         fields = "__all__"
         read_only_fields = [
             "created_by",
@@ -514,14 +517,15 @@ class IssueAttachmentSerializer(BaseSerializer):
 
 class IssueAttachmentLiteSerializer(DynamicBaseSerializer):
     class Meta:
-        model = IssueAttachment
+        model = FileAsset
         fields = [
             "id",
             "asset",
             "attributes",
-            "issue_id",
+            # "issue_id",
             "updated_at",
             "updated_by",
+            "asset_url",
         ]
         read_only_fields = fields
 

apiserver/plane/app/serializers/project.py

@@ -95,6 +95,7 @@ class ProjectLiteSerializer(BaseSerializer):
             "identifier",
             "name",
             "cover_image",
+            "cover_image_url",
             "logo_props",
             "description",
         ]
@@ -117,6 +118,7 @@ class ProjectListSerializer(DynamicBaseSerializer):
     member_role = serializers.IntegerField(read_only=True)
     anchor = serializers.CharField(read_only=True)
     members = serializers.SerializerMethodField()
+    cover_image_url = serializers.CharField(read_only=True)
 
     def get_members(self, obj):
         project_members = getattr(obj, "members_list", None)
@@ -128,6 +130,7 @@ class ProjectListSerializer(DynamicBaseSerializer):
                     "member_id": member.member_id,
                     "member__display_name": member.member.display_name,
                     "member__avatar": member.member.avatar,
+                    "member__avatar_url": member.member.avatar_url,
                 }
                 for member in project_members
             ]

apiserver/plane/app/serializers/user.py

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

apiserver/plane/app/serializers/workspace.py

@@ -22,6 +22,7 @@ class WorkSpaceSerializer(DynamicBaseSerializer):
     owner = UserLiteSerializer(read_only=True)
     total_members = serializers.IntegerField(read_only=True)
     total_issues = serializers.IntegerField(read_only=True)
+    logo_url = serializers.CharField(read_only=True)
 
     def validate_slug(self, value):
         # Check if the slug is restricted
@@ -39,6 +40,7 @@ class WorkSpaceSerializer(DynamicBaseSerializer):
             "created_at",
             "updated_at",
             "owner",
+            "logo_url",
         ]
 
 

apiserver/plane/app/urls/asset.py

@@ -5,6 +5,13 @@ from plane.app.views import (
     FileAssetEndpoint,
     UserAssetsEndpoint,
     FileAssetViewSet,
+    # V2 Endpoints
+    WorkspaceFileAssetEndpoint,
+    UserAssetsV2Endpoint,
+    StaticFileAssetEndpoint,
+    AssetRestoreEndpoint,
+    ProjectAssetEndpoint,
+    ProjectBulkAssetEndpoint,
 )
 
 
@@ -38,4 +45,49 @@ urlpatterns = [
         ),
         name="file-assets-restore",
     ),
+    # V2 Endpoints
+    path(
+        "assets/v2/workspaces/<str:slug>/",
+        WorkspaceFileAssetEndpoint.as_view(),
+        name="workspace-file-assets",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/<uuid:asset_id>/",
+        WorkspaceFileAssetEndpoint.as_view(),
+        name="workspace-file-assets",
+    ),
+    path(
+        "assets/v2/user-assets/",
+        UserAssetsV2Endpoint.as_view(),
+        name="user-file-assets",
+    ),
+    path(
+        "assets/v2/user-assets/<uuid:asset_id>/",
+        UserAssetsV2Endpoint.as_view(),
+        name="user-file-assets",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/restore/<uuid:asset_id>/",
+        AssetRestoreEndpoint.as_view(),
+        name="asset-restore",
+    ),
+    path(
+        "assets/v2/static/<uuid:asset_id>/",
+        StaticFileAssetEndpoint.as_view(),
+        name="static-file-asset",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/",
+        ProjectAssetEndpoint.as_view(),
+        name="bulk-asset-update",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/<uuid:pk>/",
+        ProjectAssetEndpoint.as_view(),
+        name="bulk-asset-update",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/<uuid:entity_id>/bulk/",
+        ProjectBulkAssetEndpoint.as_view(),
+    ),
 ]

apiserver/plane/app/urls/issue.py

@@ -11,7 +11,6 @@ from plane.app.views import (
     IssueActivityEndpoint,
     IssueArchiveViewSet,
     IssueCommentViewSet,
-    IssueDraftViewSet,
     IssueListEndpoint,
     IssueReactionViewSet,
     IssueRelationViewSet,
@@ -20,7 +19,9 @@ from plane.app.views import (
     IssueViewSet,
     LabelViewSet,
     BulkArchiveIssuesEndpoint,
+    DeletedIssuesListViewSet,
     IssuePaginatedViewSet,
+    IssueAttachmentV2Endpoint,
 )
 
 urlpatterns = [
@@ -39,7 +40,7 @@ urlpatterns = [
         ),
         name="project-issue",
     ),
-    # updated v1 paginated issues
+    # updated v2 paginated issues
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/v2/issues/",
         IssuePaginatedViewSet.as_view({"get": "list"}),
@@ -132,6 +133,18 @@ urlpatterns = [
         IssueAttachmentEndpoint.as_view(),
         name="project-issue-attachments",
     ),
+    # V2 Attachments
+    path(
+        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/attachments/",
+        IssueAttachmentV2Endpoint.as_view(),
+        name="project-issue-attachments",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/attachments/<uuid:pk>/",
+        IssueAttachmentV2Endpoint.as_view(),
+        name="project-issue-attachments",
+    ),
+    ## Export Issues
     path(
         "workspaces/<str:slug>/export-issues/",
         ExportIssuesEndpoint.as_view(),
@@ -289,26 +302,9 @@ 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",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/deleted-issues/",
+        DeletedIssuesListViewSet.as_view(),
+        name="deleted-issues",
     ),
 ]

apiserver/plane/app/urls/workspace.py

@@ -27,6 +27,7 @@ from plane.app.views import (
     WorkspaceCyclesEndpoint,
     WorkspaceFavoriteEndpoint,
     WorkspaceFavoriteGroupEndpoint,
+    WorkspaceDraftIssueViewSet,
 )
 
 
@@ -254,4 +255,30 @@ 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,6 +40,8 @@ from .workspace.base import (
     ExportWorkspaceUserActivityEndpoint,
 )
 
+from .workspace.draft import WorkspaceDraftIssueViewSet
+
 from .workspace.favorite import (
     WorkspaceFavoriteEndpoint,
     WorkspaceFavoriteGroupEndpoint,
@@ -108,12 +110,25 @@ from .cycle.archive import (
     CycleArchiveUnarchiveEndpoint,
 )
 
-from .asset.base import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
+from .asset.base import (
+    FileAssetEndpoint,
+    UserAssetsEndpoint,
+    FileAssetViewSet,
+)
+from .asset.v2 import (
+    WorkspaceFileAssetEndpoint,
+    UserAssetsV2Endpoint,
+    StaticFileAssetEndpoint,
+    AssetRestoreEndpoint,
+    ProjectAssetEndpoint,
+    ProjectBulkAssetEndpoint,
+)
 from .issue.base import (
     IssueListEndpoint,
     IssueViewSet,
     IssueUserDisplayPropertyEndpoint,
     BulkDeleteIssuesEndpoint,
+    DeletedIssuesListViewSet,
     IssuePaginatedViewSet,
 )
 
@@ -125,6 +140,8 @@ from .issue.archive import IssueArchiveViewSet, BulkArchiveIssuesEndpoint
 
 from .issue.attachment import (
     IssueAttachmentEndpoint,
+    # V2
+    IssueAttachmentV2Endpoint,
 )
 
 from .issue.comment import (
@@ -132,8 +149,6 @@ from .issue.comment import (
     CommentReactionViewSet,
 )
 
-from .issue.draft import IssueDraftViewSet
-
 from .issue.label import (
     LabelViewSet,
     BulkCreateIssueLabelsEndpoint,

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

@@ -1,7 +1,10 @@
 # Django imports
-from django.db.models import Count, F, Sum
+from django.db.models import Count, F, Sum, Q
 from django.db.models.functions import ExtractMonth
 from django.utils import timezone
+from django.db.models.functions import Concat
+from django.db.models import Case, When, Value
+from django.db import models
 
 # Third party imports
 from rest_framework import status
@@ -118,14 +121,37 @@ class AnalyticsEndpoint(BaseAPIView):
         if x_axis in ["assignees__id"] or segment in ["assignees__id"]:
             assignee_details = (
                 Issue.issue_objects.filter(
+                    Q(
+                        Q(assignees__avatar__isnull=False)
+                        | Q(assignees__avatar_asset__isnull=False)
+                    ),
                     workspace__slug=slug,
                     **filters,
-                    assignees__avatar__isnull=False,
+                )
+                .annotate(
+                    assignees__avatar_url=Case(
+                        # If `avatar_asset` exists, use it to generate the asset URL
+                        When(
+                            assignees__avatar_asset__isnull=False,
+                            then=Concat(
+                                Value("/api/assets/v2/static/"),
+                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                Value("/"),
+                            ),
+                        ),
+                        # If `avatar_asset` is None, fall back to using `avatar` field directly
+                        When(
+                            assignees__avatar_asset__isnull=True,
+                            then="assignees__avatar",
+                        ),
+                        default=Value(None),
+                        output_field=models.CharField(),
+                    )
                 )
                 .order_by("assignees__id")
                 .distinct("assignees__id")
                 .values(
-                    "assignees__avatar",
+                    "assignees__avatar_url",
                     "assignees__display_name",
                     "assignees__first_name",
                     "assignees__last_name",
@@ -355,7 +381,6 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
         user_details = [
             "created_by__first_name",
             "created_by__last_name",
-            "created_by__avatar",
             "created_by__display_name",
             "created_by__id",
         ]
@@ -364,13 +389,32 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
             base_issues.exclude(created_by=None)
             .values(*user_details)
             .annotate(count=Count("id"))
+            .annotate(
+                created_by__avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        created_by__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "created_by__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(
+                        created_by__avatar_asset__isnull=True,
+                        then="created_by__avatar",
+                    ),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
             .order_by("-count")[:5]
         )
 
         user_assignee_details = [
             "assignees__first_name",
             "assignees__last_name",
-            "assignees__avatar",
             "assignees__display_name",
             "assignees__id",
         ]
@@ -379,6 +423,26 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
             base_issues.filter(completed_at__isnull=False)
             .exclude(assignees=None)
             .values(*user_assignee_details)
+            .annotate(
+                assignees__avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        assignees__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(
+                        assignees__avatar_asset__isnull=True,
+                        then="assignees__avatar",
+                    ),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
             .annotate(count=Count("id"))
             .order_by("-count")[:5]
         )
@@ -387,6 +451,26 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
             base_issues.filter(completed_at__isnull=True)
             .values(*user_assignee_details)
             .annotate(count=Count("id"))
+            .annotate(
+                assignees__avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        assignees__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(
+                        assignees__avatar_asset__isnull=True,
+                        then="assignees__avatar",
+                    ),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
             .order_by("-count")
         )
 

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

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

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

@@ -1,6 +1,7 @@
 # Django imports
 from django.contrib.postgres.aggregates import ArrayAgg
 from django.contrib.postgres.fields import ArrayField
+from django.db import models
 from django.db.models import (
     Case,
     CharField,
@@ -18,7 +19,7 @@ from django.db.models import (
     Sum,
     FloatField,
 )
-from django.db.models.functions import Coalesce, Cast
+from django.db.models.functions import Coalesce, Cast, Concat
 from django.utils import timezone
 
 # Third party imports
@@ -139,7 +140,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                 Prefetch(
                     "issue_cycle__issue__assignees",
                     queryset=User.objects.only(
-                        "avatar", "first_name", "id"
+                        "avatar_asset", "first_name", "id"
                     ).distinct(),
                 )
             )
@@ -400,8 +401,27 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                     )
                     .annotate(display_name=F("assignees__display_name"))
                     .annotate(assignee_id=F("assignees__id"))
-                    .annotate(avatar=F("assignees__avatar"))
-                    .values("display_name", "assignee_id", "avatar")
+                    .annotate(
+                        avatar_url=Case(
+                            # If `avatar_asset` exists, use it to generate the asset URL
+                            When(
+                                assignees__avatar_asset__isnull=False,
+                                then=Concat(
+                                    Value("/api/assets/v2/static/"),
+                                    "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                    Value("/"),
+                                ),
+                            ),
+                            # If `avatar_asset` is None, fall back to using `avatar` field directly
+                            When(
+                                assignees__avatar_asset__isnull=True,
+                                then="assignees__avatar",
+                            ),
+                            default=Value(None),
+                            output_field=models.CharField(),
+                        )
+                    )
+                    .values("display_name", "assignee_id", "avatar_url")
                     .annotate(
                         total_estimates=Sum(
                             Cast("estimate_point__value", FloatField())
@@ -494,13 +514,13 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
                 .annotate(first_name=F("assignees__first_name"))
                 .annotate(last_name=F("assignees__last_name"))
                 .annotate(assignee_id=F("assignees__id"))
-                .annotate(avatar=F("assignees__avatar"))
+                .annotate(avatar_url=F("assignees__avatar_url"))
                 .annotate(display_name=F("assignees__display_name"))
                 .values(
                     "first_name",
                     "last_name",
                     "assignee_id",
-                    "avatar",
+                    "avatar_url",
                     "display_name",
                 )
                 .annotate(
@@ -604,7 +624,7 @@ class CycleArchiveUnarchiveEndpoint(BaseAPIView):
             pk=cycle_id, project_id=project_id, workspace__slug=slug
         )
 
-        if cycle.end_date >= timezone.now().date():
+        if cycle.end_date >= timezone.now():
             return Response(
                 {"error": "Only completed cycles can be archived"},
                 status=status.HTTP_400_BAD_REQUEST,

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

@@ -20,7 +20,8 @@ from django.db.models import (
     Sum,
     FloatField,
 )
-from django.db.models.functions import Coalesce, Cast
+from django.db import models
+from django.db.models.functions import Coalesce, Cast, Concat
 from django.utils import timezone
 from django.core.serializers.json import DjangoJSONEncoder
 
@@ -81,7 +82,7 @@ class CycleViewSet(BaseViewSet):
                 Prefetch(
                     "issue_cycle__issue__assignees",
                     queryset=User.objects.only(
-                        "avatar", "first_name", "id"
+                        "avatar_asset", "first_name", "id"
                     ).distinct(),
                 )
             )
@@ -187,6 +188,7 @@ class CycleViewSet(BaseViewSet):
                 "completed_issues",
                 "assignee_ids",
                 "status",
+                "version",
                 "created_by",
             )
 
@@ -216,6 +218,7 @@ class CycleViewSet(BaseViewSet):
             "completed_issues",
             "assignee_ids",
             "status",
+            "version",
             "created_by",
         )
         return Response(data, status=status.HTTP_200_OK)
@@ -255,6 +258,7 @@ class CycleViewSet(BaseViewSet):
                         "external_id",
                         "progress_snapshot",
                         "logo_props",
+                        "version",
                         # meta fields
                         "is_favorite",
                         "total_issues",
@@ -306,10 +310,7 @@ class CycleViewSet(BaseViewSet):
 
         request_data = request.data
 
-        if (
-            cycle.end_date is not None
-            and cycle.end_date < timezone.now().date()
-        ):
+        if cycle.end_date is not None and cycle.end_date < timezone.now():
             if "sort_order" in request_data:
                 # Can only change sort order for a completed cycle``
                 request_data = {
@@ -347,6 +348,7 @@ class CycleViewSet(BaseViewSet):
                 "external_id",
                 "progress_snapshot",
                 "logo_props",
+                "version",
                 # meta fields
                 "is_favorite",
                 "total_issues",
@@ -412,6 +414,7 @@ class CycleViewSet(BaseViewSet):
                 "progress_snapshot",
                 "sub_issues",
                 "logo_props",
+                "version",
                 # meta fields
                 "is_favorite",
                 "total_issues",
@@ -665,8 +668,27 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                 )
                 .annotate(display_name=F("assignees__display_name"))
                 .annotate(assignee_id=F("assignees__id"))
-                .annotate(avatar=F("assignees__avatar"))
-                .values("display_name", "assignee_id", "avatar")
+                .annotate(
+                    avatar_url=Case(
+                        # If `avatar_asset` exists, use it to generate the asset URL
+                        When(
+                            assignees__avatar_asset__isnull=False,
+                            then=Concat(
+                                Value("/api/assets/v2/static/"),
+                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                Value("/"),
+                            ),
+                        ),
+                        # If `avatar_asset` is None, fall back to using `avatar` field directly
+                        When(
+                            assignees__avatar_asset__isnull=True,
+                            then="assignees__avatar",
+                        ),
+                        default=Value(None),
+                        output_field=models.CharField(),
+                    )
+                )
+                .values("display_name", "assignee_id", "avatar_url")
                 .annotate(
                     total_estimates=Sum(
                         Cast("estimate_point__value", FloatField())
@@ -703,7 +725,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                         if item["assignee_id"]
                         else None
                     ),
-                    "avatar": item["avatar"],
+                    "avatar": item.get("avatar"),
+                    "avatar_url": item.get("avatar_url"),
                     "total_estimates": item["total_estimates"],
                     "completed_estimates": item["completed_estimates"],
                     "pending_estimates": item["pending_estimates"],
@@ -780,8 +803,27 @@ class TransferCycleIssueEndpoint(BaseAPIView):
             )
             .annotate(display_name=F("assignees__display_name"))
             .annotate(assignee_id=F("assignees__id"))
-            .annotate(avatar=F("assignees__avatar"))
-            .values("display_name", "assignee_id", "avatar")
+            .annotate(
+                avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        assignees__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(
+                        assignees__avatar_asset__isnull=True,
+                        then="assignees__avatar",
+                    ),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
+            .values("display_name", "assignee_id", "avatar_url")
             .annotate(
                 total_issues=Count(
                     "id",
@@ -820,7 +862,8 @@ class TransferCycleIssueEndpoint(BaseAPIView):
                 "assignee_id": (
                     str(item["assignee_id"]) if item["assignee_id"] else None
                 ),
-                "avatar": item["avatar"],
+                "avatar": item.get("avatar"),
+                "avatar_url": item.get("avatar_url"),
                 "total_issues": item["total_issues"],
                 "completed_issues": item["completed_issues"],
                 "pending_issues": item["pending_issues"],
@@ -925,7 +968,7 @@ class TransferCycleIssueEndpoint(BaseAPIView):
 
         if (
             new_cycle.end_date is not None
-            and new_cycle.end_date < timezone.now().date()
+            and new_cycle.end_date < timezone.now()
         ):
             return Response(
                 {
@@ -1148,6 +1191,7 @@ class CycleProgressEndpoint(BaseAPIView):
             status=status.HTTP_200_OK,
         )
 
+
 class CycleAnalyticsEndpoint(BaseAPIView):
 
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
@@ -1198,8 +1242,27 @@ class CycleAnalyticsEndpoint(BaseAPIView):
                 )
                 .annotate(display_name=F("assignees__display_name"))
                 .annotate(assignee_id=F("assignees__id"))
-                .annotate(avatar=F("assignees__avatar"))
-                .values("display_name", "assignee_id", "avatar")
+                .annotate(
+                    avatar_url=Case(
+                        # If `avatar_asset` exists, use it to generate the asset URL
+                        When(
+                            assignees__avatar_asset__isnull=False,
+                            then=Concat(
+                                Value("/api/assets/v2/static/"),
+                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                Value("/"),
+                            ),
+                        ),
+                        # If `avatar_asset` is None, fall back to using `avatar` field directly
+                        When(
+                            assignees__avatar_asset__isnull=True,
+                            then="assignees__avatar",
+                        ),
+                        default=Value(None),
+                        output_field=models.CharField(),
+                    )
+                )
+                .values("display_name", "assignee_id", "avatar_url")
                 .annotate(
                     total_estimates=Sum(
                         Cast("estimate_point__value", FloatField())
@@ -1282,8 +1345,27 @@ class CycleAnalyticsEndpoint(BaseAPIView):
                 )
                 .annotate(display_name=F("assignees__display_name"))
                 .annotate(assignee_id=F("assignees__id"))
-                .annotate(avatar=F("assignees__avatar"))
-                .values("display_name", "assignee_id", "avatar")
+                .annotate(
+                    avatar_url=Case(
+                        # If `avatar_asset` exists, use it to generate the asset URL
+                        When(
+                            assignees__avatar_asset__isnull=False,
+                            then=Concat(
+                                Value("/api/assets/v2/static/"),
+                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                Value("/"),
+                            ),
+                        ),
+                        # If `avatar_asset` is None, fall back to using `avatar` field directly
+                        When(
+                            assignees__avatar_asset__isnull=True,
+                            then="assignees__avatar",
+                        ),
+                        default=Value(None),
+                        output_field=models.CharField(),
+                    )
+                )
+                .values("display_name", "assignee_id", "avatar_url")
                 .annotate(
                     total_issues=Count(
                         "assignee_id",

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

@@ -22,7 +22,7 @@ from plane.db.models import (
     Cycle,
     CycleIssue,
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
 )
 from plane.utils.grouper import (
@@ -110,8 +110,9 @@ class CycleIssueViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -246,10 +247,7 @@ class CycleIssueViewSet(BaseViewSet):
             workspace__slug=slug, project_id=project_id, pk=cycle_id
         )
 
-        if (
-            cycle.end_date is not None
-            and cycle.end_date < timezone.now().date()
-        ):
+        if cycle.end_date is not None and cycle.end_date < timezone.now():
             return Response(
                 {
                     "error": "The Cycle has already been completed so no new issues can be added"

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

@@ -36,12 +36,10 @@ from plane.db.models import (
     DashboardWidget,
     Issue,
     IssueActivity,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     IssueRelation,
     Project,
-    ProjectMember,
-    User,
     Widget,
     WorkspaceMember,
 )
@@ -58,7 +56,8 @@ def dashboard_overview_stats(self, request, slug):
             project__project_projectmember__member=request.user,
             workspace__slug=slug,
             assignees__in=[request.user],
-        ).filter(
+        )
+        .filter(
             Q(
                 project__project_projectmember__role=5,
                 project__guest_view_all_features=True,
@@ -85,7 +84,8 @@ def dashboard_overview_stats(self, request, slug):
             project__project_projectmember__member=request.user,
             workspace__slug=slug,
             assignees__in=[request.user],
-        ).filter(
+        )
+        .filter(
             Q(
                 project__project_projectmember__role=5,
                 project__guest_view_all_features=True,
@@ -110,7 +110,8 @@ def dashboard_overview_stats(self, request, slug):
             project__project_projectmember__is_active=True,
             project__project_projectmember__member=request.user,
             created_by_id=request.user.id,
-        ).filter(
+        )
+        .filter(
             Q(
                 project__project_projectmember__role=5,
                 project__guest_view_all_features=True,
@@ -136,7 +137,8 @@ def dashboard_overview_stats(self, request, slug):
             project__project_projectmember__member=request.user,
             assignees__in=[request.user],
             state__group="completed",
-        ).filter(
+        )
+        .filter(
             Q(
                 project__project_projectmember__role=5,
                 project__guest_view_all_features=True,
@@ -197,8 +199,9 @@ def dashboard_assigned_issues(self, request, slug):
             .values("count")
         )
         .annotate(
-            attachment_count=IssueAttachment.objects.filter(
-                issue=OuterRef("id")
+            attachment_count=FileAsset.objects.filter(
+                issue_id=OuterRef("id"),
+                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
             )
             .order_by()
             .annotate(count=Func(F("id"), function="Count"))
@@ -360,8 +363,9 @@ def dashboard_created_issues(self, request, slug):
             .values("count")
         )
         .annotate(
-            attachment_count=IssueAttachment.objects.filter(
-                issue=OuterRef("id")
+            attachment_count=FileAsset.objects.filter(
+                issue_id=OuterRef("id"),
+                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
             )
             .order_by()
             .annotate(count=Func(F("id"), function="Count"))

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

@@ -1,5 +1,9 @@
 import random
 import string
+import json
+
+# Django imports
+from django.utils import timezone
 
 # Third party imports
 from rest_framework.response import Response
@@ -19,6 +23,7 @@ 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):
@@ -249,11 +254,66 @@ class EstimatePointEndpoint(BaseViewSet):
         )
         # update all the issues with the new estimate
         if new_estimate_id:
-            _ = Issue.objects.filter(
+            issues = Issue.objects.filter(
                 project_id=project_id,
                 workspace__slug=slug,
                 estimate_point_id=estimate_point_id,
-            ).update(estimate_point_id=new_estimate_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()),
+                )
 
         # 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,
-    IssueAttachment,
+    FileAsset,
     Project,
     ProjectMember,
 )
@@ -120,8 +120,9 @@ class InboxIssueViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -167,10 +168,10 @@ class InboxIssueViewSet(BaseViewSet):
 
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
     def list(self, request, slug, project_id):
-        inbox_id = Inbox.objects.get(
+        inbox_id = Inbox.objects.filter(
             workspace__slug=slug, project_id=project_id
-        )
-        project = Project.objects.get(pk=project_id) 
+        ).first()
+        project = Project.objects.get(pk=project_id)
         filters = issue_filters(request.GET, "GET", "issue__")
         inbox_issue = (
             InboxIssue.objects.filter(
@@ -323,7 +324,7 @@ class InboxIssueViewSet(BaseViewSet):
                 serializer.errors, status=status.HTTP_400_BAD_REQUEST
             )
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=Issue)
     def partial_update(self, request, slug, project_id, pk):
         inbox_id = Inbox.objects.filter(
             workspace__slug=slug, project_id=project_id
@@ -418,7 +419,7 @@ class InboxIssueViewSet(BaseViewSet):
                 )
 
         # Only project admins and members can edit inbox issue attributes
-        if project_member.role > 5:
+        if project_member.role > 15:
             serializer = InboxIssueSerializer(
                 inbox_issue, data=request.data, partial=True
             )
@@ -527,9 +528,9 @@ class InboxIssueViewSet(BaseViewSet):
         model=Issue,
     )
     def retrieve(self, request, slug, project_id, pk):
-        inbox_id = Inbox.objects.get(
+        inbox_id = Inbox.objects.filter(
             workspace__slug=slug, project_id=project_id
-        )
+        ).first()
         project = Project.objects.get(pk=project_id)
         inbox_issue = (
             InboxIssue.objects.select_related("issue")

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

@@ -30,7 +30,7 @@ from plane.app.serializers import (
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.db.models import (
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     IssueSubscriber,
     IssueReaction,
@@ -79,8 +79,9 @@ class IssueArchiveViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -236,12 +237,6 @@ class IssueArchiveViewSet(BaseViewSet):
                     ),
                 )
             )
-            .prefetch_related(
-                Prefetch(
-                    "issue_attachment",
-                    queryset=IssueAttachment.objects.select_related("issue"),
-                )
-            )
             .prefetch_related(
                 Prefetch(
                     "issue_link",

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

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

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

@@ -35,7 +35,7 @@ from plane.app.serializers import (
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.db.models import (
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     IssueUserProperty,
     IssueReaction,
@@ -91,8 +91,9 @@ class IssueListEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -214,8 +215,9 @@ class IssueViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -234,11 +236,17 @@ class IssueViewSet(BaseViewSet):
     @method_decorator(gzip_page)
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
     def list(self, request, slug, project_id):
+        extra_filters = {}
+        if request.GET.get("updated_at__gt", None) is not None:
+            extra_filters = {
+                "updated_at__gt": request.GET.get("updated_at__gt")
+            }
+
         project = Project.objects.get(pk=project_id, workspace__slug=slug)
         filters = issue_filters(request.query_params, "GET")
         order_by_param = request.GET.get("order_by", "-created_at")
 
-        issue_queryset = self.get_queryset().filter(**filters)
+        issue_queryset = self.get_queryset().filter(**filters, **extra_filters)
         # Custom ordering for priority and state
 
         # Issue queryset
@@ -494,12 +502,6 @@ class IssueViewSet(BaseViewSet):
                     ),
                 )
             )
-            .prefetch_related(
-                Prefetch(
-                    "issue_attachment",
-                    queryset=IssueAttachment.objects.select_related("issue"),
-                )
-            )
             .prefetch_related(
                 Prefetch(
                     "issue_link",
@@ -713,16 +715,38 @@ class BulkDeleteIssuesEndpoint(BaseAPIView):
         )
 
 
+class DeletedIssuesListViewSet(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id):
+        filters = {}
+        if request.GET.get("updated_at__gt", None) is not None:
+            filters = {"updated_at__gt": request.GET.get("updated_at__gt")}
+        deleted_issues = (
+            Issue.all_objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+            )
+            .filter(Q(archived_at__isnull=False) | Q(deleted_at__isnull=False))
+            .filter(**filters)
+            .values_list("id", flat=True)
+        )
+
+        return Response(deleted_issues, status=status.HTTP_200_OK)
+
+
 class IssuePaginatedViewSet(BaseViewSet):
     def get_queryset(self):
         workspace_slug = self.kwargs.get("slug")
         project_id = self.kwargs.get("project_id")
 
+        issue_queryset = Issue.issue_objects.filter(
+            workspace__slug=workspace_slug, project_id=project_id
+        )
+
         return (
-            Issue.issue_objects.filter(
-                workspace__slug=workspace_slug, project_id=project_id
+            issue_queryset.select_related(
+                "workspace", "project", "state", "parent"
             )
-            .select_related("workspace", "project", "state", "parent")
             .prefetch_related("assignees", "labels", "issue_module__module")
             .annotate(cycle_id=F("issue_cycle__cycle_id"))
             .annotate(
@@ -731,14 +755,6 @@ 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")
@@ -764,13 +780,14 @@ class IssuePaginatedViewSet(BaseViewSet):
     def list(self, request, slug, project_id):
         cursor = request.GET.get("cursor", None)
         is_description_required = request.GET.get("description", False)
-        updated_at = request.GET.get("updated_at__gte", None)
+        updated_at = request.GET.get("updated_at__gt", None)
 
         # required fields
         required_fields = [
             "id",
             "name",
             "state_id",
+            "state__group",
             "sort_order",
             "completed_at",
             "estimate_point",
@@ -787,7 +804,6 @@ class IssuePaginatedViewSet(BaseViewSet):
             "updated_by",
             "is_draft",
             "archived_at",
-            "deleted_at",
             "module_ids",
             "label_ids",
             "assignee_ids",
@@ -802,13 +818,28 @@ class IssuePaginatedViewSet(BaseViewSet):
         # querying issues
         base_queryset = Issue.issue_objects.filter(
             workspace__slug=slug, project_id=project_id
-        ).order_by("updated_at")
+        )
+
+        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__gte=updated_at)
-            queryset = queryset.filter(updated_at__gte=updated_at)
+            base_queryset = base_queryset.filter(updated_at__gt=updated_at)
+            queryset = queryset.filter(updated_at__gt=updated_at)
 
         queryset = queryset.annotate(
             label_ids=Coalesce(

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

@@ -1,410 +0,0 @@
-# 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/reaction.py

@@ -37,7 +37,7 @@ class IssueReactionViewSet(BaseViewSet):
             .distinct()
         )
 
-    @allow_permission(ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST)
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
     def create(self, request, slug, project_id, issue_id):
         serializer = IssueReactionSerializer(data=request.data)
         if serializer.is_valid():
@@ -60,7 +60,7 @@ class IssueReactionViewSet(BaseViewSet):
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
-    @allow_permission(ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST)
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
     def destroy(self, request, slug, project_id, issue_id, reaction_code):
         issue_reaction = IssueReaction.objects.get(
             workspace__slug=slug,

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

@@ -24,7 +24,7 @@ from plane.db.models import (
     Project,
     IssueRelation,
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
 )
 from plane.bgtasks.issue_activities_task import issue_activity
@@ -91,8 +91,9 @@ class IssueRelationViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -267,7 +268,7 @@ class IssueRelationViewSet(BaseViewSet):
             IssueRelationSerializer(issue_relation).data,
             cls=DjangoJSONEncoder,
         )
-        issue_relation.delete()
+        issue_relation.delete(soft=False)
         issue_activity.delay(
             type="issue_relation.activity.deleted",
             requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),

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

@@ -28,7 +28,7 @@ from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import (
     Issue,
     IssueLink,
-    IssueAttachment,
+    FileAsset,
 )
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.utils.user_timezone_converter import user_timezone_converter
@@ -56,8 +56,9 @@ class SubIssuesEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))

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

@@ -14,9 +14,12 @@ from django.db.models import (
     Value,
     Sum,
     FloatField,
+    Case,
+    When,
 )
-from django.db.models.functions import Coalesce, Cast
+from django.db.models.functions import Coalesce, Cast, Concat
 from django.utils import timezone
+from django.db import models
 
 # Third party imports
 from rest_framework import status
@@ -364,12 +367,31 @@ class ModuleArchiveUnarchiveEndpoint(BaseAPIView):
                     .annotate(last_name=F("assignees__last_name"))
                     .annotate(assignee_id=F("assignees__id"))
                     .annotate(display_name=F("assignees__display_name"))
-                    .annotate(avatar=F("assignees__avatar"))
+                    .annotate(
+                        avatar_url=Case(
+                            # If `avatar_asset` exists, use it to generate the asset URL
+                            When(
+                                assignees__avatar_asset__isnull=False,
+                                then=Concat(
+                                    Value("/api/assets/v2/static/"),
+                                    "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                    Value("/"),
+                                ),
+                            ),
+                            # If `avatar_asset` is None, fall back to using `avatar` field directly
+                            When(
+                                assignees__avatar_asset__isnull=True,
+                                then="assignees__avatar",
+                            ),
+                            default=Value(None),
+                            output_field=models.CharField(),
+                        )
+                    )
                     .values(
                         "first_name",
                         "last_name",
                         "assignee_id",
-                        "avatar",
+                        "avatar_url",
                         "display_name",
                     )
                     .annotate(
@@ -437,7 +459,9 @@ class ModuleArchiveUnarchiveEndpoint(BaseAPIView):
                     )
                     .order_by("label_name")
                 )
-                data["estimate_distribution"]["assignees"] = assignee_distribution
+                data["estimate_distribution"][
+                    "assignees"
+                ] = assignee_distribution
                 data["estimate_distribution"]["labels"] = label_distribution
 
                 if modules and modules.start_date and modules.target_date:
@@ -461,12 +485,31 @@ class ModuleArchiveUnarchiveEndpoint(BaseAPIView):
                 .annotate(last_name=F("assignees__last_name"))
                 .annotate(assignee_id=F("assignees__id"))
                 .annotate(display_name=F("assignees__display_name"))
-                .annotate(avatar=F("assignees__avatar"))
+                .annotate(
+                    avatar_url=Case(
+                        # If `avatar_asset` exists, use it to generate the asset URL
+                        When(
+                            assignees__avatar_asset__isnull=False,
+                            then=Concat(
+                                Value("/api/assets/v2/static/"),
+                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                Value("/"),
+                            ),
+                        ),
+                        # If `avatar_asset` is None, fall back to using `avatar` field directly
+                        When(
+                            assignees__avatar_asset__isnull=True,
+                            then="assignees__avatar",
+                        ),
+                        default=Value(None),
+                        output_field=models.CharField(),
+                    )
+                )
                 .values(
                     "first_name",
                     "last_name",
                     "assignee_id",
-                    "avatar",
+                    "avatar_url",
                     "display_name",
                 )
                 .annotate(

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

@@ -18,8 +18,11 @@ from django.db.models import (
     Value,
     Sum,
     FloatField,
+    Case,
+    When,
 )
-from django.db.models.functions import Coalesce, Cast
+from django.db import models
+from django.db.models.functions import Coalesce, Cast, Concat
 from django.core.serializers.json import DjangoJSONEncoder
 from django.utils import timezone
 
@@ -30,6 +33,7 @@ from rest_framework.response import Response
 # Module imports
 from plane.app.permissions import (
     ProjectEntityPermission,
+    ProjectLitePermission,
     allow_permission,
     ROLE,
 )
@@ -317,13 +321,12 @@ 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(
@@ -386,8 +389,7 @@ 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:
@@ -435,13 +437,7 @@ 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()
@@ -488,12 +484,31 @@ class ModuleViewSet(BaseViewSet):
                 .annotate(last_name=F("assignees__last_name"))
                 .annotate(assignee_id=F("assignees__id"))
                 .annotate(display_name=F("assignees__display_name"))
-                .annotate(avatar=F("assignees__avatar"))
+                .annotate(
+                    avatar_url=Case(
+                        # If `avatar_asset` exists, use it to generate the asset URL
+                        When(
+                            assignees__avatar_asset__isnull=False,
+                            then=Concat(
+                                Value("/api/assets/v2/static/"),
+                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                Value("/"),
+                            ),
+                        ),
+                        # If `avatar_asset` is None, fall back to using `avatar` field directly
+                        When(
+                            assignees__avatar_asset__isnull=True,
+                            then="assignees__avatar",
+                        ),
+                        default=Value(None),
+                        output_field=models.CharField(),
+                    )
+                )
                 .values(
                     "first_name",
                     "last_name",
                     "assignee_id",
-                    "avatar",
+                    "avatar_url",
                     "display_name",
                 )
                 .annotate(
@@ -585,12 +600,31 @@ class ModuleViewSet(BaseViewSet):
             .annotate(last_name=F("assignees__last_name"))
             .annotate(assignee_id=F("assignees__id"))
             .annotate(display_name=F("assignees__display_name"))
-            .annotate(avatar=F("assignees__avatar"))
+            .annotate(
+                avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        assignees__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(
+                        assignees__avatar_asset__isnull=True,
+                        then="assignees__avatar",
+                    ),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
             .values(
                 "first_name",
                 "last_name",
                 "assignee_id",
-                "avatar",
+                "avatar_url",
                 "display_name",
             )
             .annotate(
@@ -672,7 +706,13 @@ class ModuleViewSet(BaseViewSet):
             "labels": label_distribution,
             "completion_chart": {},
         }
-        if modules and modules.start_date and modules.target_date:
+
+        if (
+            modules
+            and modules.start_date
+            and modules.target_date
+            and modules.total_issues > 0
+        ):
             data["distribution"]["completion_chart"] = burndown_plot(
                 queryset=modules,
                 slug=slug,
@@ -838,6 +878,9 @@ 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,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     ModuleIssue,
     Project,
@@ -73,8 +73,9 @@ class ModuleIssueViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))

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

@@ -41,7 +41,7 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
         )
 
     @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER],
+        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST],
         level="WORKSPACE",
     )
     def list(self, request, slug):
@@ -207,7 +207,7 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
         return Response(serializer.data, status=status.HTTP_200_OK)
 
     @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE"
+        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
     )
     def mark_unread(self, request, slug, pk):
         notification = Notification.objects.get(
@@ -219,7 +219,7 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
         return Response(serializer.data, status=status.HTTP_200_OK)
 
     @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE"
+        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
     )
     def archive(self, request, slug, pk):
         notification = Notification.objects.get(
@@ -231,7 +231,7 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
         return Response(serializer.data, status=status.HTTP_200_OK)
 
     @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE"
+        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
     )
     def unarchive(self, request, slug, pk):
         notification = Notification.objects.get(
@@ -286,7 +286,7 @@ class UnreadNotificationEndpoint(BaseAPIView):
 
 class MarkAllReadNotificationViewSet(BaseViewSet):
     @allow_permission(
-        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE"
+        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE"
     )
     def create(self, request, slug):
         snoozed = request.data.get("snoozed", False)

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

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

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

@@ -53,6 +53,7 @@ from plane.db.models import (
 from plane.utils.cache import cache_response
 from plane.bgtasks.webhook_task import model_activity
 from plane.bgtasks.recent_visited_task import recent_visited_task
+from plane.utils.exception_logger import log_exception
 
 
 class ProjectViewSet(BaseViewSet):
@@ -173,7 +174,7 @@ class ProjectViewSet(BaseViewSet):
             member=request.user,
             workspace__slug=slug,
             is_active=True,
-            role=10,
+            role=15,
         ).exists():
             projects = projects.filter(
                 Q(
@@ -413,9 +414,20 @@ 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)
@@ -438,11 +450,16 @@ class ProjectViewSet(BaseViewSet):
             if serializer.is_valid():
                 serializer.save()
                 if serializer.data["inbox_view"]:
-                    Inbox.objects.get_or_create(
-                        name=f"{project.name} Inbox",
+                    inbox = Inbox.objects.filter(
                         project=project,
                         is_default=True,
-                    )
+                    ).first()
+                    if not inbox:
+                        Inbox.objects.create(
+                            name=f"{project.name} Inbox",
+                            project=project,
+                            is_default=True,
+                        )
 
                     # Create the triage state in Backlog group
                     State.objects.get_or_create(
@@ -492,6 +509,44 @@ 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):
 
@@ -666,18 +721,22 @@ class ProjectPublicCoverImagesEndpoint(BaseAPIView):
             "Prefix": "static/project-cover/",
         }
 
-        response = s3.list_objects_v2(**params)
-        # Extracting file keys from the response
-        if "Contents" in response:
-            for content in response["Contents"]:
-                if not content["Key"].endswith(
-                    "/"
-                ):  # This line ensures we're only getting files, not "sub-folders"
-                    files.append(
-                        f"https://{settings.AWS_STORAGE_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
-                    )
+        try:
+            response = s3.list_objects_v2(**params)
+            # Extracting file keys from the response
+            if "Contents" in response:
+                for content in response["Contents"]:
+                    if not content["Key"].endswith(
+                        "/"
+                    ):  # This line ensures we're only getting files, not "sub-folders"
+                        files.append(
+                            f"https://{settings.AWS_STORAGE_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
+                        )
 
-        return Response(files, status=status.HTTP_200_OK)
+            return Response(files, status=status.HTTP_200_OK)
+        except Exception as e:
+            log_exception(e)
+            return Response([], status=status.HTTP_200_OK)
 
 
 class DeployBoardViewSet(BaseViewSet):

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

@@ -414,6 +414,7 @@ class UserProjectRolesEndpoint(BaseAPIView):
         project_members = ProjectMember.objects.filter(
             workspace__slug=slug,
             member_id=request.user.id,
+            is_active=True,
         ).values("project_id", "role")
 
         project_members = {

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

@@ -90,7 +90,7 @@ class GlobalSearchEndpoint(BaseAPIView):
             "project__identifier",
             "project_id",
             "workspace__slug",
-        )
+        )[:100]
 
     def filter_cycles(self, query, slug, project_id, workspace_search):
         fields = ["name"]

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

@@ -97,6 +97,6 @@ class IssueSearchEndpoint(BaseAPIView):
                 "state__name",
                 "state__group",
                 "state__color",
-            ),
+            )[:100],
             status=status.HTTP_200_OK,
         )

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

@@ -29,7 +29,7 @@ from plane.app.serializers import (
 )
 from plane.db.models import (
     Issue,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     IssueView,
     Workspace,
@@ -213,8 +213,9 @@ class WorkspaceViewIssuesViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -431,8 +432,7 @@ 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,8 +457,7 @@ 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()
@@ -498,8 +497,7 @@ 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(
@@ -532,8 +530,7 @@ 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,
@@ -578,8 +575,7 @@ 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,
@@ -589,8 +585,7 @@ 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

@@ -0,0 +1,334 @@
+# 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,7 +74,6 @@ 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,
-    IssueAttachment,
+    FileAsset,
     IssueLink,
     IssueSubscriber,
     Project,
@@ -128,8 +128,9 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -359,8 +360,8 @@ class WorkspaceUserProfileEndpoint(BaseAPIView):
                     "email": user_data.email,
                     "first_name": user_data.first_name,
                     "last_name": user_data.last_name,
-                    "avatar": user_data.avatar,
-                    "cover_image": user_data.cover_image,
+                    "avatar_url": user_data.avatar_url,
+                    "cover_image_url": user_data.cover_image_url,
                     "date_joined": user_data.date_joined,
                     "user_timezone": user_data.user_timezone,
                     "display_name": user_data.display_name,
@@ -504,7 +505,7 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
 
         upcoming_cycles = CycleIssue.objects.filter(
             workspace__slug=slug,
-            cycle__start_date__gt=timezone.now().date(),
+            cycle__start_date__gt=timezone.now(),
             issue__assignees__in=[
                 user_id,
             ],
@@ -512,8 +513,8 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
 
         present_cycle = CycleIssue.objects.filter(
             workspace__slug=slug,
-            cycle__start_date__lt=timezone.now().date(),
-            cycle__end_date__gt=timezone.now().date(),
+            cycle__start_date__lt=timezone.now(),
+            cycle__end_date__gt=timezone.now(),
             issue__assignees__in=[
                 user_id,
             ],

apiserver/plane/bgtasks/analytic_plot_export.py

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

apiserver/plane/bgtasks/deletion_task.py

@@ -2,6 +2,7 @@
 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
@@ -18,17 +19,25 @@ def soft_delete_related_objects(
     for field in related_fields:
         if field.one_to_many or field.one_to_one:
             try:
-                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)
+                # 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)
             except ObjectDoesNotExist:
                 pass
 
@@ -154,8 +163,7 @@ 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/dummy_data_task.py

@@ -347,7 +347,7 @@ def create_issues(workspace, project, user_id, issue_count):
             )
         )
 
-        text = fake.text(max_nb_chars=60000)
+        text = fake.text(max_nb_chars=3000)
         issues.append(
             Issue(
                 state_id=states[random.randint(0, len(states) - 1)],
@@ -490,18 +490,23 @@ def create_issue_assignees(workspace, project, user_id, issue_count):
 def create_issue_labels(workspace, project, user_id, issue_count):
     # labels
     labels = Label.objects.filter(project=project).values_list("id", flat=True)
-    issues = random.sample(
-        list(
+    # issues = random.sample(
+    #     list(
+    #         Issue.objects.filter(project=project).values_list("id", flat=True)
+    #     ),
+    #     int(issue_count / 2),
+    # )
+    issues = list(
             Issue.objects.filter(project=project).values_list("id", flat=True)
-        ),
-        int(issue_count / 2),
-    )
+        ) 
+    shuffled_labels = list(labels)
 
     # Bulk issue
     bulk_issue_labels = []
     for issue in issues:
+        random.shuffle(shuffled_labels)
         for label in random.sample(
-            list(labels), random.randint(0, len(labels) - 1)
+            shuffled_labels, random.randint(0, 5)
         ):
             bulk_issue_labels.append(
                 IssueLabel(
@@ -552,25 +557,33 @@ def create_module_issues(workspace, project, user_id, issue_count):
     modules = Module.objects.filter(project=project).values_list(
         "id", flat=True
     )
-    issues = random.sample(
-        list(
+    # issues = random.sample(
+    #     list(
+    #         Issue.objects.filter(project=project).values_list("id", flat=True)
+    #     ),
+    #     int(issue_count / 2),
+    # )
+    issues = list(
             Issue.objects.filter(project=project).values_list("id", flat=True)
-        ),
-        int(issue_count / 2),
-    )
+        ) 
+
+    shuffled_modules = list(modules)
 
     # Bulk issue
     bulk_module_issues = []
     for issue in issues:
-        module = modules[random.randint(0, len(modules) - 1)]
-        bulk_module_issues.append(
-            ModuleIssue(
-                module_id=module,
-                issue_id=issue,
-                project=project,
-                workspace=workspace,
+        random.shuffle(shuffled_modules)
+        for module in random.sample(
+            shuffled_modules, random.randint(0, 5)
+        ):
+            bulk_module_issues.append(
+                ModuleIssue(
+                    module_id=module,
+                    issue_id=issue,
+                    project=project,
+                    workspace=workspace,
+                )
             )
-        )
     # Issue assignees
     ModuleIssue.objects.bulk_create(
         bulk_module_issues, batch_size=1000, ignore_conflicts=True

apiserver/plane/bgtasks/email_notification_task.py

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

apiserver/plane/bgtasks/export_task.py

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

apiserver/plane/bgtasks/file_asset_task.py

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

apiserver/plane/bgtasks/issue_activities_task.py

@@ -465,7 +465,7 @@ def track_estimate_points(
             IssueActivity(
                 issue_id=issue_id,
                 actor_id=actor_id,
-                verb="updated",
+                verb="removed" if new_estimate is None else "updated",
                 old_identifier=(
                     current_instance.get("estimate_point")
                     if current_instance.get("estimate_point") is not None
@@ -1700,16 +1700,12 @@ 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,14 +42,12 @@ def archive_old_issues():
                 ),
                 Q(issue_cycle__isnull=True)
                 | (
-                    Q(issue_cycle__cycle__end_date__lt=timezone.now().date())
+                    Q(issue_cycle__cycle__end_date__lt=timezone.now())
                     & Q(issue_cycle__isnull=False)
                 ),
                 Q(issue_module__isnull=True)
                 | (
-                    Q(
-                        issue_module__module__target_date__lt=timezone.now().date()
-                    )
+                    Q(issue_module__module__target_date__lt=timezone.now())
                     & Q(issue_module__isnull=False)
                 ),
             ).filter(
@@ -122,14 +120,12 @@ def close_old_issues():
                 ),
                 Q(issue_cycle__isnull=True)
                 | (
-                    Q(issue_cycle__cycle__end_date__lt=timezone.now().date())
+                    Q(issue_cycle__cycle__end_date__lt=timezone.now())
                     & Q(issue_cycle__isnull=False)
                 ),
                 Q(issue_module__isnull=True)
                 | (
-                    Q(
-                        issue_module__module__target_date__lt=timezone.now().date()
-                    )
+                    Q(issue_module__module__target_date__lt=timezone.now())
                     & 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_file_asset",
+        "task": "plane.bgtasks.file_asset_task.delete_unuploaded_file_asset",
         "schedule": crontab(hour=0, minute=0),
     },
     "check-every-five-minutes-to-send-email-notifications": {
@@ -40,6 +40,10 @@ 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,67 +1,45 @@
 # Python imports
+import os
 import boto3
-import json
 from botocore.exceptions import ClientError
 
 # Django imports
 from django.core.management import BaseCommand
-from django.conf import settings
 
 
 class Command(BaseCommand):
     help = "Create the default bucket for the instance"
 
-    def set_bucket_public_policy(self, s3_client, bucket_name):
-        public_policy = {
-            "Version": "2012-10-17",
-            "Statement": [
-                {
-                    "Effect": "Allow",
-                    "Principal": "*",
-                    "Action": ["s3:GetObject"],
-                    "Resource": [f"arn:aws:s3:::{bucket_name}/*"],
-                }
-            ],
-        }
-
-        try:
-            s3_client.put_bucket_policy(
-                Bucket=bucket_name, Policy=json.dumps(public_policy)
-            )
-            self.stdout.write(
-                self.style.SUCCESS(
-                    f"Public read access policy set for bucket '{bucket_name}'."
-                )
-            )
-        except ClientError as e:
-            self.stdout.write(
-                self.style.ERROR(
-                    f"Error setting public read access policy: {e}"
-                )
-            )
-
     def handle(self, *args, **options):
         # Create a session using the credentials from Django settings
         try:
-            session = boto3.session.Session(
-                aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
-                aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
+            s3_client = boto3.client(
+                "s3",
+                endpoint_url=os.environ.get(
+                    "AWS_S3_ENDPOINT_URL"
+                ),  # MinIO endpoint
+                aws_access_key_id=os.environ.get(
+                    "AWS_ACCESS_KEY_ID"
+                ),  # MinIO access key
+                aws_secret_access_key=os.environ.get(
+                    "AWS_SECRET_ACCESS_KEY"
+                ),  # MinIO secret key
+                region_name=os.environ.get("AWS_REGION"),  # MinIO region
+                config=boto3.session.Config(signature_version="s3v4"),
             )
-            # Create an S3 client using the session
-            s3_client = session.client(
-                "s3", endpoint_url=settings.AWS_S3_ENDPOINT_URL
-            )
-            bucket_name = settings.AWS_STORAGE_BUCKET_NAME
-
+            # Get the bucket name from the environment
+            bucket_name = os.environ.get("AWS_S3_BUCKET_NAME")
             self.stdout.write(self.style.NOTICE("Checking bucket..."))
-
             # Check if the bucket exists
             s3_client.head_bucket(Bucket=bucket_name)
-
-            self.set_bucket_public_policy(s3_client, bucket_name)
+            # If the bucket exists, print a success message
+            self.stdout.write(
+                self.style.SUCCESS(f"Bucket '{bucket_name}' exists.")
+            )
+            return
         except ClientError as e:
             error_code = int(e.response["Error"]["Code"])
-            bucket_name = settings.AWS_STORAGE_BUCKET_NAME
+            bucket_name = os.environ.get("AWS_S3_BUCKET_NAME")
             if error_code == 404:
                 # Bucket does not exist, create it
                 self.stdout.write(
@@ -76,13 +54,16 @@ class Command(BaseCommand):
                             f"Bucket '{bucket_name}' created successfully."
                         )
                     )
-                    self.set_bucket_public_policy(s3_client, bucket_name)
+
+                # Handle the exception if the bucket creation fails
                 except ClientError as create_error:
                     self.stdout.write(
                         self.style.ERROR(
                             f"Failed to create bucket: {create_error}"
                         )
                     )
+
+            # Handle the exception if access to the bucket is forbidden
             elif error_code == 403:
                 # Access to the bucket is forbidden
                 self.stdout.write(

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

@@ -73,7 +73,7 @@ class Command(BaseCommand):
 
                 from plane.bgtasks.dummy_data_task import create_dummy_data
 
-                create_dummy_data.delay(
+                create_dummy_data(
                     slug=workspace_slug,
                     email=creator,
                     members=members,

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,179 @@
+# 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,6 +5,7 @@ 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
@@ -23,7 +24,6 @@ from .issue import (
     Issue,
     IssueActivity,
     IssueAssignee,
-    IssueAttachment,
     IssueBlocker,
     IssueComment,
     IssueLabel,

apiserver/plane/db/models/asset.py

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

apiserver/plane/db/models/cycle.py

@@ -1,3 +1,6 @@
+# Python imports
+import pytz
+
 # Django imports
 from django.conf import settings
 from django.db import models
@@ -55,10 +58,12 @@ class Cycle(ProjectBaseModel):
     description = models.TextField(
         verbose_name="Cycle Description", blank=True
     )
-    start_date = models.DateField(
+    start_date = models.DateTimeField(
         verbose_name="Start Date", blank=True, null=True
     )
-    end_date = models.DateField(verbose_name="End Date", blank=True, null=True)
+    end_date = models.DateTimeField(
+        verbose_name="End Date", blank=True, null=True
+    )
     owned_by = models.ForeignKey(
         settings.AUTH_USER_MODEL,
         on_delete=models.CASCADE,
@@ -71,6 +76,12 @@ 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,6 +20,7 @@ class DeployBoard(WorkspaceBaseModel):
         ("cycle", "Task"),
         ("page", "Page"),
         ("view", "View"),
+        ("inbox", "Inbox"),
     )
 
     entity_identifier = models.UUIDField(null=True)
@@ -41,6 +42,7 @@ class DeployBoard(WorkspaceBaseModel):
     is_votes_enabled = models.BooleanField(default=False)
     view_props = models.JSONField(default=dict)
     is_activity_enabled = models.BooleanField(default=True)
+    is_disabled = models.BooleanField(default=False)
 
     def __str__(self):
         """Return name of the deploy board"""

apiserver/plane/db/models/draft.py

@@ -0,0 +1,253 @@
+# 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.URLField(blank=True, null=True)
+    avatar_url = models.TextField(blank=True, null=True)
 
     def __str__(self):
         """Return provider of the integration"""

apiserver/plane/db/models/issue_type.py

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

apiserver/plane/db/models/notification.py

@@ -6,7 +6,6 @@ from django.db import models
 from .base import BaseModel
 
 
-
 class Notification(BaseModel):
     workspace = models.ForeignKey(
         "db.Workspace", related_name="notifications", on_delete=models.CASCADE
@@ -90,12 +89,31 @@ class UserNotificationPreference(BaseModel):
         null=True,
     )
 
-    # 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)
+    # 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)
 
     class Meta:
         verbose_name = "UserNotificationPreference"

apiserver/plane/db/models/project.py

@@ -1,4 +1,5 @@
 # Python imports
+import pytz
 from uuid import uuid4
 
 # Django imports
@@ -7,7 +8,7 @@ from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import models
 from django.db.models import Q
 
-# Modeule imports
+# Module imports
 from plane.db.mixins import AuditModel
 
 # Module imports
@@ -98,7 +99,14 @@ class Project(BaseModel):
     is_time_tracking_enabled = models.BooleanField(default=False)
     is_issue_type_enabled = models.BooleanField(default=False)
     guest_view_all_features = models.BooleanField(default=False)
-    cover_image = models.URLField(blank=True, null=True, max_length=800)
+    cover_image = models.TextField(blank=True, null=True)
+    cover_image_asset = models.ForeignKey(
+        "db.FileAsset",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="project_cover_image",
+    )
     estimate = models.ForeignKey(
         "db.Estimate",
         on_delete=models.SET_NULL,
@@ -119,6 +127,23 @@ 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,6 +17,7 @@ from django.dispatch import receiver
 from django.utils import timezone
 
 # Module imports
+from plane.db.models import FileAsset
 from ..mixins import TimeAuditModel
 
 
@@ -48,8 +49,24 @@ class User(AbstractBaseUser, PermissionsMixin):
     display_name = models.CharField(max_length=255, default="")
     first_name = models.CharField(max_length=255, blank=True)
     last_name = models.CharField(max_length=255, blank=True)
+    # avatar
     avatar = models.TextField(blank=True)
+    avatar_asset = models.ForeignKey(
+        FileAsset,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="user_avatar",
+    )
+    # cover image
     cover_image = models.URLField(blank=True, null=True, max_length=800)
+    cover_image_asset = models.ForeignKey(
+        FileAsset,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="user_cover_image",
+    )
 
     # tracking metrics
     date_joined = models.DateTimeField(
@@ -111,6 +128,28 @@ class User(AbstractBaseUser, PermissionsMixin):
     def __str__(self):
         return f"{self.username} <{self.email}>"
 
+    @property
+    def avatar_url(self):
+        # Return the logo asset url if it exists
+        if self.avatar_asset:
+            return self.avatar_asset.asset_url
+
+        # Return the logo url if it exists
+        if self.avatar:
+            return self.avatar
+        return None
+
+    @property
+    def cover_image_url(self):
+        # Return the logo asset url if it exists
+        if self.cover_image_asset:
+            return self.cover_image_asset.asset_url
+
+        # Return the logo url if it exists
+        if self.cover_image:
+            return self.cover_image
+        return None
+
     def save(self, *args, **kwargs):
         self.email = self.email.lower().strip()
         self.mobile_number = self.mobile_number
@@ -182,7 +221,11 @@ class Account(TimeAuditModel):
     )
     provider_account_id = models.CharField(max_length=255)
     provider = models.CharField(
-        choices=(("google", "Google"), ("github", "Github"), ("gitlab", "GitLab")),
+        choices=(
+            ("google", "Google"),
+            ("github", "Github"),
+            ("gitlab", "GitLab"),
+        ),
     )
     access_token = models.TextField()
     access_token_expired_at = models.DateTimeField(null=True)
@@ -209,9 +252,4 @@ 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,7 +118,14 @@ def slug_validator(value):
 
 class Workspace(BaseModel):
     name = models.CharField(max_length=80, verbose_name="Workspace Name")
-    logo = models.URLField(verbose_name="Logo", blank=True, null=True)
+    logo = models.TextField(verbose_name="Logo", blank=True, null=True)
+    logo_asset = models.ForeignKey(
+        "db.FileAsset",
+        on_delete=models.SET_NULL,
+        related_name="workspace_logo",
+        blank=True,
+        null=True,
+    )
     owner = models.ForeignKey(
         settings.AUTH_USER_MODEL,
         on_delete=models.CASCADE,
@@ -138,6 +145,17 @@ class Workspace(BaseModel):
         """Return name of the Workspace"""
         return self.name
 
+    @property
+    def logo_url(self):
+        # Return the logo asset url if it exists
+        if self.logo_asset:
+            return self.logo_asset.asset_url
+
+        # Return the logo url if it exists
+        if self.logo:
+            return self.logo
+        return None
+
     class Meta:
         verbose_name = "Workspace"
         verbose_name_plural = "Workspaces"

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

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

apiserver/plane/license/bgtasks/tracer.py

@@ -0,0 +1,97 @@
+# 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,7 +9,10 @@ from django.conf import settings
 
 # Module imports
 from plane.license.models import Instance
-from plane.db.models import User
+from plane.db.models import (
+    User,
+)
+from plane.license.bgtasks.tracer import instance_traces
 
 
 class Command(BaseCommand):
@@ -21,16 +24,24 @@ 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"
             )
@@ -38,12 +49,7 @@ class Command(BaseCommand):
             if not machine_signature:
                 raise CommandError("Machine signature is required")
 
-            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(),
-            }
+            payload = self.read_package_json()
 
             instance = Instance.objects.create(
                 instance_name="Plane Community Edition",
@@ -60,4 +66,15 @@ class Command(BaseCommand):
             self.stdout.write(
                 self.style.SUCCESS("Instance already registered")
             )
-            return
+            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

apiserver/plane/settings/common.py

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

apiserver/plane/settings/storage.py

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