use common getIssues from issue service instead of multiple different services for modules and cycles

.env.example

@@ -8,13 +8,6 @@ PGDATA="/var/lib/postgresql/data"
 REDIS_HOST="plane-redis"
 REDIS_PORT="6379"
 
-# RabbitMQ Settings
-RABBITMQ_HOST="plane-mq"
-RABBITMQ_PORT="5672"
-RABBITMQ_USER="plane"
-RABBITMQ_PASSWORD="plane"
-RABBITMQ_VHOST="plane"
-
 # AWS Settings
 AWS_REGION=""
 AWS_ACCESS_KEY_ID="access-key"

.eslintrc-staged.js

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

@@ -0,0 +1,10 @@
+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/"],
+    },
+  },
+};

.gitattributes

@@ -1 +0,0 @@
-*.sh text eol=lf

.github/actions/build-push-ce/action.yml

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

.github/workflows/build-aio-base.yml

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

.github/workflows/build-aio-branch.yml

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

.github/workflows/build-branch.yml

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

.github/workflows/codeql.yml

@@ -29,11 +29,11 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
+        uses: github/codeql-action/init@v2
         with:
           languages: ${{ matrix.language }}
           # If you wish to specify custom queries, you can do so here or in a config file.
@@ -46,7 +46,7 @@ jobs:
       # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v3
+        uses: github/codeql-action/autobuild@v2
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
@@ -59,6 +59,6 @@ jobs:
       #     ./location_of_script_within_repo/buildscript.sh
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
+        uses: github/codeql-action/analyze@v2
         with:
           category: "/language:${{matrix.language}}"

.github/workflows/create-sync-pr.yml

@@ -8,20 +8,37 @@ on:
 
 env:
   CURRENT_BRANCH: ${{ github.ref_name }}
-  TARGET_BRANCH: "preview" # The target branch that you would like to merge changes like develop
+  SOURCE_BRANCH: ${{ vars.SYNC_SOURCE_BRANCH_NAME }} # The sync branch such as "sync/ce"
+  TARGET_BRANCH: ${{ vars.SYNC_TARGET_BRANCH_NAME }} # The target branch that you would like to merge changes like develop
   GITHUB_TOKEN: ${{ secrets.ACCESS_TOKEN }} # Personal access token required to modify contents and workflows
+  REVIEWER: ${{ vars.SYNC_PR_REVIEWER }}
   ACCOUNT_USER_NAME: ${{ vars.ACCOUNT_USER_NAME }}
   ACCOUNT_USER_EMAIL: ${{ vars.ACCOUNT_USER_EMAIL }}
 
 jobs:
-  create_pull_request:
+  Check_Branch:
+    runs-on: ubuntu-latest
+    outputs:
+      BRANCH_MATCH: ${{ steps.check-branch.outputs.MATCH }}
+    steps:
+      - name: Check if current branch matches the secret
+        id: check-branch
+        run: |
+          if [ "$CURRENT_BRANCH" = "$SOURCE_BRANCH" ]; then
+            echo "MATCH=true" >> $GITHUB_OUTPUT
+          else
+            echo "MATCH=false" >> $GITHUB_OUTPUT
+          fi
+  Create_PR:
+    if: ${{ needs.Check_Branch.outputs.BRANCH_MATCH == 'true' }}
+    needs: [Check_Branch]
     runs-on: ubuntu-latest
     permissions:
       pull-requests: write
       contents: write
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v4.1.1
         with:
           fetch-depth: 0 # Fetch all history for all branches and tags
 
@@ -42,11 +59,11 @@ jobs:
       - name: Create PR to Target Branch
         run: |
           # get all pull requests and check if there is already a PR
-          PR_EXISTS=$(gh pr list --base $TARGET_BRANCH --head $CURRENT_BRANCH --state open --json number | jq '.[] | .number')
+          PR_EXISTS=$(gh pr list --base $TARGET_BRANCH --head $SOURCE_BRANCH --state open --json number | jq '.[] | .number')
           if [ -n "$PR_EXISTS" ]; then
             echo "Pull Request already exists: $PR_EXISTS"
           else
             echo "Creating new pull request"
-            PR_URL=$(gh pr create --base $TARGET_BRANCH --head $CURRENT_BRANCH --title "${{ vars.SYNC_PR_TITLE }}" --body "")
+            PR_URL=$(gh pr create --base $TARGET_BRANCH --head $SOURCE_BRANCH --title "sync: community changes" --body "")
             echo "Pull Request created: $PR_URL"
           fi

.github/workflows/feature-deployment.yml

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

.github/workflows/repo-sync.yml

@@ -17,7 +17,7 @@ jobs:
       contents: read
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v4.1.1
         with:
           persist-credentials: false
           fetch-depth: 0

.idx/dev.nix

@@ -1,16 +0,0 @@
-{ pkgs, ... }: {
-
-  # Which nixpkgs channel to use.
-  channel = "stable-23.11"; # or "unstable"
-
-  # Use https://search.nixos.org/packages to find packages
-  packages = [
-    pkgs.nodejs_20
-    pkgs.python3
-  ];
-
-  services.docker.enable = true;
-  services.postgres.enable = true;
-  services.redis.enable = true;
-
-}

.lintstagedrc.json

@@ -0,0 +1,3 @@
+{
+  "*.{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 information.
+Before submitting a new issue, please search the [issues](https://github.com/makeplane/plane/issues) tab. Maybe an issue or discussion already exists and might inform you of workarounds. Otherwise, you can give new informplaneation.
 
 While we want to fix all the [issues](https://github.com/makeplane/plane/issues), before fixing a bug we need to be able to reproduce and confirm it. Please provide us with a minimal reproduction scenario using a repository or [Gist](https://gist.github.com/). Having a live, reproducible scenario gives us the information without asking questions back & forth with additional questions like:
 

SECURITY.md

@@ -1,39 +1,44 @@
-# 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.
+# Security Policy
 
-## 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.
+This document outlines security procedures and vulnerabilities reporting for the Plane project.
 
-To ensure a responsible and effective disclosure process, please adhere to the following:
+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.
 
-- 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.
+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.
 
-## 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:
+## Out of Scope Vulnerabilities
 
-- 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.
+We appreciate your help in identifying vulnerabilities. However, please note that the following types of vulnerabilities are considered out of scope:
 
-## Our commitment
+- 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.
 
-At Plane, we are committed to maintaining transparent and collaborative communication throughout the vulnerability resolution process. Here's what you can expect from us:
+## 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.
+If you discover a vulnerability, please adhere to the following reporting process:
 
-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.
+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

admin/.eslintrc.js

@@ -1,8 +1,52 @@
 module.exports = {
   root: true,
-  extends: ["@plane/eslint-config/next.js"],
+  extends: ["custom"],
   parser: "@typescript-eslint/parser",
-  parserOptions: {
-    project: true,
+  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,
+        },
+      },
+    ],
+  },
+}

admin/app/general/form.tsx

@@ -9,9 +9,8 @@ import { IInstance, IInstanceAdmin } from "@plane/types";
 import { Button, Input, TOAST_TYPE, ToggleSwitch, setToast } from "@plane/ui";
 // components
 import { ControllerInput } from "@/components/common";
-import { useInstance } from "@/hooks/store";
-import { IntercomConfig } from "./intercom";
 // hooks
+import { useInstance } from "@/hooks/store";
 
 export interface IGeneralConfigurationForm {
   instance: IInstance;
@@ -21,13 +20,11 @@ export interface IGeneralConfigurationForm {
 export const GeneralConfigurationForm: FC<IGeneralConfigurationForm> = observer((props) => {
   const { instance, instanceAdmins } = props;
   // hooks
-  const { instanceConfigurations, updateInstanceInfo, updateInstanceConfigurations } = useInstance();
-
+  const { updateInstanceInfo } = useInstance();
   // form data
   const {
     handleSubmit,
     control,
-    watch,
     formState: { errors, isSubmitting },
   } = useForm<Partial<IInstance>>({
     defaultValues: {
@@ -39,16 +36,7 @@ export const GeneralConfigurationForm: FC<IGeneralConfigurationForm> = observer(
   const onSubmit = async (formData: Partial<IInstance>) => {
     const payload: Partial<IInstance> = { ...formData };
 
-    // update the intercom configuration
-    const isIntercomEnabled =
-      instanceConfigurations?.find((config) => config.key === "IS_INTERCOM_ENABLED")?.value === "1";
-    if (!payload.is_telemetry_enabled && isIntercomEnabled) {
-      try {
-        await updateInstanceConfigurations({ IS_INTERCOM_ENABLED: "0" });
-      } catch (error) {
-        console.error(error);
-      }
-    }
+    console.log("payload", payload);
 
     await updateInstanceInfo(payload)
       .then(() =>
@@ -86,7 +74,6 @@ export const GeneralConfigurationForm: FC<IGeneralConfigurationForm> = observer(
               value={instanceAdmins[0]?.user_detail?.email ?? ""}
               placeholder="Admin email"
               className="w-full cursor-not-allowed !text-custom-text-400"
-              autoComplete="on"
               disabled
             />
           </div>
@@ -106,8 +93,7 @@ export const GeneralConfigurationForm: FC<IGeneralConfigurationForm> = observer(
       </div>
 
       <div className="space-y-3">
-        <div className="text-lg font-medium">Chat + telemetry</div>
-        <IntercomConfig isTelemetryEnabled={watch("is_telemetry_enabled") ?? false} />
+        <div className="text-lg font-medium">Telemetry</div>
         <div className="flex items-center gap-14 px-4 py-3 border border-custom-border-200 rounded">
           <div className="grow flex items-center gap-4">
             <div className="shrink-0">

admin/app/general/intercom.tsx

@@ -1,82 +0,0 @@
-"use client";
-
-import { FC, useState } from "react";
-import { observer } from "mobx-react";
-import useSWR from "swr";
-import { MessageSquare } from "lucide-react";
-import { IFormattedInstanceConfiguration } from "@plane/types";
-import { ToggleSwitch } from "@plane/ui";
-// hooks
-import { useInstance } from "@/hooks/store";
-
-type TIntercomConfig = {
-  isTelemetryEnabled: boolean;
-};
-
-export const IntercomConfig: FC<TIntercomConfig> = observer((props) => {
-  const { isTelemetryEnabled } = props;
-  // hooks
-  const { instanceConfigurations, updateInstanceConfigurations, fetchInstanceConfigurations } = useInstance();
-  // states
-  const [isSubmitting, setIsSubmitting] = useState<boolean>(false);
-
-  // derived values
-  const isIntercomEnabled = isTelemetryEnabled
-    ? instanceConfigurations
-      ? instanceConfigurations?.find((config) => config.key === "IS_INTERCOM_ENABLED")?.value === "1"
-        ? true
-        : false
-      : undefined
-    : false;
-
-  const { isLoading } = useSWR(isTelemetryEnabled ? "INSTANCE_CONFIGURATIONS" : null, () =>
-    isTelemetryEnabled ? fetchInstanceConfigurations() : null
-  );
-
-  const initialLoader = isLoading && isIntercomEnabled === undefined;
-
-  const submitInstanceConfigurations = async (payload: Partial<IFormattedInstanceConfiguration>) => {
-    try {
-      await updateInstanceConfigurations(payload);
-    } catch (error) {
-      console.error(error);
-    } finally {
-      setIsSubmitting(false);
-    }
-  };
-
-  const enableIntercomConfig = () => {
-    submitInstanceConfigurations({ IS_INTERCOM_ENABLED: isIntercomEnabled ? "0" : "1" });
-  };
-
-  return (
-    <>
-      <div className="flex items-center gap-14 px-4 py-3 border border-custom-border-200 rounded">
-        <div className="grow flex items-center gap-4">
-          <div className="shrink-0">
-            <div className="flex items-center justify-center w-10 h-10 bg-custom-background-80 rounded-full">
-              <MessageSquare className="w-6 h-6 text-custom-text-300/80 p-0.5" />
-            </div>
-          </div>
-
-          <div className="grow">
-            <div className="text-sm font-medium text-custom-text-100 leading-5">Talk to Plane</div>
-            <div className="text-xs font-normal text-custom-text-300 leading-5">
-              Let your members chat with us via Intercom or another service. Toggling Telemetry off turns this off
-              automatically.
-            </div>
-          </div>
-
-          <div className="ml-auto">
-            <ToggleSwitch
-              value={isIntercomEnabled ? true : false}
-              onChange={enableIntercomConfig}
-              size="sm"
-              disabled={!isTelemetryEnabled || isSubmitting || initialLoader}
-            />
-          </div>
-        </div>
-      </div>
-    </>
-  );
-});

admin/app/general/page.tsx

@@ -7,7 +7,7 @@ import { GeneralConfigurationForm } from "./form";
 
 function GeneralPage() {
   const { instance, instanceAdmins } = useInstance();
-
+  console.log("instance", instance);
   return (
     <>
       <div className="relative container mx-auto w-full h-full p-4 py-4 space-y-6 flex flex-col">

admin/ce/components/authentication/authentication-modes.tsx

@@ -10,9 +10,8 @@ import {
 // components
 import { AuthenticationMethodCard } from "@/components/authentication";
 // helpers
+import { UpgradeButton } from "@/components/common/upgrade-button";
 import { getBaseAuthenticationModes } from "@/helpers/authentication.helper";
-// plane admin components
-import { UpgradeButton } from "@/plane-admin/components/common";
 // images
 import OIDCLogo from "@/public/logos/oidc-logo.svg";
 import SAMLLogo from "@/public/logos/saml-logo.svg";
@@ -28,24 +27,24 @@ export const getAuthenticationModes: (props: TGetBaseAuthenticationModeProps) =>
   updateConfig,
   resolvedTheme,
 }) => [
-  ...getBaseAuthenticationModes({ disabled, updateConfig, resolvedTheme }),
-  {
-    key: "oidc",
-    name: "OIDC",
-    description: "Authenticate your users via the OpenID Connect protocol.",
-    icon: <Image src={OIDCLogo} height={22} width={22} alt="OIDC Logo" />,
-    config: <UpgradeButton />,
-    unavailable: true,
-  },
-  {
-    key: "saml",
-    name: "SAML",
-    description: "Authenticate your users via the Security Assertion Markup Language protocol.",
-    icon: <Image src={SAMLLogo} height={22} width={22} alt="SAML Logo" className="pl-0.5" />,
-    config: <UpgradeButton />,
-    unavailable: true,
-  },
-];
+    ...getBaseAuthenticationModes({ disabled, updateConfig, resolvedTheme }),
+    {
+      key: "oidc",
+      name: "OIDC",
+      description: "Authenticate your users via the OpenID Connect protocol.",
+      icon: <Image src={OIDCLogo} height={22} width={22} alt="OIDC Logo" />,
+      config: <UpgradeButton />,
+      unavailable: true,
+    },
+    {
+      key: "saml",
+      name: "SAML",
+      description: "Authenticate your users via the Security Assertion Markup Language protocol.",
+      icon: <Image src={SAMLLogo} height={22} width={22} alt="SAML Logo" className="pl-0.5" />,
+      config: <UpgradeButton />,
+      unavailable: true,
+    },
+  ];
 
 export const AuthenticationModes: React.FC<TAuthenticationModeProps> = observer((props) => {
   const { disabled, updateConfig } = props;

admin/ce/components/common/index.ts

@@ -1 +0,0 @@
-export * from "./upgrade-button";

admin/ce/store/root.store.ts

@@ -1,19 +0,0 @@
-import { enableStaticRendering } from "mobx-react";
-// stores
-import { CoreRootStore } from "@/store/root.store";
-
-enableStaticRendering(typeof window === "undefined");
-
-export class RootStore extends CoreRootStore {
-  constructor() {
-    super();
-  }
-
-  hydrate(initialData: any) {
-    super.hydrate(initialData);
-  }
-
-  resetOnSignOut() {
-    super.resetOnSignOut();
-  }
-}

admin/core/components/admin-sidebar/help-section.tsx

@@ -96,7 +96,7 @@ export const HelpSection: FC = observer(() => {
           leaveTo="transform opacity-0 scale-95"
         >
           <div
-            className={`absolute bottom-2 min-w-[10rem] z-[15] ${
+            className={`absolute bottom-2 min-w-[10rem] ${
               isSidebarCollapsed ? "left-full" : "-left-[75px]"
             } divide-y divide-custom-border-200 whitespace-nowrap rounded bg-custom-background-100 p-1 shadow-custom-shadow-xs`}
             ref={helpOptionsRef}

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

@@ -2,14 +2,15 @@
 
 import { FC, useEffect, useRef } from "react";
 import { observer } from "mobx-react";
-// plane helpers
-import { useOutsideClickDetector } from "@plane/helpers";
-// components
-import { HelpSection, SidebarMenu, SidebarDropdown } from "@/components/admin-sidebar";
 // hooks
+import { HelpSection, SidebarMenu, SidebarDropdown } from "@/components/admin-sidebar";
 import { useTheme } from "@/hooks/store";
+import useOutsideClickDetector from "@/hooks/use-outside-click-detector";
+// components
 
-export const InstanceSidebar: FC = observer(() => {
+export interface IInstanceSidebar {}
+
+export const InstanceSidebar: FC<IInstanceSidebar> = observer(() => {
   // store
   const { isSidebarCollapsed, toggleSidebar } = useTheme();
 

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

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

admin/core/components/authentication/auth-banner.tsx

@@ -1,29 +0,0 @@
-import { FC } from "react";
-import { Info, X } from "lucide-react";
-// helpers
-import { TAuthErrorInfo } from "@/helpers/authentication.helper";
-
-type TAuthBanner = {
-  bannerData: TAuthErrorInfo | undefined;
-  handleBannerData?: (bannerData: TAuthErrorInfo | undefined) => void;
-};
-
-export const AuthBanner: FC<TAuthBanner> = (props) => {
-  const { bannerData, handleBannerData } = props;
-
-  if (!bannerData) return <></>;
-  return (
-    <div className="relative flex items-center p-2 rounded-md gap-2 border border-custom-primary-100/50 bg-custom-primary-100/10">
-      <div className="w-4 h-4 flex-shrink-0 relative flex justify-center items-center">
-        <Info size={16} className="text-custom-primary-100" />
-      </div>
-      <div className="w-full text-sm font-medium text-custom-primary-100">{bannerData?.message}</div>
-      <div
-        className="relative ml-auto w-6 h-6 rounded-sm flex justify-center items-center transition-all cursor-pointer hover:bg-custom-primary-100/20 text-custom-primary-100/80"
-        onClick={() => handleBannerData && handleBannerData(undefined)}
-      >
-        <X className="w-4 h-4 flex-shrink-0" />
-      </div>
-    </div>
-  );
-};

admin/core/components/authentication/index.ts

@@ -1,4 +1,3 @@
-export * from "./auth-banner";
 export * from "./email-config-switch";
 export * from "./password-config-switch";
 export * from "./authentication-method-card";

admin/core/components/common/index.ts

@@ -8,3 +8,4 @@ export * from "./empty-state";
 export * from "./logo-spinner";
 export * from "./page-header";
 export * from "./code-block";
+export * from "./upgrade-button";

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

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

admin/core/components/instance/setup-form.tsx

@@ -174,7 +174,6 @@ export const InstanceSetupForm: FC = (props) => {
                 placeholder="Wilber"
                 value={formData.first_name}
                 onChange={(e) => handleFormChange("first_name", e.target.value)}
-                autoComplete="on"
                 autoFocus
               />
             </div>
@@ -191,7 +190,6 @@ export const InstanceSetupForm: FC = (props) => {
                 placeholder="Wright"
                 value={formData.last_name}
                 onChange={(e) => handleFormChange("last_name", e.target.value)}
-                autoComplete="on"
               />
             </div>
           </div>
@@ -210,7 +208,6 @@ export const InstanceSetupForm: FC = (props) => {
               value={formData.email}
               onChange={(e) => handleFormChange("email", e.target.value)}
               hasError={errorData.type && errorData.type === EErrorCodes.INVALID_EMAIL ? true : false}
-              autoComplete="on"
             />
             {errorData.type && errorData.type === EErrorCodes.INVALID_EMAIL && errorData.message && (
               <p className="px-1 text-xs text-red-500">{errorData.message}</p>
@@ -250,7 +247,6 @@ export const InstanceSetupForm: FC = (props) => {
                 hasError={errorData.type && errorData.type === EErrorCodes.INVALID_PASSWORD ? true : false}
                 onFocus={() => setIsPasswordInputFocused(true)}
                 onBlur={() => setIsPasswordInputFocused(false)}
-                autoComplete="on"
               />
               {showPassword.password ? (
                 <button

admin/core/components/login/sign-in-form.tsx

@@ -8,16 +8,8 @@ import { Button, Input, Spinner } from "@plane/ui";
 // components
 import { Banner } from "@/components/common";
 // helpers
-import {
-  authErrorHandler,
-  EAuthenticationErrorCodes,
-  EErrorAlertType,
-  TAuthErrorInfo,
-} from "@/helpers/authentication.helper";
-
 import { API_BASE_URL } from "@/helpers/common.helper";
 import { AuthService } from "@/services/auth.service";
-import { AuthBanner } from "../authentication";
 // ui
 // icons
 
@@ -61,11 +53,12 @@ export const InstanceSignInForm: FC = (props) => {
   const [csrfToken, setCsrfToken] = useState<string | undefined>(undefined);
   const [formData, setFormData] = useState<TFormData>(defaultFromData);
   const [isSubmitting, setIsSubmitting] = useState(false);
-  const [errorInfo, setErrorInfo] = useState<TAuthErrorInfo | undefined>(undefined);
 
   const handleFormChange = (key: keyof TFormData, value: string | boolean) =>
     setFormData((prev) => ({ ...prev, [key]: value }));
 
+  console.log("csrfToken", csrfToken);
+
   useEffect(() => {
     if (csrfToken === undefined)
       authService.requestCSRFToken().then((data) => data?.csrf_token && setCsrfToken(data.csrf_token));
@@ -100,15 +93,6 @@ export const InstanceSignInForm: FC = (props) => {
     [formData.email, formData.password, isSubmitting]
   );
 
-  useEffect(() => {
-    if (errorCode) {
-      const errorDetail = authErrorHandler(errorCode?.toString() as EAuthenticationErrorCodes);
-      if (errorDetail) {
-        setErrorInfo(errorDetail);
-      }
-    }
-  }, [errorCode]);
-
   return (
     <div className="flex-grow container mx-auto max-w-lg px-10 lg:max-w-md lg:px-5 py-10 lg:pt-28 transition-all">
       <div className="relative flex flex-col space-y-6">
@@ -121,11 +105,7 @@ export const InstanceSignInForm: FC = (props) => {
           </p>
         </div>
 
-        {errorData.type && errorData?.message ? (
-          <Banner type="error" message={errorData?.message} />
-        ) : (
-          <>{errorInfo && <AuthBanner bannerData={errorInfo} handleBannerData={(value) => setErrorInfo(value)} />}</>
-        )}
+        {errorData.type && errorData?.message && <Banner type="error" message={errorData?.message} />}
 
         <form
           className="space-y-4"
@@ -149,7 +129,6 @@ export const InstanceSignInForm: FC = (props) => {
               placeholder="name@company.com"
               value={formData.email}
               onChange={(e) => handleFormChange("email", e.target.value)}
-              autoComplete="on"
               autoFocus
             />
           </div>
@@ -168,7 +147,6 @@ export const InstanceSignInForm: FC = (props) => {
                 placeholder="Enter your password"
                 value={formData.password}
                 onChange={(e) => handleFormChange("password", e.target.value)}
-                autoComplete="on"
               />
               {showPassword ? (
                 <button

admin/core/hooks/use-outside-click-detector.tsx

@@ -0,0 +1,21 @@
+"use client";
+
+import React, { useEffect } from "react";
+
+const useOutsideClickDetector = (ref: React.RefObject<HTMLElement>, callback: () => void) => {
+  const handleClick = (event: MouseEvent) => {
+    if (ref.current && !ref.current.contains(event.target as Node)) {
+      callback();
+    }
+  };
+
+  useEffect(() => {
+    document.addEventListener("mousedown", handleClick);
+
+    return () => {
+      document.removeEventListener("mousedown", handleClick);
+    };
+  });
+};
+
+export default useOutsideClickDetector;

admin/core/layouts/admin-layout.tsx

@@ -18,7 +18,6 @@ export const AdminLayout: FC<TAdminLayout> = observer((props) => {
   const { children } = props;
   // router
   const router = useRouter();
-  // store hooks
   const { isUserLoggedIn } = useUser();
 
   useEffect(() => {

admin/core/lib/store-provider.tsx

@@ -1,8 +1,8 @@
 "use client";
 
 import { ReactNode, createContext } from "react";
-// plane admin store
-import { RootStore } from "@/plane-admin/store/root.store";
+// store
+import { RootStore } from "@/store/root.store";
 
 let rootStore = new RootStore();
 

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/core/store/instance.store.ts

@@ -13,7 +13,7 @@ import { EInstanceStatus, TInstanceStatus } from "@/helpers/instance.helper";
 // services
 import { InstanceService } from "@/services/instance.service";
 // root store
-import { CoreRootStore } from "@/store/root.store";
+import { RootStore } from "@/store/root.store";
 
 export interface IInstanceStore {
   // issues
@@ -46,7 +46,7 @@ export class InstanceStore implements IInstanceStore {
   // service
   instanceService;
 
-  constructor(private store: CoreRootStore) {
+  constructor(private store: RootStore) {
     makeObservable(this, {
       // observable
       isLoading: observable.ref,

admin/core/store/root.store.ts

@@ -6,7 +6,7 @@ import { IUserStore, UserStore } from "./user.store";
 
 enableStaticRendering(typeof window === "undefined");
 
-export abstract class CoreRootStore {
+export class RootStore {
   theme: IThemeStore;
   instance: IInstanceStore;
   user: IUserStore;

admin/core/store/theme.store.ts

@@ -1,6 +1,6 @@
 import { action, observable, makeObservable } from "mobx";
 // root store
-import { CoreRootStore } from "@/store/root.store";
+import { RootStore } from "@/store/root.store";
 
 type TTheme = "dark" | "light";
 export interface IThemeStore {
@@ -21,7 +21,7 @@ export class ThemeStore implements IThemeStore {
   isSidebarCollapsed: boolean | undefined = undefined;
   theme: string | undefined = undefined;
 
-  constructor(private store: CoreRootStore) {
+  constructor(private store: RootStore) {
     makeObservable(this, {
       // observables
       isNewUserPopup: observable.ref,

admin/core/store/user.store.ts

@@ -6,7 +6,7 @@ import { EUserStatus, TUserStatus } from "@/helpers/user.helper";
 import { AuthService } from "@/services/auth.service";
 import { UserService } from "@/services/user.service";
 // root store
-import { CoreRootStore } from "@/store/root.store";
+import { RootStore } from "@/store/root.store";
 
 export interface IUserStore {
   // observables
@@ -31,7 +31,7 @@ export class UserStore implements IUserStore {
   userService;
   authService;
 
-  constructor(private store: CoreRootStore) {
+  constructor(private store: RootStore) {
     makeObservable(this, {
       // observables
       isLoading: observable.ref,

admin/ee/components/common/index.ts

@@ -1 +0,0 @@
-export * from "ce/components/common";

admin/ee/store/root.store.ts

@@ -1 +0,0 @@
-export * from "ce/store/root.store";

admin/helpers/file.helper.ts

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

admin/helpers/string.helper.ts

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

admin/next-env.d.ts

@@ -2,4 +2,4 @@
 /// <reference types="next/image-types/global" />
 
 // NOTE: This file should not be edited
-// see https://nextjs.org/docs/app/building-your-application/configuring/typescript for more information.
+// see https://nextjs.org/docs/basic-features/typescript for more information.

admin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "admin",
-  "version": "0.23.1",
+  "version": "0.22.0",
   "private": true,
   "scripts": {
     "dev": "turbo run develop",
@@ -8,44 +8,43 @@
     "build": "next build",
     "preview": "next build && next start",
     "start": "next start",
-    "lint": "eslint . --ext .ts,.tsx",
-    "lint:errors": "eslint . --ext .ts,.tsx --quiet"
+    "lint": "next lint"
   },
   "dependencies": {
     "@headlessui/react": "^1.7.19",
-    "@plane/constants": "*",
-    "@plane/helpers": "*",
     "@plane/types": "*",
     "@plane/ui": "*",
-    "@sentry/nextjs": "^8.32.0",
+    "@plane/constants": "*",
     "@tailwindcss/typography": "^0.5.9",
     "@types/lodash": "^4.17.0",
     "autoprefixer": "10.4.14",
-    "axios": "^1.7.4",
+    "axios": "^1.6.7",
+    "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.12",
+    "next": "^14.2.3",
     "next-themes": "^0.2.1",
     "postcss": "^8.4.38",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "react-hook-form": "7.51.5",
+    "react-hook-form": "^7.51.0",
     "swr": "^2.2.4",
     "tailwindcss": "3.3.2",
     "uuid": "^9.0.1",
     "zxcvbn": "^4.4.2"
   },
   "devDependencies": {
-    "@plane/eslint-config": "*",
-    "@plane/typescript-config": "*",
+    "@types/js-cookie": "^3.0.6",
     "@types/node": "18.16.1",
-    "@types/react": "^18.3.11",
+    "@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": "*",
-    "typescript": "5.3.3"
+    "tsconfig": "*",
+    "typescript": "^5.4.2"
   }
-}
+}

admin/tsconfig.json

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

apiserver/.env.example

@@ -15,18 +15,12 @@ POSTGRES_DB="plane"
 POSTGRES_PORT=5432
 DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
 
+
 # Redis Settings
 REDIS_HOST="plane-redis"
 REDIS_PORT="6379"
 REDIS_URL="redis://${REDIS_HOST}:6379/"
 
-# RabbitMQ Settings
-RABBITMQ_HOST="plane-mq"
-RABBITMQ_PORT="5672"
-RABBITMQ_USER="plane"
-RABBITMQ_PASSWORD="plane"
-RABBITMQ_VHOST="plane"
-
 # AWS Settings
 AWS_REGION=""
 AWS_ACCESS_KEY_ID="access-key"
@@ -56,7 +50,3 @@ GUNICORN_WORKERS=2
 ADMIN_BASE_URL=
 SPACE_BASE_URL=
 APP_BASE_URL=
-
-
-# Hard delete files after days
-HARD_DELETE_AFTER_DAYS=60

apiserver/Dockerfile.api

@@ -1,30 +1,29 @@
-FROM python:3.12.5-alpine AS backend
+FROM python:3.11.1-alpine3.17 AS backend
 
 # set environment variables
 ENV PYTHONDONTWRITEBYTECODE 1
 ENV PYTHONUNBUFFERED 1
 ENV PIP_DISABLE_PIP_VERSION_CHECK=1 
-ENV INSTANCE_CHANGELOG_URL https://api.plane.so/api/public/anchor/8e1c2e4c7bc5493eb7731be3862f6960/pages/
 
 WORKDIR /code
 
-RUN apk add --no-cache \
-    "libpq" \
-    "libxslt" \
-    "nodejs-current" \
-    "xmlsec"
+RUN apk --no-cache add \
+    "libpq~=15" \
+    "libxslt~=1.1" \
+    "nodejs-current~=19" \
+    "xmlsec~=1.2"
 
 COPY requirements.txt ./
 COPY requirements ./requirements
 RUN apk add --no-cache libffi-dev
 RUN apk add --no-cache --virtual .build-deps \
     "bash~=5.2" \
-    "g++" \
-    "gcc" \
-    "cargo" \
-    "git" \
-    "make" \
-    "postgresql-dev" \
+    "g++~=12.2" \
+    "gcc~=12.2" \
+    "cargo~=1.64" \
+    "git~=2" \
+    "make~=4.3" \
+    "postgresql13-dev~=13" \
     "libc-dev" \
     "linux-headers" \
     && \

apiserver/Dockerfile.dev

@@ -1,25 +1,24 @@
-FROM python:3.12.5-alpine AS backend
+FROM python:3.11.1-alpine3.17 AS backend
 
 # set environment variables
 ENV PYTHONDONTWRITEBYTECODE 1
 ENV PYTHONUNBUFFERED 1
 ENV PIP_DISABLE_PIP_VERSION_CHECK=1 
-ENV INSTANCE_CHANGELOG_URL https://api.plane.so/api/public/anchor/8e1c2e4c7bc5493eb7731be3862f6960/pages/
 
 RUN apk --no-cache add \
     "bash~=5.2" \
-    "libpq" \
-    "libxslt" \
-    "nodejs-current" \
-    "xmlsec" \
+    "libpq~=15" \
+    "libxslt~=1.1" \
+    "nodejs-current~=19" \
+    "xmlsec~=1.2" \
     "libffi-dev" \
     "bash~=5.2" \
-    "g++" \
-    "gcc" \
-    "cargo" \
-    "git" \
-    "make" \
-    "postgresql-dev" \
+    "g++~=12.2" \
+    "gcc~=12.2" \
+    "cargo~=1.64" \
+    "git~=2" \
+    "make~=4.3" \
+    "postgresql13-dev~=13" \
     "libc-dev" \
     "linux-headers"
 

apiserver/bin/docker-entrypoint-api-local.sh

@@ -32,3 +32,4 @@ python manage.py create_bucket
 python manage.py clear_cache
 
 python manage.py runserver 0.0.0.0:8000 --settings=plane.settings.local
+

apiserver/package.json

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

apiserver/plane/api/rate_limit.py

@@ -40,44 +40,3 @@ class ApiKeyRateThrottle(SimpleRateThrottle):
             request.META["X-RateLimit-Reset"] = reset_time
 
         return allowed
-
-
-class ServiceTokenRateThrottle(SimpleRateThrottle):
-    scope = "service_token"
-    rate = "300/minute"
-
-    def get_cache_key(self, request, view):
-        # Retrieve the API key from the request header
-        api_key = request.headers.get("X-Api-Key")
-        if not api_key:
-            return None  # Allow the request if there's no API key
-
-        # Use the API key as part of the cache key
-        return f"{self.scope}:{api_key}"
-
-    def allow_request(self, request, view):
-        allowed = super().allow_request(request, view)
-
-        if allowed:
-            now = self.timer()
-            # Calculate the remaining limit and reset time
-            history = self.cache.get(self.key, [])
-
-            # Remove old histories
-            while history and history[-1] <= now - self.duration:
-                history.pop()
-
-            # Calculate the requests
-            num_requests = len(history)
-
-            # Check available requests
-            available = self.num_requests - num_requests
-
-            # Unix timestamp for when the rate limit will reset
-            reset_time = int(now + self.duration)
-
-            # Add headers
-            request.META["X-RateLimit-Remaining"] = max(0, available)
-            request.META["X-RateLimit-Reset"] = reset_time
-
-        return allowed

apiserver/plane/api/serializers/__init__.py

@@ -5,11 +5,11 @@ from .issue import (
     IssueSerializer,
     LabelSerializer,
     IssueLinkSerializer,
+    IssueAttachmentSerializer,
     IssueCommentSerializer,
     IssueAttachmentSerializer,
     IssueActivitySerializer,
     IssueExpandSerializer,
-    IssueLiteSerializer,
 )
 from .state import StateLiteSerializer, StateSerializer
 from .cycle import CycleSerializer, CycleIssueSerializer, CycleLiteSerializer
@@ -18,4 +18,4 @@ from .module import (
     ModuleIssueSerializer,
     ModuleLiteSerializer,
 )
-from .intake import IntakeIssueSerializer
+from .inbox import InboxIssueSerializer

apiserver/plane/api/serializers/base.py

@@ -67,7 +67,6 @@ class BaseSerializer(serializers.ModelSerializer):
                     # Import all the expandable serializers
                     from . import (
                         IssueSerializer,
-                        IssueLiteSerializer,
                         ProjectLiteSerializer,
                         StateLiteSerializer,
                         UserLiteSerializer,
@@ -87,7 +86,6 @@ class BaseSerializer(serializers.ModelSerializer):
                         "actor": UserLiteSerializer,
                         "owned_by": UserLiteSerializer,
                         "members": UserLiteSerializer,
-                        "parent": IssueLiteSerializer,
                     }
                     # Check if field in expansion  then expand the field
                     if expand in expansion:

apiserver/plane/api/serializers/cycle.py

@@ -40,7 +40,6 @@ class CycleSerializer(BaseSerializer):
             "workspace",
             "project",
             "owned_by",
-            "deleted_at",
         ]
 
 

apiserver/plane/api/serializers/inbox.py

@@ -1,17 +1,15 @@
 # Module improts
 from .base import BaseSerializer
 from .issue import IssueExpandSerializer
-from plane.db.models import IntakeIssue
-from rest_framework import serializers
+from plane.db.models import InboxIssue
 
 
-class IntakeIssueSerializer(BaseSerializer):
+class InboxIssueSerializer(BaseSerializer):
 
     issue_detail = IssueExpandSerializer(read_only=True, source="issue")
-    inbox = serializers.UUIDField(source="intake.id", read_only=True)
 
     class Meta:
-        model = IntakeIssue
+        model = InboxIssue
         fields = "__all__"
         read_only_fields = [
             "id",

apiserver/plane/api/serializers/issue.py

@@ -1,3 +1,6 @@
+from django.core.exceptions import ValidationError
+from django.core.validators import URLValidator
+
 # Django imports
 from django.utils import timezone
 from lxml import html
@@ -8,10 +11,9 @@ from rest_framework import serializers
 # Module imports
 from plane.db.models import (
     Issue,
-    IssueType,
     IssueActivity,
     IssueAssignee,
-    FileAsset,
+    IssueAttachment,
     IssueComment,
     IssueLabel,
     IssueLink,
@@ -27,10 +29,6 @@ from .module import ModuleLiteSerializer, ModuleSerializer
 from .state import StateLiteSerializer
 from .user import UserLiteSerializer
 
-# Django imports
-from django.core.exceptions import ValidationError
-from django.core.validators import URLValidator
-
 
 class IssueSerializer(BaseSerializer):
     assignees = serializers.ListField(
@@ -48,12 +46,6 @@ class IssueSerializer(BaseSerializer):
         write_only=True,
         required=False,
     )
-    type_id = serializers.PrimaryKeyRelatedField(
-        source="type",
-        queryset=IssueType.objects.all(),
-        required=False,
-        allow_null=True,
-    )
 
     class Meta:
         model = Issue
@@ -61,6 +53,7 @@ class IssueSerializer(BaseSerializer):
             "id",
             "workspace",
             "project",
+            "created_by",
             "updated_by",
             "updated_at",
         ]
@@ -137,19 +130,9 @@ class IssueSerializer(BaseSerializer):
         workspace_id = self.context["workspace_id"]
         default_assignee_id = self.context["default_assignee_id"]
 
-        issue_type = validated_data.pop("type", None)
-
-        if not issue_type:
-            # Get default issue type
-            issue_type = IssueType.objects.filter(
-                project_issue_types__project_id=project_id, is_default=True
-            ).first()
-            issue_type = issue_type
-
         issue = Issue.objects.create(
             **validated_data,
             project_id=project_id,
-            type=issue_type,
         )
 
         # Issue Audit Users
@@ -275,17 +258,6 @@ class IssueSerializer(BaseSerializer):
         return data
 
 
-class IssueLiteSerializer(BaseSerializer):
-    class Meta:
-        model = Issue
-        fields = [
-            "id",
-            "sequence_id",
-            "project_id",
-        ]
-        read_only_fields = fields
-
-
 class LabelSerializer(BaseSerializer):
     class Meta:
         model = Label
@@ -298,7 +270,6 @@ class LabelSerializer(BaseSerializer):
             "updated_by",
             "created_at",
             "updated_at",
-            "deleted_at",
         ]
 
 
@@ -360,14 +331,16 @@ class IssueLinkSerializer(BaseSerializer):
 
 class IssueAttachmentSerializer(BaseSerializer):
     class Meta:
-        model = FileAsset
+        model = IssueAttachment
         fields = "__all__"
         read_only_fields = [
             "id",
             "workspace",
             "project",
             "issue",
+            "created_by",
             "updated_by",
+            "created_at",
             "updated_at",
         ]
 

apiserver/plane/api/serializers/module.py

@@ -39,7 +39,6 @@ class ModuleSerializer(BaseSerializer):
             "updated_by",
             "created_at",
             "updated_at",
-            "deleted_at",
         ]
 
     def to_representation(self, instance):
@@ -71,16 +70,6 @@ class ModuleSerializer(BaseSerializer):
         project_id = self.context["project_id"]
         workspace_id = self.context["workspace_id"]
 
-        module_name = validated_data.get("name")
-        if module_name:
-            # Lookup for the module name in the module table for that project
-            if Module.objects.filter(
-                name=module_name, project_id=project_id
-            ).exists():
-                raise serializers.ValidationError(
-                    {"error": "Module with this name already exists"}
-                )
-
         module = Module.objects.create(**validated_data, project_id=project_id)
         if members is not None:
             ModuleMember.objects.bulk_create(
@@ -103,19 +92,6 @@ class ModuleSerializer(BaseSerializer):
 
     def update(self, instance, validated_data):
         members = validated_data.pop("members", None)
-        module_name = validated_data.get("name")
-        if module_name:
-            # Lookup for the module name in the module table for that project
-            if (
-                Module.objects.filter(
-                    name=module_name, project=instance.project
-                )
-                .exclude(id=instance.id)
-                .exists()
-            ):
-                raise serializers.ValidationError(
-                    {"error": "Module with this name already exists"}
-                )
 
         if members is not None:
             ModuleMember.objects.filter(module=instance).delete()

apiserver/plane/api/serializers/project.py

@@ -19,8 +19,6 @@ class ProjectSerializer(BaseSerializer):
     sort_order = serializers.FloatField(read_only=True)
     member_role = serializers.IntegerField(read_only=True)
     is_deployed = serializers.BooleanField(read_only=True)
-    cover_image_url = serializers.CharField(read_only=True)
-    inbox_view = serializers.BooleanField(read_only=True, source="intake_view")
 
     class Meta:
         model = Project
@@ -33,8 +31,6 @@ class ProjectSerializer(BaseSerializer):
             "updated_at",
             "created_by",
             "updated_by",
-            "deleted_at",
-            "cover_image_url",
         ]
 
     def validate(self, data):
@@ -90,8 +86,6 @@ class ProjectSerializer(BaseSerializer):
 
 
 class ProjectLiteSerializer(BaseSerializer):
-    cover_image_url = serializers.CharField(read_only=True)
-
     class Meta:
         model = Project
         fields = [
@@ -102,6 +96,5 @@ class ProjectLiteSerializer(BaseSerializer):
             "icon_prop",
             "emoji",
             "description",
-            "cover_image_url",
         ]
         read_only_fields = fields

apiserver/plane/api/serializers/state.py

@@ -23,7 +23,6 @@ class StateSerializer(BaseSerializer):
             "updated_at",
             "workspace",
             "project",
-            "deleted_at",
         ]
 
 

apiserver/plane/api/serializers/user.py

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

apiserver/plane/api/urls/__init__.py

@@ -3,7 +3,7 @@ from .state import urlpatterns as state_patterns
 from .issue import urlpatterns as issue_patterns
 from .cycle import urlpatterns as cycle_patterns
 from .module import urlpatterns as module_patterns
-from .intake import urlpatterns as intake_patterns
+from .inbox import urlpatterns as inbox_patterns
 from .member import urlpatterns as member_patterns
 
 urlpatterns = [
@@ -12,6 +12,6 @@ urlpatterns = [
     *issue_patterns,
     *cycle_patterns,
     *module_patterns,
-    *intake_patterns,
+    *inbox_patterns,
     *member_patterns,
 ]

apiserver/plane/api/urls/inbox.py

@@ -0,0 +1,17 @@
+from django.urls import path
+
+from plane.api.views import InboxIssueAPIEndpoint
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
+        InboxIssueAPIEndpoint.as_view(),
+        name="inbox-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:issue_id>/",
+        InboxIssueAPIEndpoint.as_view(),
+        name="inbox-issue",
+    ),
+]

apiserver/plane/api/urls/intake.py

@@ -1,27 +0,0 @@
-from django.urls import path
-
-from plane.api.views import IntakeIssueAPIEndpoint
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:issue_id>/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="intake-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/<uuid:issue_id>/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="intake-issue",
-    ),
-]

apiserver/plane/api/urls/member.py

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

apiserver/plane/api/views/__init__.py

@@ -25,6 +25,6 @@ from .module import (
     ModuleArchiveUnarchiveAPIEndpoint,
 )
 
-from .member import ProjectMemberAPIEndpoint
+from .member import WorkspaceMemberAPIEndpoint
 
-from .intake import IntakeIssueAPIEndpoint
+from .inbox import InboxIssueAPIEndpoint

apiserver/plane/api/views/base.py

@@ -7,7 +7,6 @@ from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.db import IntegrityError
 from django.urls import resolve
 from django.utils import timezone
-from plane.db.models.api import APIToken
 from rest_framework import status
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
@@ -17,7 +16,7 @@ from rest_framework.views import APIView
 
 # Module imports
 from plane.api.middleware.api_authentication import APIKeyAuthentication
-from plane.api.rate_limit import ApiKeyRateThrottle, ServiceTokenRateThrottle
+from plane.api.rate_limit import ApiKeyRateThrottle
 from plane.utils.exception_logger import log_exception
 from plane.utils.paginator import BasePaginator
 
@@ -45,29 +44,15 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
         IsAuthenticated,
     ]
 
+    throttle_classes = [
+        ApiKeyRateThrottle,
+    ]
+
     def filter_queryset(self, queryset):
         for backend in list(self.filter_backends):
             queryset = backend().filter_queryset(self.request, queryset, self)
         return queryset
 
-    def get_throttles(self):
-        throttle_classes = []
-        api_key = self.request.headers.get("X-Api-Key")
-
-        if api_key:
-            service_token = APIToken.objects.filter(
-                token=api_key,
-                is_service=True,
-            ).first()
-
-            if service_token:
-                throttle_classes.append(ServiceTokenRateThrottle())
-                return throttle_classes
-
-        throttle_classes.append(ApiKeyRateThrottle())
-
-        return throttle_classes
-
     def handle_exception(self, exc):
         """
         Handle any exception that occurs, by returning an appropriate response,
@@ -167,4 +152,4 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
             for expand in self.request.GET.get("expand", "").split(",")
             if expand
         ]
-        return expand if expand else None
+        return expand if expand else None

apiserver/plane/api/views/cycle.py

@@ -13,12 +13,8 @@ from django.db.models import (
     Q,
     Sum,
     FloatField,
-    Case,
-    When,
-    Value,
 )
-from django.db.models.functions import Cast, Concat
-from django.db import models
+from django.db.models.functions import Cast
 
 # Third party imports
 from rest_framework import status
@@ -30,16 +26,15 @@ from plane.api.serializers import (
     CycleSerializer,
 )
 from plane.app.permissions import ProjectEntityPermission
-from plane.bgtasks.issue_activities_task import issue_activity
+from plane.bgtasks.issue_activites_task import issue_activity
 from plane.db.models import (
     Cycle,
     CycleIssue,
     Issue,
     Project,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
     ProjectMember,
-    UserFavorite,
 )
 from plane.utils.analytics_plot import burndown_plot
 
@@ -78,7 +73,6 @@ class CycleAPIEndpoint(BaseAPIView):
                     filter=Q(
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -89,7 +83,6 @@ class CycleAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="completed",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -100,7 +93,6 @@ class CycleAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="cancelled",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -111,7 +103,6 @@ class CycleAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="started",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -122,7 +113,6 @@ class CycleAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="unstarted",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -133,7 +123,6 @@ class CycleAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="backlog",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -217,7 +206,8 @@ class CycleAPIEndpoint(BaseAPIView):
         # Incomplete Cycles
         if cycle_view == "incomplete":
             queryset = queryset.filter(
-                Q(end_date__gte=timezone.now()) | Q(end_date__isnull=True),
+                Q(end_date__gte=timezone.now().date())
+                | Q(end_date__isnull=True),
             )
             return self.paginate(
                 request=request,
@@ -318,7 +308,10 @@ class CycleAPIEndpoint(BaseAPIView):
 
         request_data = request.data
 
-        if cycle.end_date is not None and cycle.end_date < timezone.now():
+        if (
+            cycle.end_date is not None
+            and cycle.end_date < timezone.now().date()
+        ):
             if "sort_order" in request_data:
                 # Can only change sort order
                 request_data = {
@@ -411,12 +404,6 @@ class CycleAPIEndpoint(BaseAPIView):
         )
         # Delete the cycle
         cycle.delete()
-        # Delete the user favorite cycle
-        UserFavorite.objects.filter(
-            entity_type="cycle",
-            entity_identifier=pk,
-            project_id=project_id,
-        ).delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
@@ -443,7 +430,6 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                     filter=Q(
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -454,7 +440,6 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="completed",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -465,7 +450,6 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="cancelled",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -476,7 +460,6 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="started",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -487,7 +470,6 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="unstarted",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -498,7 +480,6 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="backlog",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -512,7 +493,6 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="completed",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -523,7 +503,6 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="started",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -547,19 +526,13 @@ class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
         cycle = Cycle.objects.get(
             pk=cycle_id, project_id=project_id, workspace__slug=slug
         )
-        if cycle.end_date >= timezone.now():
+        if cycle.end_date >= timezone.now().date():
             return Response(
                 {"error": "Only completed cycles can be archived"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
         cycle.archived_at = timezone.now()
         cycle.save()
-        UserFavorite.objects.filter(
-            entity_type="cycle",
-            entity_identifier=cycle_id,
-            project_id=project_id,
-            workspace__slug=slug,
-        ).delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
     def delete(self, request, slug, project_id, cycle_id):
@@ -629,10 +602,7 @@ class CycleIssueAPIEndpoint(BaseAPIView):
         # List
         order_by = request.GET.get("order_by", "created_at")
         issues = (
-            Issue.issue_objects.filter(
-                issue_cycle__cycle_id=cycle_id,
-                issue_cycle__deleted_at__isnull=True,
-            )
+            Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
             .annotate(
                 sub_issues_count=Issue.issue_objects.filter(
                     parent=OuterRef("id")
@@ -658,9 +628,8 @@ class CycleIssueAPIEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -692,63 +661,61 @@ class CycleIssueAPIEndpoint(BaseAPIView):
             workspace__slug=slug, project_id=project_id, pk=cycle_id
         )
 
+        issues = Issue.objects.filter(
+            pk__in=issues, workspace__slug=slug, project_id=project_id
+        ).values_list("id", flat=True)
+
         # Get all CycleIssues already created
-        cycle_issues = list(
-            CycleIssue.objects.filter(
-                ~Q(cycle_id=cycle_id), issue_id__in=issues
-            )
-        )
-
-        existing_issues = [
-            str(cycle_issue.issue_id)
-            for cycle_issue in cycle_issues
-            if str(cycle_issue.issue_id) in issues
-        ]
-        new_issues = list(set(issues) - set(existing_issues))
-
-        # New issues to create
-        created_records = CycleIssue.objects.bulk_create(
-            [
-                CycleIssue(
-                    project_id=project_id,
-                    workspace_id=cycle.workspace_id,
-                    cycle_id=cycle_id,
-                    issue_id=issue,
-                )
-                for issue in new_issues
-            ],
-            ignore_conflicts=True,
-            batch_size=10,
-        )
-
-        # Updated Issues
-        updated_records = []
+        cycle_issues = list(CycleIssue.objects.filter(issue_id__in=issues))
         update_cycle_issue_activity = []
-        # Iterate over each cycle_issue in cycle_issues
-        for cycle_issue in cycle_issues:
-            old_cycle_id = cycle_issue.cycle_id
-            # Update the cycle_issue's cycle_id
-            cycle_issue.cycle_id = cycle_id
-            # Add the modified cycle_issue to the records_to_update list
-            updated_records.append(cycle_issue)
-            # Record the update activity
-            update_cycle_issue_activity.append(
-                {
-                    "old_cycle_id": str(old_cycle_id),
-                    "new_cycle_id": str(cycle_id),
-                    "issue_id": str(cycle_issue.issue_id),
-                }
-            )
+        record_to_create = []
+        records_to_update = []
 
-        # Update the cycle issues
+        for issue in issues:
+            cycle_issue = [
+                cycle_issue
+                for cycle_issue in cycle_issues
+                if str(cycle_issue.issue_id) in issues
+            ]
+            # Update only when cycle changes
+            if len(cycle_issue):
+                if cycle_issue[0].cycle_id != cycle_id:
+                    update_cycle_issue_activity.append(
+                        {
+                            "old_cycle_id": str(cycle_issue[0].cycle_id),
+                            "new_cycle_id": str(cycle_id),
+                            "issue_id": str(cycle_issue[0].issue_id),
+                        }
+                    )
+                    cycle_issue[0].cycle_id = cycle_id
+                    records_to_update.append(cycle_issue[0])
+            else:
+                record_to_create.append(
+                    CycleIssue(
+                        project_id=project_id,
+                        workspace=cycle.workspace,
+                        created_by=request.user,
+                        updated_by=request.user,
+                        cycle=cycle,
+                        issue_id=issue,
+                    )
+                )
+
+        CycleIssue.objects.bulk_create(
+            record_to_create,
+            batch_size=10,
+            ignore_conflicts=True,
+        )
         CycleIssue.objects.bulk_update(
-            updated_records, ["cycle_id"], batch_size=100
+            records_to_update,
+            ["cycle"],
+            batch_size=10,
         )
 
         # Capture Issue Activity
         issue_activity.delay(
             type="cycle.activity.created",
-            requested_data=json.dumps({"cycles_list": issues}),
+            requested_data=json.dumps({"cycles_list": str(issues)}),
             actor_id=str(self.request.user.id),
             issue_id=None,
             project_id=str(self.kwargs.get("project_id", None)),
@@ -756,14 +723,13 @@ class CycleIssueAPIEndpoint(BaseAPIView):
                 {
                     "updated_cycle_issues": update_cycle_issue_activity,
                     "created_cycle_issues": serializers.serialize(
-                        "json", created_records
+                        "json", record_to_create
                     ),
                 }
             ),
             epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
         )
+
         # Return all Cycle Issues
         return Response(
             CycleIssueSerializer(self.get_queryset(), many=True).data,
@@ -829,7 +795,6 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                     filter=Q(
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -840,7 +805,6 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="completed",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -851,7 +815,6 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="cancelled",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -862,7 +825,6 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="started",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -873,7 +835,6 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="unstarted",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -884,7 +845,6 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                         issue_cycle__issue__state__group="backlog",
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
-                        issue_cycle__deleted_at__isnull=True,
                     ),
                 )
             )
@@ -901,34 +861,13 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
             assignee_estimate_data = (
                 Issue.issue_objects.filter(
                     issue_cycle__cycle_id=cycle_id,
-                    issue_cycle__deleted_at__isnull=True,
                     workspace__slug=slug,
                     project_id=project_id,
                 )
                 .annotate(display_name=F("assignees__display_name"))
                 .annotate(assignee_id=F("assignees__id"))
                 .annotate(avatar=F("assignees__avatar"))
-                .annotate(
-                    avatar_url=Case(
-                        # If `avatar_asset` exists, use it to generate the asset URL
-                        When(
-                            assignees__avatar_asset__isnull=False,
-                            then=Concat(
-                                Value("/api/assets/v2/static/"),
-                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                                Value("/"),
-                            ),
-                        ),
-                        # If `avatar_asset` is None, fall back to using `avatar` field directly
-                        When(
-                            assignees__avatar_asset__isnull=True,
-                            then="assignees__avatar",
-                        ),
-                        default=Value(None),
-                        output_field=models.CharField(),
-                    )
-                )
-                .values("display_name", "assignee_id", "avatar", "avatar_url")
+                .values("display_name", "assignee_id", "avatar")
                 .annotate(
                     total_estimates=Sum(
                         Cast("estimate_point__value", FloatField())
@@ -965,8 +904,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                         if item["assignee_id"]
                         else None
                     ),
-                    "avatar": item.get("avatar", None),
-                    "avatar_url": item.get("avatar_url", None),
+                    "avatar": item["avatar"],
                     "total_estimates": item["total_estimates"],
                     "completed_estimates": item["completed_estimates"],
                     "pending_estimates": item["pending_estimates"],
@@ -977,7 +915,6 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
             label_distribution_data = (
                 Issue.issue_objects.filter(
                     issue_cycle__cycle_id=cycle_id,
-                    issue_cycle__deleted_at__isnull=True,
                     workspace__slug=slug,
                     project_id=project_id,
                 )
@@ -1039,34 +976,13 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
         assignee_distribution = (
             Issue.issue_objects.filter(
                 issue_cycle__cycle_id=cycle_id,
-                issue_cycle__deleted_at__isnull=True,
                 workspace__slug=slug,
                 project_id=project_id,
             )
             .annotate(display_name=F("assignees__display_name"))
             .annotate(assignee_id=F("assignees__id"))
             .annotate(avatar=F("assignees__avatar"))
-            .annotate(
-                avatar_url=Case(
-                    # If `avatar_asset` exists, use it to generate the asset URL
-                    When(
-                        assignees__avatar_asset__isnull=False,
-                        then=Concat(
-                            Value("/api/assets/v2/static/"),
-                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                            Value("/"),
-                        ),
-                    ),
-                    # If `avatar_asset` is None, fall back to using `avatar` field directly
-                    When(
-                        assignees__avatar_asset__isnull=True,
-                        then="assignees__avatar",
-                    ),
-                    default=Value(None),
-                    output_field=models.CharField(),
-                )
-            )
-            .values("display_name", "assignee_id", "avatar_url")
+            .values("display_name", "assignee_id", "avatar")
             .annotate(
                 total_issues=Count(
                     "id",
@@ -1105,8 +1021,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
                 "assignee_id": (
                     str(item["assignee_id"]) if item["assignee_id"] else None
                 ),
-                "avatar": item.get("avatar", None),
-                "avatar_url": item.get("avatar_url", None),
+                "avatar": item["avatar"],
                 "total_issues": item["total_issues"],
                 "completed_issues": item["completed_issues"],
                 "pending_issues": item["pending_issues"],
@@ -1118,7 +1033,6 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
         label_distribution = (
             Issue.issue_objects.filter(
                 issue_cycle__cycle_id=cycle_id,
-                issue_cycle__deleted_at__isnull=True,
                 workspace__slug=slug,
                 project_id=project_id,
             )
@@ -1212,7 +1126,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
 
         if (
             new_cycle.end_date is not None
-            and new_cycle.end_date < timezone.now()
+            and new_cycle.end_date < timezone.now().date()
         ):
             return Response(
                 {

apiserver/plane/api/views/inbox.py

@@ -1,7 +1,7 @@
 # Python imports
 import json
 
-# Django imports
+# Django improts
 from django.core.serializers.json import DjangoJSONEncoder
 from django.utils import timezone
 from django.db.models import Q, Value, UUIDField
@@ -14,12 +14,12 @@ from rest_framework import status
 from rest_framework.response import Response
 
 # Module imports
-from plane.api.serializers import IntakeIssueSerializer, IssueSerializer
+from plane.api.serializers import InboxIssueSerializer, IssueSerializer
 from plane.app.permissions import ProjectLitePermission
-from plane.bgtasks.issue_activities_task import issue_activity
+from plane.bgtasks.issue_activites_task import issue_activity
 from plane.db.models import (
-    Intake,
-    IntakeIssue,
+    Inbox,
+    InboxIssue,
     Issue,
     Project,
     ProjectMember,
@@ -29,10 +29,10 @@ from plane.db.models import (
 from .base import BaseAPIView
 
 
-class IntakeIssueAPIEndpoint(BaseAPIView):
+class InboxIssueAPIEndpoint(BaseAPIView):
     """
     This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to intake issues.
+    `update` and `destroy` actions related to inbox issues.
 
     """
 
@@ -40,15 +40,15 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
         ProjectLitePermission,
     ]
 
-    serializer_class = IntakeIssueSerializer
-    model = IntakeIssue
+    serializer_class = InboxIssueSerializer
+    model = InboxIssue
 
     filterset_fields = [
         "status",
     ]
 
     def get_queryset(self):
-        intake = Intake.objects.filter(
+        inbox = Inbox.objects.filter(
             workspace__slug=self.kwargs.get("slug"),
             project_id=self.kwargs.get("project_id"),
         ).first()
@@ -58,16 +58,16 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
             pk=self.kwargs.get("project_id"),
         )
 
-        if intake is None and not project.intake_view:
-            return IntakeIssue.objects.none()
+        if inbox is None and not project.inbox_view:
+            return InboxIssue.objects.none()
 
         return (
-            IntakeIssue.objects.filter(
+            InboxIssue.objects.filter(
                 Q(snoozed_till__gte=timezone.now())
                 | Q(snoozed_till__isnull=True),
                 workspace__slug=self.kwargs.get("slug"),
                 project_id=self.kwargs.get("project_id"),
-                intake_id=intake.id,
+                inbox_id=inbox.id,
             )
             .select_related("issue", "workspace", "project")
             .order_by(self.kwargs.get("order_by", "-created_at"))
@@ -75,22 +75,22 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
 
     def get(self, request, slug, project_id, issue_id=None):
         if issue_id:
-            intake_issue_queryset = self.get_queryset().get(issue_id=issue_id)
-            intake_issue_data = IntakeIssueSerializer(
-                intake_issue_queryset,
+            inbox_issue_queryset = self.get_queryset().get(issue_id=issue_id)
+            inbox_issue_data = InboxIssueSerializer(
+                inbox_issue_queryset,
                 fields=self.fields,
                 expand=self.expand,
             ).data
             return Response(
-                intake_issue_data,
+                inbox_issue_data,
                 status=status.HTTP_200_OK,
             )
         issue_queryset = self.get_queryset()
         return self.paginate(
             request=request,
             queryset=(issue_queryset),
-            on_results=lambda intake_issues: IntakeIssueSerializer(
-                intake_issues,
+            on_results=lambda inbox_issues: InboxIssueSerializer(
+                inbox_issues,
                 many=True,
                 fields=self.fields,
                 expand=self.expand,
@@ -104,7 +104,7 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        intake = Intake.objects.filter(
+        inbox = Inbox.objects.filter(
             workspace__slug=slug, project_id=project_id
         ).first()
 
@@ -113,11 +113,11 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
             pk=project_id,
         )
 
-        # Intake view
-        if intake is None and not project.intake_view:
+        # Inbox view
+        if inbox is None and not project.inbox_view:
             return Response(
                 {
-                    "error": "Intake is not enabled for this project enable it through the project's api"
+                    "error": "Inbox is not enabled for this project enable it through the project's api"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )
@@ -139,7 +139,7 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
         state, _ = State.objects.get_or_create(
             name="Triage",
             group="triage",
-            description="Default state for managing all Intake Issues",
+            description="Default state for managing all Inbox Issues",
             project_id=project_id,
             color="#ff7700",
             is_triage=True,
@@ -157,12 +157,12 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
             state=state,
         )
 
-        # create an intake issue
-        intake_issue = IntakeIssue.objects.create(
-            intake_id=intake.id,
+        # create an inbox issue
+        inbox_issue = InboxIssue.objects.create(
+            inbox_id=inbox.id,
             project_id=project_id,
             issue=issue,
-            source=request.data.get("source", "IN-APP"),
+            source=request.data.get("source", "in-app"),
         )
         # Create an Issue Activity
         issue_activity.delay(
@@ -173,14 +173,14 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
             project_id=str(project_id),
             current_instance=None,
             epoch=int(timezone.now().timestamp()),
-            intake=str(intake_issue.id),
+            inbox=str(inbox_issue.id),
         )
 
-        serializer = IntakeIssueSerializer(intake_issue)
+        serializer = InboxIssueSerializer(inbox_issue)
         return Response(serializer.data, status=status.HTTP_200_OK)
 
     def patch(self, request, slug, project_id, issue_id):
-        intake = Intake.objects.filter(
+        inbox = Inbox.objects.filter(
             workspace__slug=slug, project_id=project_id
         ).first()
 
@@ -189,21 +189,21 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
             pk=project_id,
         )
 
-        # Intake view
-        if intake is None and not project.intake_view:
+        # Inbox view
+        if inbox is None and not project.inbox_view:
             return Response(
                 {
-                    "error": "Intake is not enabled for this project enable it through the project's api"
+                    "error": "Inbox is not enabled for this project enable it through the project's api"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        # Get the intake issue
-        intake_issue = IntakeIssue.objects.get(
+        # Get the inbox issue
+        inbox_issue = InboxIssue.objects.get(
             issue_id=issue_id,
             workspace__slug=slug,
             project_id=project_id,
-            intake_id=intake.id,
+            inbox_id=inbox.id,
         )
 
         # Get the project member
@@ -215,11 +215,11 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
         )
 
         # Only project members admins and created_by users can access this endpoint
-        if project_member.role <= 5 and str(intake_issue.created_by_id) != str(
+        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
             request.user.id
         ):
             return Response(
-                {"error": "You cannot edit intake issues"},
+                {"error": "You cannot edit inbox issues"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
@@ -232,10 +232,7 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
                     ArrayAgg(
                         "labels__id",
                         distinct=True,
-                        filter=Q(
-                            ~Q(labels__id__isnull=True)
-                            & Q(label_issue__deleted_at__isnull=True),
-                        ),
+                        filter=~Q(labels__id__isnull=True),
                     ),
                     Value([], output_field=ArrayField(UUIDField())),
                 ),
@@ -243,11 +240,7 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
                     ArrayAgg(
                         "assignees__id",
                         distinct=True,
-                        filter=Q(
-                            ~Q(assignees__id__isnull=True)
-                            & Q(assignees__member_project__is_active=True)
-                            & Q(issue_assignee__deleted_at__isnull=True)
-                        ),
+                        filter=~Q(assignees__id__isnull=True),
                     ),
                     Value([], output_field=ArrayField(UUIDField())),
                 ),
@@ -256,8 +249,9 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
                 workspace__slug=slug,
                 project_id=project_id,
             )
-            # Only allow guests to edit name and description
-            if project_member.role <= 5:
+            # Only allow guests and viewers to edit name and description
+            if project_member.role <= 10:
+                # viewers and guests since only viewers and guests
                 issue_data = {
                     "name": issue_data.get("name", issue.name),
                     "description_html": issue_data.get(
@@ -288,7 +282,7 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
                             cls=DjangoJSONEncoder,
                         ),
                         epoch=int(timezone.now().timestamp()),
-                        intake=(intake_issue.id),
+                        inbox=(inbox_issue.id),
                     )
                 issue_serializer.save()
             else:
@@ -296,13 +290,13 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
                     issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
                 )
 
-        # Only project admins and members can edit intake issue attributes
-        if project_member.role > 15:
-            serializer = IntakeIssueSerializer(
-                intake_issue, data=request.data, partial=True
+        # Only project admins and members can edit inbox issue attributes
+        if project_member.role > 10:
+            serializer = InboxIssueSerializer(
+                inbox_issue, data=request.data, partial=True
             )
             current_instance = json.dumps(
-                IntakeIssueSerializer(intake_issue).data, cls=DjangoJSONEncoder
+                InboxIssueSerializer(inbox_issue).data, cls=DjangoJSONEncoder
             )
 
             if serializer.is_valid():
@@ -345,7 +339,7 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
 
                 # create a activity for status change
                 issue_activity.delay(
-                    type="intake.activity.created",
+                    type="inbox.activity.created",
                     requested_data=json.dumps(
                         request.data, cls=DjangoJSONEncoder
                     ),
@@ -356,7 +350,7 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
                     epoch=int(timezone.now().timestamp()),
                     notification=False,
                     origin=request.META.get("HTTP_ORIGIN"),
-                    intake=str(intake_issue.id),
+                    inbox=str(inbox_issue.id),
                 )
 
                 return Response(serializer.data, status=status.HTTP_200_OK)
@@ -365,12 +359,12 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
             )
         else:
             return Response(
-                IntakeIssueSerializer(intake_issue).data,
+                InboxIssueSerializer(inbox_issue).data,
                 status=status.HTTP_200_OK,
             )
 
     def delete(self, request, slug, project_id, issue_id):
-        intake = Intake.objects.filter(
+        inbox = Inbox.objects.filter(
             workspace__slug=slug, project_id=project_id
         ).first()
 
@@ -379,25 +373,25 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
             pk=project_id,
         )
 
-        # Intake view
-        if intake is None and not project.intake_view:
+        # Inbox view
+        if inbox is None and not project.inbox_view:
             return Response(
                 {
-                    "error": "Intake is not enabled for this project enable it through the project's api"
+                    "error": "Inbox is not enabled for this project enable it through the project's api"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        # Get the intake issue
-        intake_issue = IntakeIssue.objects.get(
+        # Get the inbox issue
+        inbox_issue = InboxIssue.objects.get(
             issue_id=issue_id,
             workspace__slug=slug,
             project_id=project_id,
-            intake_id=intake.id,
+            inbox_id=inbox.id,
         )
 
         # Check the issue status
-        if intake_issue.status in [-2, -1, 0, 2]:
+        if inbox_issue.status in [-2, -1, 0, 2]:
             # Delete the issue also
             issue = Issue.objects.filter(
                 workspace__slug=slug, project_id=project_id, pk=issue_id
@@ -417,5 +411,5 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
                 )
             issue.delete()
 
-        intake_issue.delete()
+        inbox_issue.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/issue.py

@@ -16,7 +16,6 @@ from django.db.models import (
     Q,
     Value,
     When,
-    Subquery,
 )
 from django.utils import timezone
 
@@ -39,17 +38,16 @@ from plane.app.permissions import (
     ProjectLitePermission,
     ProjectMemberPermission,
 )
-from plane.bgtasks.issue_activities_task import issue_activity
+from plane.bgtasks.issue_activites_task import issue_activity
 from plane.db.models import (
     Issue,
     IssueActivity,
-    FileAsset,
+    IssueAttachment,
     IssueComment,
     IssueLink,
     Label,
     Project,
     ProjectMember,
-    CycleIssue,
 )
 
 from .base import BaseAPIView
@@ -153,25 +151,6 @@ class IssueAPIEndpoint(BaseAPIView):
         ).distinct()
 
     def get(self, request, slug, project_id, pk=None):
-        external_id = request.GET.get("external_id")
-        external_source = request.GET.get("external_source")
-
-        if external_id and external_source:
-            issue = Issue.objects.get(
-                external_id=external_id,
-                external_source=external_source,
-                workspace__slug=slug,
-                project_id=project_id,
-            )
-            return Response(
-                IssueSerializer(
-                    issue,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-                status=status.HTTP_200_OK,
-            )
-
         if pk:
             issue = Issue.issue_objects.annotate(
                 sub_issues_count=Issue.issue_objects.filter(
@@ -204,13 +183,7 @@ class IssueAPIEndpoint(BaseAPIView):
 
         issue_queryset = (
             self.get_queryset()
-            .annotate(
-                cycle_id=Subquery(
-                    CycleIssue.objects.filter(
-                        issue=OuterRef("id"), deleted_at__isnull=True
-                    ).values("cycle_id")[:1]
-                )
-            )
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
             .annotate(
                 link_count=IssueLink.objects.filter(issue=OuterRef("id"))
                 .order_by()
@@ -218,9 +191,8 @@ class IssueAPIEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -343,11 +315,8 @@ class IssueAPIEndpoint(BaseAPIView):
                 project_id=project_id,
                 pk=serializer.data["id"],
             ).first()
-            issue.created_at = request.data.get("created_at", timezone.now())
-            issue.created_by_id = request.data.get(
-                "created_by", request.user.id
-            )
-            issue.save(update_fields=["created_at", "created_by"])
+            issue.created_at = request.data.get("created_at")
+            issue.save(update_fields=["created_at"])
 
             # Track the issue
             issue_activity.delay(
@@ -364,124 +333,6 @@ class IssueAPIEndpoint(BaseAPIView):
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
-    def put(self, request, slug, project_id):
-        # Get the entities required for putting the issue, external_id and
-        # external_source are must to identify the issue here
-        project = Project.objects.get(pk=project_id)
-        external_id = request.data.get("external_id")
-        external_source = request.data.get("external_source")
-
-        # If the external_id and source are present, we need to find the exact
-        # issue that needs to be updated with the provided external_id and
-        # external_source
-        if external_id and external_source:
-            try:
-                issue = Issue.objects.get(
-                    project_id=project_id,
-                    workspace__slug=slug,
-                    external_id=external_id,
-                    external_source=external_source,
-                )
-
-                # Get the current instance of the issue in order to track
-                # changes and dispatch the issue activity
-                current_instance = json.dumps(
-                    IssueSerializer(issue).data, cls=DjangoJSONEncoder
-                )
-
-                # Get the requested data, encode it as django object and pass it
-                # to serializer to validation
-                requested_data = json.dumps(
-                    self.request.data, cls=DjangoJSONEncoder
-                )
-                serializer = IssueSerializer(
-                    issue,
-                    data=request.data,
-                    context={
-                        "project_id": project_id,
-                        "workspace_id": project.workspace_id,
-                    },
-                    partial=True,
-                )
-                if serializer.is_valid():
-                    # If the serializer is valid, save the issue and dispatch
-                    # the update issue activity worker event.
-                    serializer.save()
-                    issue_activity.delay(
-                        type="issue.activity.updated",
-                        requested_data=requested_data,
-                        actor_id=str(request.user.id),
-                        issue_id=str(issue.id),
-                        project_id=str(project_id),
-                        current_instance=current_instance,
-                        epoch=int(timezone.now().timestamp()),
-                    )
-                    return Response(serializer.data, status=status.HTTP_200_OK)
-                return Response(
-                    # If the serializer is not valid, respond with 400 bad
-                    # request
-                    serializer.errors,
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            except Issue.DoesNotExist:
-                # If the issue does not exist, a new record needs to be created
-                # for the requested data.
-                # Serialize the data with the context of the project and
-                # workspace
-                serializer = IssueSerializer(
-                    data=request.data,
-                    context={
-                        "project_id": project_id,
-                        "workspace_id": project.workspace_id,
-                        "default_assignee_id": project.default_assignee_id,
-                    },
-                )
-
-                # If the serializer is valid, save the issue and dispatch the
-                # issue activity worker event as created
-                if serializer.is_valid():
-                    serializer.save()
-                    # Refetch the issue
-                    issue = Issue.objects.filter(
-                        workspace__slug=slug,
-                        project_id=project_id,
-                        pk=serializer.data["id"],
-                    ).first()
-
-                    # If any of the created_at or created_by is present, update
-                    # the issue with the provided data, else return with the
-                    # default states given.
-                    issue.created_at = request.data.get(
-                        "created_at", timezone.now()
-                    )
-                    issue.created_by_id = request.data.get(
-                        "created_by", request.user.id
-                    )
-                    issue.save(update_fields=["created_at", "created_by"])
-
-                    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(project_id),
-                        current_instance=None,
-                        epoch=int(timezone.now().timestamp()),
-                    )
-                    return Response(
-                        serializer.data, status=status.HTTP_201_CREATED
-                    )
-                return Response(
-                    serializer.errors, status=status.HTTP_400_BAD_REQUEST
-                )
-        else:
-            return Response(
-                {"error": "external_id and external_source are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
     def patch(self, request, slug, project_id, pk=None):
         issue = Issue.objects.get(
             workspace__slug=slug, project_id=project_id, pk=pk
@@ -759,20 +610,14 @@ class IssueLinkAPIEndpoint(BaseAPIView):
                 project_id=project_id,
                 issue_id=issue_id,
             )
-
-            link = IssueLink.objects.get(pk=serializer.data["id"])
-            link.created_by_id = request.data.get(
-                "created_by", request.user.id
-            )
-            link.save(update_fields=["created_by"])
             issue_activity.delay(
                 type="link.activity.created",
                 requested_data=json.dumps(
                     serializer.data, cls=DjangoJSONEncoder
                 ),
+                actor_id=str(self.request.user.id),
                 issue_id=str(self.kwargs.get("issue_id")),
                 project_id=str(self.kwargs.get("project_id")),
-                actor_id=str(link.created_by_id),
                 current_instance=None,
                 epoch=int(timezone.now().timestamp()),
             )
@@ -926,24 +771,12 @@ class IssueCommentAPIEndpoint(BaseAPIView):
                 issue_id=issue_id,
                 actor=request.user,
             )
-            issue_comment = IssueComment.objects.get(
-                pk=serializer.data.get("id")
-            )
-            # Update the created_at and the created_by and save the comment
-            issue_comment.created_at = request.data.get(
-                "created_at", timezone.now()
-            )
-            issue_comment.created_by_id = request.data.get(
-                "created_by", request.user.id
-            )
-            issue_comment.save(update_fields=["created_at", "created_by"])
-
             issue_activity.delay(
                 type="comment.activity.created",
                 requested_data=json.dumps(
                     serializer.data, cls=DjangoJSONEncoder
                 ),
-                actor_id=str(issue_comment.created_by_id),
+                actor_id=str(self.request.user.id),
                 issue_id=str(self.kwargs.get("issue_id")),
                 project_id=str(self.kwargs.get("project_id")),
                 current_instance=None,
@@ -1071,7 +904,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
     permission_classes = [
         ProjectEntityPermission,
     ]
-    model = FileAsset
+    model = IssueAttachment
     parser_classes = (MultiPartParser, FormParser)
 
     def post(self, request, slug, project_id, issue_id):
@@ -1079,7 +912,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
         if (
             request.data.get("external_id")
             and request.data.get("external_source")
-            and FileAsset.objects.filter(
+            and IssueAttachment.objects.filter(
                 project_id=project_id,
                 workspace__slug=slug,
                 issue_id=issue_id,
@@ -1087,7 +920,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
                 external_id=request.data.get("external_id"),
             ).exists()
         ):
-            issue_attachment = FileAsset.objects.filter(
+            issue_attachment = IssueAttachment.objects.filter(
                 workspace__slug=slug,
                 project_id=project_id,
                 external_id=request.data.get("external_id"),
@@ -1121,7 +954,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def delete(self, request, slug, project_id, issue_id, pk):
-        issue_attachment = FileAsset.objects.get(pk=pk)
+        issue_attachment = IssueAttachment.objects.get(pk=pk)
         issue_attachment.asset.delete(save=False)
         issue_attachment.delete()
         issue_activity.delay(
@@ -1139,7 +972,7 @@ class IssueAttachmentEndpoint(BaseAPIView):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
     def get(self, request, slug, project_id, issue_id):
-        issue_attachments = FileAsset.objects.filter(
+        issue_attachments = IssueAttachment.objects.filter(
             issue_id=issue_id, workspace__slug=slug, project_id=project_id
         )
         serializer = IssueAttachmentSerializer(issue_attachments, many=True)

apiserver/plane/api/views/member.py

@@ -21,19 +21,11 @@ from plane.db.models import (
     ProjectMember,
 )
 
-from plane.app.permissions import (
-    ProjectMemberPermission,
-)
-
 
 # API endpoint to get and insert users inside the workspace
-class ProjectMemberAPIEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectMemberPermission,
-    ]
-
+class WorkspaceMemberAPIEndpoint(BaseAPIView):
     # Get all the users that are present inside the workspace
-    def get(self, request, slug, project_id):
+    def get(self, request, slug):
         # Check if the workspace exists
         if not Workspace.objects.filter(slug=slug).exists():
             return Response(
@@ -42,14 +34,14 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
             )
 
         # Get the workspace members that are present inside the workspace
-        project_members = ProjectMember.objects.filter(
-            project_id=project_id, workspace__slug=slug
-        ).values_list("member_id", flat=True)
+        workspace_members = WorkspaceMember.objects.filter(
+            workspace__slug=slug
+        )
 
         # Get all the users that are present inside the workspace
         users = UserLiteSerializer(
             User.objects.filter(
-                id__in=project_members,
+                id__in=workspace_members.values_list("member_id", flat=True)
             ),
             many=True,
         ).data
@@ -57,13 +49,14 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
         return Response(users, status=status.HTTP_200_OK)
 
     # Insert a new user inside the workspace, and assign the user to the project
-    def post(self, request, slug, project_id):
+    def post(self, request, slug):
         # Check if user with email already exists, and send bad request if it's
         # not present, check for workspace and valid project mandat
         # ------------------- Validation -------------------
         if (
             request.data.get("email") is None
             or request.data.get("display_name") is None
+            or request.data.get("project_id") is None
         ):
             return Response(
                 {
@@ -83,7 +76,9 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
             )
 
         workspace = Workspace.objects.filter(slug=slug).first()
-        project = Project.objects.filter(pk=project_id).first()
+        project = Project.objects.filter(
+            pk=request.data.get("project_id")
+        ).first()
 
         if not all([workspace, project]):
             return Response(
@@ -133,7 +128,7 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
             workspace_member = WorkspaceMember.objects.create(
                 workspace=workspace,
                 member=user,
-                role=request.data.get("role", 5),
+                role=request.data.get("role", 10),
             )
             workspace_member.save()
 
@@ -142,7 +137,7 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
             project_member = ProjectMember.objects.create(
                 project=project,
                 member=user,
-                role=request.data.get("role", 5),
+                role=request.data.get("role", 10),
             )
             project_member.save()
 
@@ -150,4 +145,3 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
         user_data = UserLiteSerializer(user).data
 
         return Response(user_data, status=status.HTTP_201_CREATED)
-

apiserver/plane/api/views/module.py

@@ -18,17 +18,16 @@ from plane.api.serializers import (
     ModuleSerializer,
 )
 from plane.app.permissions import ProjectEntityPermission
-from plane.bgtasks.issue_activities_task import issue_activity
+from plane.bgtasks.issue_activites_task import issue_activity
 from plane.db.models import (
     Issue,
-    FileAsset,
+    IssueAttachment,
     IssueLink,
     Module,
     ModuleIssue,
     ModuleLink,
     Project,
     ProjectMember,
-    UserFavorite,
 )
 
 from .base import BaseAPIView
@@ -71,7 +70,6 @@ class ModuleAPIEndpoint(BaseAPIView):
                     filter=Q(
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 ),
@@ -83,7 +81,6 @@ class ModuleAPIEndpoint(BaseAPIView):
                         issue_module__issue__state__group="completed",
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 )
@@ -95,7 +92,6 @@ class ModuleAPIEndpoint(BaseAPIView):
                         issue_module__issue__state__group="cancelled",
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 )
@@ -107,7 +103,6 @@ class ModuleAPIEndpoint(BaseAPIView):
                         issue_module__issue__state__group="started",
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 )
@@ -119,7 +114,6 @@ class ModuleAPIEndpoint(BaseAPIView):
                         issue_module__issue__state__group="unstarted",
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 )
@@ -131,7 +125,6 @@ class ModuleAPIEndpoint(BaseAPIView):
                         issue_module__issue__state__group="backlog",
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 )
@@ -304,25 +297,10 @@ class ModuleAPIEndpoint(BaseAPIView):
             actor_id=str(request.user.id),
             issue_id=None,
             project_id=str(project_id),
-            current_instance=json.dumps(
-                {
-                    "module_name": str(module.name),
-                }
-            ),
+            current_instance=None,
             epoch=int(timezone.now().timestamp()),
         )
         module.delete()
-        # Delete the module issues
-        ModuleIssue.objects.filter(
-            module=pk,
-            project_id=project_id,
-        ).delete()
-        # Delete the user favorite module
-        UserFavorite.objects.filter(
-            entity_type="module",
-            entity_identifier=pk,
-            project_id=project_id,
-        ).delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
@@ -373,10 +351,7 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
     def get(self, request, slug, project_id, module_id):
         order_by = request.GET.get("order_by", "created_at")
         issues = (
-            Issue.issue_objects.filter(
-                issue_module__module_id=module_id,
-                issue_module__deleted_at__isnull=True,
-            )
+            Issue.issue_objects.filter(issue_module__module_id=module_id)
             .annotate(
                 sub_issues_count=Issue.issue_objects.filter(
                     parent=OuterRef("id")
@@ -402,9 +377,8 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                attachment_count=FileAsset.objects.filter(
-                    issue_id=OuterRef("id"),
-                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -534,6 +508,7 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
 
 
 class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
+
     permission_classes = [
         ProjectEntityPermission,
     ]
@@ -561,7 +536,6 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                     filter=Q(
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 ),
@@ -573,7 +547,6 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_module__issue__state__group="completed",
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 )
@@ -585,7 +558,6 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_module__issue__state__group="cancelled",
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 )
@@ -597,7 +569,6 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_module__issue__state__group="started",
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 )
@@ -609,7 +580,6 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_module__issue__state__group="unstarted",
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 )
@@ -621,7 +591,6 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
                         issue_module__issue__state__group="backlog",
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
-                        issue_module__deleted_at__isnull=True,
                     ),
                     distinct=True,
                 )
@@ -654,12 +623,6 @@ class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
             )
         module.archived_at = timezone.now()
         module.save()
-        UserFavorite.objects.filter(
-            entity_type="module",
-            entity_identifier=pk,
-            project_id=project_id,
-            workspace__slug=slug,
-        ).delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
     def delete(self, request, slug, project_id, pk):

apiserver/plane/api/views/project.py

@@ -18,7 +18,7 @@ from plane.app.permissions import ProjectBasePermission
 # Module imports
 from plane.db.models import (
     Cycle,
-    Intake,
+    Inbox,
     IssueUserProperty,
     Module,
     Project,
@@ -26,7 +26,6 @@ from plane.db.models import (
     ProjectMember,
     State,
     Workspace,
-    UserFavorite,
 )
 from plane.bgtasks.webhook_task import model_activity
 from .base import BaseAPIView
@@ -285,11 +284,6 @@ class ProjectAPIEndpoint(BaseAPIView):
             current_instance = json.dumps(
                 ProjectSerializer(project).data, cls=DjangoJSONEncoder
             )
-
-            intake_view = request.data.get(
-                "inbox_view", request.data.get("intake_view", False)
-            )
-
             if project.archived_at:
                 return Response(
                     {"error": "Archived project cannot be updated"},
@@ -298,33 +292,25 @@ class ProjectAPIEndpoint(BaseAPIView):
 
             serializer = ProjectSerializer(
                 project,
-                data={
-                    **request.data,
-                    "intake_view": intake_view,
-                },
+                data={**request.data},
                 context={"workspace_id": workspace.id},
                 partial=True,
             )
 
             if serializer.is_valid():
                 serializer.save()
-                if serializer.data["intake_view"]:
-                    intake = Intake.objects.filter(
+                if serializer.data["inbox_view"]:
+                    Inbox.objects.get_or_create(
+                        name=f"{project.name} Inbox",
                         project=project,
                         is_default=True,
-                    ).first()
-                    if not intake:
-                        Intake.objects.create(
-                            name=f"{project.name} Intake",
-                            project=project,
-                            is_default=True,
-                        )
+                    )
 
                     # Create the triage state in Backlog group
                     State.objects.get_or_create(
                         name="Triage",
                         group="triage",
-                        description="Default state for managing all Intake Issues",
+                        description="Default state for managing all Inbox Issues",
                         project_id=pk,
                         color="#ff7700",
                         is_triage=True,
@@ -370,12 +356,6 @@ class ProjectAPIEndpoint(BaseAPIView):
 
     def delete(self, request, slug, pk):
         project = Project.objects.get(pk=pk, workspace__slug=slug)
-        # Delete the user favorite cycle
-        UserFavorite.objects.filter(
-            entity_type="project",
-            entity_identifier=pk,
-            project_id=pk,
-        ).delete()
         project.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
@@ -390,10 +370,6 @@ class ProjectArchiveUnarchiveAPIEndpoint(BaseAPIView):
         project = Project.objects.get(pk=project_id, workspace__slug=slug)
         project.archived_at = timezone.now()
         project.save()
-        UserFavorite.objects.filter(
-            workspace__slug=slug,
-            project=project_id,
-        ).delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
     def delete(self, request, slug, project_id):

apiserver/plane/app/permissions/__init__.py

@@ -12,4 +12,3 @@ from .project import (
     ProjectMemberPermission,
     ProjectLitePermission,
 )
-from .base import allow_permission, ROLE

apiserver/plane/app/permissions/base.py

@@ -1,60 +0,0 @@
-from plane.db.models import WorkspaceMember, ProjectMember
-from functools import wraps
-from rest_framework.response import Response
-from rest_framework import status
-
-from enum import Enum
-
-class ROLE(Enum):
-    ADMIN = 20
-    MEMBER = 15
-    GUEST = 5
-
-
-def allow_permission(allowed_roles, level="PROJECT", creator=False, model=None):
-    def decorator(view_func):
-        @wraps(view_func)
-        def _wrapped_view(instance, request, *args, **kwargs):
-
-            # Check for creator if required
-            if creator and model:
-                obj = model.objects.filter(
-                    id=kwargs["pk"], created_by=request.user
-                ).exists()
-                if obj:
-                    return view_func(instance, request, *args, **kwargs)
-
-            # Convert allowed_roles to their values if they are enum members
-            allowed_role_values = [
-                role.value if isinstance(role, ROLE) else role
-                for role in allowed_roles
-            ]
-
-            # Check role permissions
-            if level == "WORKSPACE":
-                if WorkspaceMember.objects.filter(
-                    member=request.user,
-                    workspace__slug=kwargs["slug"],
-                    role__in=allowed_role_values,
-                    is_active=True,
-                ).exists():
-                    return view_func(instance, request, *args, **kwargs)
-            else:
-                if ProjectMember.objects.filter(
-                    member=request.user,
-                    workspace__slug=kwargs["slug"],
-                    project_id=kwargs["project_id"],
-                    role__in=allowed_role_values,
-                    is_active=True,
-                ).exists():
-                    return view_func(instance, request, *args, **kwargs)
-
-            # Return permission denied if no conditions are met
-            return Response(
-                {"error": "You don't have the required permissions."},
-                status=status.HTTP_403_FORBIDDEN,
-            )
-
-        return _wrapped_view
-
-    return decorator

apiserver/plane/app/permissions/project.py

@@ -7,6 +7,7 @@ from plane.db.models import ProjectMember, WorkspaceMember
 # Permission Mappings
 Admin = 20
 Member = 15
+Viewer = 10
 Guest = 5
 
 

apiserver/plane/app/permissions/workspace.py

@@ -6,8 +6,9 @@ from plane.db.models import WorkspaceMember
 
 
 # Permission Mappings
-Admin = 20
-Member = 15
+Owner = 20
+Admin = 15
+Member = 10
 Guest = 5
 
 
@@ -30,7 +31,7 @@ class WorkSpaceBasePermission(BasePermission):
             return WorkspaceMember.objects.filter(
                 member=request.user,
                 workspace__slug=view.workspace_slug,
-                role__in=[Admin, Member],
+                role__in=[Owner, Admin],
                 is_active=True,
             ).exists()
 
@@ -39,7 +40,7 @@ class WorkSpaceBasePermission(BasePermission):
             return WorkspaceMember.objects.filter(
                 member=request.user,
                 workspace__slug=view.workspace_slug,
-                role=Admin,
+                role=Owner,
                 is_active=True,
             ).exists()
 
@@ -52,7 +53,7 @@ class WorkspaceOwnerPermission(BasePermission):
         return WorkspaceMember.objects.filter(
             workspace__slug=view.workspace_slug,
             member=request.user,
-            role=Admin,
+            role=Owner,
         ).exists()
 
 
@@ -64,7 +65,7 @@ class WorkSpaceAdminPermission(BasePermission):
         return WorkspaceMember.objects.filter(
             member=request.user,
             workspace__slug=view.workspace_slug,
-            role__in=[Admin, Member],
+            role__in=[Owner, Admin],
             is_active=True,
         ).exists()
 
@@ -85,7 +86,7 @@ class WorkspaceEntityPermission(BasePermission):
         return WorkspaceMember.objects.filter(
             member=request.user,
             workspace__slug=view.workspace_slug,
-            role__in=[Admin, Member],
+            role__in=[Owner, Admin],
             is_active=True,
         ).exists()
 

apiserver/plane/app/serializers/__init__.py

@@ -57,7 +57,7 @@ from .issue import (
     IssueFlatSerializer,
     IssueStateSerializer,
     IssueLinkSerializer,
-    IssueIntakeSerializer,
+    IssueInboxSerializer,
     IssueLiteSerializer,
     IssueAttachmentSerializer,
     IssueSubscriberSerializer,
@@ -92,7 +92,6 @@ from .page import (
     SubPageSerializer,
     PageDetailSerializer,
     PageVersionSerializer,
-    PageVersionDetailSerializer,
 )
 
 from .estimate import (
@@ -102,12 +101,12 @@ from .estimate import (
     WorkspaceEstimateSerializer,
 )
 
-from .intake import (
-    IntakeSerializer,
-    IntakeIssueSerializer,
-    IssueStateIntakeSerializer,
-    IntakeIssueLiteSerializer,
-    IntakeIssueDetailSerializer,
+from .inbox import (
+    InboxSerializer,
+    InboxIssueSerializer,
+    IssueStateInboxSerializer,
+    InboxIssueLiteSerializer,
+    InboxIssueDetailSerializer,
 )
 
 from .analytic import AnalyticViewSerializer
@@ -122,11 +121,3 @@ from .exporter import ExporterHistorySerializer
 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

@@ -60,10 +60,10 @@ class DynamicBaseSerializer(BaseSerializer):
                     CycleIssueSerializer,
                     IssueLiteSerializer,
                     IssueRelationSerializer,
-                    IntakeIssueLiteSerializer,
+                    InboxIssueLiteSerializer,
                     IssueReactionLiteSerializer,
+                    IssueAttachmentLiteSerializer,
                     IssueLinkLiteSerializer,
-                    RelatedIssueSerializer,
                 )
 
                 # Expansion mapper
@@ -84,14 +84,13 @@ class DynamicBaseSerializer(BaseSerializer):
                     "issue_cycle": CycleIssueSerializer,
                     "parent": IssueLiteSerializer,
                     "issue_relation": IssueRelationSerializer,
-                    "issue_intake": IntakeIssueLiteSerializer,
-                    "issue_related": RelatedIssueSerializer,
+                    "issue_inbox": InboxIssueLiteSerializer,
                     "issue_reactions": IssueReactionLiteSerializer,
+                    "issue_attachment": IssueAttachmentLiteSerializer,
                     "issue_link": IssueLinkLiteSerializer,
                     "sub_issues": IssueLiteSerializer,
                 }
 
-            if field not in self.fields and field in expansion:
                 self.fields[field] = expansion[field](
                     many=(
                         True
@@ -102,12 +101,11 @@ class DynamicBaseSerializer(BaseSerializer):
                             "labels",
                             "issue_cycle",
                             "issue_relation",
-                            "issue_intake",
+                            "issue_inbox",
                             "issue_reactions",
                             "issue_attachment",
                             "issue_link",
                             "sub_issues",
-                            "issue_related",
                         ]
                         else False
                     )
@@ -132,12 +130,11 @@ class DynamicBaseSerializer(BaseSerializer):
                         LabelSerializer,
                         CycleIssueSerializer,
                         IssueRelationSerializer,
-                        IntakeIssueLiteSerializer,
+                        InboxIssueLiteSerializer,
                         IssueLiteSerializer,
                         IssueReactionLiteSerializer,
                         IssueAttachmentLiteSerializer,
                         IssueLinkLiteSerializer,
-                        RelatedIssueSerializer,
                     )
 
                     # Expansion mapper
@@ -158,8 +155,7 @@ class DynamicBaseSerializer(BaseSerializer):
                         "issue_cycle": CycleIssueSerializer,
                         "parent": IssueLiteSerializer,
                         "issue_relation": IssueRelationSerializer,
-                        "issue_intake": IntakeIssueLiteSerializer,
-                        "issue_related": RelatedIssueSerializer,
+                        "issue_inbox": InboxIssueLiteSerializer,
                         "issue_reactions": IssueReactionLiteSerializer,
                         "issue_attachment": IssueAttachmentLiteSerializer,
                         "issue_link": IssueLinkLiteSerializer,
@@ -182,29 +178,4 @@ class DynamicBaseSerializer(BaseSerializer):
                             instance, f"{expand}_id", None
                         )
 
-            # Check if issue_attachments is in fields or expand
-            if (
-                "issue_attachments" in self.fields
-                or "issue_attachments" in self.expand
-            ):
-                # Import the model here to avoid circular imports
-                from plane.db.models import FileAsset
-
-                issue_id = getattr(instance, "id", None)
-
-                if issue_id:
-                    # Fetch related issue_attachments
-                    issue_attachments = FileAsset.objects.filter(
-                        issue_id=issue_id,
-                        entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
-                    )
-                    # Serialize issue_attachments and add them to the response
-                    response["issue_attachments"] = (
-                        IssueAttachmentLiteSerializer(
-                            issue_attachments, many=True
-                        ).data
-                    )
-                else:
-                    response["issue_attachments"] = []
-
         return response

apiserver/plane/app/serializers/draft.py

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

@@ -1,101 +0,0 @@
-from rest_framework import serializers
-
-from plane.db.models import (
-    UserFavorite,
-    Cycle,
-    Module,
-    Issue,
-    IssueView,
-    Page,
-    Project,
-)
-
-
-class ProjectFavoriteLiteSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = Project
-        fields = ["id", "name", "logo_props"]
-
-
-class PageFavoriteLiteSerializer(serializers.ModelSerializer):
-    project_id = serializers.SerializerMethodField()
-
-    class Meta:
-        model = Page
-        fields = ["id", "name", "logo_props", "project_id"]
-
-    def get_project_id(self, obj):
-        project = (
-            obj.projects.first()
-        )  # This gets the first project related to the Page
-        return project.id if project else None
-
-
-class CycleFavoriteLiteSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = Cycle
-        fields = ["id", "name", "logo_props", "project_id"]
-
-
-class ModuleFavoriteLiteSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = Module
-        fields = ["id", "name", "logo_props", "project_id"]
-
-
-class ViewFavoriteSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = IssueView
-        fields = ["id", "name", "logo_props", "project_id"]
-
-
-def get_entity_model_and_serializer(entity_type):
-    entity_map = {
-        "cycle": (Cycle, CycleFavoriteLiteSerializer),
-        "issue": (Issue, None),
-        "module": (Module, ModuleFavoriteLiteSerializer),
-        "view": (IssueView, ViewFavoriteSerializer),
-        "page": (Page, PageFavoriteLiteSerializer),
-        "project": (Project, ProjectFavoriteLiteSerializer),
-        "folder": (None, None),
-    }
-    return entity_map.get(entity_type, (None, None))
-
-
-class UserFavoriteSerializer(serializers.ModelSerializer):
-    entity_data = serializers.SerializerMethodField()
-
-    class Meta:
-        model = UserFavorite
-        fields = [
-            "id",
-            "entity_type",
-            "entity_identifier",
-            "entity_data",
-            "name",
-            "is_folder",
-            "sequence",
-            "parent",
-            "workspace_id",
-            "project_id",
-        ]
-        read_only_fields = ["workspace", "created_by", "updated_by"]
-
-    def get_entity_data(self, obj):
-        entity_type = obj.entity_type
-        entity_identifier = obj.entity_identifier
-
-        entity_model, entity_serializer = get_entity_model_and_serializer(
-            entity_type
-        )
-        if entity_model and entity_serializer:
-            try:
-                entity = entity_model.objects.get(pk=entity_identifier)
-                return entity_serializer(entity).data
-            except entity_model.DoesNotExist:
-                return None
-        return None

apiserver/plane/app/serializers/inbox.py

@@ -4,22 +4,22 @@ from rest_framework import serializers
 # Module imports
 from .base import BaseSerializer
 from .issue import (
-    IssueIntakeSerializer,
+    IssueInboxSerializer,
     LabelLiteSerializer,
     IssueDetailSerializer,
 )
 from .project import ProjectLiteSerializer
 from .state import StateLiteSerializer
 from .user import UserLiteSerializer
-from plane.db.models import Intake, IntakeIssue, Issue
+from plane.db.models import Inbox, InboxIssue, Issue
 
 
-class IntakeSerializer(BaseSerializer):
+class InboxSerializer(BaseSerializer):
     project_detail = ProjectLiteSerializer(source="project", read_only=True)
     pending_issue_count = serializers.IntegerField(read_only=True)
 
     class Meta:
-        model = Intake
+        model = Inbox
         fields = "__all__"
         read_only_fields = [
             "project",
@@ -27,11 +27,11 @@ class IntakeSerializer(BaseSerializer):
         ]
 
 
-class IntakeIssueSerializer(BaseSerializer):
-    issue = IssueIntakeSerializer(read_only=True)
+class InboxIssueSerializer(BaseSerializer):
+    issue = IssueInboxSerializer(read_only=True)
 
     class Meta:
-        model = IntakeIssue
+        model = InboxIssue
         fields = [
             "id",
             "status",
@@ -53,14 +53,14 @@ class IntakeIssueSerializer(BaseSerializer):
         return super().to_representation(instance)
 
 
-class IntakeIssueDetailSerializer(BaseSerializer):
+class InboxIssueDetailSerializer(BaseSerializer):
     issue = IssueDetailSerializer(read_only=True)
-    duplicate_issue_detail = IssueIntakeSerializer(
+    duplicate_issue_detail = IssueInboxSerializer(
         read_only=True, source="duplicate_to"
     )
 
     class Meta:
-        model = IntakeIssue
+        model = InboxIssue
         fields = [
             "id",
             "status",
@@ -85,14 +85,14 @@ class IntakeIssueDetailSerializer(BaseSerializer):
         return super().to_representation(instance)
 
 
-class IntakeIssueLiteSerializer(BaseSerializer):
+class InboxIssueLiteSerializer(BaseSerializer):
     class Meta:
-        model = IntakeIssue
+        model = InboxIssue
         fields = ["id", "status", "duplicate_to", "snoozed_till", "source"]
         read_only_fields = fields
 
 
-class IssueStateIntakeSerializer(BaseSerializer):
+class IssueStateInboxSerializer(BaseSerializer):
     state_detail = StateLiteSerializer(read_only=True, source="state")
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
     label_details = LabelLiteSerializer(
@@ -102,7 +102,7 @@ class IssueStateIntakeSerializer(BaseSerializer):
         read_only=True, source="assignees", many=True
     )
     sub_issues_count = serializers.IntegerField(read_only=True)
-    issue_intake = IntakeIssueLiteSerializer(read_only=True, many=True)
+    issue_inbox = InboxIssueLiteSerializer(read_only=True, many=True)
 
     class Meta:
         model = Issue

apiserver/plane/app/serializers/issue.py

@@ -27,7 +27,7 @@ from plane.db.models import (
     Module,
     ModuleIssue,
     IssueLink,
-    FileAsset,
+    IssueAttachment,
     IssueReaction,
     CommentReaction,
     IssueVote,
@@ -95,8 +95,6 @@ class IssueCreateSerializer(BaseSerializer):
         write_only=True,
         required=False,
     )
-    project_id = serializers.UUIDField(source="project.id", read_only=True)
-    workspace_id = serializers.UUIDField(source="workspace.id", read_only=True)
 
     class Meta:
         model = Issue
@@ -439,21 +437,17 @@ class IssueLinkSerializer(BaseSerializer):
             "issue",
         ]
 
-    def to_internal_value(self, data):
-        # Modify the URL before validation by appending http:// if missing
-        url = data.get("url", "")
-        if url and not url.startswith(("http://", "https://")):
-            data["url"] = "http://" + url
-
-        return super().to_internal_value(data)
-
     def validate_url(self, value):
-        # Use Django's built-in URLValidator for validation
-        url_validator = URLValidator()
+        # Check URL format
+        validate_url = URLValidator()
         try:
-            url_validator(value)
+            validate_url(value)
         except ValidationError:
-            raise serializers.ValidationError({"error": "Invalid URL format."})
+            raise serializers.ValidationError("Invalid URL format.")
+
+        # Check URL scheme
+        if not value.startswith(("http://", "https://")):
+            raise serializers.ValidationError("Invalid URL scheme.")
 
         return value
 
@@ -500,11 +494,8 @@ class IssueLinkLiteSerializer(BaseSerializer):
 
 
 class IssueAttachmentSerializer(BaseSerializer):
-
-    asset_url = serializers.CharField(read_only=True)
-
     class Meta:
-        model = FileAsset
+        model = IssueAttachment
         fields = "__all__"
         read_only_fields = [
             "created_by",
@@ -519,15 +510,14 @@ class IssueAttachmentSerializer(BaseSerializer):
 
 class IssueAttachmentLiteSerializer(DynamicBaseSerializer):
     class Meta:
-        model = FileAsset
+        model = IssueAttachment
         fields = [
             "id",
             "asset",
             "attributes",
-            # "issue_id",
+            "issue_id",
             "updated_at",
             "updated_by",
-            "asset_url",
         ]
         read_only_fields = fields
 
@@ -543,7 +533,6 @@ class IssueReactionSerializer(BaseSerializer):
             "project",
             "issue",
             "actor",
-            "deleted_at",
         ]
 
 
@@ -562,13 +551,7 @@ class CommentReactionSerializer(BaseSerializer):
     class Meta:
         model = CommentReaction
         fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "comment",
-            "actor",
-            "deleted_at",
-        ]
+        read_only_fields = ["workspace", "project", "comment", "actor"]
 
 
 class IssueVoteSerializer(BaseSerializer):
@@ -645,7 +628,7 @@ class IssueStateSerializer(DynamicBaseSerializer):
         fields = "__all__"
 
 
-class IssueIntakeSerializer(DynamicBaseSerializer):
+class IssueInboxSerializer(DynamicBaseSerializer):
     label_ids = serializers.ListField(
         child=serializers.UUIDField(),
         required=False,

apiserver/plane/app/serializers/module.py

@@ -5,10 +5,6 @@ from rest_framework import serializers
 from .base import BaseSerializer, DynamicBaseSerializer
 from .project import ProjectLiteSerializer
 
-# Django imports
-from django.core.validators import URLValidator
-from django.core.exceptions import ValidationError
-
 from plane.db.models import (
     User,
     Module,
@@ -43,7 +39,6 @@ class ModuleWriteSerializer(BaseSerializer):
             "created_at",
             "updated_at",
             "archived_at",
-            "deleted_at",
         ]
 
     def to_representation(self, instance):
@@ -68,16 +63,6 @@ class ModuleWriteSerializer(BaseSerializer):
         members = validated_data.pop("member_ids", None)
         project = self.context["project"]
 
-        module_name = validated_data.get("name")
-        if module_name:
-            # Lookup for the module name in the module table for that project
-            if Module.objects.filter(
-                name=module_name, project=project
-            ).exists():
-                raise serializers.ValidationError(
-                    {"error": "Module with this name already exists"}
-                )
-
         module = Module.objects.create(**validated_data, project=project)
         if members is not None:
             ModuleMember.objects.bulk_create(
@@ -100,19 +85,6 @@ class ModuleWriteSerializer(BaseSerializer):
 
     def update(self, instance, validated_data):
         members = validated_data.pop("member_ids", None)
-        module_name = validated_data.get("name")
-        if module_name:
-            # Lookup for the module name in the module table for that project
-            if (
-                Module.objects.filter(
-                    name=module_name, project=instance.project
-                )
-                .exclude(id=instance.id)
-                .exists()
-            ):
-                raise serializers.ValidationError(
-                    {"error": "Module with this name already exists"}
-                )
 
         if members is not None:
             ModuleMember.objects.filter(module=instance).delete()
@@ -182,48 +154,16 @@ class ModuleLinkSerializer(BaseSerializer):
             "module",
         ]
 
-    def to_internal_value(self, data):
-        # Modify the URL before validation by appending http:// if missing
-        url = data.get("url", "")
-        if url and not url.startswith(("http://", "https://")):
-            data["url"] = "http://" + url
-
-        return super().to_internal_value(data)
-
-    def validate_url(self, value):
-        # Use Django's built-in URLValidator for validation
-        url_validator = URLValidator()
-        try:
-            url_validator(value)
-        except ValidationError:
-            raise serializers.ValidationError({"error": "Invalid URL format."})
-
-        return value
-
+    # Validation if url already exists
     def create(self, validated_data):
-        validated_data["url"] = self.validate_url(validated_data.get("url"))
         if ModuleLink.objects.filter(
             url=validated_data.get("url"),
             module_id=validated_data.get("module_id"),
         ).exists():
-            raise serializers.ValidationError({"error": "URL already exists."})
-        return super().create(validated_data)
-
-    def update(self, instance, validated_data):
-        validated_data["url"] = self.validate_url(validated_data.get("url"))
-        if (
-            ModuleLink.objects.filter(
-                url=validated_data.get("url"),
-                module_id=instance.module_id,
-            )
-            .exclude(pk=instance.id)
-            .exists()
-        ):
             raise serializers.ValidationError(
                 {"error": "URL already exists for this Issue"}
             )
-
-        return super().update(instance, validated_data)
+        return ModuleLink.objects.create(**validated_data)
 
 
 class ModuleSerializer(DynamicBaseSerializer):
@@ -288,14 +228,7 @@ class ModuleDetailSerializer(ModuleSerializer):
     cancelled_estimate_points = serializers.FloatField(read_only=True)
 
     class Meta(ModuleSerializer.Meta):
-        fields = ModuleSerializer.Meta.fields + [
-            "link_module",
-            "sub_issues",
-            "backlog_estimate_points",
-            "unstarted_estimate_points",
-            "started_estimate_points",
-            "cancelled_estimate_points",
-        ]
+        fields = ModuleSerializer.Meta.fields + ["link_module", "sub_issues", "backlog_estimate_points", "unstarted_estimate_points", "started_estimate_points", "cancelled_estimate_points"]
 
 
 class ModuleUserPropertiesSerializer(BaseSerializer):

apiserver/plane/app/serializers/notification.py

@@ -12,7 +12,6 @@ class NotificationSerializer(BaseSerializer):
         read_only=True, source="triggered_by"
     )
     is_inbox_issue = serializers.BooleanField(read_only=True)
-    is_intake_issue = serializers.BooleanField(read_only=True)
     is_mentioned_notification = serializers.BooleanField(read_only=True)
 
     class Meta:

apiserver/plane/app/serializers/page.py

@@ -167,40 +167,7 @@ class PageLogSerializer(BaseSerializer):
 class PageVersionSerializer(BaseSerializer):
     class Meta:
         model = PageVersion
-        fields = [
-            "id",
-            "workspace",
-            "page",
-            "last_saved_at",
-            "owned_by",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-        ]
-        read_only_fields = [
-            "workspace",
-            "page",
-        ]
-
-
-class PageVersionDetailSerializer(BaseSerializer):
-    class Meta:
-        model = PageVersion
-        fields = [
-            "id",
-            "workspace",
-            "page",
-            "last_saved_at",
-            "description_binary",
-            "description_html",
-            "description_json",
-            "owned_by",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-        ]
+        fields = "__all__"
         read_only_fields = [
             "workspace",
             "page",

apiserver/plane/app/serializers/project.py

@@ -22,14 +22,12 @@ class ProjectSerializer(BaseSerializer):
     workspace_detail = WorkspaceLiteSerializer(
         source="workspace", read_only=True
     )
-    inbox_view = serializers.BooleanField(read_only=True, source="intake_view")
 
     class Meta:
         model = Project
         fields = "__all__"
         read_only_fields = [
             "workspace",
-            "deleted_at",
         ]
 
     def create(self, validated_data):
@@ -96,7 +94,6 @@ class ProjectLiteSerializer(BaseSerializer):
             "identifier",
             "name",
             "cover_image",
-            "cover_image_url",
             "logo_props",
             "description",
         ]
@@ -119,8 +116,6 @@ class ProjectListSerializer(DynamicBaseSerializer):
     member_role = serializers.IntegerField(read_only=True)
     anchor = serializers.CharField(read_only=True)
     members = serializers.SerializerMethodField()
-    cover_image_url = serializers.CharField(read_only=True)
-    inbox_view = serializers.BooleanField(read_only=True, source="intake_view")
 
     def get_members(self, obj):
         project_members = getattr(obj, "members_list", None)
@@ -132,7 +127,6 @@ class ProjectListSerializer(DynamicBaseSerializer):
                     "member_id": member.member_id,
                     "member__display_name": member.member.display_name,
                     "member__avatar": member.member.avatar,
-                    "member__avatar_url": member.member.avatar_url,
                 }
                 for member in project_members
             ]

apiserver/plane/app/serializers/user.py

@@ -16,39 +16,26 @@ from .base import BaseSerializer
 class UserSerializer(BaseSerializer):
     class Meta:
         model = User
-        # Exclude password field from the serializer
-        fields = [
-            field.name
-            for field in User._meta.fields
-            if field.name != "password"
-        ]
-        # Make all system fields and email read only
+        fields = "__all__"
         read_only_fields = [
             "id",
-            "username",
-            "mobile_number",
-            "email",
-            "token",
             "created_at",
             "updated_at",
             "is_superuser",
             "is_staff",
-            "is_managed",
             "last_active",
             "last_login_time",
             "last_logout_time",
             "last_login_ip",
             "last_logout_ip",
             "last_login_uagent",
-            "last_location",
-            "last_login_medium",
-            "created_location",
+            "token_updated_at",
             "is_bot",
             "is_password_autoset",
             "is_email_verified",
             "is_active",
-            "token_updated_at",
         ]
+        extra_kwargs = {"password": {"write_only": True}}
 
         # If the user has already filled first name or last name then he is onboarded
         def get_is_onboarded(self, obj):
@@ -56,15 +43,12 @@ class UserSerializer(BaseSerializer):
 
 
 class UserMeSerializer(BaseSerializer):
-
     class Meta:
         model = User
         fields = [
             "id",
             "avatar",
             "cover_image",
-            "avatar_url",
-            "cover_image_url",
             "date_joined",
             "display_name",
             "email",
@@ -159,7 +143,6 @@ class UserLiteSerializer(BaseSerializer):
             "first_name",
             "last_name",
             "avatar",
-            "avatar_url",
             "is_bot",
             "display_name",
         ]
@@ -177,11 +160,9 @@ class UserAdminLiteSerializer(BaseSerializer):
             "first_name",
             "last_name",
             "avatar",
-            "avatar_url",
             "is_bot",
             "display_name",
             "email",
-            "last_login_medium",
         ]
         read_only_fields = [
             "id",
@@ -227,15 +208,9 @@ class ProfileSerializer(BaseSerializer):
     class Meta:
         model = Profile
         fields = "__all__"
-        read_only_fields = [
-            "user",
-        ]
 
 
 class AccountSerializer(BaseSerializer):
     class Meta:
         model = Account
         fields = "__all__"
-        read_only_fields = [
-            "user",
-        ]

apiserver/plane/app/serializers/webhook.py

@@ -40,7 +40,7 @@ class WebhookSerializer(DynamicBaseSerializer):
 
         for addr in ip_addresses:
             ip = ipaddress.ip_address(addr[4][0])
-            if ip.is_loopback:
+            if ip.is_private or ip.is_loopback:
                 raise serializers.ValidationError(
                     {"url": "URL resolves to a blocked IP address."}
                 )
@@ -92,7 +92,7 @@ class WebhookSerializer(DynamicBaseSerializer):
 
             for addr in ip_addresses:
                 ip = ipaddress.ip_address(addr[4][0])
-                if ip.is_loopback:
+                if ip.is_private or ip.is_loopback:
                     raise serializers.ValidationError(
                         {"url": "URL resolves to a blocked IP address."}
                     )

apiserver/plane/app/serializers/workspace.py

@@ -22,7 +22,6 @@ class WorkSpaceSerializer(DynamicBaseSerializer):
     owner = UserLiteSerializer(read_only=True)
     total_members = serializers.IntegerField(read_only=True)
     total_issues = serializers.IntegerField(read_only=True)
-    logo_url = serializers.CharField(read_only=True)
 
     def validate_slug(self, value):
         # Check if the slug is restricted
@@ -40,7 +39,6 @@ class WorkSpaceSerializer(DynamicBaseSerializer):
             "created_at",
             "updated_at",
             "owner",
-            "logo_url",
         ]
 
 
@@ -65,7 +63,6 @@ class WorkSpaceMemberSerializer(DynamicBaseSerializer):
 
 
 class WorkspaceMemberMeSerializer(BaseSerializer):
-    draft_issue_count = serializers.IntegerField(read_only=True)
     class Meta:
         model = WorkspaceMember
         fields = "__all__"

apiserver/plane/app/urls/__init__.py

@@ -5,7 +5,7 @@ from .cycle import urlpatterns as cycle_urls
 from .dashboard import urlpatterns as dashboard_urls
 from .estimate import urlpatterns as estimate_urls
 from .external import urlpatterns as external_urls
-from .intake import urlpatterns as intake_urls
+from .inbox import urlpatterns as inbox_urls
 from .issue import urlpatterns as issue_urls
 from .module import urlpatterns as module_urls
 from .notification import urlpatterns as notification_urls
@@ -25,7 +25,7 @@ urlpatterns = [
     *dashboard_urls,
     *estimate_urls,
     *external_urls,
-    *intake_urls,
+    *inbox_urls,
     *issue_urls,
     *module_urls,
     *notification_urls,

apiserver/plane/app/urls/api.py

@@ -1,5 +1,5 @@
 from django.urls import path
-from plane.app.views import ApiTokenEndpoint, ServiceApiTokenEndpoint
+from plane.app.views import ApiTokenEndpoint
 
 urlpatterns = [
     # API Tokens
@@ -13,10 +13,5 @@ urlpatterns = [
         ApiTokenEndpoint.as_view(),
         name="api-tokens",
     ),
-    path(
-        "workspaces/<str:slug>/service-api-tokens/",
-        ServiceApiTokenEndpoint.as_view(),
-        name="service-api-tokens",
-    ),
     ## End API Tokens
 ]

apiserver/plane/app/urls/asset.py

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

apiserver/plane/app/urls/cycle.py

@@ -6,8 +6,6 @@ from plane.app.views import (
     CycleIssueViewSet,
     CycleDateCheckEndpoint,
     CycleFavoriteViewSet,
-    CycleProgressEndpoint,
-    CycleAnalyticsEndpoint,
     TransferCycleIssueEndpoint,
     CycleUserPropertiesEndpoint,
     CycleArchiveUnarchiveEndpoint,
@@ -108,14 +106,4 @@ urlpatterns = [
         CycleArchiveUnarchiveEndpoint.as_view(),
         name="cycle-archive-unarchive",
     ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/progress/",
-        CycleProgressEndpoint.as_view(),
-        name="project-cycle",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/analytics/",
-        CycleAnalyticsEndpoint.as_view(),
-        name="project-cycle",
-    ),
 ]

apiserver/plane/app/urls/inbox.py

@@ -0,0 +1,53 @@
+from django.urls import path
+
+
+from plane.app.views import (
+    InboxViewSet,
+    InboxIssueViewSet,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/",
+        InboxViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="inbox",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:pk>/",
+        InboxViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="inbox",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
+        InboxIssueViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="inbox-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:issue_id>/",
+        InboxIssueViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="inbox-issue",
+    ),
+]

apiserver/plane/app/urls/intake.py

@@ -1,95 +0,0 @@
-from django.urls import path
-
-
-from plane.app.views import (
-    IntakeViewSet,
-    IntakeIssueViewSet,
-)
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intakes/",
-        IntakeViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
-        name="intake",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intakes/<uuid:pk>/",
-        IntakeViewSet.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="intake",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/",
-        IntakeIssueViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
-        name="intake-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/<uuid:pk>/",
-        IntakeIssueViewSet.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="intake-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/",
-        IntakeViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
-        name="inbox",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:pk>/",
-        IntakeViewSet.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="inbox",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
-        IntakeIssueViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
-        name="inbox-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:pk>/",
-        IntakeIssueViewSet.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="inbox-issue",
-    ),
-]