✨ feat: Add support for hardBreak extension

This commit adds support for the hardBreak extension in the `CoreEditorExtensions` component located at `packages/editor/core/src/ui/extensions/index.tsx`. The extension now includes an HTMLAttributes object with a class of "p-2" for styling purposes.

.github/ISSUE_TEMPLATE/--bug-report.yaml

@@ -2,7 +2,7 @@ name: Bug report
 description: Create a bug report to help us improve Plane
 title: "[bug]: "
 labels: [🐛bug]
-assignees: [srinivaspendem, pushya22]
+assignees: [srinivaspendem, pushya-plane]
 body:
 - type: markdown
   attributes:
@@ -45,7 +45,7 @@ body:
       - Deploy preview
   validations:
     required: true
-- type: dropdown
+  type: dropdown
   id: browser
   attributes:
     label: Browser

.github/ISSUE_TEMPLATE/--feature-request.yaml

@@ -2,7 +2,7 @@ name: Feature request
 description: Suggest a feature to improve Plane
 title: "[feature]: "
 labels: [✨feature]
-assignees: [srinivaspendem, pushya22]
+assignees: [srinivaspendem, pushya-plane]
 body:
 - type: markdown
   attributes:

.github/workflows/build-branch.yml

@@ -1,123 +1,99 @@
 name: Branch Build
 
 on:
-  workflow_dispatch:
-  push:
+  pull_request:
+    types:
+      - closed
     branches:
       - master
       - preview
+      - qa
       - develop
+      - release-*
   release:
     types: [released, prereleased]
 
 env:
-  TARGET_BRANCH: ${{ github.ref_name || github.event.release.target_commitish }}
+  TARGET_BRANCH: ${{ github.event.pull_request.base.ref || github.event.release.target_commitish }}
 
 jobs:
   branch_build_setup:
+    if: ${{ (github.event_name == 'pull_request' && github.event.action =='closed' && github.event.pull_request.merged == true) || github.event_name == 'release' }}
     name: Build-Push Web/Space/API/Proxy Docker Image
-    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 }}
-      gh_buildx_version: ${{ steps.set_env_variables.outputs.BUILDX_VERSION }}
-      gh_buildx_platforms: ${{ steps.set_env_variables.outputs.BUILDX_PLATFORMS }}
-      gh_buildx_endpoint: ${{ steps.set_env_variables.outputs.BUILDX_ENDPOINT }}
-      build_frontend: ${{ steps.changed_files.outputs.frontend_any_changed }}
-      build_space: ${{ steps.changed_files.outputs.space_any_changed }}
-      build_backend: ${{ steps.changed_files.outputs.backend_any_changed }}
-      build_proxy: ${{ steps.changed_files.outputs.proxy_any_changed }}
+    runs-on: ubuntu-20.04
 
     steps:
-      - id: set_env_variables
-        name: Set Environment Variables
-        run: |
-          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
-            echo "BUILDX_ENDPOINT=makeplane/plane-dev" >> $GITHUB_OUTPUT
-          else
-            echo "BUILDX_DRIVER=docker-container" >> $GITHUB_OUTPUT
-            echo "BUILDX_VERSION=latest" >> $GITHUB_OUTPUT
-            echo "BUILDX_PLATFORMS=linux/amd64" >> $GITHUB_OUTPUT
-            echo "BUILDX_ENDPOINT=" >> $GITHUB_OUTPUT
-          fi
-          echo "TARGET_BRANCH=${{ env.TARGET_BRANCH }}" >> $GITHUB_OUTPUT
+      - name: Check out the repo
+        uses: actions/checkout@v3.3.0
 
-      - id: checkout_files
-        name: Checkout Files
-        uses: actions/checkout@v4
-
-      - name: Get changed files
-        id: changed_files
-        uses: tj-actions/changed-files@v42
+      - name: Uploading Proxy Source
+        uses: actions/upload-artifact@v3
         with:
-          files_yaml: |
-            frontend:
-              - web/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
-            space:
-              - space/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
-            backend:
-              - apiserver/**
-            proxy:
-              - nginx/**
+          name: proxy-src-code
+          path: ./nginx
+      - name: Uploading Backend Source
+        uses: actions/upload-artifact@v3
+        with:
+          name: backend-src-code
+          path: ./apiserver
+      - name: Uploading Web Source
+        uses: actions/upload-artifact@v3
+        with:
+          name: web-src-code
+          path: |
+            ./
+            !./apiserver
+            !./nginx
+            !./deploy
+            !./space
+      - name: Uploading Space Source
+        uses: actions/upload-artifact@v3
+        with:
+          name: space-src-code
+          path: |
+            ./
+            !./apiserver
+            !./nginx
+            !./deploy
+            !./web
+    outputs:
+      gh_branch_name: ${{ env.TARGET_BRANCH }}
 
   branch_build_push_frontend:
-    if: ${{ needs.branch_build_setup.outputs.build_frontend == 'true' || 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: ${{ secrets.DOCKERHUB_USERNAME }}/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 }}
+      FRONTEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
     steps:
-      - name: Set Frontend Docker Tag
+      - name: Set Frontend Docker Tag 
         run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend:stable,${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend:${{ github.event.release.tag_name }}
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend:latest
+          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
+          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
           else
             TAG=${{ env.FRONTEND_TAG }}
           fi
           echo "FRONTEND_TAG=${TAG}" >> $GITHUB_ENV
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2.5.0
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2.1.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+      - name: Downloading Web Source Code
+        uses: actions/download-artifact@v3
         with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
-        uses: actions/checkout@v4
+          name: web-src-code
 
       - name: Build and Push Frontend to Docker Container Registry
-        uses: docker/build-push-action@v5.1.0
+        uses: docker/build-push-action@v4.0.0
         with:
           context: .
           file: ./web/Dockerfile.web
-          platforms: ${{ env.BUILDX_PLATFORMS }}
+          platforms: linux/amd64
           tags: ${{ env.FRONTEND_TAG }}
           push: true
         env:
@@ -126,50 +102,40 @@ jobs:
           DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
 
   branch_build_push_space:
-    if: ${{ needs.branch_build_setup.outputs.build_space == 'true' || 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: ${{ secrets.DOCKERHUB_USERNAME }}/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 }}
+      SPACE_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
     steps:
-      - name: Set Space Docker Tag
+      - name: Set Space Docker Tag 
         run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space:stable,${{ secrets.DOCKERHUB_USERNAME }}/plane-space:${{ github.event.release.tag_name }}
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space:latest
+          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
+          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
           else
             TAG=${{ env.SPACE_TAG }}
           fi
           echo "SPACE_TAG=${TAG}" >> $GITHUB_ENV
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2.5.0
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2.1.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+      - name: Downloading Space Source Code
+        uses: actions/download-artifact@v3
         with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
-        uses: actions/checkout@v4
+          name: space-src-code
 
       - name: Build and Push Space to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+        uses: docker/build-push-action@v4.0.0
         with:
           context: .
           file: ./space/Dockerfile.space
-          platforms: ${{ env.BUILDX_PLATFORMS }}
+          platforms: linux/amd64
           tags: ${{ env.SPACE_TAG }}
           push: true
         env:
@@ -178,50 +144,40 @@ jobs:
           DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
 
   branch_build_push_backend:
-    if: ${{ needs.branch_build_setup.outputs.build_backend == 'true' || 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: ${{ secrets.DOCKERHUB_USERNAME }}/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 }}
+      BACKEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
     steps:
-      - name: Set Backend Docker Tag
+      - name: Set Backend Docker Tag 
         run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend:stable,${{ secrets.DOCKERHUB_USERNAME }}/plane-backend:${{ github.event.release.tag_name }}
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend:latest
+          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
+          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
           else
             TAG=${{ env.BACKEND_TAG }}
           fi
           echo "BACKEND_TAG=${TAG}" >> $GITHUB_ENV
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2.5.0
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2.1.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+      - name: Downloading Backend Source Code
+        uses: actions/download-artifact@v3
         with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
-        uses: actions/checkout@v4
+          name: backend-src-code
 
       - name: Build and Push Backend to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+        uses: docker/build-push-action@v4.0.0
         with:
-          context: ./apiserver
-          file: ./apiserver/Dockerfile.api
-          platforms: ${{ env.BUILDX_PLATFORMS }}
+          context: .
+          file: ./Dockerfile.api
+          platforms: linux/amd64
           push: true
           tags: ${{ env.BACKEND_TAG }}
         env:
@@ -230,54 +186,44 @@ jobs:
           DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
 
   branch_build_push_proxy:
-    if: ${{ needs.branch_build_setup.outputs.build_proxy == 'true' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     runs-on: ubuntu-20.04
     needs: [branch_build_setup]
     env:
-      PROXY_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/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 }}
+      PROXY_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
     steps:
-      - name: Set Proxy Docker Tag
+      - name: Set Proxy Docker Tag 
         run: |
-          if [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy:stable,${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy:${{ github.event.release.tag_name }}
-          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy:latest
+          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
+          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
           else
             TAG=${{ env.PROXY_TAG }}
           fi
           echo "PROXY_TAG=${TAG}" >> $GITHUB_ENV
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2.5.0
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2.1.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+      - name: Downloading Proxy Source Code
+        uses: actions/download-artifact@v3
         with:
-          driver: ${{ env.BUILDX_DRIVER }}
-          version: ${{ env.BUILDX_VERSION }}
-          endpoint: ${{ env.BUILDX_ENDPOINT }}
-
-      - name: Check out the repo
-        uses: actions/checkout@v4
+          name: proxy-src-code
 
       - name: Build and Push Plane-Proxy to Docker Hub
-        uses: docker/build-push-action@v5.1.0
+        uses: docker/build-push-action@v4.0.0
         with:
-          context: ./nginx
-          file: ./nginx/Dockerfile
-          platforms: ${{ env.BUILDX_PLATFORMS }}
+          context: .
+          file: ./Dockerfile
+          platforms: linux/amd64
           tags: ${{ env.PROXY_TAG }}
           push: true
         env:
           DOCKER_BUILDKIT: 1
           DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
           DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
-

.github/workflows/build-test-pull-request.yml

@@ -21,6 +21,7 @@ jobs:
         uses: actions/setup-node@v2
         with:
           node-version: 18.x
+          cache: "yarn"
 
       - name: Get changed files
         id: changed-files

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

@@ -1,23 +1,25 @@
 name: Create Sync Action
 
 on:
-  workflow_dispatch:
-  push:
+  pull_request:
     branches:
       - preview
-
+    types:
+      - closed
 env:
-  SOURCE_BRANCH_NAME: ${{ github.ref_name }}
+  SOURCE_BRANCH_NAME: ${{github.event.pull_request.base.ref}}
 
 jobs:
   sync_changes:
+    # Only run the job when a PR is merged
+    if: github.event.pull_request.merged == true
     runs-on: ubuntu-latest
     permissions:
       pull-requests: write
       contents: read
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v2
         with:
           persist-credentials: false
           fetch-depth: 0
@@ -31,25 +33,14 @@ jobs:
           sudo apt update
           sudo apt install gh -y
 
-      - name: Push Changes to Target Repo A
+      - name: Push Changes to Target Repo
         env:
           GH_TOKEN: ${{ secrets.ACCESS_TOKEN }}
         run: |
-          TARGET_REPO="${{ secrets.TARGET_REPO_A }}"
-          TARGET_BRANCH="${{ secrets.TARGET_REPO_A_BRANCH_NAME }}"
+          TARGET_REPO="${{ secrets.SYNC_TARGET_REPO_NAME }}"
+          TARGET_BRANCH="${{ secrets.SYNC_TARGET_BRANCH_NAME }}"
           SOURCE_BRANCH="${{ env.SOURCE_BRANCH_NAME }}"
 
           git checkout $SOURCE_BRANCH
-          git remote add target-origin-a "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
-          git push target-origin-a $SOURCE_BRANCH:$TARGET_BRANCH
-
-      - name: Push Changes to Target Repo B
-        env:
-          GH_TOKEN: ${{ secrets.ACCESS_TOKEN }}
-        run: |
-          TARGET_REPO="${{ secrets.TARGET_REPO_B }}"
-          TARGET_BRANCH="${{ secrets.TARGET_REPO_B_BRANCH_NAME }}"
-          SOURCE_BRANCH="${{ env.SOURCE_BRANCH_NAME }}"
-
-          git remote add target-origin-b "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
-          git push target-origin-b $SOURCE_BRANCH:$TARGET_BRANCH
+          git remote add target-origin "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
+          git push target-origin $SOURCE_BRANCH:$TARGET_BRANCH

apiserver/Dockerfile.dev

@@ -33,10 +33,15 @@ RUN pip install -r requirements/local.txt --compile --no-cache-dir
 RUN addgroup -S plane && \
     adduser -S captain -G plane
 
-COPY . .
+RUN chown captain.plane /code
 
-RUN chown -R captain.plane /code
-RUN chmod -R +x /code/bin
+USER captain
+
+# Add in Django deps and generate Django's static files
+
+USER root
+
+# RUN chmod +x ./bin/takeoff ./bin/worker ./bin/beat
 RUN chmod -R 777 /code
 
 USER captain

apiserver/bin/beat

@@ -2,7 +2,4 @@
 set -e
 
 python manage.py wait_for_db
-# Wait for migrations
-python manage.py wait_for_migrations
-# Run the processes
 celery -A plane beat -l info

apiserver/bin/takeoff

@@ -1,8 +1,7 @@
 #!/bin/bash
 set -e
 python manage.py wait_for_db
-# Wait for migrations
-python manage.py wait_for_migrations
+python manage.py migrate
 
 # Create the default bucket
 #!/bin/bash

apiserver/bin/takeoff.local

@@ -1,8 +1,7 @@
 #!/bin/bash
 set -e
 python manage.py wait_for_db
-# Wait for migrations
-python manage.py wait_for_migrations
+python manage.py migrate
 
 # Create the default bucket
 #!/bin/bash

apiserver/bin/worker

@@ -2,7 +2,4 @@
 set -e
 
 python manage.py wait_for_db
-# Wait for migrations
-python manage.py wait_for_migrations
-# Run the processes
 celery -A plane worker -l info

apiserver/package.json

@@ -1,4 +1,4 @@
 {
   "name": "plane-api",
-  "version": "0.16.0"
+  "version": "0.14.0"
 }

apiserver/plane/api/views/base.py

@@ -1,8 +1,6 @@
 # Python imports
 import zoneinfo
 import json
-from urllib.parse import urlparse
-
 
 # Django imports
 from django.conf import settings
@@ -53,11 +51,6 @@ class WebhookMixin:
             and self.request.method in ["POST", "PATCH", "DELETE"]
             and response.status_code in [200, 201, 204]
         ):
-            url = request.build_absolute_uri()
-            parsed_url = urlparse(url)
-            # Extract the scheme and netloc
-            scheme = parsed_url.scheme
-            netloc = parsed_url.netloc
             # Push the object to delay
             send_webhook.delay(
                 event=self.webhook_event,
@@ -66,7 +59,6 @@ class WebhookMixin:
                 action=self.request.method,
                 slug=self.workspace_slug,
                 bulk=self.bulk,
-                current_site=f"{scheme}://{netloc}",
             )
 
         return response

apiserver/plane/api/views/cycle.py

@@ -45,10 +45,7 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
         return (
             Cycle.objects.filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
+            .filter(project__project_projectmember__member=self.request.user)
             .select_related("project")
             .select_related("workspace")
             .select_related("owned_by")
@@ -246,29 +243,6 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
         ):
             serializer = CycleSerializer(data=request.data)
             if serializer.is_valid():
-                if (
-                    request.data.get("external_id")
-                    and request.data.get("external_source")
-                    and Cycle.objects.filter(
-                        project_id=project_id,
-                        workspace__slug=slug,
-                        external_source=request.data.get("external_source"),
-                        external_id=request.data.get("external_id"),
-                    ).exists()
-                ):
-                    cycle = Cycle.objects.filter(
-                        workspace__slug=slug,
-                        project_id=project_id,
-                        external_source=request.data.get("external_source"),
-                        external_id=request.data.get("external_id"),
-                    ).first()
-                    return Response(
-                        {
-                            "error": "Cycle with the same external id and external source already exists",
-                            "id": str(cycle.id),
-                        },
-                        status=status.HTTP_409_CONFLICT,
-                    )
                 serializer.save(
                     project_id=project_id,
                     owned_by=request.user,
@@ -315,23 +289,6 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
 
         serializer = CycleSerializer(cycle, data=request.data, partial=True)
         if serializer.is_valid():
-            if (
-                request.data.get("external_id")
-                and (cycle.external_id != request.data.get("external_id"))
-                and Cycle.objects.filter(
-                    project_id=project_id,
-                    workspace__slug=slug,
-                    external_source=request.data.get("external_source", cycle.external_source),
-                    external_id=request.data.get("external_id"),
-                ).exists()
-            ):
-                return Response(
-                    {
-                        "error": "Cycle with the same external id and external source already exists",
-                        "id": str(cycle.id),
-                    },
-                    status=status.HTTP_409_CONFLICT,
-                )
             serializer.save()
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -393,10 +350,7 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
             )
             .filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
+            .filter(project__project_projectmember__member=self.request.user)
             .filter(cycle_id=self.kwargs.get("cycle_id"))
             .select_related("project")
             .select_related("workspace")

apiserver/plane/api/views/issue.py

@@ -220,30 +220,6 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
         )
 
         if serializer.is_valid():
-            if (
-                request.data.get("external_id")
-                and request.data.get("external_source")
-                and Issue.objects.filter(
-                    project_id=project_id,
-                    workspace__slug=slug,
-                    external_source=request.data.get("external_source"),
-                    external_id=request.data.get("external_id"),
-                ).exists()
-            ):
-                issue = Issue.objects.filter(
-                    workspace__slug=slug,
-                    project_id=project_id,
-                    external_id=request.data.get("external_id"),
-                    external_source=request.data.get("external_source"),
-                ).first()
-                return Response(
-                    {
-                        "error": "Issue with the same external id and external source already exists",
-                        "id": str(issue.id),
-                    },
-                    status=status.HTTP_409_CONFLICT,
-                )
-
             serializer.save()
 
             # Track the issue
@@ -280,26 +256,6 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
             partial=True,
         )
         if serializer.is_valid():
-            if (
-                str(request.data.get("external_id"))
-                and (issue.external_id != str(request.data.get("external_id")))
-                and Issue.objects.filter(
-                    project_id=project_id,
-                    workspace__slug=slug,
-                    external_source=request.data.get(
-                        "external_source", issue.external_source
-                    ),
-                    external_id=request.data.get("external_id"),
-                ).exists()
-            ):
-                return Response(
-                    {
-                        "error": "Issue with the same external id and external source already exists",
-                        "id": str(issue.id),
-                    },
-                    status=status.HTTP_409_CONFLICT,
-                )
-
             serializer.save()
             issue_activity.delay(
                 type="issue.activity.updated",
@@ -307,8 +263,6 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
                 actor_id=str(request.user.id),
                 issue_id=str(pk),
                 project_id=str(project_id),
-                external_id__isnull=False,
-                external_source__isnull=False,
                 current_instance=current_instance,
                 epoch=int(timezone.now().timestamp()),
             )
@@ -352,10 +306,7 @@ class LabelAPIEndpoint(BaseAPIView):
         return (
             Label.objects.filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
+            .filter(project__project_projectmember__member=self.request.user)
             .select_related("project")
             .select_related("workspace")
             .select_related("parent")
@@ -367,30 +318,6 @@ class LabelAPIEndpoint(BaseAPIView):
         try:
             serializer = LabelSerializer(data=request.data)
             if serializer.is_valid():
-                if (
-                    request.data.get("external_id")
-                    and request.data.get("external_source")
-                    and Label.objects.filter(
-                        project_id=project_id,
-                        workspace__slug=slug,
-                        external_source=request.data.get("external_source"),
-                        external_id=request.data.get("external_id"),
-                    ).exists()
-                ):
-                    label = Label.objects.filter(
-                        workspace__slug=slug,
-                        project_id=project_id,
-                        external_id=request.data.get("external_id"),
-                        external_source=request.data.get("external_source"),
-                    ).first()
-                    return Response(
-                        {
-                            "error": "Label with the same external id and external source already exists",
-                            "id": str(label.id),
-                        },
-                        status=status.HTTP_409_CONFLICT,
-                    )
-
                 serializer.save(project_id=project_id)
                 return Response(
                     serializer.data, status=status.HTTP_201_CREATED
@@ -399,17 +326,11 @@ class LabelAPIEndpoint(BaseAPIView):
                 serializer.errors, status=status.HTTP_400_BAD_REQUEST
             )
         except IntegrityError:
-            label = Label.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                name=request.data.get("name"),
-            ).first()
             return Response(
                 {
-                    "error": "Label with the same name already exists in the project",
-                    "id": str(label.id),
+                    "error": "Label with the same name already exists in the project"
                 },
-                status=status.HTTP_409_CONFLICT,
+                status=status.HTTP_400_BAD_REQUEST,
             )
 
     def get(self, request, slug, project_id, pk=None):
@@ -436,25 +357,6 @@ class LabelAPIEndpoint(BaseAPIView):
         label = self.get_queryset().get(pk=pk)
         serializer = LabelSerializer(label, data=request.data, partial=True)
         if serializer.is_valid():
-            if (
-                str(request.data.get("external_id"))
-                and (label.external_id != str(request.data.get("external_id")))
-                and Issue.objects.filter(
-                    project_id=project_id,
-                    workspace__slug=slug,
-                    external_source=request.data.get(
-                        "external_source", label.external_source
-                    ),
-                    external_id=request.data.get("external_id"),
-                ).exists()
-            ):
-                return Response(
-                    {
-                        "error": "Label with the same external id and external source already exists",
-                        "id": str(label.id),
-                    },
-                    status=status.HTTP_409_CONFLICT,
-                )
             serializer.save()
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -484,10 +386,7 @@ class IssueLinkAPIEndpoint(BaseAPIView):
             IssueLink.objects.filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
             .filter(issue_id=self.kwargs.get("issue_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
+            .filter(project__project_projectmember__member=self.request.user)
             .order_by(self.kwargs.get("order_by", "-created_at"))
             .distinct()
         )
@@ -613,11 +512,11 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
             )
             .filter(project_id=self.kwargs.get("project_id"))
             .filter(issue_id=self.kwargs.get("issue_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
-            .select_related("workspace", "project", "issue", "actor")
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .select_related("actor")
             .annotate(
                 is_member=Exists(
                     ProjectMember.objects.filter(
@@ -653,33 +552,6 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
         )
 
     def post(self, request, slug, project_id, issue_id):
-
-        # Validation check if the issue already exists
-        if (
-            request.data.get("external_id")
-            and request.data.get("external_source")
-            and IssueComment.objects.filter(
-                project_id=project_id,
-                workspace__slug=slug,
-                external_source=request.data.get("external_source"),
-                external_id=request.data.get("external_id"),
-            ).exists()
-        ):
-            issue_comment = IssueComment.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                external_id=request.data.get("external_id"),
-                external_source=request.data.get("external_source"),
-            ).first()
-            return Response(
-                {
-                    "error": "Issue Comment with the same external id and external source already exists",
-                    "id": str(issue_comment.id),
-                },
-                status=status.HTTP_409_CONFLICT,
-            )
-
-
         serializer = IssueCommentSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save(
@@ -713,29 +585,6 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
             IssueCommentSerializer(issue_comment).data,
             cls=DjangoJSONEncoder,
         )
-
-        # Validation check if the issue already exists
-        if (
-            str(request.data.get("external_id"))
-            and (issue_comment.external_id != str(request.data.get("external_id")))
-            and Issue.objects.filter(
-                project_id=project_id,
-                workspace__slug=slug,
-                external_source=request.data.get(
-                    "external_source", issue_comment.external_source
-                ),
-                external_id=request.data.get("external_id"),
-            ).exists()
-        ):
-            return Response(
-                {
-                    "error": "Issue Comment with the same external id and external source already exists",
-                    "id": str(issue_comment.id),
-                },
-                status=status.HTTP_409_CONFLICT,
-            )
-
-
         serializer = IssueCommentSerializer(
             issue_comment, data=request.data, partial=True
         )
@@ -790,7 +639,6 @@ class IssueActivityAPIEndpoint(BaseAPIView):
             .filter(
                 ~Q(field__in=["comment", "vote", "reaction", "draft"]),
                 project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
             )
             .select_related("actor", "workspace", "issue", "project")
         ).order_by(request.GET.get("order_by", "created_at"))

apiserver/plane/api/views/module.py

@@ -132,29 +132,6 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
             },
         )
         if serializer.is_valid():
-            if (
-                request.data.get("external_id")
-                and request.data.get("external_source")
-                and Module.objects.filter(
-                    project_id=project_id,
-                    workspace__slug=slug,
-                    external_source=request.data.get("external_source"),
-                    external_id=request.data.get("external_id"),
-                ).exists()
-            ):
-                module = Module.objects.filter(
-                    project_id=project_id,
-                    workspace__slug=slug,
-                    external_source=request.data.get("external_source"),
-                    external_id=request.data.get("external_id"),
-                ).first()
-                return Response(
-                    {
-                        "error": "Module with the same external id and external source already exists",
-                        "id": str(module.id),
-                    },
-                    status=status.HTTP_409_CONFLICT,
-                )
             serializer.save()
             module = Module.objects.get(pk=serializer.data["id"])
             serializer = ModuleSerializer(module)
@@ -172,25 +149,8 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
             partial=True,
         )
         if serializer.is_valid():
-            if (
-                request.data.get("external_id")
-                and (module.external_id != request.data.get("external_id"))
-                and Module.objects.filter(
-                    project_id=project_id,
-                    workspace__slug=slug,
-                    external_source=request.data.get("external_source", module.external_source),
-                    external_id=request.data.get("external_id"),
-                ).exists()
-            ):
-                return Response(
-                    {
-                        "error": "Module with the same external id and external source already exists",
-                        "id": str(module.id),
-                    },
-                    status=status.HTTP_409_CONFLICT,
-                )
             serializer.save()
-            return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def get(self, request, slug, project_id, pk=None):
@@ -273,10 +233,7 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
             .filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
             .filter(module_id=self.kwargs.get("module_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
+            .filter(project__project_projectmember__member=self.request.user)
             .select_related("project")
             .select_related("workspace")
             .select_related("module")

apiserver/plane/api/views/state.py

@@ -1,5 +1,7 @@
+# Python imports
+from itertools import groupby
+
 # Django imports
-from django.db import IntegrityError
 from django.db.models import Q
 
 # Third party imports
@@ -24,10 +26,7 @@ class StateAPIEndpoint(BaseAPIView):
         return (
             State.objects.filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
+            .filter(project__project_projectmember__member=self.request.user)
             .filter(~Q(name="Triage"))
             .select_related("project")
             .select_related("workspace")
@@ -35,51 +34,13 @@ class StateAPIEndpoint(BaseAPIView):
         )
 
     def post(self, request, slug, project_id):
-        try:
-            serializer = StateSerializer(
-                data=request.data, context={"project_id": project_id}
-            )
-            if serializer.is_valid():
-                if (
-                    request.data.get("external_id")
-                    and request.data.get("external_source")
-                    and State.objects.filter(
-                        project_id=project_id,
-                        workspace__slug=slug,
-                        external_source=request.data.get("external_source"),
-                        external_id=request.data.get("external_id"),
-                    ).exists()
-                ):
-                    state = State.objects.filter(
-                        workspace__slug=slug,
-                        project_id=project_id,
-                        external_id=request.data.get("external_id"),
-                        external_source=request.data.get("external_source"),
-                    ).first()
-                    return Response(
-                        {
-                            "error": "State with the same external id and external source already exists",
-                            "id": str(state.id),
-                        },
-                        status=status.HTTP_409_CONFLICT,
-                    )
-
-                serializer.save(project_id=project_id)
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError as e:
-            state = State.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                name=request.data.get("name"),
-            ).first()
-            return Response(
-                {
-                    "error": "State with the same name already exists in the project",
-                    "id": str(state.id),
-                },
-                status=status.HTTP_409_CONFLICT,
-            )
+        serializer = StateSerializer(
+            data=request.data, context={"project_id": project_id}
+        )
+        if serializer.is_valid():
+            serializer.save(project_id=project_id)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def get(self, request, slug, project_id, state_id=None):
         if state_id:
@@ -130,23 +91,6 @@ class StateAPIEndpoint(BaseAPIView):
         )
         serializer = StateSerializer(state, data=request.data, partial=True)
         if serializer.is_valid():
-            if (
-                str(request.data.get("external_id"))
-                and (state.external_id != str(request.data.get("external_id")))
-                and State.objects.filter(
-                    project_id=project_id,
-                    workspace__slug=slug,
-                    external_source=request.data.get("external_source", state.external_source),
-                    external_id=request.data.get("external_id"),
-                ).exists()
-            ):
-                return Response(
-                    {
-                        "error": "State with the same external id and external source already exists",
-                        "id": str(state.id),
-                    },
-                    status=status.HTTP_409_CONFLICT,
-                )
             serializer.save()
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/app/serializers/__init__.py

@@ -68,14 +68,9 @@ from .issue import (
     IssueRelationSerializer,
     RelatedIssueSerializer,
     IssuePublicSerializer,
-    IssueDetailSerializer,
-    IssueReactionLiteSerializer,
-    IssueAttachmentLiteSerializer,
-    IssueLinkLiteSerializer,
 )
 
 from .module import (
-    ModuleDetailSerializer,
     ModuleWriteSerializer,
     ModuleSerializer,
     ModuleIssueSerializer,
@@ -109,19 +104,17 @@ from .estimate import (
     EstimateSerializer,
     EstimatePointSerializer,
     EstimateReadSerializer,
-    WorkspaceEstimateSerializer,
 )
 
 from .inbox import (
     InboxSerializer,
     InboxIssueSerializer,
     IssueStateInboxSerializer,
-    InboxIssueLiteSerializer,
 )
 
 from .analytic import AnalyticViewSerializer
 
-from .notification import NotificationSerializer, UserNotificationPreferenceSerializer
+from .notification import NotificationSerializer
 
 from .exporter import ExporterHistorySerializer
 

apiserver/plane/app/serializers/base.py

@@ -58,12 +58,8 @@ class DynamicBaseSerializer(BaseSerializer):
                     IssueSerializer,
                     LabelSerializer,
                     CycleIssueSerializer,
-                    IssueLiteSerializer,
+                    IssueFlatSerializer,
                     IssueRelationSerializer,
-                    InboxIssueLiteSerializer,
-                    IssueReactionLiteSerializer,
-                    IssueAttachmentLiteSerializer,
-                    IssueLinkLiteSerializer,
                 )
 
                 # Expansion mapper
@@ -82,34 +78,11 @@ class DynamicBaseSerializer(BaseSerializer):
                     "assignees": UserLiteSerializer,
                     "labels": LabelSerializer,
                     "issue_cycle": CycleIssueSerializer,
-                    "parent": IssueLiteSerializer,
+                    "parent": IssueSerializer,
                     "issue_relation": IssueRelationSerializer,
-                    "issue_inbox": InboxIssueLiteSerializer,
-                    "issue_reactions": IssueReactionLiteSerializer,
-                    "issue_attachment": IssueAttachmentLiteSerializer,
-                    "issue_link": IssueLinkLiteSerializer,
-                    "sub_issues": IssueLiteSerializer,
                 }
-
-                self.fields[field] = expansion[field](
-                    many=(
-                        True
-                        if field
-                        in [
-                            "members",
-                            "assignees",
-                            "labels",
-                            "issue_cycle",
-                            "issue_relation",
-                            "issue_inbox",
-                            "issue_reactions",
-                            "issue_attachment",
-                            "issue_link",
-                            "sub_issues",
-                        ]
-                        else False
-                    )
-                )
+                
+                self.fields[field] = expansion[field](many=True if field in ["members", "assignees", "labels", "issue_cycle", "issue_relation"] else False)            
 
         return self.fields
 
@@ -130,11 +103,6 @@ class DynamicBaseSerializer(BaseSerializer):
                         LabelSerializer,
                         CycleIssueSerializer,
                         IssueRelationSerializer,
-                        InboxIssueLiteSerializer,
-                        IssueLiteSerializer,
-                        IssueReactionLiteSerializer,
-                        IssueAttachmentLiteSerializer,
-                        IssueLinkLiteSerializer,
                     )
 
                     # Expansion mapper
@@ -153,13 +121,8 @@ class DynamicBaseSerializer(BaseSerializer):
                         "assignees": UserLiteSerializer,
                         "labels": LabelSerializer,
                         "issue_cycle": CycleIssueSerializer,
-                        "parent": IssueLiteSerializer,
-                        "issue_relation": IssueRelationSerializer,
-                        "issue_inbox": InboxIssueLiteSerializer,
-                        "issue_reactions": IssueReactionLiteSerializer,
-                        "issue_attachment": IssueAttachmentLiteSerializer,
-                        "issue_link": IssueLinkLiteSerializer,
-                        "sub_issues": IssueLiteSerializer,
+                        "parent": IssueSerializer,
+                        "issue_relation": IssueRelationSerializer
                     }
                     # Check if field in expansion then expand the field
                     if expand in expansion:

apiserver/plane/app/serializers/cycle.py

@@ -3,7 +3,10 @@ from rest_framework import serializers
 
 # Module imports
 from .base import BaseSerializer
+from .user import UserLiteSerializer
 from .issue import IssueStateSerializer
+from .workspace import WorkspaceLiteSerializer
+from .project import ProjectLiteSerializer
 from plane.db.models import (
     Cycle,
     CycleIssue,
@@ -11,6 +14,7 @@ from plane.db.models import (
     CycleUserProperties,
 )
 
+
 class CycleWriteSerializer(BaseSerializer):
     def validate(self, data):
         if (
@@ -26,57 +30,66 @@ class CycleWriteSerializer(BaseSerializer):
     class Meta:
         model = Cycle
         fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "owned_by",
-        ]
 
 
 class CycleSerializer(BaseSerializer):
-    # favorite
+    owned_by = UserLiteSerializer(read_only=True)
     is_favorite = serializers.BooleanField(read_only=True)
     total_issues = serializers.IntegerField(read_only=True)
-    # state group wise distribution
     cancelled_issues = serializers.IntegerField(read_only=True)
     completed_issues = serializers.IntegerField(read_only=True)
     started_issues = serializers.IntegerField(read_only=True)
     unstarted_issues = serializers.IntegerField(read_only=True)
     backlog_issues = serializers.IntegerField(read_only=True)
-
-    # active | draft | upcoming | completed
+    assignees = serializers.SerializerMethodField(read_only=True)
+    total_estimates = serializers.IntegerField(read_only=True)
+    completed_estimates = serializers.IntegerField(read_only=True)
+    started_estimates = serializers.IntegerField(read_only=True)
+    workspace_detail = WorkspaceLiteSerializer(
+        read_only=True, source="workspace"
+    )
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
     status = serializers.CharField(read_only=True)
 
+    def validate(self, data):
+        if (
+            data.get("start_date", None) is not None
+            and data.get("end_date", None) is not None
+            and data.get("start_date", None) > data.get("end_date", None)
+        ):
+            raise serializers.ValidationError(
+                "Start date cannot exceed end date"
+            )
+        return data
+
+    def get_assignees(self, obj):
+        members = [
+            {
+                "avatar": assignee.avatar,
+                "display_name": assignee.display_name,
+                "id": assignee.id,
+            }
+            for issue_cycle in obj.issue_cycle.prefetch_related(
+                "issue__assignees"
+            ).all()
+            for assignee in issue_cycle.issue.assignees.all()
+        ]
+        # Use a set comprehension to return only the unique objects
+        unique_objects = {frozenset(item.items()) for item in members}
+
+        # Convert the set back to a list of dictionaries
+        unique_list = [dict(item) for item in unique_objects]
+
+        return unique_list
 
     class Meta:
         model = Cycle
-        fields = [
-            # necessary fields
-            "id",
-            "workspace_id",
-            "project_id",
-            # model fields
-            "name",
-            "description",
-            "start_date",
-            "end_date",
-            "owned_by_id",
-            "view_props",
-            "sort_order",
-            "external_source",
-            "external_id",
-            "progress_snapshot",
-            # meta fields
-            "is_favorite",
-            "total_issues",
-            "cancelled_issues",
-            "completed_issues",
-            "started_issues",
-            "unstarted_issues",
-            "backlog_issues",
-            "status",
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "owned_by",
         ]
-        read_only_fields = fields
 
 
 class CycleIssueSerializer(BaseSerializer):

apiserver/plane/app/serializers/estimate.py

@@ -61,18 +61,3 @@ class EstimateReadSerializer(BaseSerializer):
             "name",
             "description",
         ]
-
-
-class WorkspaceEstimateSerializer(BaseSerializer):
-    points = EstimatePointSerializer(read_only=True, many=True)
-
-    class Meta:
-        model = Estimate
-        fields = "__all__"
-        read_only_fields = [
-            "points",
-            "name",
-            "description",
-        ]
-
-

apiserver/plane/app/serializers/issue.py

@@ -259,17 +259,14 @@ class IssuePropertySerializer(BaseSerializer):
 
 
 class LabelSerializer(BaseSerializer):
+    workspace_detail = WorkspaceLiteSerializer(
+        source="workspace", read_only=True
+    )
+    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+
     class Meta:
         model = Label
-        fields = [
-            "parent",
-            "name",
-            "color",
-            "id",
-            "project_id",
-            "workspace_id",
-            "sort_order",
-        ]
+        fields = "__all__"
         read_only_fields = [
             "workspace",
             "project",
@@ -298,13 +295,8 @@ class IssueLabelSerializer(BaseSerializer):
 
 class IssueRelationSerializer(BaseSerializer):
     id = serializers.UUIDField(source="related_issue.id", read_only=True)
-    project_id = serializers.PrimaryKeyRelatedField(
-        source="related_issue.project_id", read_only=True
-    )
-    sequence_id = serializers.IntegerField(
-        source="related_issue.sequence_id", read_only=True
-    )
-    name = serializers.CharField(source="related_issue.name", read_only=True)
+    project_id = serializers.PrimaryKeyRelatedField(source="related_issue.project_id", read_only=True)
+    sequence_id = serializers.IntegerField(source="related_issue.sequence_id", read_only=True)
     relation_type = serializers.CharField(read_only=True)
 
     class Meta:
@@ -314,7 +306,6 @@ class IssueRelationSerializer(BaseSerializer):
             "project_id",
             "sequence_id",
             "relation_type",
-            "name",
         ]
         read_only_fields = [
             "workspace",
@@ -324,13 +315,8 @@ class IssueRelationSerializer(BaseSerializer):
 
 class RelatedIssueSerializer(BaseSerializer):
     id = serializers.UUIDField(source="issue.id", read_only=True)
-    project_id = serializers.PrimaryKeyRelatedField(
-        source="issue.project_id", read_only=True
-    )
-    sequence_id = serializers.IntegerField(
-        source="issue.sequence_id", read_only=True
-    )
-    name = serializers.CharField(source="issue.name", read_only=True)
+    project_id = serializers.PrimaryKeyRelatedField(source="issue.project_id", read_only=True)
+    sequence_id = serializers.IntegerField(source="issue.sequence_id", read_only=True)
     relation_type = serializers.CharField(read_only=True)
 
     class Meta:
@@ -340,7 +326,6 @@ class RelatedIssueSerializer(BaseSerializer):
             "project_id",
             "sequence_id",
             "relation_type",
-            "name",
         ]
         read_only_fields = [
             "workspace",
@@ -444,22 +429,6 @@ class IssueLinkSerializer(BaseSerializer):
         return IssueLink.objects.create(**validated_data)
 
 
-class IssueLinkLiteSerializer(BaseSerializer):
-
-    class Meta:
-        model = IssueLink
-        fields = [
-            "id",
-            "issue_id",
-            "title",
-            "url",
-            "metadata",
-            "created_by_id",
-            "created_at",
-        ]
-        read_only_fields = fields
-
-
 class IssueAttachmentSerializer(BaseSerializer):
     class Meta:
         model = IssueAttachment
@@ -475,21 +444,6 @@ class IssueAttachmentSerializer(BaseSerializer):
         ]
 
 
-class IssueAttachmentLiteSerializer(DynamicBaseSerializer):
-
-    class Meta:
-        model = IssueAttachment
-        fields = [
-            "id",
-            "asset",
-            "attributes",
-            "issue_id",
-            "updated_at",
-            "updated_by_id",
-        ]
-        read_only_fields = fields
-
-
 class IssueReactionSerializer(BaseSerializer):
     actor_detail = UserLiteSerializer(read_only=True, source="actor")
 
@@ -504,15 +458,16 @@ class IssueReactionSerializer(BaseSerializer):
         ]
 
 
-class IssueReactionLiteSerializer(DynamicBaseSerializer):
+class CommentReactionLiteSerializer(BaseSerializer):
+    actor_detail = UserLiteSerializer(read_only=True, source="actor")
 
     class Meta:
-        model = IssueReaction
+        model = CommentReaction
         fields = [
             "id",
-            "actor_id",
-            "issue_id",
             "reaction",
+            "comment",
+            "actor_detail",
         ]
 
 
@@ -546,7 +501,9 @@ class IssueCommentSerializer(BaseSerializer):
     workspace_detail = WorkspaceLiteSerializer(
         read_only=True, source="workspace"
     )
-    comment_reactions = CommentReactionSerializer(read_only=True, many=True)
+    comment_reactions = CommentReactionLiteSerializer(
+        read_only=True, many=True
+    )
     is_member = serializers.BooleanField(read_only=True)
 
     class Meta:
@@ -599,17 +556,18 @@ class IssueStateSerializer(DynamicBaseSerializer):
 
 class IssueSerializer(DynamicBaseSerializer):
     # ids
+    project_id = serializers.PrimaryKeyRelatedField(read_only=True)
+    state_id = serializers.PrimaryKeyRelatedField(read_only=True)
+    parent_id = serializers.PrimaryKeyRelatedField(read_only=True)
     cycle_id = serializers.PrimaryKeyRelatedField(read_only=True)
-    module_ids = serializers.ListField(
-        child=serializers.UUIDField(), required=False,
-    )
+    module_id = serializers.PrimaryKeyRelatedField(read_only=True)
 
     # Many to many
-    label_ids = serializers.ListField(
-        child=serializers.UUIDField(), required=False,
+    label_ids = serializers.PrimaryKeyRelatedField(
+        read_only=True, many=True, source="labels"
     )
-    assignee_ids = serializers.ListField(
-        child=serializers.UUIDField(), required=False,
+    assignee_ids = serializers.PrimaryKeyRelatedField(
+        read_only=True, many=True, source="assignees"
     )
 
     # Count items
@@ -617,12 +575,16 @@ class IssueSerializer(DynamicBaseSerializer):
     attachment_count = serializers.IntegerField(read_only=True)
     link_count = serializers.IntegerField(read_only=True)
 
+    # is_subscribed
+    is_subscribed = serializers.BooleanField(read_only=True)
+
     class Meta:
         model = Issue
         fields = [
             "id",
             "name",
             "state_id",
+            "description_html",
             "sort_order",
             "completed_at",
             "estimate_point",
@@ -633,7 +595,7 @@ class IssueSerializer(DynamicBaseSerializer):
             "project_id",
             "parent_id",
             "cycle_id",
-            "module_ids",
+            "module_id",
             "label_ids",
             "assignee_ids",
             "sub_issues_count",
@@ -643,45 +605,46 @@ class IssueSerializer(DynamicBaseSerializer):
             "updated_by",
             "attachment_count",
             "link_count",
+            "is_subscribed",
             "is_draft",
             "archived_at",
         ]
         read_only_fields = fields
 
 
-class IssueDetailSerializer(IssueSerializer):
-    description_html = serializers.CharField()
-    is_subscribed = serializers.BooleanField(read_only=True)
-
-    class Meta(IssueSerializer.Meta):
-        fields = IssueSerializer.Meta.fields + [
-            "description_html",
-            "is_subscribed",
-        ]
-
-
 class IssueLiteSerializer(DynamicBaseSerializer):
+    workspace_detail = WorkspaceLiteSerializer(
+        read_only=True, source="workspace"
+    )
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    state_detail = StateLiteSerializer(read_only=True, source="state")
+    label_details = LabelLiteSerializer(
+        read_only=True, source="labels", many=True
+    )
+    assignee_details = UserLiteSerializer(
+        read_only=True, source="assignees", many=True
+    )
+    sub_issues_count = serializers.IntegerField(read_only=True)
+    cycle_id = serializers.UUIDField(read_only=True)
+    module_id = serializers.UUIDField(read_only=True)
+    attachment_count = serializers.IntegerField(read_only=True)
+    link_count = serializers.IntegerField(read_only=True)
+    issue_reactions = IssueReactionSerializer(read_only=True, many=True)
 
     class Meta:
         model = Issue
-        fields = [
-            "id",
-            "sequence_id",
-            "project_id",
+        fields = "__all__"
+        read_only_fields = [
+            "start_date",
+            "target_date",
+            "completed_at",
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
         ]
-        read_only_fields = fields
-
-
-class IssueDetailSerializer(IssueSerializer):
-    description_html = serializers.CharField()
-    is_subscribed = serializers.BooleanField()
-
-    class Meta(IssueSerializer.Meta):
-        fields = IssueSerializer.Meta.fields + [
-            "description_html",
-            "is_subscribed",
-        ]
-        read_only_fields = fields
 
 
 class IssuePublicSerializer(BaseSerializer):

apiserver/plane/app/serializers/module.py

@@ -5,6 +5,7 @@ from rest_framework import serializers
 from .base import BaseSerializer, DynamicBaseSerializer
 from .user import UserLiteSerializer
 from .project import ProjectLiteSerializer
+from .workspace import WorkspaceLiteSerializer
 
 from plane.db.models import (
     User,
@@ -18,18 +19,17 @@ from plane.db.models import (
 
 
 class ModuleWriteSerializer(BaseSerializer):
-    lead_id = serializers.PrimaryKeyRelatedField(
-        source="lead",
-        queryset=User.objects.all(),
-        required=False,
-        allow_null=True,
-    )
-    member_ids = serializers.ListField(
+    members = serializers.ListField(
         child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
         write_only=True,
         required=False,
     )
 
+    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+    workspace_detail = WorkspaceLiteSerializer(
+        source="workspace", read_only=True
+    )
+
     class Meta:
         model = Module
         fields = "__all__"
@@ -44,9 +44,7 @@ class ModuleWriteSerializer(BaseSerializer):
 
     def to_representation(self, instance):
         data = super().to_representation(instance)
-        data["member_ids"] = [
-            str(member.id) for member in instance.members.all()
-        ]
+        data["members"] = [str(member.id) for member in instance.members.all()]
         return data
 
     def validate(self, data):
@@ -61,10 +59,12 @@ class ModuleWriteSerializer(BaseSerializer):
         return data
 
     def create(self, validated_data):
-        members = validated_data.pop("member_ids", None)
+        members = validated_data.pop("members", None)
+
         project = self.context["project"]
 
         module = Module.objects.create(**validated_data, project=project)
+
         if members is not None:
             ModuleMember.objects.bulk_create(
                 [
@@ -85,7 +85,7 @@ class ModuleWriteSerializer(BaseSerializer):
         return module
 
     def update(self, instance, validated_data):
-        members = validated_data.pop("member_ids", None)
+        members = validated_data.pop("members", None)
 
         if members is not None:
             ModuleMember.objects.filter(module=instance).delete()
@@ -142,6 +142,7 @@ class ModuleIssueSerializer(BaseSerializer):
 
 
 class ModuleLinkSerializer(BaseSerializer):
+    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
 
     class Meta:
         model = ModuleLink
@@ -169,9 +170,12 @@ class ModuleLinkSerializer(BaseSerializer):
 
 
 class ModuleSerializer(DynamicBaseSerializer):
-    member_ids = serializers.ListField(
-        child=serializers.UUIDField(), required=False, allow_null=True
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    lead_detail = UserLiteSerializer(read_only=True, source="lead")
+    members_detail = UserLiteSerializer(
+        read_only=True, many=True, source="members"
     )
+    link_module = ModuleLinkSerializer(read_only=True, many=True)
     is_favorite = serializers.BooleanField(read_only=True)
     total_issues = serializers.IntegerField(read_only=True)
     cancelled_issues = serializers.IntegerField(read_only=True)
@@ -182,46 +186,15 @@ class ModuleSerializer(DynamicBaseSerializer):
 
     class Meta:
         model = Module
-        fields = [
-            # Required fields
-            "id",
-            "workspace_id",
-            "project_id",
-            # Model fields
-            "name",
-            "description",
-            "description_text",
-            "description_html",
-            "start_date",
-            "target_date",
-            "status",
-            "lead_id",
-            "member_ids",
-            "view_props",
-            "sort_order",
-            "external_source",
-            "external_id",
-            # computed fields
-            "is_favorite",
-            "total_issues",
-            "cancelled_issues",
-            "completed_issues",
-            "started_issues",
-            "unstarted_issues",
-            "backlog_issues",
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
             "created_at",
             "updated_at",
         ]
-        read_only_fields = fields
-
-
-
-class ModuleDetailSerializer(ModuleSerializer):
-
-    link_module = ModuleLinkSerializer(read_only=True, many=True)
-
-    class Meta(ModuleSerializer.Meta):
-        fields = ModuleSerializer.Meta.fields + ['link_module']
 
 
 class ModuleFavoriteSerializer(BaseSerializer):

apiserver/plane/app/serializers/notification.py

@@ -1,7 +1,7 @@
 # Module imports
 from .base import BaseSerializer
 from .user import UserLiteSerializer
-from plane.db.models import Notification, UserNotificationPreference
+from plane.db.models import Notification
 
 
 class NotificationSerializer(BaseSerializer):
@@ -12,10 +12,3 @@ class NotificationSerializer(BaseSerializer):
     class Meta:
         model = Notification
         fields = "__all__"
-
-
-class UserNotificationPreferenceSerializer(BaseSerializer):
-
-    class Meta:
-        model = UserNotificationPreference
-        fields = "__all__"

apiserver/plane/app/serializers/state.py

@@ -8,17 +8,7 @@ from plane.db.models import State
 class StateSerializer(BaseSerializer):
     class Meta:
         model = State
-        fields = [
-            "id",
-            "project_id",
-            "workspace_id",
-            "name",
-            "color",
-            "group",
-            "default",
-            "description",
-            "sequence",
-        ]
+        fields = "__all__"
         read_only_fields = [
             "workspace",
             "project",

apiserver/plane/app/urls/cycle.py

@@ -8,10 +8,16 @@ from plane.app.views import (
     CycleFavoriteViewSet,
     TransferCycleIssueEndpoint,
     CycleUserPropertiesEndpoint,
+    ActiveCycleEndpoint
 )
 
 
 urlpatterns = [
+    path(
+        "workspaces/<str:slug>/active-cycles/",
+        ActiveCycleEndpoint.as_view(),
+        name="workspace-active-cycle",
+    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/",
         CycleViewSet.as_view(

apiserver/plane/app/urls/issue.py

@@ -2,7 +2,6 @@ from django.urls import path
 
 
 from plane.app.views import (
-    IssueListEndpoint,
     IssueViewSet,
     LabelViewSet,
     BulkCreateIssueLabelsEndpoint,
@@ -26,11 +25,6 @@ from plane.app.views import (
 
 
 urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/list/",
-        IssueListEndpoint.as_view(),
-        name="project-issue",
-    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/",
         IssueViewSet.as_view(
@@ -90,13 +84,11 @@ urlpatterns = [
         BulkImportIssuesEndpoint.as_view(),
         name="project-issues-bulk",
     ),
-    # deprecated endpoint TODO: remove once confirmed
     path(
         "workspaces/<str:slug>/my-issues/",
         UserWorkSpaceIssues.as_view(),
         name="workspace-issues",
     ),
-    ## 
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/sub-issues/",
         SubIssuesEndpoint.as_view(),
@@ -259,15 +251,23 @@ urlpatterns = [
         name="project-issue-archive",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/archive/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-issues/<uuid:pk>/",
         IssueArchiveViewSet.as_view(
             {
                 "get": "retrieve",
-                "post": "archive",
-                "delete": "unarchive",
+                "delete": "destroy",
             }
         ),
-        name="project-issue-archive-unarchive",
+        name="project-issue-archive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/unarchive/<uuid:pk>/",
+        IssueArchiveViewSet.as_view(
+            {
+                "post": "unarchive",
+            }
+        ),
+        name="project-issue-archive",
     ),
     ## End Issue Archives
     ## Issue Relation

apiserver/plane/app/urls/module.py

@@ -35,26 +35,17 @@ urlpatterns = [
         name="project-modules",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/modules/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/",
         ModuleIssueViewSet.as_view(
             {
-                "post": "create_issue_modules",
-            }
-        ),
-        name="issue-module",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/issues/",
-        ModuleIssueViewSet.as_view(
-            {
-                "post": "create_module_issues",
                 "get": "list",
+                "post": "create",
             }
         ),
         name="project-module-issues",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/issues/<uuid:issue_id>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/<uuid:issue_id>/",
         ModuleIssueViewSet.as_view(
             {
                 "get": "retrieve",

apiserver/plane/app/urls/notification.py

@@ -5,7 +5,6 @@ from plane.app.views import (
     NotificationViewSet,
     UnreadNotificationEndpoint,
     MarkAllReadNotificationViewSet,
-    UserNotificationPreferenceEndpoint,
 )
 
 
@@ -64,9 +63,4 @@ urlpatterns = [
         ),
         name="mark-all-read-notifications",
     ),
-    path(
-        "users/me/notification-preferences/",
-        UserNotificationPreferenceEndpoint.as_view(),
-        name="user-notification-preferences",
-    ),
 ]

apiserver/plane/app/urls/workspace.py

@@ -20,10 +20,6 @@ from plane.app.views import (
     WorkspaceLabelsEndpoint,
     WorkspaceProjectMemberEndpoint,
     WorkspaceUserPropertiesEndpoint,
-    WorkspaceStatesEndpoint,
-    WorkspaceEstimatesEndpoint,
-    WorkspaceModulesEndpoint,
-    WorkspaceCyclesEndpoint,
 )
 
 
@@ -211,24 +207,4 @@ urlpatterns = [
         WorkspaceUserPropertiesEndpoint.as_view(),
         name="workspace-user-filters",
     ),
-    path(
-        "workspaces/<str:slug>/states/",
-        WorkspaceStatesEndpoint.as_view(),
-        name="workspace-state",
-    ),
-    path(
-        "workspaces/<str:slug>/estimates/",
-        WorkspaceEstimatesEndpoint.as_view(),
-        name="workspace-estimate",
-    ),
-    path(
-        "workspaces/<str:slug>/modules/",
-        WorkspaceModulesEndpoint.as_view(),
-        name="workspace-modules",
-    ),
-    path(
-        "workspaces/<str:slug>/cycles/",
-        WorkspaceCyclesEndpoint.as_view(),
-        name="workspace-cycles",
-    ),
 ]

apiserver/plane/app/views/__init__.py

@@ -47,10 +47,6 @@ from .workspace import (
     WorkspaceLabelsEndpoint,
     WorkspaceProjectMemberEndpoint,
     WorkspaceUserPropertiesEndpoint,
-    WorkspaceStatesEndpoint,
-    WorkspaceEstimatesEndpoint,
-    WorkspaceModulesEndpoint,
-    WorkspaceCyclesEndpoint,
 )
 from .state import StateViewSet
 from .view import (
@@ -66,10 +62,10 @@ from .cycle import (
     CycleFavoriteViewSet,
     TransferCycleIssueEndpoint,
     CycleUserPropertiesEndpoint,
+    ActiveCycleEndpoint,
 )
 from .asset import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
 from .issue import (
-    IssueListEndpoint,
     IssueViewSet,
     WorkSpaceIssuesEndpoint,
     IssueActivityEndpoint,
@@ -170,7 +166,6 @@ from .notification import (
     NotificationViewSet,
     UnreadNotificationEndpoint,
     MarkAllReadNotificationViewSet,
-    UserNotificationPreferenceEndpoint,
 )
 
 from .exporter import ExportIssuesEndpoint

apiserver/plane/app/views/analytic.py

@@ -1,7 +1,6 @@
 # Django imports
 from django.db.models import Count, Sum, F, Q
 from django.db.models.functions import ExtractMonth
-from django.utils import timezone
 
 # Third party imports
 from rest_framework import status
@@ -332,9 +331,8 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
             .order_by("state_group")
         )
 
-        current_year = timezone.now().year
         issue_completed_month_wise = (
-            base_issues.filter(completed_at__year=current_year)
+            base_issues.filter(completed_at__isnull=False)
             .annotate(month=ExtractMonth("completed_at"))
             .values("month")
             .annotate(count=Count("*"))

apiserver/plane/app/views/auth_extended.py

@@ -401,8 +401,8 @@ class EmailCheckEndpoint(BaseAPIView):
                 email=email,
                 user_agent=request.META.get("HTTP_USER_AGENT"),
                 ip=request.META.get("REMOTE_ADDR"),
-                event_name="Sign up",
-                medium="Magic link",
+                event_name="SIGN_IN",
+                medium="MAGIC_LINK",
                 first_time=True,
             )
             key, token, current_attempt = generate_magic_token(email=email)
@@ -438,8 +438,8 @@ class EmailCheckEndpoint(BaseAPIView):
                     email=email,
                     user_agent=request.META.get("HTTP_USER_AGENT"),
                     ip=request.META.get("REMOTE_ADDR"),
-                    event_name="Sign in",
-                    medium="Magic link",
+                    event_name="SIGN_IN",
+                    medium="MAGIC_LINK",
                     first_time=False,
                 )
 
@@ -468,8 +468,8 @@ class EmailCheckEndpoint(BaseAPIView):
                     email=email,
                     user_agent=request.META.get("HTTP_USER_AGENT"),
                     ip=request.META.get("REMOTE_ADDR"),
-                    event_name="Sign in",
-                    medium="Email",
+                    event_name="SIGN_IN",
+                    medium="EMAIL",
                     first_time=False,
                 )
 

apiserver/plane/app/views/authentication.py

@@ -274,8 +274,8 @@ class SignInEndpoint(BaseAPIView):
             email=email,
             user_agent=request.META.get("HTTP_USER_AGENT"),
             ip=request.META.get("REMOTE_ADDR"),
-            event_name="Sign in",
-            medium="Email",
+            event_name="SIGN_IN",
+            medium="EMAIL",
             first_time=False,
         )
 
@@ -349,8 +349,8 @@ class MagicSignInEndpoint(BaseAPIView):
                     email=email,
                     user_agent=request.META.get("HTTP_USER_AGENT"),
                     ip=request.META.get("REMOTE_ADDR"),
-                    event_name="Sign in",
-                    medium="Magic link",
+                    event_name="SIGN_IN",
+                    medium="MAGIC_LINK",
                     first_time=False,
                 )
 

apiserver/plane/app/views/base.py

@@ -64,7 +64,6 @@ class WebhookMixin:
                 action=self.request.method,
                 slug=self.workspace_slug,
                 bulk=self.bulk,
-                current_site=request.META.get("HTTP_ORIGIN"),
             )
 
         return response

apiserver/plane/app/views/config.py

@@ -66,15 +66,15 @@ class ConfigurationEndpoint(BaseAPIView):
                 },
                 {
                     "key": "SLACK_CLIENT_ID",
-                    "default": os.environ.get("SLACK_CLIENT_ID", None),
+                    "default": os.environ.get("SLACK_CLIENT_ID", "1"),
                 },
                 {
                     "key": "POSTHOG_API_KEY",
-                    "default": os.environ.get("POSTHOG_API_KEY", None),
+                    "default": os.environ.get("POSTHOG_API_KEY", "1"),
                 },
                 {
                     "key": "POSTHOG_HOST",
-                    "default": os.environ.get("POSTHOG_HOST", None),
+                    "default": os.environ.get("POSTHOG_HOST", "1"),
                 },
                 {
                     "key": "UNSPLASH_ACCESS_KEY",
@@ -181,11 +181,11 @@ class MobileConfigurationEndpoint(BaseAPIView):
                 },
                 {
                     "key": "POSTHOG_API_KEY",
-                    "default": os.environ.get("POSTHOG_API_KEY", None),
+                    "default": os.environ.get("POSTHOG_API_KEY", "1"),
                 },
                 {
                     "key": "POSTHOG_HOST",
-                    "default": os.environ.get("POSTHOG_HOST", None),
+                    "default": os.environ.get("POSTHOG_HOST", "1"),
                 },
                 {
                     "key": "UNSPLASH_ACCESS_KEY",

apiserver/plane/app/views/dashboard.py

@@ -15,10 +15,6 @@ from django.db.models import (
     Func,
     Prefetch,
 )
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models import Value, UUIDField
-from django.db.models.functions import Coalesce
 from django.utils import timezone
 
 # Third Party imports
@@ -104,7 +100,7 @@ def dashboard_assigned_issues(self, request, slug):
         )
         .filter(**filters)
         .select_related("workspace", "project", "state", "parent")
-        .prefetch_related("assignees", "labels", "issue_module__module")
+        .prefetch_related("assignees", "labels")
         .prefetch_related(
             Prefetch(
                 "issue_relation",
@@ -114,6 +110,7 @@ def dashboard_assigned_issues(self, request, slug):
             )
         )
         .annotate(cycle_id=F("issue_cycle__cycle_id"))
+        .annotate(module_id=F("issue_module__module_id"))
         .annotate(
             link_count=IssueLink.objects.filter(issue=OuterRef("id"))
             .order_by()
@@ -134,32 +131,7 @@ def dashboard_assigned_issues(self, request, slug):
             .annotate(count=Func(F("id"), function="Count"))
             .values("count")
         )
-        .annotate(
-            label_ids=Coalesce(
-                ArrayAgg(
-                    "labels__id",
-                    distinct=True,
-                    filter=~Q(labels__id__isnull=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            assignee_ids=Coalesce(
-                ArrayAgg(
-                    "assignees__id",
-                    distinct=True,
-                    filter=~Q(assignees__id__isnull=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            module_ids=Coalesce(
-                ArrayAgg(
-                    "issue_module__module_id",
-                    distinct=True,
-                    filter=~Q(issue_module__module_id__isnull=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-        )
+        .order_by("created_at")
     )
 
     # Priority Ordering
@@ -174,23 +146,6 @@ def dashboard_assigned_issues(self, request, slug):
         )
     ).order_by("priority_order")
 
-    if issue_type == "pending":
-        pending_issues_count = assigned_issues.filter(
-            state__group__in=["backlog", "started", "unstarted"]
-        ).count()
-        pending_issues = assigned_issues.filter(
-            state__group__in=["backlog", "started", "unstarted"]
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(
-                    pending_issues, many=True, expand=self.expand
-                ).data,
-                "count": pending_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
     if issue_type == "completed":
         completed_issues_count = assigned_issues.filter(
             state__group__in=["completed"]
@@ -266,8 +221,9 @@ def dashboard_created_issues(self, request, slug):
         )
         .filter(**filters)
         .select_related("workspace", "project", "state", "parent")
-        .prefetch_related("assignees", "labels", "issue_module__module")
+        .prefetch_related("assignees", "labels")
         .annotate(cycle_id=F("issue_cycle__cycle_id"))
+        .annotate(module_id=F("issue_module__module_id"))
         .annotate(
             link_count=IssueLink.objects.filter(issue=OuterRef("id"))
             .order_by()
@@ -288,32 +244,6 @@ def dashboard_created_issues(self, request, slug):
             .annotate(count=Func(F("id"), function="Count"))
             .values("count")
         )
-        .annotate(
-            label_ids=Coalesce(
-                ArrayAgg(
-                    "labels__id",
-                    distinct=True,
-                    filter=~Q(labels__id__isnull=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            assignee_ids=Coalesce(
-                ArrayAgg(
-                    "assignees__id",
-                    distinct=True,
-                    filter=~Q(assignees__id__isnull=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            module_ids=Coalesce(
-                ArrayAgg(
-                    "issue_module__module_id",
-                    distinct=True,
-                    filter=~Q(issue_module__module_id__isnull=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-        )
         .order_by("created_at")
     )
 
@@ -329,23 +259,6 @@ def dashboard_created_issues(self, request, slug):
         )
     ).order_by("priority_order")
 
-    if issue_type == "pending":
-        pending_issues_count = created_issues.filter(
-            state__group__in=["backlog", "started", "unstarted"]
-        ).count()
-        pending_issues = created_issues.filter(
-            state__group__in=["backlog", "started", "unstarted"]
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(
-                    pending_issues, many=True, expand=self.expand
-                ).data,
-                "count": pending_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
     if issue_type == "completed":
         completed_issues_count = created_issues.filter(
             state__group__in=["completed"]

apiserver/plane/app/views/inbox.py

@@ -3,12 +3,8 @@ import json
 
 # Django import
 from django.utils import timezone
-from django.db.models import Q, Count, OuterRef, Func, F, Prefetch, Exists
+from django.db.models import Q, Count, OuterRef, Func, F, Prefetch
 from django.core.serializers.json import DjangoJSONEncoder
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models import Value, UUIDField
-from django.db.models.functions import Coalesce
 
 # Third party imports
 from rest_framework import status
@@ -25,15 +21,13 @@ from plane.db.models import (
     IssueLink,
     IssueAttachment,
     ProjectMember,
-    IssueReaction,
-    IssueSubscriber,
 )
 from plane.app.serializers import (
-    IssueCreateSerializer,
     IssueSerializer,
     InboxSerializer,
     InboxIssueSerializer,
-    IssueDetailSerializer,
+    IssueCreateSerializer,
+    IssueStateInboxSerializer,
 )
 from plane.utils.issue_filters import issue_filters
 from plane.bgtasks.issue_activites_task import issue_activity
@@ -94,23 +88,39 @@ class InboxIssueViewSet(BaseViewSet):
     ]
 
     def get_queryset(self):
-        return (
-            Issue.objects.filter(
-                project_id=self.kwargs.get("project_id"),
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(
+                Q(snoozed_till__gte=timezone.now())
+                | Q(snoozed_till__isnull=True),
                 workspace__slug=self.kwargs.get("slug"),
-                issue_inbox__inbox_id=self.kwargs.get("inbox_id"),
+                project_id=self.kwargs.get("project_id"),
+                inbox_id=self.kwargs.get("inbox_id"),
             )
+            .select_related("issue", "workspace", "project")
+        )
+
+    def list(self, request, slug, project_id, inbox_id):
+        filters = issue_filters(request.query_params, "GET")
+        issues = (
+            Issue.objects.filter(
+                issue_inbox__inbox_id=inbox_id,
+                workspace__slug=slug,
+                project_id=project_id,
+            )
+            .filter(**filters)
             .select_related("workspace", "project", "state", "parent")
-            .prefetch_related("assignees", "labels", "issue_module__module")
-            .prefetch_related(
-                Prefetch(
-                    "issue_inbox",
-                    queryset=InboxIssue.objects.only(
-                        "status", "duplicate_to", "snoozed_till", "source"
-                    ),
+            .prefetch_related("assignees", "labels")
+            .order_by("issue_inbox__snoozed_till", "issue_inbox__status")
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
                 )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
             )
-            .annotate(cycle_id=F("issue_cycle__cycle_id"))
             .annotate(
                 link_count=IssueLink.objects.filter(issue=OuterRef("id"))
                 .order_by()
@@ -125,83 +135,18 @@ class InboxIssueViewSet(BaseViewSet):
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
             )
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
+            .prefetch_related(
+                Prefetch(
+                    "issue_inbox",
+                    queryset=InboxIssue.objects.only(
+                        "status", "duplicate_to", "snoozed_till", "source"
+                    ),
                 )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
             )
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=~Q(labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=~Q(assignees__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "issue_module__module_id",
-                        distinct=True,
-                        filter=~Q(issue_module__module_id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-        ).distinct()
-
-    def list(self, request, slug, project_id, inbox_id):
-        filters = issue_filters(request.query_params, "GET")
-        issue_queryset = (
-            self.get_queryset()
-            .filter(**filters)
-            .order_by("issue_inbox__snoozed_till", "issue_inbox__status")
         )
-        if self.expand:
-            issues = IssueSerializer(
-                issue_queryset, expand=self.expand, many=True
-            ).data
-        else:
-            issues = issue_queryset.values(
-                "id",
-                "name",
-                "state_id",
-                "sort_order",
-                "completed_at",
-                "estimate_point",
-                "priority",
-                "start_date",
-                "target_date",
-                "sequence_id",
-                "project_id",
-                "parent_id",
-                "cycle_id",
-                "module_ids",
-                "label_ids",
-                "assignee_ids",
-                "sub_issues_count",
-                "created_at",
-                "updated_at",
-                "created_by",
-                "updated_by",
-                "attachment_count",
-                "link_count",
-                "is_draft",
-                "archived_at",
-            )
+        issues_data = IssueStateInboxSerializer(issues, many=True).data
         return Response(
-            issues,
+            issues_data,
             status=status.HTTP_200_OK,
         )
 
@@ -255,8 +200,6 @@ class InboxIssueViewSet(BaseViewSet):
             project_id=str(project_id),
             current_instance=None,
             epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
         )
         # create an inbox issue
         InboxIssue.objects.create(
@@ -266,8 +209,7 @@ class InboxIssueViewSet(BaseViewSet):
             source=request.data.get("source", "in-app"),
         )
 
-        issue = self.get_queryset().filter(pk=issue.id).first()
-        serializer = IssueSerializer(issue, expand=self.expand)
+        serializer = IssueStateInboxSerializer(issue)
         return Response(serializer.data, status=status.HTTP_200_OK)
 
     def partial_update(self, request, slug, project_id, inbox_id, issue_id):
@@ -297,7 +239,11 @@ class InboxIssueViewSet(BaseViewSet):
         issue_data = request.data.pop("issue", False)
 
         if bool(issue_data):
-            issue = self.get_queryset().filter(pk=inbox_issue.issue_id).first()
+            issue = Issue.objects.get(
+                pk=inbox_issue.issue_id,
+                workspace__slug=slug,
+                project_id=project_id,
+            )
             # Only allow guests and viewers to edit name and description
             if project_member.role <= 10:
                 # viewers and guests since only viewers and guests
@@ -331,8 +277,6 @@ class InboxIssueViewSet(BaseViewSet):
                             cls=DjangoJSONEncoder,
                         ),
                         epoch=int(timezone.now().timestamp()),
-                        notification=True,
-                        origin=request.META.get("HTTP_ORIGIN"),
                     )
                 issue_serializer.save()
             else:
@@ -383,54 +327,22 @@ class InboxIssueViewSet(BaseViewSet):
                         if state is not None:
                             issue.state = state
                             issue.save()
-                return Response(status=status.HTTP_204_NO_CONTENT)
+
+                return Response(serializer.data, status=status.HTTP_200_OK)
             return Response(
                 serializer.errors, status=status.HTTP_400_BAD_REQUEST
             )
         else:
-            issue = self.get_queryset().filter(pk=issue_id).first()
-            serializer = IssueSerializer(issue, expand=self.expand)
-            return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(
+                InboxIssueSerializer(inbox_issue).data,
+                status=status.HTTP_200_OK,
+            )
 
     def retrieve(self, request, slug, project_id, inbox_id, issue_id):
-        issue = (
-            self.get_queryset()
-            .filter(pk=issue_id)
-            .prefetch_related(
-                Prefetch(
-                    "issue_reactions",
-                    queryset=IssueReaction.objects.select_related(
-                        "issue", "actor"
-                    ),
-                )
-            )
-            .prefetch_related(
-                Prefetch(
-                    "issue_attachment",
-                    queryset=IssueAttachment.objects.select_related("issue"),
-                )
-            )
-            .prefetch_related(
-                Prefetch(
-                    "issue_link",
-                    queryset=IssueLink.objects.select_related("created_by"),
-                )
-            )
-            .annotate(
-                is_subscribed=Exists(
-                    IssueSubscriber.objects.filter(
-                        workspace__slug=slug,
-                        project_id=project_id,
-                        issue_id=OuterRef("pk"),
-                        subscriber=request.user,
-                    )
-                )
-            )
-        ).first()
-        if issue is None:
-            return Response({"error": "Requested object was not found"}, status=status.HTTP_404_NOT_FOUND)
-        
-        serializer = IssueDetailSerializer(issue)
+        issue = Issue.objects.get(
+            pk=issue_id, workspace__slug=slug, project_id=project_id
+        )
+        serializer = IssueStateInboxSerializer(issue)
         return Response(serializer.data, status=status.HTTP_200_OK)
 
     def destroy(self, request, slug, project_id, inbox_id, issue_id):

apiserver/plane/app/views/integration/slack.py

@@ -36,10 +36,7 @@ class SlackProjectSyncViewSet(BaseViewSet):
                 workspace__slug=self.kwargs.get("slug"),
                 project_id=self.kwargs.get("project_id"),
             )
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
+            .filter(project__project_projectmember__member=self.request.user)
         )
 
     def create(self, request, slug, project_id, workspace_integration_id):

apiserver/plane/app/views/module.py

@@ -4,12 +4,9 @@ import json
 # Django Imports
 from django.utils import timezone
 from django.db.models import Prefetch, F, OuterRef, Func, Exists, Count, Q
+from django.core import serializers
 from django.utils.decorators import method_decorator
 from django.views.decorators.gzip import gzip_page
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models import Value, UUIDField
-from django.db.models.functions import Coalesce
 
 # Third party imports
 from rest_framework.response import Response
@@ -25,7 +22,6 @@ from plane.app.serializers import (
     ModuleFavoriteSerializer,
     IssueSerializer,
     ModuleUserPropertiesSerializer,
-    ModuleDetailSerializer,
 )
 from plane.app.permissions import (
     ProjectEntityPermission,
@@ -40,9 +36,11 @@ from plane.db.models import (
     ModuleFavorite,
     IssueLink,
     IssueAttachment,
+    IssueSubscriber,
     ModuleUserProperties,
 )
 from plane.bgtasks.issue_activites_task import issue_activity
+from plane.utils.grouper import group_results
 from plane.utils.issue_filters import issue_filters
 from plane.utils.analytics_plot import burndown_plot
 
@@ -62,7 +60,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
         )
 
     def get_queryset(self):
-        favorite_subquery = ModuleFavorite.objects.filter(
+        subquery = ModuleFavorite.objects.filter(
             user=self.request.user,
             module_id=OuterRef("pk"),
             project_id=self.kwargs.get("project_id"),
@@ -73,7 +71,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
             .get_queryset()
             .filter(project_id=self.kwargs.get("project_id"))
             .filter(workspace__slug=self.kwargs.get("slug"))
-            .annotate(is_favorite=Exists(favorite_subquery))
+            .annotate(is_favorite=Exists(subquery))
             .select_related("project")
             .select_related("workspace")
             .select_related("lead")
@@ -145,16 +143,6 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
                     ),
                 )
             )
-            .annotate(
-                member_ids=Coalesce(
-                    ArrayAgg(
-                        "members__id",
-                        distinct=True,
-                        filter=~Q(members__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                )
-            )
             .order_by("-is_favorite", "-created_at")
         )
 
@@ -167,84 +155,25 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
         if serializer.is_valid():
             serializer.save()
 
-            module = (
-                self.get_queryset()
-                .filter(pk=serializer.data["id"])
-                .values(  # Required fields
-                    "id",
-                    "workspace_id",
-                    "project_id",
-                    # Model fields
-                    "name",
-                    "description",
-                    "description_text",
-                    "description_html",
-                    "start_date",
-                    "target_date",
-                    "status",
-                    "lead_id",
-                    "member_ids",
-                    "view_props",
-                    "sort_order",
-                    "external_source",
-                    "external_id",
-                    # computed fields
-                    "is_favorite",
-                    "total_issues",
-                    "cancelled_issues",
-                    "completed_issues",
-                    "started_issues",
-                    "unstarted_issues",
-                    "backlog_issues",
-                    "created_at",
-                    "updated_at",
-                )
-            ).first()
-            return Response(module, status=status.HTTP_201_CREATED)
+            module = Module.objects.get(pk=serializer.data["id"])
+            serializer = ModuleSerializer(module)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def list(self, request, slug, project_id):
         queryset = self.get_queryset()
-        if self.fields:
-            modules = ModuleSerializer(
-                queryset,
-                many=True,
-                fields=self.fields,
-            ).data
-        else:
-            modules = queryset.values(  # Required fields
-                "id",
-                "workspace_id",
-                "project_id",
-                # Model fields
-                "name",
-                "description",
-                "description_text",
-                "description_html",
-                "start_date",
-                "target_date",
-                "status",
-                "lead_id",
-                "member_ids",
-                "view_props",
-                "sort_order",
-                "external_source",
-                "external_id",
-                # computed fields
-                "is_favorite",
-                "total_issues",
-                "cancelled_issues",
-                "completed_issues",
-                "started_issues",
-                "unstarted_issues",
-                "backlog_issues",
-                "created_at",
-                "updated_at",
-            )
+        fields = [
+            field
+            for field in request.GET.get("fields", "").split(",")
+            if field
+        ]
+        modules = ModuleSerializer(
+            queryset, many=True, fields=fields if fields else None
+        ).data
         return Response(modules, status=status.HTTP_200_OK)
 
     def retrieve(self, request, slug, project_id, pk):
-        queryset = self.get_queryset().filter(pk=pk)
+        queryset = self.get_queryset().get(pk=pk)
 
         assignee_distribution = (
             Issue.objects.filter(
@@ -266,7 +195,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
             )
             .annotate(
                 total_issues=Count(
-                    "id",
+                    "assignee_id",
                     filter=Q(
                         archived_at__isnull=True,
                         is_draft=False,
@@ -275,7 +204,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
             )
             .annotate(
                 completed_issues=Count(
-                    "id",
+                    "assignee_id",
                     filter=Q(
                         completed_at__isnull=False,
                         archived_at__isnull=True,
@@ -285,7 +214,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
             )
             .annotate(
                 pending_issues=Count(
-                    "id",
+                    "assignee_id",
                     filter=Q(
                         completed_at__isnull=True,
                         archived_at__isnull=True,
@@ -308,7 +237,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
             .values("label_name", "color", "label_id")
             .annotate(
                 total_issues=Count(
-                    "id",
+                    "label_id",
                     filter=Q(
                         archived_at__isnull=True,
                         is_draft=False,
@@ -317,7 +246,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
             )
             .annotate(
                 completed_issues=Count(
-                    "id",
+                    "label_id",
                     filter=Q(
                         completed_at__isnull=False,
                         archived_at__isnull=True,
@@ -327,7 +256,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
             )
             .annotate(
                 pending_issues=Count(
-                    "id",
+                    "label_id",
                     filter=Q(
                         completed_at__isnull=True,
                         archived_at__isnull=True,
@@ -338,16 +267,16 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
             .order_by("label_name")
         )
 
-        data = ModuleDetailSerializer(queryset.first()).data
+        data = ModuleSerializer(queryset).data
         data["distribution"] = {
             "assignees": assignee_distribution,
             "labels": label_distribution,
             "completion_chart": {},
         }
 
-        if queryset.first().start_date and queryset.first().target_date:
+        if queryset.start_date and queryset.target_date:
             data["distribution"]["completion_chart"] = burndown_plot(
-                queryset=queryset.first(),
+                queryset=queryset,
                 slug=slug,
                 project_id=project_id,
                 module_id=pk,
@@ -358,47 +287,6 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
             status=status.HTTP_200_OK,
         )
 
-    def partial_update(self, request, slug, project_id, pk):
-        queryset = self.get_queryset().filter(pk=pk)
-        serializer = ModuleWriteSerializer(
-            queryset.first(), data=request.data, partial=True
-        )
-
-        if serializer.is_valid():
-            serializer.save()
-            module = queryset.values(  
-                # Required fields
-                "id",
-                "workspace_id",
-                "project_id",
-                # Model fields
-                "name",
-                "description",
-                "description_text",
-                "description_html",
-                "start_date",
-                "target_date",
-                "status",
-                "lead_id",
-                "member_ids",
-                "view_props",
-                "sort_order",
-                "external_source",
-                "external_id",
-                # computed fields
-                "is_favorite",
-                "total_issues",
-                "cancelled_issues",
-                "completed_issues",
-                "started_issues",
-                "unstarted_issues",
-                "backlog_issues",
-                "created_at",
-                "updated_at",
-            ).first()
-            return Response(module, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
     def destroy(self, request, slug, project_id, pk):
         module = Module.objects.get(
             workspace__slug=slug, project_id=project_id, pk=pk
@@ -408,20 +296,21 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
                 "issue", flat=True
             )
         )
-        _ = [
-            issue_activity.delay(
-                type="module.activity.deleted",
-                requested_data=json.dumps({"module_id": str(pk)}),
-                actor_id=str(request.user.id),
-                issue_id=str(issue),
-                project_id=project_id,
-                current_instance=json.dumps({"module_name": str(module.name)}),
-                epoch=int(timezone.now().timestamp()),
-                notification=True,
-                origin=request.META.get("HTTP_ORIGIN"),
-            )
-            for issue in module_issues
-        ]
+        issue_activity.delay(
+            type="module.activity.deleted",
+            requested_data=json.dumps(
+                {
+                    "module_id": str(pk),
+                    "module_name": str(module.name),
+                    "issues": [str(issue_id) for issue_id in module_issues],
+                }
+            ),
+            actor_id=str(request.user.id),
+            issue_id=str(pk),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+        )
         module.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
@@ -442,15 +331,61 @@ class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
     ]
 
     def get_queryset(self):
-        return (
-            Issue.issue_objects.filter(
-                project_id=self.kwargs.get("project_id"),
-                workspace__slug=self.kwargs.get("slug"),
-                issue_module__module_id=self.kwargs.get("module_id"),
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("issue")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
             )
-            .select_related("workspace", "project", "state", "parent")
-            .prefetch_related("assignees", "labels", "issue_module__module")
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(module_id=self.kwargs.get("module_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("module")
+            .select_related("issue", "issue__state", "issue__project")
+            .prefetch_related("issue__assignees", "issue__labels")
+            .prefetch_related("module__members")
+            .distinct()
+        )
+
+    @method_decorator(gzip_page)
+    def list(self, request, slug, project_id, module_id):
+        fields = [
+            field
+            for field in request.GET.get("fields", "").split(",")
+            if field
+        ]
+        order_by = request.GET.get("order_by", "created_at")
+        filters = issue_filters(request.query_params, "GET")
+        issues = (
+            Issue.issue_objects.filter(issue_module__module_id=module_id)
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .filter(project_id=project_id)
+            .filter(workspace__slug=slug)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("state")
+            .select_related("parent")
+            .prefetch_related("assignees")
+            .prefetch_related("labels")
+            .order_by(order_by)
+            .filter(**filters)
             .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(module_id=F("issue_module__module_id"))
             .annotate(
                 link_count=IssueLink.objects.filter(issue=OuterRef("id"))
                 .order_by()
@@ -466,167 +401,103 @@ class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
                 .values("count")
             )
             .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
+                is_subscribed=Exists(
+                    IssueSubscriber.objects.filter(
+                        subscriber=self.request.user, issue_id=OuterRef("id")
+                    )
                 )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
             )
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=~Q(labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=~Q(assignees__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "issue_module__module_id",
-                        distinct=True,
-                        filter=~Q(issue_module__module_id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-        ).distinct()
+        )
+        serializer = IssueSerializer(
+            issues, many=True, fields=fields if fields else None
+        )
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
-    @method_decorator(gzip_page)
-    def list(self, request, slug, project_id, module_id):
-        fields = [
-            field
-            for field in request.GET.get("fields", "").split(",")
-            if field
-        ]
-        filters = issue_filters(request.query_params, "GET")
-        issue_queryset = self.get_queryset().filter(**filters)
-        if self.fields or self.expand:
-            issues = IssueSerializer(
-                issue_queryset, many=True, fields=fields if fields else None
-            ).data
-        else:
-            issues = issue_queryset.values(
-                "id",
-                "name",
-                "state_id",
-                "sort_order",
-                "completed_at",
-                "estimate_point",
-                "priority",
-                "start_date",
-                "target_date",
-                "sequence_id",
-                "project_id",
-                "parent_id",
-                "cycle_id",
-                "module_ids",
-                "label_ids",
-                "assignee_ids",
-                "sub_issues_count",
-                "created_at",
-                "updated_at",
-                "created_by",
-                "updated_by",
-                "attachment_count",
-                "link_count",
-                "is_draft",
-                "archived_at",
-            )
-        return Response(issues, status=status.HTTP_200_OK)
-
-    # create multiple issues inside a module
-    def create_module_issues(self, request, slug, project_id, module_id):
+    def create(self, request, slug, project_id, module_id):
         issues = request.data.get("issues", [])
-        if not issues:
+        if not len(issues):
             return Response(
                 {"error": "Issues are required"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-        project = Project.objects.get(pk=project_id)
-        _ = ModuleIssue.objects.bulk_create(
-            [
-                ModuleIssue(
-                    issue_id=str(issue),
-                    module_id=module_id,
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    created_by=request.user,
-                    updated_by=request.user,
+        module = Module.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=module_id
+        )
+
+        module_issues = list(ModuleIssue.objects.filter(issue_id__in=issues))
+
+        update_module_issue_activity = []
+        records_to_update = []
+        record_to_create = []
+
+        for issue in issues:
+            module_issue = [
+                module_issue
+                for module_issue in module_issues
+                if str(module_issue.issue_id) in issues
+            ]
+
+            if len(module_issue):
+                if module_issue[0].module_id != module_id:
+                    update_module_issue_activity.append(
+                        {
+                            "old_module_id": str(module_issue[0].module_id),
+                            "new_module_id": str(module_id),
+                            "issue_id": str(module_issue[0].issue_id),
+                        }
+                    )
+                    module_issue[0].module_id = module_id
+                    records_to_update.append(module_issue[0])
+            else:
+                record_to_create.append(
+                    ModuleIssue(
+                        module=module,
+                        issue_id=issue,
+                        project_id=project_id,
+                        workspace=module.workspace,
+                        created_by=request.user,
+                        updated_by=request.user,
+                    )
                 )
-                for issue in issues
-            ],
+
+        ModuleIssue.objects.bulk_create(
+            record_to_create,
             batch_size=10,
             ignore_conflicts=True,
         )
-        # Bulk Update the activity
-        _ = [
-            issue_activity.delay(
-                type="module.activity.created",
-                requested_data=json.dumps({"module_id": str(module_id)}),
-                actor_id=str(request.user.id),
-                issue_id=str(issue),
-                project_id=project_id,
-                current_instance=None,
-                epoch=int(timezone.now().timestamp()),
-                notification=True,
-                origin=request.META.get("HTTP_ORIGIN"),
-            )
-            for issue in issues
-        ]
-        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
 
-    # create multiple module inside an issue
-    def create_issue_modules(self, request, slug, project_id, issue_id):
-        modules = request.data.get("modules", [])
-        if not modules:
-            return Response(
-                {"error": "Modules are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        project = Project.objects.get(pk=project_id)
-        _ = ModuleIssue.objects.bulk_create(
-            [
-                ModuleIssue(
-                    issue_id=issue_id,
-                    module_id=module,
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    created_by=request.user,
-                    updated_by=request.user,
-                )
-                for module in modules
-            ],
+        ModuleIssue.objects.bulk_update(
+            records_to_update,
+            ["module"],
             batch_size=10,
-            ignore_conflicts=True,
         )
-        # Bulk Update the activity
-        _ = [
-            issue_activity.delay(
-                type="module.activity.created",
-                requested_data=json.dumps({"module_id": module}),
-                actor_id=str(request.user.id),
-                issue_id=issue_id,
-                project_id=project_id,
-                current_instance=None,
-                epoch=int(timezone.now().timestamp()),
-                notification=True,
-                origin=request.META.get("HTTP_ORIGIN"),
-            )
-            for module in modules
-        ]
 
-        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
+        # Capture Issue Activity
+        issue_activity.delay(
+            type="module.activity.created",
+            requested_data=json.dumps({"modules_list": issues}),
+            actor_id=str(self.request.user.id),
+            issue_id=None,
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps(
+                {
+                    "updated_module_issues": update_module_issue_activity,
+                    "created_module_issues": serializers.serialize(
+                        "json", record_to_create
+                    ),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
+        )
+
+        issues = self.get_queryset().values_list("issue_id", flat=True)
+
+        return Response(
+            IssueSerializer(
+                Issue.objects.filter(pk__in=issues), many=True
+            ).data,
+            status=status.HTTP_200_OK,
+        )
 
     def destroy(self, request, slug, project_id, module_id, issue_id):
         module_issue = ModuleIssue.objects.get(
@@ -637,16 +508,17 @@ class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
         )
         issue_activity.delay(
             type="module.activity.deleted",
-            requested_data=json.dumps({"module_id": str(module_id)}),
+            requested_data=json.dumps(
+                {
+                    "module_id": str(module_id),
+                    "issues": [str(issue_id)],
+                }
+            ),
             actor_id=str(request.user.id),
             issue_id=str(issue_id),
             project_id=str(project_id),
-            current_instance=json.dumps(
-                {"module_name": module_issue.module.name}
-            ),
+            current_instance=None,
             epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
         )
         module_issue.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
@@ -673,10 +545,7 @@ class ModuleLinkViewSet(BaseViewSet):
             .filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
             .filter(module_id=self.kwargs.get("module_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
+            .filter(project__project_projectmember__member=self.request.user)
             .order_by("-created_at")
             .distinct()
         )

apiserver/plane/app/views/notification.py

@@ -1,5 +1,5 @@
 # Django imports
-from django.db.models import Q, OuterRef, Exists
+from django.db.models import Q
 from django.utils import timezone
 
 # Third party imports
@@ -15,9 +15,8 @@ from plane.db.models import (
     IssueSubscriber,
     Issue,
     WorkspaceMember,
-    UserNotificationPreference,
 )
-from plane.app.serializers import NotificationSerializer, UserNotificationPreferenceSerializer
+from plane.app.serializers import NotificationSerializer
 
 
 class NotificationViewSet(BaseViewSet, BasePaginator):
@@ -72,29 +71,11 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
 
         # Subscribed issues
         if type == "watching":
-            issue_ids = (
-                IssueSubscriber.objects.filter(
-                    workspace__slug=slug, subscriber_id=request.user.id
-                )
-                .annotate(
-                    created=Exists(
-                        Issue.objects.filter(
-                            created_by=request.user, pk=OuterRef("issue_id")
-                        )
-                    )
-                )
-                .annotate(
-                    assigned=Exists(
-                        IssueAssignee.objects.filter(
-                            pk=OuterRef("issue_id"), assignee=request.user
-                        )
-                    )
-                )
-                .filter(created=False, assigned=False)
-                .values_list("issue_id", flat=True)
-            )
+            issue_ids = IssueSubscriber.objects.filter(
+                workspace__slug=slug, subscriber_id=request.user.id
+            ).values_list("issue_id", flat=True)
             notifications = notifications.filter(
-                entity_identifier__in=issue_ids,
+                entity_identifier__in=issue_ids
             )
 
         # Assigned Issues
@@ -314,31 +295,3 @@ class MarkAllReadNotificationViewSet(BaseViewSet):
             updated_notifications, ["read_at"], batch_size=100
         )
         return Response({"message": "Successful"}, status=status.HTTP_200_OK)
-
-
-class UserNotificationPreferenceEndpoint(BaseAPIView):
-    model = UserNotificationPreference
-    serializer_class = UserNotificationPreferenceSerializer
-
-    # request the object
-    def get(self, request):
-        user_notification_preference = UserNotificationPreference.objects.get(
-            user=request.user
-        )
-        serializer = UserNotificationPreferenceSerializer(
-            user_notification_preference
-        )
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    # update the object
-    def patch(self, request):
-        user_notification_preference = UserNotificationPreference.objects.get(
-            user=request.user
-        )
-        serializer = UserNotificationPreferenceSerializer(
-            user_notification_preference, data=request.data, partial=True
-        )
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/app/views/oauth.py

@@ -296,7 +296,7 @@ class OauthEndpoint(BaseAPIView):
                 email=email,
                 user_agent=request.META.get("HTTP_USER_AGENT"),
                 ip=request.META.get("REMOTE_ADDR"),
-                event_name="Sign in",
+                event_name="SIGN_IN",
                 medium=medium.upper(),
                 first_time=False,
             )
@@ -427,7 +427,7 @@ class OauthEndpoint(BaseAPIView):
                 email=email,
                 user_agent=request.META.get("HTTP_USER_AGENT"),
                 ip=request.META.get("REMOTE_ADDR"),
-                event_name="Sign up",
+                event_name="SIGN_IN",
                 medium=medium.upper(),
                 first_time=True,
             )

apiserver/plane/app/views/page.py

@@ -60,10 +60,7 @@ class PageViewSet(BaseViewSet):
             .get_queryset()
             .filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
+            .filter(project__project_projectmember__member=self.request.user)
             .filter(parent__isnull=True)
             .filter(Q(owned_by=self.request.user) | Q(access=0))
             .select_related("project")
@@ -161,18 +158,18 @@ class PageViewSet(BaseViewSet):
             pk=page_id, workspace__slug=slug, project_id=project_id
         )
 
-        # only the owner or admin can archive the page
+        # only the owner and admin can archive the page
         if (
             ProjectMember.objects.filter(
                 project_id=project_id,
                 member=request.user,
                 is_active=True,
-                role__lte=15,
+                role__gte=20,
             ).exists()
-            and request.user.id != page.owned_by_id
+            or request.user.id != page.owned_by_id
         ):
             return Response(
-                {"error": "Only the owner or admin can archive the page"},
+                {"error": "Only the owner and admin can archive the page"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
@@ -185,18 +182,18 @@ class PageViewSet(BaseViewSet):
             pk=page_id, workspace__slug=slug, project_id=project_id
         )
 
-        # only the owner or admin can un archive the page
+        # only the owner and admin can un archive the page
         if (
             ProjectMember.objects.filter(
                 project_id=project_id,
                 member=request.user,
                 is_active=True,
-                role__lte=15,
+                role__gt=20,
             ).exists()
-            and request.user.id != page.owned_by_id
+            or request.user.id != page.owned_by_id
         ):
             return Response(
-                {"error": "Only the owner or admin can un archive the page"},
+                {"error": "Only the owner and admin can un archive the page"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 

apiserver/plane/app/views/project.py

@@ -68,7 +68,7 @@ from plane.bgtasks.project_invitation_task import project_invitation
 
 
 class ProjectViewSet(WebhookMixin, BaseViewSet):
-    serializer_class = ProjectListSerializer
+    serializer_class = ProjectSerializer
     model = Project
     webhook_event = "project"
 
@@ -76,13 +76,12 @@ class ProjectViewSet(WebhookMixin, BaseViewSet):
         ProjectBasePermission,
     ]
 
+    def get_serializer_class(self, *args, **kwargs):
+        if self.action in ["update", "partial_update"]:
+            return ProjectSerializer
+        return ProjectDetailSerializer
+
     def get_queryset(self):
-        sort_order = ProjectMember.objects.filter(
-            member=self.request.user,
-            project_id=OuterRef("pk"),
-            workspace__slug=self.kwargs.get("slug"),
-            is_active=True,
-        ).values("sort_order")
         return self.filter_queryset(
             super()
             .get_queryset()
@@ -153,7 +152,6 @@ class ProjectViewSet(WebhookMixin, BaseViewSet):
                     )
                 )
             )
-            .annotate(sort_order=Subquery(sort_order))
             .prefetch_related(
                 Prefetch(
                     "project_projectmember",
@@ -173,8 +171,16 @@ class ProjectViewSet(WebhookMixin, BaseViewSet):
             for field in request.GET.get("fields", "").split(",")
             if field
         ]
+
+        sort_order_query = ProjectMember.objects.filter(
+            member=request.user,
+            project_id=OuterRef("pk"),
+            workspace__slug=self.kwargs.get("slug"),
+            is_active=True,
+        ).values("sort_order")
         projects = (
             self.get_queryset()
+            .annotate(sort_order=Subquery(sort_order_query))
             .order_by("sort_order", "name")
         )
         if request.GET.get("per_page", False) and request.GET.get(
@@ -203,7 +209,7 @@ class ProjectViewSet(WebhookMixin, BaseViewSet):
                 serializer.save()
 
                 # Add the user as Administrator to the project
-                _ = ProjectMember.objects.create(
+                project_member = ProjectMember.objects.create(
                     project_id=serializer.data["id"],
                     member=request.user,
                     role=20,
@@ -684,19 +690,6 @@ class ProjectMemberViewSet(BaseViewSet):
             .order_by("sort_order")
         )
 
-        bulk_project_members = []
-        member_roles = {member.get("member_id"): member.get("role") for member in members}
-        # Update roles in the members array based on the member_roles dictionary
-        for project_member in  ProjectMember.objects.filter(project_id=project_id, member_id__in=[member.get("member_id") for member in members]):
-            project_member.role = member_roles[str(project_member.member_id)]
-            project_member.is_active = True
-            bulk_project_members.append(project_member)
-
-        # Update the roles of the existing members
-        ProjectMember.objects.bulk_update(
-            bulk_project_members, ["is_active", "role"], batch_size=100
-        )
-
         for member in members:
             sort_order = [
                 project_member.get("sort_order")
@@ -723,6 +716,25 @@ class ProjectMemberViewSet(BaseViewSet):
                 )
             )
 
+            # Check if the user is already a member of the project and is inactive
+            if ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member_id=member.get("member_id"),
+                is_active=False,
+            ).exists():
+                member_detail = ProjectMember.objects.get(
+                    workspace__slug=slug,
+                    project_id=project_id,
+                    member_id=member.get("member_id"),
+                    is_active=False,
+                )
+                # Check if the user has not deactivated the account
+                user = User.objects.filter(pk=member.get("member_id")).first()
+                if user.is_active:
+                    member_detail.is_active = True
+                    member_detail.save(update_fields=["is_active"])
+
         project_members = ProjectMember.objects.bulk_create(
             bulk_project_members,
             batch_size=10,
@@ -733,8 +745,8 @@ class ProjectMemberViewSet(BaseViewSet):
             bulk_issue_props, batch_size=10, ignore_conflicts=True
         )
 
-        project_members = ProjectMember.objects.filter(project_id=project_id, member_id__in=[member.get("member_id") for member in members])
-        serializer = ProjectMemberRoleSerializer(project_members, many=True)
+        serializer = ProjectMemberSerializer(project_members, many=True)
+
         return Response(serializer.data, status=status.HTTP_201_CREATED)
 
     def list(self, request, slug, project_id):

apiserver/plane/app/views/search.py

@@ -48,8 +48,8 @@ class GlobalSearchEndpoint(BaseAPIView):
         return (
             Project.objects.filter(
                 q,
-                project_projectmember__member=self.request.user,
-                project_projectmember__is_active=True,
+                Q(project_projectmember__member=self.request.user)
+                | Q(network=2),
                 workspace__slug=slug,
             )
             .distinct()
@@ -71,7 +71,6 @@ class GlobalSearchEndpoint(BaseAPIView):
         issues = Issue.issue_objects.filter(
             q,
             project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
             workspace__slug=slug,
         )
 
@@ -96,7 +95,6 @@ class GlobalSearchEndpoint(BaseAPIView):
         cycles = Cycle.objects.filter(
             q,
             project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
             workspace__slug=slug,
         )
 
@@ -120,7 +118,6 @@ class GlobalSearchEndpoint(BaseAPIView):
         modules = Module.objects.filter(
             q,
             project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
             workspace__slug=slug,
         )
 
@@ -144,7 +141,6 @@ class GlobalSearchEndpoint(BaseAPIView):
         pages = Page.objects.filter(
             q,
             project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
             workspace__slug=slug,
         )
 
@@ -168,7 +164,6 @@ class GlobalSearchEndpoint(BaseAPIView):
         issue_views = IssueView.objects.filter(
             q,
             project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
             workspace__slug=slug,
         )
 
@@ -233,7 +228,7 @@ class IssueSearchEndpoint(BaseAPIView):
         parent = request.query_params.get("parent", "false")
         issue_relation = request.query_params.get("issue_relation", "false")
         cycle = request.query_params.get("cycle", "false")
-        module = request.query_params.get("module", False)
+        module = request.query_params.get("module", "false")
         sub_issue = request.query_params.get("sub_issue", "false")
 
         issue_id = request.query_params.get("issue_id", False)
@@ -241,7 +236,6 @@ class IssueSearchEndpoint(BaseAPIView):
         issues = Issue.issue_objects.filter(
             workspace__slug=slug,
             project__project_projectmember__member=self.request.user,
-            project__project_projectmember__is_active=True,
         )
 
         if workspace_search == "false":
@@ -253,7 +247,12 @@ class IssueSearchEndpoint(BaseAPIView):
         if parent == "true" and issue_id:
             issue = Issue.issue_objects.get(pk=issue_id)
             issues = issues.filter(
-                ~Q(pk=issue_id), ~Q(pk=issue.parent_id), ~Q(parent_id=issue_id))
+                ~Q(pk=issue_id), ~Q(pk=issue.parent_id), parent__isnull=True
+            ).exclude(
+                pk__in=Issue.issue_objects.filter(
+                    parent__isnull=False
+                ).values_list("parent_id", flat=True)
+            )
         if issue_relation == "true" and issue_id:
             issue = Issue.issue_objects.get(pk=issue_id)
             issues = issues.filter(
@@ -270,8 +269,8 @@ class IssueSearchEndpoint(BaseAPIView):
         if cycle == "true":
             issues = issues.exclude(issue_cycle__isnull=False)
 
-        if module:
-            issues = issues.exclude(issue_module__module=module)
+        if module == "true":
+            issues = issues.exclude(issue_module__isnull=False)
 
         return Response(
             issues.values(

apiserver/plane/app/views/state.py

@@ -9,12 +9,9 @@ from rest_framework.response import Response
 from rest_framework import status
 
 # Module imports
-from . import BaseViewSet, BaseAPIView
+from . import BaseViewSet
 from plane.app.serializers import StateSerializer
-from plane.app.permissions import (
-    ProjectEntityPermission,
-    WorkspaceEntityPermission,
-)
+from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import State, Issue
 
 
@@ -25,16 +22,16 @@ class StateViewSet(BaseViewSet):
         ProjectEntityPermission,
     ]
 
+    def perform_create(self, serializer):
+        serializer.save(project_id=self.kwargs.get("project_id"))
+
     def get_queryset(self):
         return self.filter_queryset(
             super()
             .get_queryset()
             .filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
+            .filter(project__project_projectmember__member=self.request.user)
             .filter(~Q(name="Triage"))
             .select_related("project")
             .select_related("workspace")

apiserver/plane/app/views/view.py

@@ -1,6 +1,6 @@
 # Django imports
 from django.db.models import (
-    Q,
+    Prefetch,
     OuterRef,
     Func,
     F,
@@ -13,21 +13,16 @@ from django.db.models import (
 )
 from django.utils.decorators import method_decorator
 from django.views.decorators.gzip import gzip_page
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models import Value, UUIDField
-from django.db.models.functions import Coalesce
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models import Value, UUIDField
+from django.db.models import Prefetch, OuterRef, Exists
 
 # Third party imports
 from rest_framework.response import Response
 from rest_framework import status
 
 # Module imports
-from . import BaseViewSet
+from . import BaseViewSet, BaseAPIView
 from plane.app.serializers import (
+    GlobalViewSerializer,
     IssueViewSerializer,
     IssueSerializer,
     IssueViewFavoriteSerializer,
@@ -35,16 +30,22 @@ from plane.app.serializers import (
 from plane.app.permissions import (
     WorkspaceEntityPermission,
     ProjectEntityPermission,
+    WorkspaceViewerPermission,
+    ProjectLitePermission,
 )
 from plane.db.models import (
     Workspace,
+    GlobalView,
     IssueView,
     Issue,
     IssueViewFavorite,
+    IssueReaction,
     IssueLink,
     IssueAttachment,
+    IssueSubscriber,
 )
 from plane.utils.issue_filters import issue_filters
+from plane.utils.grouper import group_results
 
 
 class GlobalViewViewSet(BaseViewSet):
@@ -86,60 +87,17 @@ class GlobalViewIssuesViewSet(BaseViewSet):
                 .values("count")
             )
             .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
-            .select_related("workspace", "project", "state", "parent")
-            .prefetch_related("assignees", "labels", "issue_module__module")
-            .annotate(cycle_id=F("issue_cycle__cycle_id"))
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("state")
+            .select_related("parent")
+            .prefetch_related("assignees")
+            .prefetch_related("labels")
+            .prefetch_related(
+                Prefetch(
+                    "issue_reactions",
+                    queryset=IssueReaction.objects.select_related("actor"),
                 )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=~Q(labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=~Q(assignees__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "issue_module__module_id",
-                        distinct=True,
-                        filter=~Q(issue_module__module_id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
             )
         )
 
@@ -167,7 +125,38 @@ class GlobalViewIssuesViewSet(BaseViewSet):
         issue_queryset = (
             self.get_queryset()
             .filter(**filters)
+            .filter(project__project_projectmember__member=self.request.user)
             .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(module_id=F("issue_module__module_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(
+                    parent=OuterRef("id")
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                is_subscribed=Exists(
+                    IssueSubscriber.objects.filter(
+                        subscriber=self.request.user, issue_id=OuterRef("id")
+                    )
+                )
+            )
         )
 
         # Priority Ordering
@@ -230,39 +219,10 @@ class GlobalViewIssuesViewSet(BaseViewSet):
         else:
             issue_queryset = issue_queryset.order_by(order_by_param)
 
-        if self.fields:
-            issues = IssueSerializer(
-                issue_queryset, many=True, fields=self.fields
-            ).data
-        else:
-            issues = issue_queryset.values(
-                "id",
-                "name",
-                "state_id",
-                "sort_order",
-                "completed_at",
-                "estimate_point",
-                "priority",
-                "start_date",
-                "target_date",
-                "sequence_id",
-                "project_id",
-                "parent_id",
-                "cycle_id",
-                "module_ids",
-                "label_ids",
-                "assignee_ids",
-                "sub_issues_count",
-                "created_at",
-                "updated_at",
-                "created_by",
-                "updated_by",
-                "attachment_count",
-                "link_count",
-                "is_draft",
-                "archived_at",
-            )
-        return Response(issues, status=status.HTTP_200_OK)
+        serializer = IssueSerializer(
+            issue_queryset, many=True, fields=fields if fields else None
+        )
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
 
 class IssueViewViewSet(BaseViewSet):
@@ -287,10 +247,7 @@ class IssueViewViewSet(BaseViewSet):
             .get_queryset()
             .filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
+            .filter(project__project_projectmember__member=self.request.user)
             .select_related("project")
             .select_related("workspace")
             .annotate(is_favorite=Exists(subquery))

apiserver/plane/app/views/workspace.py

@@ -22,14 +22,9 @@ from django.db.models import (
     When,
     Max,
     IntegerField,
-    Sum,
 )
 from django.db.models.functions import ExtractWeek, Cast, ExtractDay
 from django.db.models.fields import DateField
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models import Value, UUIDField
-from django.db.models.functions import Coalesce
 
 # Third party modules
 from rest_framework import status
@@ -51,14 +46,10 @@ from plane.app.serializers import (
     WorkspaceMemberMeSerializer,
     ProjectMemberRoleSerializer,
     WorkspaceUserPropertiesSerializer,
-    WorkspaceEstimateSerializer,
-    StateSerializer,
-    LabelSerializer,
 )
 from plane.app.views.base import BaseAPIView
 from . import BaseViewSet
 from plane.db.models import (
-    State,
     User,
     Workspace,
     WorkspaceMemberInvite,
@@ -76,11 +67,6 @@ from plane.db.models import (
     CycleIssue,
     IssueReaction,
     WorkspaceUserProperties,
-    Estimate,
-    EstimatePoint,
-    Module,
-    ModuleLink,
-    Cycle,
 )
 from plane.app.permissions import (
     WorkSpaceBasePermission,
@@ -93,12 +79,6 @@ from plane.app.permissions import (
 from plane.bgtasks.workspace_invitation_task import workspace_invitation
 from plane.utils.issue_filters import issue_filters
 from plane.bgtasks.event_tracking_task import workspace_invite_event
-from plane.app.serializers.module import (
-    ModuleSerializer,
-)
-from plane.app.serializers.cycle import (
-    CycleSerializer,
-)
 
 
 class WorkSpaceViewSet(BaseViewSet):
@@ -560,6 +540,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
             .get_queryset()
             .filter(
                 workspace__slug=self.kwargs.get("slug"),
+                member__is_bot=False,
                 is_active=True,
             )
             .select_related("workspace", "workspace__owner")
@@ -767,6 +748,7 @@ class WorkspaceProjectMemberEndpoint(BaseAPIView):
         project_ids = (
             ProjectMember.objects.filter(
                 member=request.user,
+                member__is_bot=False,
                 is_active=True,
             )
             .values_list("project_id", flat=True)
@@ -776,6 +758,7 @@ class WorkspaceProjectMemberEndpoint(BaseAPIView):
         # Get all the project members in which the user is involved
         project_members = ProjectMember.objects.filter(
             workspace__slug=slug,
+            member__is_bot=False,
             project_id__in=project_ids,
             is_active=True,
         ).select_related("project", "member", "workspace")
@@ -1086,7 +1069,6 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
                 workspace__slug=slug,
                 assignees__in=[user_id],
                 project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True
             )
             .filter(**filters)
             .annotate(state_group=F("state__group"))
@@ -1102,7 +1084,6 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
                 workspace__slug=slug,
                 assignees__in=[user_id],
                 project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True
             )
             .filter(**filters)
             .values("priority")
@@ -1125,7 +1106,6 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
             Issue.issue_objects.filter(
                 workspace__slug=slug,
                 project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True,
                 created_by_id=user_id,
             )
             .filter(**filters)
@@ -1137,7 +1117,6 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
                 workspace__slug=slug,
                 assignees__in=[user_id],
                 project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True,
             )
             .filter(**filters)
             .count()
@@ -1149,7 +1128,6 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
                 workspace__slug=slug,
                 assignees__in=[user_id],
                 project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True,
             )
             .filter(**filters)
             .count()
@@ -1161,7 +1139,6 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
                 assignees__in=[user_id],
                 state__group="completed",
                 project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True
             )
             .filter(**filters)
             .count()
@@ -1172,7 +1149,6 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
                 workspace__slug=slug,
                 subscriber_id=user_id,
                 project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True
             )
             .filter(**filters)
             .count()
@@ -1222,7 +1198,6 @@ class WorkspaceUserActivityEndpoint(BaseAPIView):
             ~Q(field__in=["comment", "vote", "reaction", "draft"]),
             workspace__slug=slug,
             project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True,
             actor=user_id,
         ).select_related("actor", "workspace", "issue", "project")
 
@@ -1253,7 +1228,6 @@ class WorkspaceUserProfileEndpoint(BaseAPIView):
                 Project.objects.filter(
                     workspace__slug=slug,
                     project_projectmember__member=request.user,
-                    project_projectmember__is_active=True,
                 )
                 .annotate(
                     created_issues=Count(
@@ -1363,12 +1337,12 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
                 | Q(issue_subscribers__subscriber_id=user_id),
                 workspace__slug=slug,
                 project__project_projectmember__member=request.user,
-                project__project_projectmember__is_active=True
             )
             .filter(**filters)
             .select_related("workspace", "project", "state", "parent")
-            .prefetch_related("assignees", "labels", "issue_module__module")
+            .prefetch_related("assignees", "labels")
             .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(module_id=F("issue_module__module_id"))
             .annotate(
                 link_count=IssueLink.objects.filter(issue=OuterRef("id"))
                 .order_by()
@@ -1384,39 +1358,11 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
             )
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=~Q(labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=~Q(assignees__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "issue_module__module_id",
-                        distinct=True,
-                        filter=~Q(issue_module__module_id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
             .order_by("created_at")
         ).distinct()
 
@@ -1495,234 +1441,10 @@ class WorkspaceLabelsEndpoint(BaseAPIView):
         labels = Label.objects.filter(
             workspace__slug=slug,
             project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True
+        ).values(
+            "parent", "name", "color", "id", "project_id", "workspace__slug"
         )
-        serializer = LabelSerializer(labels, many=True).data
-        return Response(serializer, status=status.HTTP_200_OK)
-
-
-class WorkspaceStatesEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkspaceEntityPermission,
-    ]
-
-    def get(self, request, slug):
-        states = State.objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True
-        )
-        serializer = StateSerializer(states, many=True).data
-        return Response(serializer, status=status.HTTP_200_OK)
-
-
-class WorkspaceEstimatesEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkspaceEntityPermission,
-    ]
-
-    def get(self, request, slug):
-        estimate_ids = Project.objects.filter(
-            workspace__slug=slug, estimate__isnull=False
-        ).values_list("estimate_id", flat=True)
-        estimates = Estimate.objects.filter(
-            pk__in=estimate_ids
-        ).prefetch_related(
-            Prefetch(
-                "points",
-                queryset=EstimatePoint.objects.select_related(
-                    "estimate", "workspace", "project"
-                ),
-            )
-        )
-        serializer = WorkspaceEstimateSerializer(estimates, many=True)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-
-class WorkspaceModulesEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkspaceViewerPermission,
-    ]
-
-    def get(self, request, slug):
-        modules = (
-            Module.objects.filter(workspace__slug=slug)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("lead")
-            .prefetch_related("members")
-            .prefetch_related(
-                Prefetch(
-                    "link_module",
-                    queryset=ModuleLink.objects.select_related(
-                        "module", "created_by"
-                    ),
-                )
-            )
-            .annotate(
-                total_issues=Count(
-                    "issue_module",
-                    filter=Q(
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                ),
-            )
-            .annotate(
-                completed_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="completed",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                cancelled_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="cancelled",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                started_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="started",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                unstarted_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="unstarted",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                backlog_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="backlog",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-        )
-
-        serializer = ModuleSerializer(modules, many=True).data
-        return Response(serializer, status=status.HTTP_200_OK)
-
-
-class WorkspaceCyclesEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkspaceViewerPermission,
-    ]
-
-    def get(self, request, slug):
-        cycles = (
-            Cycle.objects.filter(workspace__slug=slug)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("owned_by")
-            .annotate(
-                total_issues=Count(
-                    "issue_cycle",
-                    filter=Q(
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                completed_issues=Count(
-                    "issue_cycle__issue__state__group",
-                    filter=Q(
-                        issue_cycle__issue__state__group="completed",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                cancelled_issues=Count(
-                    "issue_cycle__issue__state__group",
-                    filter=Q(
-                        issue_cycle__issue__state__group="cancelled",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                started_issues=Count(
-                    "issue_cycle__issue__state__group",
-                    filter=Q(
-                        issue_cycle__issue__state__group="started",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                unstarted_issues=Count(
-                    "issue_cycle__issue__state__group",
-                    filter=Q(
-                        issue_cycle__issue__state__group="unstarted",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                backlog_issues=Count(
-                    "issue_cycle__issue__state__group",
-                    filter=Q(
-                        issue_cycle__issue__state__group="backlog",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                total_estimates=Sum("issue_cycle__issue__estimate_point")
-            )
-            .annotate(
-                completed_estimates=Sum(
-                    "issue_cycle__issue__estimate_point",
-                    filter=Q(
-                        issue_cycle__issue__state__group="completed",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                started_estimates=Sum(
-                    "issue_cycle__issue__estimate_point",
-                    filter=Q(
-                        issue_cycle__issue__state__group="started",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-        serializer = CycleSerializer(cycles, many=True).data
-        return Response(serializer, status=status.HTTP_200_OK)
+        return Response(labels, status=status.HTTP_200_OK)
 
 
 class WorkspaceUserPropertiesEndpoint(BaseAPIView):

apiserver/plane/bgtasks/email_notification_task.py

@@ -1,308 +0,0 @@
-from datetime import datetime
-from bs4 import BeautifulSoup
-
-# Third party imports
-from celery import shared_task
-from sentry_sdk import capture_exception
-
-# Django imports
-from django.utils import timezone
-from django.core.mail import EmailMultiAlternatives, get_connection
-from django.template.loader import render_to_string
-from django.utils.html import strip_tags
-from django.conf import settings
-
-# Module imports
-from plane.db.models import EmailNotificationLog, User, Issue
-from plane.license.utils.instance_value import get_email_configuration
-from plane.settings.redis import redis_instance
-
-# acquire and delete redis lock
-def acquire_lock(lock_id, expire_time=300):
-    redis_client = redis_instance()
-    """Attempt to acquire a lock with a specified expiration time."""
-    return redis_client.set(lock_id, 'true', nx=True, ex=expire_time)
-
-def release_lock(lock_id):
-    """Release a lock."""
-    redis_client = redis_instance()
-    redis_client.delete(lock_id)
-
-@shared_task
-def stack_email_notification():
-    # get all email notifications
-    email_notifications = (
-        EmailNotificationLog.objects.filter(processed_at__isnull=True)
-        .order_by("receiver")
-        .values()
-    )
-
-    # Create the below format for each of the issues
-    # {"issue_id" : { "actor_id1": [ { data }, { data } ], "actor_id2": [ { data }, { data } ] }}
-
-    # Convert to unique receivers list
-    receivers = list(
-        set(
-            [
-                str(notification.get("receiver_id"))
-                for notification in email_notifications
-            ]
-        )
-    )
-    processed_notifications = []
-    # Loop through all the issues to create the emails
-    for receiver_id in receivers:
-        # Notification triggered for the receiver
-        receiver_notifications = [
-            notification
-            for notification in email_notifications
-            if str(notification.get("receiver_id")) == receiver_id
-        ]
-        # create payload for all issues
-        payload = {}
-        email_notification_ids = []
-        for receiver_notification in receiver_notifications:
-            payload.setdefault(
-                receiver_notification.get("entity_identifier"), {}
-            ).setdefault(
-                str(receiver_notification.get("triggered_by_id")), []
-            ).append(
-                receiver_notification.get("data")
-            )
-            # append processed notifications
-            processed_notifications.append(receiver_notification.get("id"))
-            email_notification_ids.append(receiver_notification.get("id"))
-
-        # Create emails for all the issues
-        for issue_id, notification_data in payload.items():
-            send_email_notification.delay(
-                issue_id=issue_id,
-                notification_data=notification_data,
-                receiver_id=receiver_id,
-                email_notification_ids=email_notification_ids,
-            )
-
-    # Update the email notification log
-    EmailNotificationLog.objects.filter(pk__in=processed_notifications).update(
-        processed_at=timezone.now()
-    )
-
-
-def create_payload(notification_data):
-    # return format {"actor_id":  { "key": { "old_value": [], "new_value": [] } }}
-    data = {}
-    for actor_id, changes in notification_data.items():
-        for change in changes:
-            issue_activity = change.get("issue_activity")
-            if issue_activity:  # Ensure issue_activity is not None
-                field = issue_activity.get("field")
-                old_value = str(issue_activity.get("old_value"))
-                new_value = str(issue_activity.get("new_value"))
-
-                # Append old_value if it's not empty and not already in the list
-                if old_value:
-                    data.setdefault(actor_id, {}).setdefault(
-                        field, {}
-                    ).setdefault("old_value", []).append(
-                        old_value
-                    ) if old_value not in data.setdefault(
-                        actor_id, {}
-                    ).setdefault(
-                        field, {}
-                    ).get(
-                        "old_value", []
-                    ) else None
-
-                # Append new_value if it's not empty and not already in the list
-                if new_value:
-                    data.setdefault(actor_id, {}).setdefault(
-                        field, {}
-                    ).setdefault("new_value", []).append(
-                        new_value
-                    ) if new_value not in data.setdefault(
-                        actor_id, {}
-                    ).setdefault(
-                        field, {}
-                    ).get(
-                        "new_value", []
-                    ) else None
-
-                if not data.get("actor_id", {}).get("activity_time", False):
-                    data[actor_id]["activity_time"] = str(
-                        datetime.fromisoformat(
-                            issue_activity.get("activity_time").rstrip("Z")
-                        ).strftime("%Y-%m-%d %H:%M:%S")
-                    )
-
-    return data
-
-def process_mention(mention_component):
-    soup = BeautifulSoup(mention_component, 'html.parser')
-    mentions = soup.find_all('mention-component')
-    for mention in mentions:
-        user_id = mention['id']
-        user = User.objects.get(pk=user_id)
-        user_name = user.display_name
-        highlighted_name = f"@{user_name}"
-        mention.replace_with(highlighted_name)
-    return str(soup)
-
-def process_html_content(content):
-    processed_content_list = []
-    for html_content in content:
-        processed_content = process_mention(html_content)
-        processed_content_list.append(processed_content)  
-    return processed_content_list
-
-
-@shared_task
-def send_email_notification(
-    issue_id, notification_data, receiver_id, email_notification_ids
-):
-    # Convert UUIDs to a sorted, concatenated string
-    sorted_ids = sorted(email_notification_ids)
-    ids_str = "_".join(str(id) for id in sorted_ids)
-    lock_id = f"send_email_notif_{issue_id}_{receiver_id}_{ids_str}"
-
-    # acquire the lock for sending emails
-    try:
-        if acquire_lock(lock_id=lock_id):
-            # get the redis instance
-            ri = redis_instance()
-            base_api = (ri.get(str(issue_id)).decode())
-            data = create_payload(notification_data=notification_data)
-
-            # Get email configurations
-            (
-                EMAIL_HOST,
-                EMAIL_HOST_USER,
-                EMAIL_HOST_PASSWORD,
-                EMAIL_PORT,
-                EMAIL_USE_TLS,
-                EMAIL_FROM,
-            ) = get_email_configuration()
-
-            receiver = User.objects.get(pk=receiver_id)
-            issue = Issue.objects.get(pk=issue_id)
-            template_data = []
-            total_changes = 0
-            comments = []
-            actors_involved = []
-            for actor_id, changes in data.items():
-                actor = User.objects.get(pk=actor_id)
-                total_changes = total_changes + len(changes)
-                comment = changes.pop("comment", False)
-                mention = changes.pop("mention", False)
-                actors_involved.append(actor_id)
-                if comment:
-                    comments.append(
-                        {
-                            "actor_comments": comment,
-                            "actor_detail": {
-                                "avatar_url": actor.avatar,
-                                "first_name": actor.first_name,
-                                "last_name": actor.last_name,
-                            },
-                        }
-                    )
-                if mention:
-                    mention["new_value"] = process_html_content(mention.get("new_value"))
-                    mention["old_value"] = process_html_content(mention.get("old_value"))
-                    comments.append(
-                        {
-                            "actor_comments": mention,
-                            "actor_detail": {
-                                "avatar_url": actor.avatar,
-                                "first_name": actor.first_name,
-                                "last_name": actor.last_name,
-                            },
-                        }
-                    )
-                activity_time = changes.pop("activity_time")
-                # Parse the input string into a datetime object
-                formatted_time = datetime.strptime(activity_time, "%Y-%m-%d %H:%M:%S").strftime("%H:%M %p")
-
-                if changes:
-                    template_data.append(
-                        {
-                            "actor_detail": {
-                                "avatar_url": actor.avatar,
-                                "first_name": actor.first_name,
-                                "last_name": actor.last_name,
-                            },
-                            "changes": changes,
-                            "issue_details": {
-                                "name": issue.name,
-                                "identifier": f"{issue.project.identifier}-{issue.sequence_id}",
-                            },
-                            "activity_time": str(formatted_time),
-                        }
-                )
-
-            summary = "Updates were made to the issue by"
-
-            # Send the mail
-            subject = f"{issue.project.identifier}-{issue.sequence_id} {issue.name}"
-            context = {
-                "data": template_data,
-                "summary": summary,
-                "actors_involved": len(set(actors_involved)),
-                "issue": {
-                    "issue_identifier": f"{str(issue.project.identifier)}-{str(issue.sequence_id)}",
-                    "name": issue.name,
-                    "issue_url": f"{base_api}/{str(issue.project.workspace.slug)}/projects/{str(issue.project.id)}/issues/{str(issue.id)}",
-                },
-                "receiver": {
-                    "email": receiver.email,
-                },
-                "issue_url": f"{base_api}/{str(issue.project.workspace.slug)}/projects/{str(issue.project.id)}/issues/{str(issue.id)}",
-                "project_url": f"{base_api}/{str(issue.project.workspace.slug)}/projects/{str(issue.project.id)}/issues/",
-                "workspace":str(issue.project.workspace.slug),
-                "project": str(issue.project.name),
-                "user_preference": f"{base_api}/profile/preferences/email",
-                "comments": comments,
-            }
-            html_content = render_to_string(
-                "emails/notifications/issue-updates.html", context
-            )
-            text_content = strip_tags(html_content)
-
-            try:
-                connection = get_connection(
-                    host=EMAIL_HOST,
-                    port=int(EMAIL_PORT),
-                    username=EMAIL_HOST_USER,
-                    password=EMAIL_HOST_PASSWORD,
-                    use_tls=EMAIL_USE_TLS == "1",
-                )
-
-                msg = EmailMultiAlternatives(
-                    subject=subject,
-                    body=text_content,
-                    from_email=EMAIL_FROM,
-                    to=[receiver.email],
-                    connection=connection,
-                )
-                msg.attach_alternative(html_content, "text/html")
-                msg.send()
-
-                EmailNotificationLog.objects.filter(
-                    pk__in=email_notification_ids
-                ).update(sent_at=timezone.now())
-
-                # release the lock
-                release_lock(lock_id=lock_id)
-                return
-            except Exception as e:
-                capture_exception(e)
-                # release the lock
-                release_lock(lock_id=lock_id)
-                return
-        else:
-            print("Duplicate task recived. Skipping...")
-            return
-    except (Issue.DoesNotExist, User.DoesNotExist) as e:
-        if settings.DEBUG:
-            print(e)
-        release_lock(lock_id=lock_id)
-        return

apiserver/plane/bgtasks/export_task.py

@@ -97,7 +97,7 @@ def upload_to_s3(zip_file, workspace_id, token_id, slug):
         )
         # Create the new url with updated domain and protocol
         presigned_url = presigned_url.replace(
-            f"{settings.AWS_S3_ENDPOINT_URL}/{settings.AWS_STORAGE_BUCKET_NAME}/",
+            "http://plane-minio:9000/uploads/",
             f"{settings.AWS_S3_URL_PROTOCOL}//{settings.AWS_S3_CUSTOM_DOMAIN}/",
         )
     else:
@@ -292,7 +292,6 @@ def issue_export_task(
                     workspace__id=workspace_id,
                     project_id__in=project_ids,
                     project__project_projectmember__member=exporter_instance.initiated_by_id,
-                    project__project_projectmember__is_active=True
                 )
                 .select_related(
                     "project", "workspace", "state", "parent", "created_by"

apiserver/plane/bgtasks/forgot_password_task.py

@@ -21,7 +21,7 @@ from plane.license.utils.instance_value import get_email_configuration
 def forgot_password(first_name, email, uidb64, token, current_site):
     try:
         relative_link = (
-            f"/accounts/reset-password/?uidb64={uidb64}&token={token}&email={email}"
+            f"/accounts/password/?uidb64={uidb64}&token={token}&email={email}"
         )
         abs_url = str(current_site) + relative_link
 

apiserver/plane/bgtasks/importer_task.py

@@ -24,7 +24,6 @@ from plane.db.models import (
     Label,
     User,
     IssueProperty,
-    UserNotificationPreference,
 )
 
 
@@ -51,15 +50,10 @@ def service_importer(service, importer_id):
                     for user in users
                     if user.get("import", False) == "invite"
                 ],
-                batch_size=100,
+                batch_size=10,
                 ignore_conflicts=True,
             )
 
-            _ = UserNotificationPreference.objects.bulk_create(
-                [UserNotificationPreference(user=user) for user in new_users],
-                batch_size=100,
-            )
-
             workspace_users = User.objects.filter(
                 email__in=[
                     user.get("email").strip().lower()

apiserver/plane/bgtasks/issue_activites_task.py

@@ -24,11 +24,9 @@ from plane.db.models import (
     IssueReaction,
     CommentReaction,
     IssueComment,
-    IssueSubscriber,
 )
 from plane.app.serializers import IssueActivitySerializer
 from plane.bgtasks.notification_task import notifications
-from plane.settings.redis import redis_instance
 
 
 # Track Changes in name
@@ -113,15 +111,15 @@ def track_parent(
     issue_activities,
     epoch,
 ):
-    if current_instance.get("parent_id") != requested_data.get("parent_id"):
+    if current_instance.get("parent") != requested_data.get("parent"):
         old_parent = (
-            Issue.objects.filter(pk=current_instance.get("parent_id")).first()
-            if current_instance.get("parent_id") is not None
+            Issue.objects.filter(pk=current_instance.get("parent")).first()
+            if current_instance.get("parent") is not None
             else None
         )
         new_parent = (
-            Issue.objects.filter(pk=requested_data.get("parent_id")).first()
-            if requested_data.get("parent_id") is not None
+            Issue.objects.filter(pk=requested_data.get("parent")).first()
+            if requested_data.get("parent") is not None
             else None
         )
 
@@ -190,11 +188,9 @@ def track_state(
     issue_activities,
     epoch,
 ):
-    if current_instance.get("state_id") != requested_data.get("state_id"):
-        new_state = State.objects.get(pk=requested_data.get("state_id", None))
-        old_state = State.objects.get(
-            pk=current_instance.get("state_id", None)
-        )
+    if current_instance.get("state") != requested_data.get("state"):
+        new_state = State.objects.get(pk=requested_data.get("state", None))
+        old_state = State.objects.get(pk=current_instance.get("state", None))
 
         issue_activities.append(
             IssueActivity(
@@ -292,10 +288,10 @@ def track_labels(
     epoch,
 ):
     requested_labels = set(
-        [str(lab) for lab in requested_data.get("label_ids", [])]
+        [str(lab) for lab in requested_data.get("labels", [])]
     )
     current_labels = set(
-        [str(lab) for lab in current_instance.get("label_ids", [])]
+        [str(lab) for lab in current_instance.get("labels", [])]
     )
 
     added_labels = requested_labels - current_labels
@@ -353,22 +349,16 @@ def track_assignees(
     issue_activities,
     epoch,
 ):
-    requested_assignees = (
-        set([str(asg) for asg in requested_data.get("assignee_ids", [])])
-        if requested_data is not None
-        else set()
+    requested_assignees = set(
+        [str(asg) for asg in requested_data.get("assignees", [])]
     )
-    current_assignees = (
-        set([str(asg) for asg in current_instance.get("assignee_ids", [])])
-        if current_instance is not None
-        else set()
+    current_assignees = set(
+        [str(asg) for asg in current_instance.get("assignees", [])]
     )
 
-
     added_assignees = requested_assignees - current_assignees
     dropped_assginees = current_assignees - requested_assignees
 
-    bulk_subscribers = []
     for added_asignee in added_assignees:
         assignee = User.objects.get(pk=added_asignee)
         issue_activities.append(
@@ -386,21 +376,6 @@ def track_assignees(
                 epoch=epoch,
             )
         )
-        bulk_subscribers.append(
-            IssueSubscriber(
-                subscriber_id=assignee.id,
-                issue_id=issue_id,
-                workspace_id=workspace_id,
-                project_id=project_id,
-                created_by_id=assignee.id,
-                updated_by_id=assignee.id,
-            )
-        )
-
-    # Create assignees subscribers to the issue and ignore if already
-    IssueSubscriber.objects.bulk_create(
-        bulk_subscribers, batch_size=10, ignore_conflicts=True
-    )
 
     for dropped_assignee in dropped_assginees:
         assignee = User.objects.get(pk=dropped_assignee)
@@ -483,23 +458,17 @@ def track_archive_at(
                 )
             )
         else:
-            if requested_data.get("automation"):
-                comment = "Plane has archived the issue"
-                new_value = "archive"
-            else:
-                comment = "Actor has archived the issue"
-                new_value = "manual_archive"
             issue_activities.append(
                 IssueActivity(
                     issue_id=issue_id,
                     project_id=project_id,
                     workspace_id=workspace_id,
-                    comment=comment,
+                    comment="Plane has archived the issue",
                     verb="updated",
                     actor_id=actor_id,
                     field="archived_at",
                     old_value=None,
-                    new_value=new_value,
+                    new_value="archive",
                     epoch=epoch,
                 )
             )
@@ -558,20 +527,6 @@ def create_issue_activity(
             epoch=epoch,
         )
     )
-    requested_data = (
-        json.loads(requested_data) if requested_data is not None else None
-    )
-    if requested_data.get("assignee_ids") is not None:
-        track_assignees(
-            requested_data,
-            current_instance,
-            issue_id,
-            project_id,
-            workspace_id,
-            actor_id,
-            issue_activities,
-            epoch,
-        )
 
 
 def update_issue_activity(
@@ -586,14 +541,14 @@ def update_issue_activity(
 ):
     ISSUE_ACTIVITY_MAPPER = {
         "name": track_name,
-        "parent_id": track_parent,
+        "parent": track_parent,
         "priority": track_priority,
-        "state_id": track_state,
+        "state": track_state,
         "description_html": track_description,
         "target_date": track_target_date,
         "start_date": track_start_date,
-        "label_ids": track_labels,
-        "assignee_ids": track_assignees,
+        "labels": track_labels,
+        "assignees": track_assignees,
         "estimate_point": track_estimate_points,
         "archived_at": track_archive_at,
         "closed_to": track_closed_to,
@@ -878,27 +833,71 @@ def create_module_issue_activity(
     requested_data = (
         json.loads(requested_data) if requested_data is not None else None
     )
-    module = Module.objects.filter(pk=requested_data.get("module_id")).first()
-    issue = Issue.objects.filter(pk=issue_id).first()
-    if issue:
-        issue.updated_at = timezone.now()
-        issue.save(update_fields=["updated_at"])
-    issue_activities.append(
-        IssueActivity(
-            issue_id=issue_id,
-            actor_id=actor_id,
-            verb="created",
-            old_value="",
-            new_value=module.name,
-            field="modules",
-            project_id=project_id,
-            workspace_id=workspace_id,
-            comment=f"added module {module.name}",
-            new_identifier=requested_data.get("module_id"),
-            epoch=epoch,
-        )
+    current_instance = (
+        json.loads(current_instance) if current_instance is not None else None
     )
 
+    # Updated Records:
+    updated_records = current_instance.get("updated_module_issues", [])
+    created_records = json.loads(
+        current_instance.get("created_module_issues", [])
+    )
+
+    for updated_record in updated_records:
+        old_module = Module.objects.filter(
+            pk=updated_record.get("old_module_id", None)
+        ).first()
+        new_module = Module.objects.filter(
+            pk=updated_record.get("new_module_id", None)
+        ).first()
+        issue = Issue.objects.filter(pk=updated_record.get("issue_id")).first()
+        if issue:
+            issue.updated_at = timezone.now()
+            issue.save(update_fields=["updated_at"])
+
+        issue_activities.append(
+            IssueActivity(
+                issue_id=updated_record.get("issue_id"),
+                actor_id=actor_id,
+                verb="updated",
+                old_value=old_module.name,
+                new_value=new_module.name,
+                field="modules",
+                project_id=project_id,
+                workspace_id=workspace_id,
+                comment=f"updated module to ",
+                old_identifier=old_module.id,
+                new_identifier=new_module.id,
+                epoch=epoch,
+            )
+        )
+
+    for created_record in created_records:
+        module = Module.objects.filter(
+            pk=created_record.get("fields").get("module")
+        ).first()
+        issue = Issue.objects.filter(
+            pk=created_record.get("fields").get("issue")
+        ).first()
+        if issue:
+            issue.updated_at = timezone.now()
+            issue.save(update_fields=["updated_at"])
+        issue_activities.append(
+            IssueActivity(
+                issue_id=created_record.get("fields").get("issue"),
+                actor_id=actor_id,
+                verb="created",
+                old_value="",
+                new_value=module.name,
+                field="modules",
+                project_id=project_id,
+                workspace_id=workspace_id,
+                comment=f"added module {module.name}",
+                new_identifier=module.id,
+                epoch=epoch,
+            )
+        )
+
 
 def delete_module_issue_activity(
     requested_data,
@@ -916,26 +915,32 @@ def delete_module_issue_activity(
     current_instance = (
         json.loads(current_instance) if current_instance is not None else None
     )
-    module_name = current_instance.get("module_name")
-    current_issue = Issue.objects.filter(pk=issue_id).first()
-    if current_issue:
-        current_issue.updated_at = timezone.now()
-        current_issue.save(update_fields=["updated_at"])
-    issue_activities.append(
-        IssueActivity(
-            issue_id=issue_id,
-            actor_id=actor_id,
-            verb="deleted",
-            old_value=module_name,
-            new_value="",
-            field="modules",
-            project_id=project_id,
-            workspace_id=workspace_id,
-            comment=f"removed this issue from {module_name}",
-            old_identifier=requested_data.get("module_id") if requested_data.get("module_id") is not None else None,
-            epoch=epoch,
+
+    module_id = requested_data.get("module_id", "")
+    module_name = requested_data.get("module_name", "")
+    module = Module.objects.filter(pk=module_id).first()
+    issues = requested_data.get("issues")
+
+    for issue in issues:
+        current_issue = Issue.objects.filter(pk=issue).first()
+        if issue:
+            current_issue.updated_at = timezone.now()
+            current_issue.save(update_fields=["updated_at"])
+        issue_activities.append(
+            IssueActivity(
+                issue_id=issue,
+                actor_id=actor_id,
+                verb="deleted",
+                old_value=module.name if module is not None else module_name,
+                new_value="",
+                field="modules",
+                project_id=project_id,
+                workspace_id=workspace_id,
+                comment=f"removed this issue from {module.name if module is not None else module_name}",
+                old_identifier=module_id if module_id is not None else None,
+                epoch=epoch,
+            )
         )
-    )
 
 
 def create_link_activity(
@@ -1538,8 +1543,6 @@ def issue_activity(
     project_id,
     epoch,
     subscriber=True,
-    notification=False,
-    origin=None,
 ):
     try:
         issue_activities = []
@@ -1548,10 +1551,6 @@ def issue_activity(
         workspace_id = project.workspace_id
 
         if issue_id is not None:
-            if origin:
-                ri = redis_instance()
-                # set the request origin in redis
-                ri.set(str(issue_id), origin, ex=600)
             issue = Issue.objects.filter(pk=issue_id).first()
             if issue:
                 try:
@@ -1625,22 +1624,21 @@ def issue_activity(
             except Exception as e:
                 capture_exception(e)
 
-        if notification:
-            notifications.delay(
-                type=type,
-                issue_id=issue_id,
-                actor_id=actor_id,
-                project_id=project_id,
-                subscriber=subscriber,
-                issue_activities_created=json.dumps(
-                    IssueActivitySerializer(
-                        issue_activities_created, many=True
-                    ).data,
-                    cls=DjangoJSONEncoder,
-                ),
-                requested_data=requested_data,
-                current_instance=current_instance,
-            )
+        notifications.delay(
+            type=type,
+            issue_id=issue_id,
+            actor_id=actor_id,
+            project_id=project_id,
+            subscriber=subscriber,
+            issue_activities_created=json.dumps(
+                IssueActivitySerializer(
+                    issue_activities_created, many=True
+                ).data,
+                cls=DjangoJSONEncoder,
+            ),
+            requested_data=requested_data,
+            current_instance=current_instance,
+        )
 
         return
     except Exception as e:

apiserver/plane/bgtasks/issue_automation_task.py

@@ -79,7 +79,7 @@ def archive_old_issues():
                         issue_activity.delay(
                             type="issue.activity.updated",
                             requested_data=json.dumps(
-                                {"archived_at": str(archive_at), "automation": True}
+                                {"archived_at": str(archive_at)}
                             ),
                             actor_id=str(project.created_by_id),
                             issue_id=issue.id,
@@ -87,7 +87,6 @@ def archive_old_issues():
                             current_instance=json.dumps({"archived_at": None}),
                             subscriber=False,
                             epoch=int(timezone.now().timestamp()),
-                            notification=True,
                         )
                         for issue in issues_to_update
                     ]
@@ -170,7 +169,6 @@ def close_old_issues():
                             current_instance=None,
                             subscriber=False,
                             epoch=int(timezone.now().timestamp()),
-                            notification=True,
                         )
                         for issue in issues_to_update
                     ]

apiserver/plane/bgtasks/notification_task.py

@@ -10,12 +10,9 @@ from plane.db.models import (
     User,
     IssueAssignee,
     Issue,
-    State,
-    EmailNotificationLog,
     Notification,
     IssueComment,
     IssueActivity,
-    UserNotificationPreference,
 )
 
 # Third Party imports
@@ -23,7 +20,7 @@ from celery import shared_task
 from bs4 import BeautifulSoup
 
 
-# =========== Issue Description Html Parsing and notification Functions ======================
+# =========== Issue Description Html Parsing and Notification Functions ======================
 
 
 def update_mentions_for_issue(issue, project, new_mentions, removed_mention):
@@ -40,7 +37,9 @@ def update_mentions_for_issue(issue, project, new_mentions, removed_mention):
         )
 
     IssueMention.objects.bulk_create(aggregated_issue_mentions, batch_size=100)
-    IssueMention.objects.filter(issue=issue, mention__in=removed_mention).delete()
+    IssueMention.objects.filter(
+        issue=issue, mention__in=removed_mention
+    ).delete()
 
 
 def get_new_mentions(requested_instance, current_instance):
@@ -61,6 +60,8 @@ def get_new_mentions(requested_instance, current_instance):
 
 
 # Get Removed Mention
+
+
 def get_removed_mentions(requested_instance, current_instance):
     # requested_data is the newer instance of the current issue
     # current_instance is the older instance of the current issue, saved in the database
@@ -78,6 +79,8 @@ def get_removed_mentions(requested_instance, current_instance):
 
 
 # Adds mentions as subscribers
+
+
 def extract_mentions_as_subscribers(project_id, issue_id, mentions):
     # mentions is an array of User IDs representing the FILTERED set of mentioned users
 
@@ -92,7 +95,9 @@ def extract_mentions_as_subscribers(project_id, issue_id, mentions):
                 project_id=project_id,
             ).exists()
             and not IssueAssignee.objects.filter(
-                project_id=project_id, issue_id=issue_id, assignee_id=mention_id
+                project_id=project_id,
+                issue_id=issue_id,
+                assignee_id=mention_id,
             ).exists()
             and not Issue.objects.filter(
                 project_id=project_id, pk=issue_id, created_by_id=mention_id
@@ -120,7 +125,9 @@ def extract_mentions(issue_instance):
         data = json.loads(issue_instance)
         html = data.get("description_html")
         soup = BeautifulSoup(html, "html.parser")
-        mention_tags = soup.find_all("mention-component", attrs={"target": "users"})
+        mention_tags = soup.find_all(
+            "mention-component", attrs={"target": "users"}
+        )
 
         mentions = [mention_tag["id"] for mention_tag in mention_tags]
 
@@ -129,12 +136,14 @@ def extract_mentions(issue_instance):
         return []
 
 
-# =========== Comment Parsing and notification Functions ======================
+# =========== Comment Parsing and Notification Functions ======================
 def extract_comment_mentions(comment_value):
     try:
         mentions = []
         soup = BeautifulSoup(comment_value, "html.parser")
-        mentions_tags = soup.find_all("mention-component", attrs={"target": "users"})
+        mentions_tags = soup.find_all(
+            "mention-component", attrs={"target": "users"}
+        )
         for mention_tag in mentions_tags:
             mentions.append(mention_tag["id"])
         return list(set(mentions))
@@ -156,8 +165,14 @@ def get_new_comment_mentions(new_value, old_value):
     return new_mentions
 
 
-def create_mention_notification(
-    project, notification_comment, issue, actor_id, mention_id, issue_id, activity
+def createMentionNotification(
+    project,
+    notification_comment,
+    issue,
+    actor_id,
+    mention_id,
+    issue_id,
+    activity,
 ):
     return Notification(
         workspace=project.workspace,
@@ -200,199 +215,244 @@ def notifications(
     requested_data,
     current_instance,
 ):
-    try:
-        issue_activities_created = (
-            json.loads(issue_activities_created)
-            if issue_activities_created is not None
-            else None
+    issue_activities_created = (
+        json.loads(issue_activities_created)
+        if issue_activities_created is not None
+        else None
+    )
+    if type not in [
+        "issue.activity.deleted",
+        "cycle.activity.created",
+        "cycle.activity.deleted",
+        "module.activity.created",
+        "module.activity.deleted",
+        "issue_reaction.activity.created",
+        "issue_reaction.activity.deleted",
+        "comment_reaction.activity.created",
+        "comment_reaction.activity.deleted",
+        "issue_vote.activity.created",
+        "issue_vote.activity.deleted",
+        "issue_draft.activity.created",
+        "issue_draft.activity.updated",
+        "issue_draft.activity.deleted",
+    ]:
+        # Create Notifications
+        bulk_notifications = []
+
+        """
+        Mention Tasks
+        1. Perform Diffing and Extract the mentions, that mention notification needs to be sent
+        2. From the latest set of mentions, extract the users which are not a subscribers & make them subscribers
+        """
+
+        # Get new mentions from the newer instance
+        new_mentions = get_new_mentions(
+            requested_instance=requested_data,
+            current_instance=current_instance,
+        )
+        removed_mention = get_removed_mentions(
+            requested_instance=requested_data,
+            current_instance=current_instance,
         )
-        if type not in [
-            "issue.activity.deleted",
-            "cycle.activity.created",
-            "cycle.activity.deleted",
-            "module.activity.created",
-            "module.activity.deleted",
-            "issue_reaction.activity.created",
-            "issue_reaction.activity.deleted",
-            "comment_reaction.activity.created",
-            "comment_reaction.activity.deleted",
-            "issue_vote.activity.created",
-            "issue_vote.activity.deleted",
-            "issue_draft.activity.created",
-            "issue_draft.activity.updated",
-            "issue_draft.activity.deleted",
-        ]:
-            # Create Notifications
-            bulk_notifications = []
-            bulk_email_logs = []
 
-            """
-            Mention Tasks
-            1. Perform Diffing and Extract the mentions, that mention notification needs to be sent
-            2. From the latest set of mentions, extract the users which are not a subscribers & make them subscribers
-            """
+        comment_mentions = []
+        all_comment_mentions = []
 
-            # Get new mentions from the newer instance
-            new_mentions = get_new_mentions(
-                requested_instance=requested_data,
-                current_instance=current_instance,
-            )
-            removed_mention = get_removed_mentions(
-                requested_instance=requested_data,
-                current_instance=current_instance,
-            )
+        # Get New Subscribers from the mentions of the newer instance
+        requested_mentions = extract_mentions(issue_instance=requested_data)
+        mention_subscribers = extract_mentions_as_subscribers(
+            project_id=project_id,
+            issue_id=issue_id,
+            mentions=requested_mentions,
+        )
 
-            comment_mentions = []
-            all_comment_mentions = []
+        for issue_activity in issue_activities_created:
+            issue_comment = issue_activity.get("issue_comment")
+            issue_comment_new_value = issue_activity.get("new_value")
+            issue_comment_old_value = issue_activity.get("old_value")
+            if issue_comment is not None:
+                # TODO: Maybe save the comment mentions, so that in future, we can filter out the issues based on comment mentions as well.
 
-            # Get New Subscribers from the mentions of the newer instance
-            requested_mentions = extract_mentions(
-                issue_instance=requested_data
+                all_comment_mentions = (
+                    all_comment_mentions
+                    + extract_comment_mentions(issue_comment_new_value)
+                )
+
+                new_comment_mentions = get_new_comment_mentions(
+                    old_value=issue_comment_old_value,
+                    new_value=issue_comment_new_value,
+                )
+                comment_mentions = comment_mentions + new_comment_mentions
+
+        comment_mention_subscribers = extract_mentions_as_subscribers(
+            project_id=project_id,
+            issue_id=issue_id,
+            mentions=all_comment_mentions,
+        )
+        """
+        We will not send subscription activity notification to the below mentioned user sets
+        - Those who have been newly mentioned in the issue description, we will send mention notification to them.
+        - When the activity is a comment_created and there exist a mention in the comment, then we have to send the "mention_in_comment" notification
+        - When the activity is a comment_updated and there exist a mention change, then also we have to send the "mention_in_comment" notification
+        """
+
+        issue_assignees = list(
+            IssueAssignee.objects.filter(
+                project_id=project_id, issue_id=issue_id
             )
-            mention_subscribers = extract_mentions_as_subscribers(
-                project_id=project_id,
-                issue_id=issue_id,
-                mentions=requested_mentions,
+            .exclude(assignee_id__in=list(new_mentions + comment_mentions))
+            .values_list("assignee", flat=True)
+        )
+
+        issue_subscribers = list(
+            IssueSubscriber.objects.filter(
+                project_id=project_id, issue_id=issue_id
             )
+            .exclude(
+                subscriber_id__in=list(
+                    new_mentions + comment_mentions + [actor_id]
+                )
+            )
+            .values_list("subscriber", flat=True)
+        )
+
+        issue = Issue.objects.filter(pk=issue_id).first()
+
+        if issue.created_by_id is not None and str(issue.created_by_id) != str(
+            actor_id
+        ):
+            issue_subscribers = issue_subscribers + [issue.created_by_id]
+
+        if subscriber:
+            # add the user to issue subscriber
+            try:
+                if (
+                    str(issue.created_by_id) != str(actor_id)
+                    and uuid.UUID(actor_id) not in issue_assignees
+                ):
+                    _ = IssueSubscriber.objects.get_or_create(
+                        project_id=project_id,
+                        issue_id=issue_id,
+                        subscriber_id=actor_id,
+                    )
+            except Exception as e:
+                pass
+
+        project = Project.objects.get(pk=project_id)
+
+        issue_subscribers = list(
+            set(issue_subscribers + issue_assignees) - {uuid.UUID(actor_id)}
+        )
+
+        for subscriber in issue_subscribers:
+            if subscriber in issue_subscribers:
+                sender = "in_app:issue_activities:subscribed"
+            if (
+                issue.created_by_id is not None
+                and subscriber == issue.created_by_id
+            ):
+                sender = "in_app:issue_activities:created"
+            if subscriber in issue_assignees:
+                sender = "in_app:issue_activities:assigned"
 
             for issue_activity in issue_activities_created:
+                # Do not send notification for description update
+                if issue_activity.get("field") == "description":
+                    continue
                 issue_comment = issue_activity.get("issue_comment")
-                issue_comment_new_value = issue_activity.get("new_value")
-                issue_comment_old_value = issue_activity.get("old_value")
                 if issue_comment is not None:
-                    # TODO: Maybe save the comment mentions, so that in future, we can filter out the issues based on comment mentions as well.
-
-                    all_comment_mentions = (
-                        all_comment_mentions
-                        + extract_comment_mentions(issue_comment_new_value)
+                    issue_comment = IssueComment.objects.get(
+                        id=issue_comment,
+                        issue_id=issue_id,
+                        project_id=project_id,
+                        workspace_id=project.workspace_id,
                     )
 
-                    new_comment_mentions = get_new_comment_mentions(
-                        old_value=issue_comment_old_value,
-                        new_value=issue_comment_new_value,
-                    )
-                    comment_mentions = comment_mentions + new_comment_mentions
-
-            comment_mention_subscribers = extract_mentions_as_subscribers(
-                project_id=project_id,
-                issue_id=issue_id,
-                mentions=all_comment_mentions,
-            )
-            """
-            We will not send subscription activity notification to the below mentioned user sets
-            - Those who have been newly mentioned in the issue description, we will send mention notification to them.
-            - When the activity is a comment_created and there exist a mention in the comment, then we have to send the "mention_in_comment" notification
-            - When the activity is a comment_updated and there exist a mention change, then also we have to send the "mention_in_comment" notification
-            """
-
-            # ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- #
-            issue_subscribers = list(
-                IssueSubscriber.objects.filter(
-                    project_id=project_id, issue_id=issue_id
-                )
-                .exclude(
-                    subscriber_id__in=list(
-                        new_mentions + comment_mentions + [actor_id]
+                bulk_notifications.append(
+                    Notification(
+                        workspace=project.workspace,
+                        sender=sender,
+                        triggered_by_id=actor_id,
+                        receiver_id=subscriber,
+                        entity_identifier=issue_id,
+                        entity_name="issue",
+                        project=project,
+                        title=issue_activity.get("comment"),
+                        data={
+                            "issue": {
+                                "id": str(issue_id),
+                                "name": str(issue.name),
+                                "identifier": str(issue.project.identifier),
+                                "sequence_id": issue.sequence_id,
+                                "state_name": issue.state.name,
+                                "state_group": issue.state.group,
+                            },
+                            "issue_activity": {
+                                "id": str(issue_activity.get("id")),
+                                "verb": str(issue_activity.get("verb")),
+                                "field": str(issue_activity.get("field")),
+                                "actor": str(issue_activity.get("actor_id")),
+                                "new_value": str(
+                                    issue_activity.get("new_value")
+                                ),
+                                "old_value": str(
+                                    issue_activity.get("old_value")
+                                ),
+                                "issue_comment": str(
+                                    issue_comment.comment_stripped
+                                    if issue_activity.get("issue_comment")
+                                    is not None
+                                    else ""
+                                ),
+                            },
+                        },
                     )
                 )
-                .values_list("subscriber", flat=True)
-            )
 
-            issue = Issue.objects.filter(pk=issue_id).first()
+        # Add Mentioned as Issue Subscribers
+        IssueSubscriber.objects.bulk_create(
+            mention_subscribers + comment_mention_subscribers, batch_size=100
+        )
 
-            if subscriber:
-                # add the user to issue subscriber
-                try:
-                    _ = IssueSubscriber.objects.get_or_create(
-                        project_id=project_id, issue_id=issue_id, subscriber_id=actor_id
+        last_activity = (
+            IssueActivity.objects.filter(issue_id=issue_id)
+            .order_by("-created_at")
+            .first()
+        )
+
+        actor = User.objects.get(pk=actor_id)
+
+        for mention_id in comment_mentions:
+            if mention_id != actor_id:
+                for issue_activity in issue_activities_created:
+                    notification = createMentionNotification(
+                        project=project,
+                        issue=issue,
+                        notification_comment=f"{actor.display_name} has mentioned you in a comment in issue {issue.name}",
+                        actor_id=actor_id,
+                        mention_id=mention_id,
+                        issue_id=issue_id,
+                        activity=issue_activity,
                     )
-                except Exception as e:
-                    pass
+                    bulk_notifications.append(notification)
 
-            project = Project.objects.get(pk=project_id)
-
-            issue_assignees = IssueAssignee.objects.filter(
-                issue_id=issue_id, project_id=project_id
-            ).values_list("assignee", flat=True)
-
-            issue_subscribers = list(
-                set(issue_subscribers) - {uuid.UUID(actor_id)}
-            )
-
-            for subscriber in issue_subscribers:
-                if issue.created_by_id and issue.created_by_id == subscriber:
-                    sender = "in_app:issue_activities:created"
-                elif (
-                    subscriber in issue_assignees
-                    and issue.created_by_id not in issue_assignees
+        for mention_id in new_mentions:
+            if mention_id != actor_id:
+                if (
+                    last_activity is not None
+                    and last_activity.field == "description"
+                    and actor_id == str(last_activity.actor_id)
                 ):
-                    sender = "in_app:issue_activities:assigned"
-                else:
-                    sender = "in_app:issue_activities:subscribed"
-
-                preference = UserNotificationPreference.objects.get(
-                    user_id=subscriber
-                )
-
-                for issue_activity in issue_activities_created:   
-                    # If activity done in blocking then blocked by email should not go
-                    if issue_activity.get("issue_detail").get("id") != issue_id:
-                        continue;
-                    
-                    # Do not send notification for description update
-                    if issue_activity.get("field") == "description":
-                        continue
-
-                    # Check if the value should be sent or not
-                    send_email = False
-                    if (
-                        issue_activity.get("field") == "state"
-                        and preference.state_change
-                    ):
-                        send_email = True
-                    elif (
-                        issue_activity.get("field") == "state"
-                        and preference.issue_completed
-                        and State.objects.filter(
-                            project_id=project_id,
-                            pk=issue_activity.get("new_identifier"),
-                            group="completed",
-                        ).exists()
-                    ):
-                        send_email = True
-                    elif (
-                        issue_activity.get("field") == "comment"
-                        and preference.comment
-                    ):
-                        send_email = True
-                    elif preference.property_change:
-                        send_email = True
-                    else:
-                        send_email = False
-
-                    # If activity is of issue comment fetch the comment
-                    issue_comment = (
-                        IssueComment.objects.filter(
-                            id=issue_activity.get("issue_comment"),
-                            issue_id=issue_id,
-                            project_id=project_id,
-                            workspace_id=project.workspace_id,
-                        ).first()
-                        if issue_activity.get("issue_comment")
-                        else None
-                    )
-
-                    # Create in app notification
                     bulk_notifications.append(
                         Notification(
                             workspace=project.workspace,
-                            sender=sender,
+                            sender="in_app:issue_activities:mentioned",
                             triggered_by_id=actor_id,
-                            receiver_id=subscriber,
+                            receiver_id=mention_id,
                             entity_identifier=issue_id,
                             entity_name="issue",
                             project=project,
-                            title=issue_activity.get("comment"),
+                            message=f"You have been mentioned in the issue {issue.name}",
                             data={
                                 "issue": {
                                     "id": str(issue_id),
@@ -405,320 +465,36 @@ def notifications(
                                     "state_group": issue.state.group,
                                 },
                                 "issue_activity": {
-                                    "id": str(issue_activity.get("id")),
-                                    "verb": str(issue_activity.get("verb")),
-                                    "field": str(issue_activity.get("field")),
-                                    "actor": str(
-                                        issue_activity.get("actor_id")
-                                    ),
-                                    "new_value": str(
-                                        issue_activity.get("new_value")
-                                    ),
-                                    "old_value": str(
-                                        issue_activity.get("old_value")
-                                    ),
-                                    "issue_comment": str(
-                                        issue_comment.comment_stripped
-                                        if issue_comment is not None
-                                        else ""
-                                    ),
+                                    "id": str(last_activity.id),
+                                    "verb": str(last_activity.verb),
+                                    "field": str(last_activity.field),
+                                    "actor": str(last_activity.actor_id),
+                                    "new_value": str(last_activity.new_value),
+                                    "old_value": str(last_activity.old_value),
                                 },
                             },
                         )
                     )
-                    # Create email notification
-                    if send_email:
-                        bulk_email_logs.append(
-                            EmailNotificationLog(
-                                triggered_by_id=actor_id,
-                                receiver_id=subscriber,
-                                entity_identifier=issue_id,
-                                entity_name="issue",
-                                data={
-                                    "issue": {
-                                        "id": str(issue_id),
-                                        "name": str(issue.name),
-                                        "identifier": str(
-                                            issue.project.identifier
-                                        ),
-                                        "project_id": str(issue.project.id),
-                                        "workspace_slug": str(
-                                            issue.project.workspace.slug
-                                        ),
-                                        "sequence_id": issue.sequence_id,
-                                        "state_name": issue.state.name,
-                                        "state_group": issue.state.group,
-                                    },
-                                    "issue_activity": {
-                                        "id": str(issue_activity.get("id")),
-                                        "verb": str(
-                                            issue_activity.get("verb")
-                                        ),
-                                        "field": str(
-                                            issue_activity.get("field")
-                                        ),
-                                        "actor": str(
-                                            issue_activity.get("actor_id")
-                                        ),
-                                        "new_value": str(
-                                            issue_activity.get("new_value")
-                                        ),
-                                        "old_value": str(
-                                            issue_activity.get("old_value")
-                                        ),
-                                        "issue_comment": str(
-                                            issue_comment.comment_stripped
-                                            if issue_comment is not None
-                                            else ""
-                                        ),
-                                        "activity_time": issue_activity.get("created_at"),
-                                    },
-                                },
-                            )
-                        )
-
-            # ----------------------------------------------------------------------------------------------------------------- #
-
-            # Add Mentioned as Issue Subscribers
-            IssueSubscriber.objects.bulk_create(
-                mention_subscribers + comment_mention_subscribers,
-                batch_size=100,
-                ignore_conflicts=True,
-            )
-
-            last_activity = (
-                IssueActivity.objects.filter(issue_id=issue_id)
-                .order_by("-created_at")
-                .first()
-            )
-
-            actor = User.objects.get(pk=actor_id)
-
-            for mention_id in comment_mentions:
-                if mention_id != actor_id:
-                    preference = UserNotificationPreference.objects.get(
-                        user_id=mention_id
-                    )
+                else:
                     for issue_activity in issue_activities_created:
-                        notification = create_mention_notification(
+                        notification = createMentionNotification(
                             project=project,
                             issue=issue,
-                            notification_comment=f"{actor.display_name} has mentioned you in a comment in issue {issue.name}",
+                            notification_comment=f"You have been mentioned in the issue {issue.name}",
                             actor_id=actor_id,
                             mention_id=mention_id,
                             issue_id=issue_id,
                             activity=issue_activity,
                         )
-
-                        # check for email notifications
-                        if preference.mention:
-                            bulk_email_logs.append(
-                                EmailNotificationLog(
-                                    triggered_by_id=actor_id,
-                                    receiver_id=mention_id,
-                                    entity_identifier=issue_id,
-                                    entity_name="issue",
-                                    data={
-                                        "issue": {
-                                            "id": str(issue_id),
-                                            "name": str(issue.name),
-                                            "identifier": str(
-                                                issue.project.identifier
-                                            ),
-                                            "sequence_id": issue.sequence_id,
-                                            "state_name": issue.state.name,
-                                            "state_group": issue.state.group,
-                                            "project_id": str(
-                                                issue.project.id
-                                            ),
-                                            "workspace_slug": str(
-                                                issue.project.workspace.slug
-                                            ),
-                                        },
-                                        "issue_activity": {
-                                            "id": str(
-                                                issue_activity.get("id")
-                                            ),
-                                            "verb": str(
-                                                issue_activity.get("verb")
-                                            ),
-                                            "field": str("mention"),
-                                            "actor": str(
-                                                issue_activity.get("actor_id")
-                                            ),
-                                            "new_value": str(
-                                                issue_activity.get("new_value")
-                                            ),
-                                            "old_value": str(
-                                                issue_activity.get("old_value")
-                                            ),
-                                            "activity_time": issue_activity.get("created_at"),
-                                        },
-                                    },
-                                )
-                            )
                         bulk_notifications.append(notification)
 
-            for mention_id in new_mentions:
-                if mention_id != actor_id:
-                    preference = UserNotificationPreference.objects.get(
-                        user_id=mention_id
-                    )
-                    if (
-                        last_activity is not None
-                        and last_activity.field == "description"
-                        and actor_id == str(last_activity.actor_id)
-                    ):
-                        bulk_notifications.append(
-                            Notification(
-                                workspace=project.workspace,
-                                sender="in_app:issue_activities:mentioned",
-                                triggered_by_id=actor_id,
-                                receiver_id=mention_id,
-                                entity_identifier=issue_id,
-                                entity_name="issue",
-                                project=project,
-                                message=f"You have been mentioned in the issue {issue.name}",
-                                data={
-                                    "issue": {
-                                        "id": str(issue_id),
-                                        "name": str(issue.name),
-                                        "identifier": str(
-                                            issue.project.identifier
-                                        ),
-                                        "sequence_id": issue.sequence_id,
-                                        "state_name": issue.state.name,
-                                        "state_group": issue.state.group,
-                                        "project_id": str(issue.project.id),
-                                        "workspace_slug": str(
-                                            issue.project.workspace.slug
-                                        ),
-                                    },
-                                    "issue_activity": {
-                                        "id": str(last_activity.id),
-                                        "verb": str(last_activity.verb),
-                                        "field": str(last_activity.field),
-                                        "actor": str(last_activity.actor_id),
-                                        "new_value": str(
-                                            last_activity.new_value
-                                        ),
-                                        "old_value": str(
-                                            last_activity.old_value
-                                        ),
-                                    },
-                                },
-                            )
-                        )
-                        if preference.mention:
-                            bulk_email_logs.append(
-                                EmailNotificationLog(
-                                    triggered_by_id=actor_id,
-                                    receiver_id=subscriber,
-                                    entity_identifier=issue_id,
-                                    entity_name="issue",
-                                    data={
-                                        "issue": {
-                                            "id": str(issue_id),
-                                            "name": str(issue.name),
-                                            "identifier": str(
-                                                issue.project.identifier
-                                            ),
-                                            "sequence_id": issue.sequence_id,
-                                            "state_name": issue.state.name,
-                                            "state_group": issue.state.group,
-                                        },
-                                        "issue_activity": {
-                                            "id": str(last_activity.id),
-                                            "verb": str(last_activity.verb),
-                                            "field": "mention",
-                                            "actor": str(
-                                                last_activity.actor_id
-                                            ),
-                                            "new_value": str(
-                                                last_activity.new_value
-                                            ),
-                                            "old_value": str(
-                                                last_activity.old_value
-                                            ),
-                                            "activity_time": issue_activity.get("created_at"),
-                                        },
-                                    },
-                                )
-                            )
-                    else:
-                        for issue_activity in issue_activities_created:
-                            notification = create_mention_notification(
-                                project=project,
-                                issue=issue,
-                                notification_comment=f"You have been mentioned in the issue {issue.name}",
-                                actor_id=actor_id,
-                                mention_id=mention_id,
-                                issue_id=issue_id,
-                                activity=issue_activity,
-                            )
-                            if preference.mention:
-                                bulk_email_logs.append(
-                                    EmailNotificationLog(
-                                        triggered_by_id=actor_id,
-                                        receiver_id=subscriber,
-                                        entity_identifier=issue_id,
-                                        entity_name="issue",
-                                        data={
-                                            "issue": {
-                                                "id": str(issue_id),
-                                                "name": str(issue.name),
-                                                "identifier": str(
-                                                    issue.project.identifier
-                                                ),
-                                                "sequence_id": issue.sequence_id,
-                                                "state_name": issue.state.name,
-                                                "state_group": issue.state.group,
-                                            },
-                                            "issue_activity": {
-                                                "id": str(
-                                                    issue_activity.get("id")
-                                                ),
-                                                "verb": str(
-                                                    issue_activity.get("verb")
-                                                ),
-                                                "field": str("mention"),
-                                                "actor": str(
-                                                    issue_activity.get(
-                                                        "actor_id"
-                                                    )
-                                                ),
-                                                "new_value": str(
-                                                    issue_activity.get(
-                                                        "new_value"
-                                                    )
-                                                ),
-                                                "old_value": str(
-                                                    issue_activity.get(
-                                                        "old_value"
-                                                    )
-                                                ),
-                                                "activity_time": issue_activity.get("created_at"),
-                                            },
-                                        },
-                                    )
-                                )
-                            bulk_notifications.append(notification)
+        # save new mentions for the particular issue and remove the mentions that has been deleted from the description
+        update_mentions_for_issue(
+            issue=issue,
+            project=project,
+            new_mentions=new_mentions,
+            removed_mention=removed_mention,
+        )
 
-            # save new mentions for the particular issue and remove the mentions that has been deleted from the description
-            update_mentions_for_issue(
-                issue=issue,
-                project=project,
-                new_mentions=new_mentions,
-                removed_mention=removed_mention,
-            )
-            # Bulk create notifications
-            Notification.objects.bulk_create(
-                bulk_notifications, batch_size=100
-            )
-            EmailNotificationLog.objects.bulk_create(
-                bulk_email_logs, batch_size=100, ignore_conflicts=True
-            )
-        return
-    except Exception as e:
-        print(e)
-        return
+        # Bulk create notifications
+        Notification.objects.bulk_create(bulk_notifications, batch_size=100)

apiserver/plane/bgtasks/webhook_task.py

@@ -7,9 +7,6 @@ import hmac
 # Django imports
 from django.conf import settings
 from django.core.serializers.json import DjangoJSONEncoder
-from django.core.mail import EmailMultiAlternatives, get_connection
-from django.template.loader import render_to_string
-from django.utils.html import strip_tags
 
 # Third party imports
 from celery import shared_task
@@ -25,10 +22,10 @@ from plane.db.models import (
     ModuleIssue,
     CycleIssue,
     IssueComment,
-    User,
 )
 from plane.api.serializers import (
     ProjectSerializer,
+    IssueSerializer,
     CycleSerializer,
     ModuleSerializer,
     CycleIssueSerializer,
@@ -37,9 +34,6 @@ from plane.api.serializers import (
     IssueExpandSerializer,
 )
 
-# Module imports
-from plane.license.utils.instance_value import get_email_configuration
-
 SERIALIZER_MAPPER = {
     "project": ProjectSerializer,
     "issue": IssueExpandSerializer,
@@ -78,7 +72,7 @@ def get_model_data(event, event_id, many=False):
     max_retries=5,
     retry_jitter=True,
 )
-def webhook_task(self, webhook, slug, event, event_data, action, current_site):
+def webhook_task(self, webhook, slug, event, event_data, action):
     try:
         webhook = Webhook.objects.get(id=webhook, workspace__slug=slug)
 
@@ -157,18 +151,7 @@ def webhook_task(self, webhook, slug, event, event_data, action, current_site):
             response_body=str(e),
             retry_count=str(self.request.retries),
         )
-        # Retry logic
-        if self.request.retries >= self.max_retries:
-            Webhook.objects.filter(pk=webhook.id).update(is_active=False)   
-            if webhook:
-                # send email for the deactivation of the webhook
-                send_webhook_deactivation_email(
-                    webhook_id=webhook.id,
-                    receiver_id=webhook.created_by_id,
-                    reason=str(e),
-                    current_site=current_site,
-                )
-            return
+
         raise requests.RequestException()
 
     except Exception as e:
@@ -179,7 +162,7 @@ def webhook_task(self, webhook, slug, event, event_data, action, current_site):
 
 
 @shared_task()
-def send_webhook(event, payload, kw, action, slug, bulk, current_site):
+def send_webhook(event, payload, kw, action, slug, bulk):
     try:
         webhooks = Webhook.objects.filter(workspace__slug=slug, is_active=True)
 
@@ -233,7 +216,6 @@ def send_webhook(event, payload, kw, action, slug, bulk, current_site):
                         event=event,
                         event_data=data,
                         action=action,
-                        current_site=current_site,
                     )
 
     except Exception as e:
@@ -241,56 +223,3 @@ def send_webhook(event, payload, kw, action, slug, bulk, current_site):
             print(e)
         capture_exception(e)
         return
-
-
-@shared_task
-def send_webhook_deactivation_email(webhook_id, receiver_id, current_site, reason):
-    # Get email configurations
-    (
-        EMAIL_HOST,
-        EMAIL_HOST_USER,
-        EMAIL_HOST_PASSWORD,
-        EMAIL_PORT,
-        EMAIL_USE_TLS,
-        EMAIL_FROM,
-    ) = get_email_configuration()
-
-    receiver = User.objects.get(pk=receiver_id)
-    webhook = Webhook.objects.get(pk=webhook_id) 
-    subject="Webhook Deactivated"
-    message=f"Webhook {webhook.url} has been deactivated due to failed requests."
-
-    # Send the mail
-    context = {
-        "email": receiver.email,
-        "message": message,
-        "webhook_url":f"{current_site}/{str(webhook.workspace.slug)}/settings/webhooks/{str(webhook.id)}",
-    }
-    html_content = render_to_string(
-        "emails/notifications/webhook-deactivate.html", context
-    )
-    text_content = strip_tags(html_content)
-
-    try:
-        connection = get_connection(
-            host=EMAIL_HOST,
-            port=int(EMAIL_PORT),
-            username=EMAIL_HOST_USER,
-            password=EMAIL_HOST_PASSWORD,
-            use_tls=EMAIL_USE_TLS == "1",
-        )
-
-        msg = EmailMultiAlternatives(
-            subject=subject,
-            body=text_content,
-            from_email=EMAIL_FROM,
-            to=[receiver.email],
-            connection=connection,
-        )
-        msg.attach_alternative(html_content, "text/html")
-        msg.send()
-
-        return
-    except Exception as e:
-        print(e)
-        return

apiserver/plane/celery.py

@@ -2,7 +2,6 @@ import os
 from celery import Celery
 from plane.settings.redis import redis_instance
 from celery.schedules import crontab
-from django.utils.timezone import timedelta
 
 # Set the default Django settings module for the 'celery' program.
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "plane.settings.production")
@@ -29,10 +28,6 @@ app.conf.beat_schedule = {
         "task": "plane.bgtasks.file_asset_task.delete_file_asset",
         "schedule": crontab(hour=0, minute=0),
     },
-    "check-every-five-minutes-to-send-email-notifications": {
-        "task": "plane.bgtasks.email_notification_task.stack_email_notification",
-        "schedule": crontab(minute='*/5')
-    },
 }
 
 # Load task modules from all registered Django app configs.

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

@@ -1,21 +0,0 @@
-# wait_for_migrations.py
-import time
-from django.core.management.base import BaseCommand
-from django.db.migrations.executor import MigrationExecutor
-from django.db import connections, DEFAULT_DB_ALIAS
-
-class Command(BaseCommand):
-    help = 'Wait for database migrations to complete before starting Celery worker/beat'
-
-    def handle(self, *args, **kwargs):
-        while self._pending_migrations():
-            self.stdout.write("Waiting for database migrations to complete...")
-            time.sleep(10)  # wait for 10 seconds before checking again
-
-        self.stdout.write(self.style.SUCCESS("No migrations Pending. Starting processes ..."))
-
-    def _pending_migrations(self):
-        connection = connections[DEFAULT_DB_ALIAS]
-        executor = MigrationExecutor(connection)
-        targets = executor.loader.graph.leaf_nodes()
-        return bool(executor.migration_plan(targets))

apiserver/plane/db/migrations/0056_usernotificationpreference_emailnotificationlog.py

@@ -1,184 +0,0 @@
-# Generated by Django 4.2.7 on 2024-01-22 08:55
-
-from django.conf import settings
-from django.db import migrations, models
-import django.db.models.deletion
-import uuid
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("db", "0055_auto_20240108_0648"),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="UserNotificationPreference",
-            fields=[
-                (
-                    "created_at",
-                    models.DateTimeField(
-                        auto_now_add=True, verbose_name="Created At"
-                    ),
-                ),
-                (
-                    "updated_at",
-                    models.DateTimeField(
-                        auto_now=True, verbose_name="Last Modified At"
-                    ),
-                ),
-                (
-                    "id",
-                    models.UUIDField(
-                        db_index=True,
-                        default=uuid.uuid4,
-                        editable=False,
-                        primary_key=True,
-                        serialize=False,
-                        unique=True,
-                    ),
-                ),
-                ("property_change", models.BooleanField(default=True)),
-                ("state_change", models.BooleanField(default=True)),
-                ("comment", models.BooleanField(default=True)),
-                ("mention", models.BooleanField(default=True)),
-                ("issue_completed", models.BooleanField(default=True)),
-                (
-                    "created_by",
-                    models.ForeignKey(
-                        null=True,
-                        on_delete=django.db.models.deletion.SET_NULL,
-                        related_name="%(class)s_created_by",
-                        to=settings.AUTH_USER_MODEL,
-                        verbose_name="Created By",
-                    ),
-                ),
-                (
-                    "project",
-                    models.ForeignKey(
-                        null=True,
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="project_notification_preferences",
-                        to="db.project",
-                    ),
-                ),
-                (
-                    "updated_by",
-                    models.ForeignKey(
-                        null=True,
-                        on_delete=django.db.models.deletion.SET_NULL,
-                        related_name="%(class)s_updated_by",
-                        to=settings.AUTH_USER_MODEL,
-                        verbose_name="Last Modified By",
-                    ),
-                ),
-                (
-                    "user",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="notification_preferences",
-                        to=settings.AUTH_USER_MODEL,
-                    ),
-                ),
-                (
-                    "workspace",
-                    models.ForeignKey(
-                        null=True,
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="workspace_notification_preferences",
-                        to="db.workspace",
-                    ),
-                ),
-            ],
-            options={
-                "verbose_name": "UserNotificationPreference",
-                "verbose_name_plural": "UserNotificationPreferences",
-                "db_table": "user_notification_preferences",
-                "ordering": ("-created_at",),
-            },
-        ),
-        migrations.CreateModel(
-            name="EmailNotificationLog",
-            fields=[
-                (
-                    "created_at",
-                    models.DateTimeField(
-                        auto_now_add=True, verbose_name="Created At"
-                    ),
-                ),
-                (
-                    "updated_at",
-                    models.DateTimeField(
-                        auto_now=True, verbose_name="Last Modified At"
-                    ),
-                ),
-                (
-                    "id",
-                    models.UUIDField(
-                        db_index=True,
-                        default=uuid.uuid4,
-                        editable=False,
-                        primary_key=True,
-                        serialize=False,
-                        unique=True,
-                    ),
-                ),
-                ("entity_identifier", models.UUIDField(null=True)),
-                ("entity_name", models.CharField(max_length=255)),
-                ("data", models.JSONField(null=True)),
-                ("processed_at", models.DateTimeField(null=True)),
-                ("sent_at", models.DateTimeField(null=True)),
-                ("entity", models.CharField(max_length=200)),
-                (
-                    "old_value",
-                    models.CharField(blank=True, max_length=300, null=True),
-                ),
-                (
-                    "new_value",
-                    models.CharField(blank=True, max_length=300, null=True),
-                ),
-                (
-                    "created_by",
-                    models.ForeignKey(
-                        null=True,
-                        on_delete=django.db.models.deletion.SET_NULL,
-                        related_name="%(class)s_created_by",
-                        to=settings.AUTH_USER_MODEL,
-                        verbose_name="Created By",
-                    ),
-                ),
-                (
-                    "receiver",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="email_notifications",
-                        to=settings.AUTH_USER_MODEL,
-                    ),
-                ),
-                (
-                    "triggered_by",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="triggered_emails",
-                        to=settings.AUTH_USER_MODEL,
-                    ),
-                ),
-                (
-                    "updated_by",
-                    models.ForeignKey(
-                        null=True,
-                        on_delete=django.db.models.deletion.SET_NULL,
-                        related_name="%(class)s_updated_by",
-                        to=settings.AUTH_USER_MODEL,
-                        verbose_name="Last Modified By",
-                    ),
-                ),
-            ],
-            options={
-                "verbose_name": "Email Notification Log",
-                "verbose_name_plural": "Email Notification Logs",
-                "db_table": "email_notification_logs",
-                "ordering": ("-created_at",),
-            },
-        ),
-    ]

apiserver/plane/db/migrations/0057_auto_20240122_0901.py

@@ -1,28 +0,0 @@
-# Generated by Django 4.2.7 on 2024-01-22 09:01
-
-from django.db import migrations
-
-def create_notification_preferences(apps, schema_editor):
-    UserNotificationPreference = apps.get_model("db", "UserNotificationPreference")
-    User = apps.get_model("db", "User")
-
-    bulk_notification_preferences = []
-    for user_id in User.objects.filter(is_bot=False).values_list("id", flat=True):
-        bulk_notification_preferences.append(
-            UserNotificationPreference(
-                user_id=user_id,
-                created_by_id=user_id,
-            )
-        )
-    UserNotificationPreference.objects.bulk_create(
-        bulk_notification_preferences, batch_size=1000, ignore_conflicts=True
-    )
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("db", "0056_usernotificationpreference_emailnotificationlog"),
-    ]
-
-    operations = [
-        migrations.RunPython(create_notification_preferences)
-    ]

apiserver/plane/db/migrations/0058_alter_moduleissue_issue_and_more.py

@@ -1,23 +0,0 @@
-# Generated by Django 4.2.7 on 2024-01-24 18:55
-
-from django.db import migrations, models
-import django.db.models.deletion
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('db', '0057_auto_20240122_0901'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='moduleissue',
-            name='issue',
-            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='issue_module', to='db.issue'),
-        ),
-        migrations.AlterUniqueTogether(
-            name='moduleissue',
-            unique_together={('issue', 'module')},
-        ),
-    ]

apiserver/plane/db/migrations/0059_auto_20240208_0957.py

@@ -1,33 +0,0 @@
-# Generated by Django 4.2.7 on 2024-02-08 09:57
-
-from django.db import migrations
-
-
-def widgets_filter_change(apps, schema_editor):
-    Widget = apps.get_model("db", "Widget")
-    widgets_to_update = []
-
-    # Define the filter dictionaries for each widget key
-    filters_mapping = {
-        "assigned_issues": {"duration": "none", "tab": "pending"},
-        "created_issues": {"duration": "none", "tab": "pending"},
-        "issues_by_state_groups": {"duration": "none"},
-        "issues_by_priority": {"duration": "none"},
-    }
-
-    # Iterate over widgets and update filters if applicable
-    for widget in Widget.objects.all():
-        if widget.key in filters_mapping:
-            widget.filters = filters_mapping[widget.key]
-            widgets_to_update.append(widget)
-
-    # Bulk update the widgets
-    Widget.objects.bulk_update(widgets_to_update, ["filters"], batch_size=10)
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ('db', '0058_alter_moduleissue_issue_and_more'),
-    ]
-    operations = [
-        migrations.RunPython(widgets_filter_change)
-    ]

apiserver/plane/db/migrations/0060_cycle_progress_snapshot.py

@@ -1,18 +0,0 @@
-# Generated by Django 4.2.7 on 2024-02-08 09:18
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('db', '0059_auto_20240208_0957'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='cycle',
-            name='progress_snapshot',
-            field=models.JSONField(default=dict),
-        ),
-    ]

apiserver/plane/db/models/__init__.py

@@ -85,7 +85,7 @@ from .inbox import Inbox, InboxIssue
 
 from .analytic import AnalyticView
 
-from .notification import Notification, UserNotificationPreference, EmailNotificationLog
+from .notification import Notification
 
 from .exporter import ExporterHistory
 

apiserver/plane/db/models/cycle.py

@@ -68,7 +68,6 @@ class Cycle(ProjectBaseModel):
     sort_order = models.FloatField(default=65535)
     external_source = models.CharField(max_length=255, null=True, blank=True)
     external_id = models.CharField(max_length=255, blank=True, null=True)
-    progress_snapshot = models.JSONField(default=dict)
 
     class Meta:
         verbose_name = "Cycle"

apiserver/plane/db/models/issue.py

@@ -9,7 +9,6 @@ from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.core.validators import MinValueValidator, MaxValueValidator
 from django.core.exceptions import ValidationError
-from django.utils import timezone
 
 # Module imports
 from . import ProjectBaseModel
@@ -184,17 +183,6 @@ class Issue(ProjectBaseModel):
                     self.state = default_state
             except ImportError:
                 pass
-        else:
-            try:
-                from plane.db.models import State
-
-                # Check if the current issue state group is completed or not
-                if self.state.group == "completed":
-                    self.completed_at = timezone.now()
-                else:
-                    self.completed_at = None
-            except ImportError:
-                pass
 
         if self._state.adding:
             # Get the maximum display_id value from the database

apiserver/plane/db/models/module.py

@@ -134,12 +134,11 @@ class ModuleIssue(ProjectBaseModel):
     module = models.ForeignKey(
         "db.Module", on_delete=models.CASCADE, related_name="issue_module"
     )
-    issue = models.ForeignKey(
+    issue = models.OneToOneField(
         "db.Issue", on_delete=models.CASCADE, related_name="issue_module"
     )
 
     class Meta:
-        unique_together = ["issue", "module"]
         verbose_name = "Module Issue"
         verbose_name_plural = "Module Issues"
         db_table = "module_issues"

apiserver/plane/db/models/notification.py

@@ -1,9 +1,9 @@
 # Django imports
 from django.db import models
-from django.conf import settings
 
-# Module imports
-from . import BaseModel
+# Third party imports
+from .base import BaseModel
+
 
 class Notification(BaseModel):
     workspace = models.ForeignKey(
@@ -47,82 +47,3 @@ class Notification(BaseModel):
     def __str__(self):
         """Return name of the notifications"""
         return f"{self.receiver.email} <{self.workspace.name}>"
-
-
-def get_default_preference():
-    return {
-        "property_change": {
-            "email": True,
-        },
-        "state": {
-            "email": True,
-        },
-        "comment": {
-            "email": True,
-        },
-        "mentions": {
-            "email": True,
-        },
-    }
-
-
-class UserNotificationPreference(BaseModel):
-    # user it is related to
-    user = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.CASCADE,
-        related_name="notification_preferences",
-    )
-    # workspace if it is applicable
-    workspace = models.ForeignKey(
-        "db.Workspace",
-        on_delete=models.CASCADE,
-        related_name="workspace_notification_preferences",
-        null=True,
-    )
-    # project
-    project = models.ForeignKey(
-        "db.Project",
-        on_delete=models.CASCADE,
-        related_name="project_notification_preferences",
-        null=True,
-    )
-
-    # preference fields
-    property_change = models.BooleanField(default=True)
-    state_change = models.BooleanField(default=True)
-    comment = models.BooleanField(default=True)
-    mention = models.BooleanField(default=True)
-    issue_completed = models.BooleanField(default=True)
-
-    class Meta:
-        verbose_name = "UserNotificationPreference"
-        verbose_name_plural = "UserNotificationPreferences"
-        db_table = "user_notification_preferences"
-        ordering = ("-created_at",)
-
-    def __str__(self):
-        """Return the user"""
-        return f"<{self.user}>"
-
-class EmailNotificationLog(BaseModel):
-    # receiver
-    receiver = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="email_notifications")
-    triggered_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="triggered_emails")
-    # entity - can be issues, pages, etc.
-    entity_identifier = models.UUIDField(null=True)
-    entity_name = models.CharField(max_length=255)
-    # data
-    data = models.JSONField(null=True)
-    # sent at
-    processed_at = models.DateTimeField(null=True)
-    sent_at = models.DateTimeField(null=True)
-    entity = models.CharField(max_length=200)
-    old_value = models.CharField(max_length=300, blank=True, null=True)
-    new_value = models.CharField(max_length=300, blank=True, null=True)
-
-    class Meta:
-        verbose_name = "Email Notification Log"
-        verbose_name_plural = "Email Notification Logs"
-        db_table = "email_notification_logs"
-        ordering = ("-created_at",)

apiserver/plane/db/models/user.py

@@ -11,8 +11,6 @@ from django.contrib.auth.models import (
     UserManager,
     PermissionsMixin,
 )
-from django.db.models.signals import post_save
-from django.dispatch import receiver
 from django.utils import timezone
 
 
@@ -136,20 +134,3 @@ class User(AbstractBaseUser, PermissionsMixin):
             self.is_staff = True
 
         super(User, self).save(*args, **kwargs)
-
-
-
-@receiver(post_save, sender=User)
-def create_user_notification(sender, instance, created, **kwargs):
-    # create preferences
-    if created and not instance.is_bot:
-        # Module imports
-        from plane.db.models import UserNotificationPreference
-        UserNotificationPreference.objects.create(
-            user=instance,
-            property_change=False,
-            state_change=False,
-            comment=False,
-            mention=False,
-            issue_completed=False,
-        )

apiserver/plane/settings/common.py

@@ -1,5 +1,4 @@
 """Global Settings"""
-
 # Python imports
 import os
 import ssl
@@ -283,14 +282,15 @@ if REDIS_SSL:
     redis_url = os.environ.get("REDIS_URL")
     broker_url = f"{redis_url}?ssl_cert_reqs={ssl.CERT_NONE.name}&ssl_ca_certs={certifi.where()}"
     CELERY_BROKER_URL = broker_url
+    CELERY_RESULT_BACKEND = broker_url
 else:
     CELERY_BROKER_URL = REDIS_URL
+    CELERY_RESULT_BACKEND = REDIS_URL
 
 CELERY_IMPORTS = (
     "plane.bgtasks.issue_automation_task",
     "plane.bgtasks.exporter_expired_task",
     "plane.bgtasks.file_asset_task",
-    "plane.bgtasks.email_notification_task",
 )
 
 # Sentry Settings
@@ -308,9 +308,7 @@ if bool(os.environ.get("SENTRY_DSN", False)) and os.environ.get(
         traces_sample_rate=1,
         send_default_pii=True,
         environment=os.environ.get("SENTRY_ENVIRONMENT", "development"),
-        profiles_sample_rate=float(
-            os.environ.get("SENTRY_PROFILE_SAMPLE_RATE", 0.5)
-        ),
+        profiles_sample_rate=1.0,
     )
 
 

apiserver/plane/utils/analytics_plot.py

@@ -4,7 +4,6 @@ from datetime import timedelta
 
 # Django import
 from django.db import models
-from django.utils import timezone
 from django.db.models.functions import TruncDate
 from django.db.models import Count, F, Sum, Value, Case, When, CharField
 from django.db.models.functions import (
@@ -169,9 +168,6 @@ def burndown_plot(queryset, slug, project_id, cycle_id=None, module_id=None):
             if item["date"] is not None and item["date"] <= date
         )
         cumulative_pending_issues -= total_completed
-        if date > timezone.now().date():
-            chart_data[str(date)] = None
-        else:
-            chart_data[str(date)] = cumulative_pending_issues
+        chart_data[str(date)] = cumulative_pending_issues
 
     return chart_data

apiserver/plane/utils/issue_search.py

@@ -9,11 +9,11 @@ from plane.db.models import Issue
 
 
 def search_issues(query, queryset):
-    fields = ["name", "sequence_id", "project__identifier"]
+    fields = ["name", "sequence_id"]
     q = Q()
     for field in fields:
         if field == "sequence_id" and len(query) <= 20:
-            sequences = re.findall(r"\b\d+\b", query)
+            sequences = re.findall(r"[A-Za-z0-9]{1,12}-\d+", query)
             for sequence_id in sequences:
                 q |= Q(**{"sequence_id": sequence_id})
         else:

apiserver/requirements/base.txt

@@ -1,6 +1,6 @@
 # base requirements
 
-Django==4.2.10
+Django==4.2.7
 psycopg==3.1.12
 djangorestframework==3.14.0
 redis==4.6.0
@@ -30,7 +30,7 @@ openpyxl==3.1.2
 beautifulsoup4==4.12.2
 dj-database-url==2.1.0
 posthog==3.0.2
-cryptography==42.0.4
+cryptography==41.0.5
 lxml==4.9.3
 boto3==1.28.40
 

apiserver/runtime.txt

@@ -1 +1 @@
-python-3.11.8
+python-3.11.6

deploy/1-click/README.md

@@ -1,78 +0,0 @@
-# 1-Click Self-Hosting
-
-In this guide, we will walk you through the process of setting up a 1-click self-hosted environment. Self-hosting allows you to have full control over your applications and data. It's a great way to ensure privacy, control, and customization.
-
-Let's get started!
-
-## Installing Plane
-
-Installing Plane is a very easy and minimal step process.
-
-### Prerequisite
-
-- Operating System (latest): Debian / Ubuntu / Centos
-- Supported CPU Architechture: AMD64 / ARM64 / x86_64 / aarch64
-
-### Downloading Latest Stable Release
-
-```
-curl -fsSL https://raw.githubusercontent.com/makeplane/plane/master/deploy/1-click/install.sh | sh -
-
-```
-
-<details>
-    <summary>Downloading Preview Release</summary>
-
-```
-export BRANCH=preview
-
-curl -fsSL https://raw.githubusercontent.com/makeplane/plane/preview/deploy/1-click/install.sh | sh -
-
-```
-
-NOTE: `Preview` builds do not support ARM64/AARCH64 CPU architecture
-</details>
-
---
-
-
-Expect this after a successful install
-
-![Install Output](images/install.png)
-
-Access the application on a browser via http://server-ip-address
-
----
-
-### Get Control of your Plane Server Setup
-
-Plane App is available via the command `plane-app`. Running the command `plane-app --help` helps you to manage Plane
-
-![Plane Help](images/help.png)
-
-<ins>Basic Operations</ins>: 
-1. Start Server using `plane-app start`
-1. Stop Server using `plane-app stop`
-1. Restart Server using `plane-app restart`
-
-<ins>Advanced Operations</ins>:
-1. Configure Plane using `plane-app --configure`. This will give you options to modify
-    - NGINX Port (default 80)
-    - Domain Name (default is the local server public IP address)
-    - File Upload Size (default 5MB) 
-    - External Postgres DB Url (optional - default empty)
-    - External Redis URL (optional - default empty)
-    - AWS S3 Bucket (optional - to be configured only in case the user wants to use an S3 Bucket)
-
-1. Upgrade Plane using `plane-app --upgrade`. This will get the latest stable version of Plane files (docker-compose.yaml, .env, and docker images)
-
-1. Updating Plane App installer using `plane-app --update-installer` will update the `plane-app` utility. 
-
-1. Uninstall Plane using `plane-app --uninstall`. This will uninstall the Plane application from the server and all docker containers but do not remove the data stored in Postgres, Redis, and Minio. 
-
-1. Plane App can be reinstalled using `plane-app --install`. 
-
-<ins>Application Data is stored in the mentioned folders</ins>: 
-1. DB Data: /opt/plane/data/postgres
-1. Redis Data: /opt/plane/data/redis
-1. Minio Data: /opt/plane/data/minio

deploy/1-click/install.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-export GIT_REPO=makeplane/plane
-
-# Check if the user has sudo access
-if command -v curl &> /dev/null; then
-    sudo curl -sSL \
-        -o /usr/local/bin/plane-app \
-        https://raw.githubusercontent.com/$GIT_REPO/${BRANCH:-master}/deploy/1-click/plane-app?token=$(date +%s)
-else 
-    sudo wget -q \
-        -O /usr/local/bin/plane-app \
-        https://raw.githubusercontent.com/$GIT_REPO/${BRANCH:-master}/deploy/1-click/plane-app?token=$(date +%s)
-fi
-
-sudo chmod +x /usr/local/bin/plane-app
-sudo sed -i 's@export DEPLOY_BRANCH=${BRANCH:-master}@export DEPLOY_BRANCH='${BRANCH:-master}'@' /usr/local/bin/plane-app
-sudo sed -i 's@CODE_REPO=${GIT_REPO:-makeplane/plane}@CODE_REPO='$GIT_REPO'@' /usr/local/bin/plane-app
-
-plane-app -i #--help

deploy/1-click/plane-app

@@ -1,803 +0,0 @@
-#!/bin/bash
-
-function print_header() {
-clear
-
-cat <<"EOF"
----------------------------------------
- ____  _                  
-|  _ \| | __ _ _ __   ___ 
-| |_) | |/ _` | '_ \ / _ \
-|  __/| | (_| | | | |  __/
-|_|   |_|\__,_|_| |_|\___|
-
----------------------------------------
-Project management tool from the future
----------------------------------------
-
-EOF
-}
-function update_env_file() {
-    config_file=$1
-    key=$2
-    value=$3
-
-    # Check if the config file exists
-    if [ ! -f "$config_file" ]; then
-        echo "Config file not found. Creating a new one..." >&2
-        sudo touch "$config_file"
-    fi
-
-    # Check if the key already exists in the config file
-    if sudo grep "^$key=" "$config_file"; then
-        sudo awk -v key="$key" -v value="$value" -F '=' '{if ($1 == key) $2 = value} 1' OFS='=' "$config_file" | sudo tee "$config_file.tmp" > /dev/null
-        sudo mv "$config_file.tmp" "$config_file" &> /dev/null
-    else
-        # sudo echo "$key=$value" >> "$config_file"
-        echo -e "$key=$value" | sudo tee -a "$config_file" > /dev/null
-    fi
-}
-function read_env_file() {
-    config_file=$1
-    key=$2
-
-    # Check if the config file exists
-    if [ ! -f "$config_file" ]; then
-        echo "Config file not found. Creating a new one..." >&2
-        sudo touch "$config_file"
-    fi
-
-    # Check if the key already exists in the config file
-    if sudo grep -q "^$key=" "$config_file"; then
-        value=$(sudo awk -v key="$key" -F '=' '{if ($1 == key) print $2}' "$config_file")
-        echo "$value"
-    else
-        echo ""
-    fi
-}
-function update_config() {
-    config_file="$PLANE_INSTALL_DIR/config.env"
-    update_env_file $config_file $1 $2
-}
-function read_config() {
-    config_file="$PLANE_INSTALL_DIR/config.env"
-    read_env_file $config_file $1
-}
-function update_env() {
-    config_file="$PLANE_INSTALL_DIR/.env"
-    update_env_file $config_file $1 $2
-}
-function read_env() {
-    config_file="$PLANE_INSTALL_DIR/.env"
-    read_env_file $config_file $1
-}
-function show_message() {
-    print_header
-
-    if [ "$2" == "replace_last_line" ]; then
-        PROGRESS_MSG[-1]="$1"
-    else
-        PROGRESS_MSG+=("$1")
-    fi
-
-    for statement in "${PROGRESS_MSG[@]}"; do
-        echo "$statement"
-    done
-
-}
-function prepare_environment() {
-    show_message "Prepare Environment..." >&2
-
-    show_message "- Updating OS with required tools ✋"  >&2
-    sudo "$PACKAGE_MANAGER" update -y
-    # sudo "$PACKAGE_MANAGER" upgrade -y
-
-    local required_tools=("curl" "awk" "wget" "nano" "dialog" "git" "uidmap" "jq")
-
-    for tool in "${required_tools[@]}"; do
-        if ! command -v $tool &> /dev/null; then
-            sudo "$PACKAGE_MANAGER" install -y $tool
-        fi
-    done
-
-    show_message "- OS Updated ✅" "replace_last_line"  >&2
-
-    # Install Docker if not installed
-    if ! command -v docker &> /dev/null; then
-        show_message "- Installing Docker ✋"  >&2
-        # curl -o- https://get.docker.com | bash - 
-
-        if [ "$PACKAGE_MANAGER" == "yum" ]; then
-            sudo $PACKAGE_MANAGER install -y yum-utils
-            sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo &> /dev/null
-        elif [ "$PACKAGE_MANAGER" == "apt-get" ]; then
-            # Add Docker's official GPG key:
-            sudo $PACKAGE_MANAGER update 
-            sudo $PACKAGE_MANAGER install ca-certificates curl &> /dev/null
-            sudo install -m 0755 -d /etc/apt/keyrings &> /dev/null
-            sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc &> /dev/null
-            sudo chmod a+r /etc/apt/keyrings/docker.asc &> /dev/null
-
-            # Add the repository to Apt sources:
-            echo \
-                "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
-                $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
-                sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
-            
-            sudo $PACKAGE_MANAGER update
-        fi
-
-        sudo $PACKAGE_MANAGER install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y
-
-        show_message "- Docker Installed ✅" "replace_last_line"  >&2
-    else
-        show_message "- Docker is already installed ✅"  >&2
-    fi
-
-    update_config "PLANE_ARCH" "$CPU_ARCH"
-    update_config "DOCKER_VERSION" "$(docker -v | awk '{print $3}' | sed 's/,//g')"
-    update_config "PLANE_DATA_DIR" "$DATA_DIR"
-    update_config "PLANE_LOG_DIR" "$LOG_DIR"
-
-    # echo "TRUE"
-    echo "Environment prepared successfully ✅"
-    show_message "Environment prepared successfully ✅" >&2
-    show_message "" >&2
-    return 0
-}
-function download_plane() {
-    # Download Docker Compose File from github url 
-    show_message "Downloading Plane Setup Files ✋"  >&2
-    sudo curl -H 'Cache-Control: no-cache, no-store' \
-        -s -o $PLANE_INSTALL_DIR/docker-compose.yaml  \
-        https://raw.githubusercontent.com/$CODE_REPO/$DEPLOY_BRANCH/deploy/selfhost/docker-compose.yml?token=$(date +%s) 
-
-    sudo curl -H 'Cache-Control: no-cache, no-store' \
-        -s -o $PLANE_INSTALL_DIR/variables-upgrade.env \
-        https://raw.githubusercontent.com/$CODE_REPO/$DEPLOY_BRANCH/deploy/selfhost/variables.env?token=$(date +%s) 
-
-    # if .env does not exists rename variables-upgrade.env to .env
-    if [ ! -f "$PLANE_INSTALL_DIR/.env" ]; then
-        sudo mv $PLANE_INSTALL_DIR/variables-upgrade.env $PLANE_INSTALL_DIR/.env
-    fi
-
-    show_message "Plane Setup Files Downloaded ✅" "replace_last_line"  >&2
-    show_message ""  >&2
-
-    echo "PLANE_DOWNLOADED"
-    return 0
-}
-function printUsageInstructions() {
-    show_message ""  >&2
-    show_message "----------------------------------" >&2
-    show_message "Usage Instructions" >&2
-    show_message "----------------------------------" >&2
-    show_message ""  >&2
-    show_message "To use the Plane Setup utility, use below commands" >&2
-    show_message "" >&2
-
-    show_message "Usage: plane-app [OPTION]" >&2
-    show_message "" >&2
-    show_message "  start                       Start Server" >&2
-    show_message "  stop                        Stop Server" >&2
-    show_message "  restart                     Restart Server" >&2
-    show_message "" >&2
-    show_message "other options" >&2
-    show_message "  -i, --install               Install Plane" >&2
-    show_message "  -c, --configure             Configure Plane" >&2
-    show_message "  -up, --upgrade              Upgrade Plane" >&2
-    show_message "  -un, --uninstall            Uninstall Plane" >&2
-    show_message "  -ui, --update-installer     Update Plane Installer" >&2
-    show_message "  -h, --help                  Show help" >&2
-    show_message "" >&2
-    show_message ""  >&2
-    show_message "Application Data is stored in mentioned folders" >&2
-    show_message "  - DB Data: $DATA_DIR/postgres" >&2
-    show_message "  - Redis Data: $DATA_DIR/redis" >&2
-    show_message "  - Minio Data: $DATA_DIR/minio" >&2
-    show_message "" >&2
-    show_message "" >&2
-    show_message "----------------------------------" >&2
-    show_message ""  >&2
-}
-function build_local_image() {
-    show_message "- Downloading Plane Source Code ✋" >&2
-    REPO=https://github.com/$CODE_REPO.git
-    CURR_DIR=$PWD
-    PLANE_TEMP_CODE_DIR=$PLANE_INSTALL_DIR/temp
-    sudo rm -rf $PLANE_TEMP_CODE_DIR > /dev/null
-
-    sudo git clone $REPO $PLANE_TEMP_CODE_DIR  --branch $DEPLOY_BRANCH --single-branch -q > /dev/null
-
-    sudo cp $PLANE_TEMP_CODE_DIR/deploy/selfhost/build.yml $PLANE_TEMP_CODE_DIR/build.yml
-
-    show_message "- Plane Source Code Downloaded ✅" "replace_last_line" >&2
-    
-    show_message "- Building Docker Images ✋" >&2
-    sudo docker compose --env-file=$PLANE_INSTALL_DIR/.env -f $PLANE_TEMP_CODE_DIR/build.yml build --no-cache
-}
-function check_for_docker_images() {
-    show_message "" >&2
-    # show_message "Building Plane Images" >&2
-    
-    CURR_DIR=$(pwd)
-    
-    if [ "$DEPLOY_BRANCH" == "master" ]; then
-        update_env "APP_RELEASE" "latest"
-        export APP_RELEASE=latest
-    else
-        update_env "APP_RELEASE" "$DEPLOY_BRANCH"
-        export APP_RELEASE=$DEPLOY_BRANCH    
-    fi
-
-    if [ $USE_GLOBAL_IMAGES == 1 ]; then
-        # show_message "Building Plane Images for $CPU_ARCH is not required. Skipping... ✅" "replace_last_line" >&2
-        export DOCKERHUB_USER=makeplane
-        update_env "DOCKERHUB_USER" "$DOCKERHUB_USER"
-        update_env "PULL_POLICY" "always"
-        echo "Building Plane Images for $CPU_ARCH is not required. Skipping..."
-    else
-        export DOCKERHUB_USER=myplane
-        show_message "Building Plane Images for $CPU_ARCH " >&2
-        update_env "DOCKERHUB_USER" "$DOCKERHUB_USER"
-        update_env "PULL_POLICY" "never"
-
-        build_local_image
-
-        sudo rm -rf $PLANE_INSTALL_DIR/temp > /dev/null
-
-        show_message "- Docker Images Built ✅" "replace_last_line" >&2
-        sudo cd $CURR_DIR
-    fi
-
-    sudo sed -i "s|- pgdata:|- $DATA_DIR/postgres:|g" $PLANE_INSTALL_DIR/docker-compose.yaml
-    sudo sed -i "s|- redisdata:|- $DATA_DIR/redis:|g" $PLANE_INSTALL_DIR/docker-compose.yaml
-    sudo sed -i "s|- uploads:|- $DATA_DIR/minio:|g" $PLANE_INSTALL_DIR/docker-compose.yaml
-
-    show_message "Downloading Plane Images for $CPU_ARCH ✋" >&2
-    sudo docker compose -f $PLANE_INSTALL_DIR/docker-compose.yaml --env-file=$PLANE_INSTALL_DIR/.env pull
-    show_message "Plane Images Downloaded ✅" "replace_last_line" >&2
-}
-function configure_plane() {
-    show_message "" >&2
-    show_message "Configuring Plane" >&2
-    show_message "" >&2
-
-    exec 3>&1
-
-    nginx_port=$(read_env "NGINX_PORT")
-    domain_name=$(read_env "DOMAIN_NAME")
-    upload_limit=$(read_env "FILE_SIZE_LIMIT")
-
-    NGINX_SETTINGS=$(dialog \
-        --ok-label "Next" \
-        --cancel-label "Skip" \
-        --backtitle "Plane Configuration" \
-        --title "Nginx Settings" \
-        --form "" \
-        0 0 0 \
-        "Port:"                   1 1	        "${nginx_port:-80}"            1 10 50 0 \
-        "Domain:"                 2 1	        "${domain_name:-localhost}"     2 10 50 0 \
-        "Upload Limit:"           3 1	        "${upload_limit:-5242880}"       3 10 15 0 \
-    2>&1 1>&3)
-
-    save_nginx_settings=0
-    if [ $? -eq 0 ]; then
-        save_nginx_settings=1
-        nginx_port=$(echo "$NGINX_SETTINGS" | sed -n 1p)
-        domain_name=$(echo "$NGINX_SETTINGS" | sed -n 2p)
-        upload_limit=$(echo "$NGINX_SETTINGS" | sed -n 3p)
-    fi
-
-
-    # smtp_host=$(read_env "EMAIL_HOST")
-    # smtp_user=$(read_env "EMAIL_HOST_USER")
-    # smtp_password=$(read_env "EMAIL_HOST_PASSWORD")
-    # smtp_port=$(read_env "EMAIL_PORT")
-    # smtp_from=$(read_env "EMAIL_FROM")
-    # smtp_tls=$(read_env "EMAIL_USE_TLS")
-    # smtp_ssl=$(read_env "EMAIL_USE_SSL")
-
-    # SMTP_SETTINGS=$(dialog \
-    #     --ok-label "Next" \
-    #     --cancel-label "Skip" \
-    #     --backtitle "Plane Configuration" \
-    #     --title "SMTP Settings" \
-    #     --form "" \
-    #     0 0 0 \
-    #     "Host:"        1 1	  "$smtp_host" 	              1 10 80 0 \
-    #     "User:"        2 1	  "$smtp_user" 	              2 10 80 0 \
-    #     "Password:"    3 1	  "$smtp_password" 	              3 10 80 0 \
-    #     "Port:"        4 1	  "${smtp_port:-587}"               4 10 5 0 \
-    #     "From:"        5 1	  "${smtp_from:-Mailer <mailer@example.com>}"               5 10 80 0 \
-    #     "TLS:"         6 1	  "${smtp_tls:-1}"                 6 10 1 1 \
-    #     "SSL:"         7 1	  "${smtp_ssl:-0}"                 7 10 1 1 \
-    # 2>&1 1>&3)
-
-    # save_smtp_settings=0
-    # if [ $? -eq 0 ]; then
-    #     save_smtp_settings=1
-    #     smtp_host=$(echo "$SMTP_SETTINGS" | sed -n 1p)
-    #     smtp_user=$(echo "$SMTP_SETTINGS" | sed -n 2p)
-    #     smtp_password=$(echo "$SMTP_SETTINGS" | sed -n 3p)
-    #     smtp_port=$(echo "$SMTP_SETTINGS" | sed -n 4p)
-    #     smtp_from=$(echo "$SMTP_SETTINGS" | sed -n 5p)
-    #     smtp_tls=$(echo "$SMTP_SETTINGS" | sed -n 6p)
-    # fi
-    external_pgdb_url=$(dialog \
-                    --backtitle "Plane Configuration" \
-                    --title "Using External Postgres Database ?" \
-                    --ok-label "Next" \
-                    --cancel-label "Skip" \
-                    --inputbox "Enter your external database url" \
-                    8 60 3>&1 1>&2 2>&3)
-
-
-    external_redis_url=$(dialog \
-                    --backtitle "Plane Configuration" \
-                    --title "Using External Redis Database ?" \
-                    --ok-label "Next" \
-                    --cancel-label "Skip" \
-                    --inputbox "Enter your external redis url" \
-                    8 60 3>&1 1>&2 2>&3)
-
-    
-    aws_region=$(read_env "AWS_REGION")
-    aws_access_key=$(read_env "AWS_ACCESS_KEY_ID")
-    aws_secret_key=$(read_env "AWS_SECRET_ACCESS_KEY")
-    aws_bucket=$(read_env "AWS_S3_BUCKET_NAME")
-    
-
-    AWS_S3_SETTINGS=$(dialog \
-        --ok-label "Next" \
-        --cancel-label "Skip" \
-        --backtitle "Plane Configuration" \
-        --title "AWS S3 Bucket Configuration" \
-        --form "" \
-        0 0 0 \
-        "Region:"         1 1	        "$aws_region"       1 10 50 0 \
-        "Access Key:"     2 1	        "$aws_access_key"   2 10 50 0 \
-        "Secret Key:"     3 1	        "$aws_secret_key"   3 10 50 0 \
-        "Bucket:"         4 1	        "$aws_bucket"       4 10 50 0 \
-    2>&1 1>&3)
-
-    save_aws_settings=0
-    if [ $? -eq 0 ]; then
-        save_aws_settings=1
-        aws_region=$(echo "$AWS_S3_SETTINGS" | sed -n 1p)
-        aws_access_key=$(echo "$AWS_S3_SETTINGS" | sed -n 2p)
-        aws_secret_key=$(echo "$AWS_S3_SETTINGS" | sed -n 3p)
-        aws_bucket=$(echo "$AWS_S3_SETTINGS" | sed -n 4p)
-    fi
-
-    # display dialogbox asking for confirmation to continue
-    CONFIRM_CONFIG=$(dialog \
-            --title "Confirm Configuration" \
-            --backtitle "Plane Configuration" \
-            --yes-label "Confirm" \
-            --no-label "Cancel" \
-            --yesno \
-            "
-            save_ngnix_settings:  $save_nginx_settings
-            nginx_port:           $nginx_port
-            domain_name:          $domain_name
-            upload_limit:         $upload_limit
-
-            save_aws_settings:    $save_aws_settings
-            aws_region:           $aws_region
-            aws_access_key:       $aws_access_key
-            aws_secret_key:       $aws_secret_key
-            aws_bucket:           $aws_bucket
-
-            pdgb_url:             $external_pgdb_url
-            redis_url:            $external_redis_url
-            " \
-            0 0 3>&1 1>&2 2>&3)
-    
-    if [ $? -eq 0 ]; then
-        if [ $save_nginx_settings == 1 ]; then
-            update_env "NGINX_PORT" "$nginx_port"
-            update_env "DOMAIN_NAME" "$domain_name"
-            update_env "WEB_URL" "http://$domain_name"
-            update_env "CORS_ALLOWED_ORIGINS" "http://$domain_name"
-            update_env "FILE_SIZE_LIMIT" "$upload_limit"
-        fi
-
-        # check enable smpt settings value
-        # if [ $save_smtp_settings == 1 ]; then
-        #     update_env "EMAIL_HOST" "$smtp_host"
-        #     update_env "EMAIL_HOST_USER" "$smtp_user"
-        #     update_env "EMAIL_HOST_PASSWORD" "$smtp_password"
-        #     update_env "EMAIL_PORT" "$smtp_port"
-        #     update_env "EMAIL_FROM" "$smtp_from"
-        #     update_env "EMAIL_USE_TLS" "$smtp_tls"
-        #     update_env "EMAIL_USE_SSL" "$smtp_ssl"
-        # fi
-
-        # check enable aws settings value
-        if [[ $save_aws_settings == 1 &&  $aws_access_key != ""  &&  $aws_secret_key != "" ]] ; then
-            update_env "USE_MINIO" "0"
-            update_env "AWS_REGION" "$aws_region"
-            update_env "AWS_ACCESS_KEY_ID" "$aws_access_key"
-            update_env "AWS_SECRET_ACCESS_KEY" "$aws_secret_key"
-            update_env "AWS_S3_BUCKET_NAME" "$aws_bucket"
-        elif [[ -z $aws_access_key || -z $aws_secret_key  ]] ; then
-            update_env "USE_MINIO" "1"
-            update_env "AWS_REGION" ""
-            update_env "AWS_ACCESS_KEY_ID" ""
-            update_env "AWS_SECRET_ACCESS_KEY" ""
-            update_env "AWS_S3_BUCKET_NAME" "uploads"
-        fi
-
-        if [ "$external_pgdb_url" != "" ]; then
-            update_env "DATABASE_URL" "$external_pgdb_url"
-        fi
-        if [ "$external_redis_url" != "" ]; then
-            update_env "REDIS_URL" "$external_redis_url"
-        fi
-    fi
-
-    exec 3>&-
-}
-function upgrade_configuration() {
-    upg_env_file="$PLANE_INSTALL_DIR/variables-upgrade.env"
-    # Check if the file exists
-    if [ -f "$upg_env_file" ]; then
-        # Read each line from the file
-        while IFS= read -r line; do
-            # Skip comments and empty lines
-            if [[ "$line" =~ ^\s*#.*$ ]] || [[ -z "$line" ]]; then
-                continue
-            fi
-
-            # Split the line into key and value
-            key=$(echo "$line" | cut -d'=' -f1)
-            value=$(echo "$line" | cut -d'=' -f2-)
-
-            current_value=$(read_env "$key")
-
-            if [ -z "$current_value" ]; then
-                update_env "$key" "$value"
-            fi
-        done < "$upg_env_file"
-    fi
-}
-function install() {
-    show_message ""
-    if [ "$(uname)" == "Linux" ]; then
-        OS="linux"
-        OS_NAME=$(sudo awk -F= '/^ID=/{print $2}' /etc/os-release)
-        OS_NAME=$(echo "$OS_NAME" | tr -d '"')
-        print_header
-        if [ "$OS_NAME" == "ubuntu" ] || [ "$OS_NAME" == "debian" ] || 
-                [ "$OS_NAME" == "centos" ] || [ "$OS_NAME" == "amazon" ]; then
-            OS_SUPPORTED=true
-            show_message "******** Installing Plane ********"
-            show_message ""
-
-            prepare_environment
-
-            if [ $? -eq 0 ]; then
-                download_plane
-                if [ $? -eq 0 ]; then
-                    # create_service
-                    check_for_docker_images
-
-                    last_installed_on=$(read_config "INSTALLATION_DATE")
-                    # if [ "$last_installed_on" == "" ]; then
-                    #     configure_plane
-                    # fi
-                    
-                    update_env "NGINX_PORT" "80"
-                    update_env "DOMAIN_NAME" "$MY_IP"
-                    update_env "WEB_URL" "http://$MY_IP"
-                    update_env "CORS_ALLOWED_ORIGINS" "http://$MY_IP"
-
-                    update_config "INSTALLATION_DATE" "$(date '+%Y-%m-%d')"
-                    
-                    if command -v crontab &> /dev/null; then
-                        sudo touch /etc/cron.daily/makeplane
-                        sudo chmod +x /etc/cron.daily/makeplane
-                        sudo echo "0 2 * * * root /usr/local/bin/plane-app --upgrade" > /etc/cron.daily/makeplane
-                        sudo crontab /etc/cron.daily/makeplane 
-                    fi
-
-                    show_message "Plane Installed Successfully ✅"
-                    show_message ""
-                else
-                    show_message "Download Failed ❌"
-                    exit 1
-                fi
-            else
-                show_message "Initialization Failed ❌"
-                exit 1
-            fi
-            
-        else
-            OS_SUPPORTED=false
-            PROGRESS_MSG="❌❌ Unsupported OS Varient Detected : $OS_NAME ❌❌"
-            show_message ""
-            exit 1
-        fi
-    else
-        PROGRESS_MSG="❌❌❌ Unsupported OS Detected : $(uname) ❌❌❌"
-        show_message ""
-        exit 1
-    fi
-}
-function upgrade() {
-    print_header
-    if [ "$(uname)" == "Linux" ]; then
-        OS="linux"
-        OS_NAME=$(sudo awk -F= '/^ID=/{print $2}' /etc/os-release)
-        OS_NAME=$(echo "$OS_NAME" | tr -d '"')
-        if [ "$OS_NAME" == "ubuntu" ] || [ "$OS_NAME" == "debian" ] || 
-                [ "$OS_NAME" == "centos" ] || [ "$OS_NAME" == "amazon" ]; then
-
-            OS_SUPPORTED=true
-            show_message "******** Upgrading Plane ********"
-            show_message ""
-
-            prepare_environment
-
-            if [ $? -eq 0 ]; then
-                stop_server
-                download_plane
-                if [ $? -eq 0 ]; then
-                    check_for_docker_images
-                    upgrade_configuration
-                    update_config "UPGRADE_DATE" "$(date)"
-
-                    start_server
-
-                    show_message ""
-                    show_message "Plane Upgraded Successfully ✅"
-                    show_message ""
-                    printUsageInstructions
-                else
-                    show_message "Download Failed ❌"
-                    exit 1
-                fi
-            else
-                show_message "Initialization Failed ❌"
-                exit 1
-            fi
-        else
-            PROGRESS_MSG="❌❌ Unsupported OS Varient Detected : $OS_NAME ❌❌"
-            show_message ""
-            exit 1
-        fi
-    else
-        PROGRESS_MSG="❌❌❌ Unsupported OS Detected : $(uname) ❌❌❌"
-        show_message ""
-        exit 1
-    fi
-}
-function uninstall() {
-    print_header
-    if [ "$(uname)" == "Linux" ]; then
-        OS="linux"
-        OS_NAME=$(awk -F= '/^ID=/{print $2}' /etc/os-release)
-        OS_NAME=$(echo "$OS_NAME" | tr -d '"')
-        if [ "$OS_NAME" == "ubuntu" ] || [ "$OS_NAME" == "debian" ] || 
-                [ "$OS_NAME" == "centos" ] || [ "$OS_NAME" == "amazon" ]; then
-
-            OS_SUPPORTED=true
-            show_message "******** Uninstalling Plane ********"
-            show_message ""
-
-            stop_server
-
-            if ! [ -x "$(command -v docker)" ]; then
-                echo "DOCKER_NOT_INSTALLED" &> /dev/null
-            else
-                # Ask of user input to confirm uninstall docker ?
-                CONFIRM_DOCKER_PURGE=$(dialog --title "Uninstall Docker" --defaultno --yesno "Are you sure you want to uninstall docker ?" 8 60 3>&1 1>&2 2>&3)
-                if [ $? -eq 0 ]; then
-                    show_message "- Uninstalling Docker ✋"
-                    sudo docker images -q | xargs -r sudo docker rmi -f &> /dev/null
-                    sudo "$PACKAGE_MANAGER" remove -y docker-engine docker docker.io docker-ce docker-ce-cli docker-compose-plugin &> /dev/null
-                    sudo "$PACKAGE_MANAGER" autoremove -y docker-engine docker docker.io docker-ce docker-compose-plugin &> /dev/null
-                    show_message "- Docker Uninstalled ✅" "replace_last_line" >&2
-                fi
-            fi
-
-            sudo rm $PLANE_INSTALL_DIR/.env &> /dev/null
-            sudo rm $PLANE_INSTALL_DIR/variables-upgrade.env &> /dev/null
-            sudo rm $PLANE_INSTALL_DIR/config.env &> /dev/null
-            sudo rm $PLANE_INSTALL_DIR/docker-compose.yaml &> /dev/null
-
-            if command -v crontab &> /dev/null; then
-                sudo crontab -r &> /dev/null
-                sudo rm /etc/cron.daily/makeplane &> /dev/null
-            fi
-            
-            # rm -rf $PLANE_INSTALL_DIR &> /dev/null
-            show_message "- Configuration Cleaned ✅"
-
-            show_message ""
-            show_message "******** Plane Uninstalled ********"
-            show_message ""
-            show_message ""
-            show_message "Plane Configuration Cleaned with some exceptions"
-            show_message "- DB Data: $DATA_DIR/postgres"
-            show_message "- Redis Data: $DATA_DIR/redis"
-            show_message "- Minio Data: $DATA_DIR/minio"
-            show_message ""
-            show_message ""
-            show_message "Thank you for using Plane. We hope to see you again soon."
-            show_message ""
-            show_message ""
-        else
-            PROGRESS_MSG="❌❌ Unsupported OS Varient Detected : $OS_NAME ❌❌"
-            show_message ""
-            exit 1
-        fi
-    else
-        PROGRESS_MSG="❌❌❌ Unsupported OS Detected : $(uname) ❌❌❌"
-        show_message ""
-        exit 1
-    fi
-}
-function start_server() {
-    docker_compose_file="$PLANE_INSTALL_DIR/docker-compose.yaml"
-    env_file="$PLANE_INSTALL_DIR/.env"
-    # check if both the files exits 
-    if [ -f "$docker_compose_file" ] && [ -f "$env_file" ]; then
-        show_message "Starting Plane Server ($APP_RELEASE) ✋"
-        sudo docker compose -f $docker_compose_file --env-file=$env_file up -d
-
-        # Wait for containers to be running
-        echo "Waiting for containers to start..."
-        while ! sudo docker compose -f "$docker_compose_file" --env-file="$env_file" ps --services --filter "status=running" --quiet | grep -q "."; do
-            sleep 1
-        done
-        # wait for migrator container to exit with status 0 before starting the application
-        migrator_container_id=$(sudo docker container ls -aq -f "name=plane-migrator")
-
-        # if migrator container is running, wait for it to exit
-        if [ -n "$migrator_container_id" ]; then
-            while sudo docker inspect --format='{{.State.Status}}' $migrator_container_id | grep -q "running"; do
-                show_message "Waiting for Plane Server ($APP_RELEASE) to start...✋ (Migrator in progress)" "replace_last_line" >&2
-                sleep 1
-            done
-        fi
-
-        # if migrator exit status is not 0, show error message and exit
-        if [ -n "$migrator_container_id" ]; then
-            migrator_exit_code=$(sudo docker inspect --format='{{.State.ExitCode}}' $migrator_container_id)
-            if [ $migrator_exit_code -ne 0 ]; then
-                # show_message "Migrator failed with exit code $migrator_exit_code ❌" "replace_last_line" >&2
-                show_message "Plane Server failed to start ❌" "replace_last_line" >&2
-                stop_server
-                exit 1
-            fi
-        fi
-
-        api_container_id=$(sudo docker container ls -q -f "name=plane-api")
-        while ! sudo docker logs $api_container_id 2>&1 | grep -i "Application startup complete";
-        do
-            show_message "Waiting for Plane Server ($APP_RELEASE) to start...✋ (API starting)" "replace_last_line" >&2
-            sleep 1
-        done
-        show_message "Plane Server Started ($APP_RELEASE) ✅" "replace_last_line" >&2
-        show_message "---------------------------------------------------------------" >&2
-        show_message "Access the Plane application at http://$MY_IP" >&2
-        show_message "---------------------------------------------------------------" >&2
-
-    else
-        show_message "Plane Server not installed. Please install Plane first ❌" "replace_last_line" >&2
-    fi
-}
-function stop_server() {
-    docker_compose_file="$PLANE_INSTALL_DIR/docker-compose.yaml"
-    env_file="$PLANE_INSTALL_DIR/.env"
-    # check if both the files exits 
-    if [ -f "$docker_compose_file" ] && [ -f "$env_file" ]; then
-        show_message "Stopping Plane Server ($APP_RELEASE) ✋"
-        sudo docker compose -f $docker_compose_file --env-file=$env_file down
-        show_message "Plane Server Stopped ($APP_RELEASE) ✅" "replace_last_line" >&2
-    else
-        show_message "Plane Server not installed [Skipping] ✅" "replace_last_line" >&2
-    fi
-}
-function restart_server() {
-    docker_compose_file="$PLANE_INSTALL_DIR/docker-compose.yaml"
-    env_file="$PLANE_INSTALL_DIR/.env"
-    # check if both the files exits 
-    if [ -f "$docker_compose_file" ] && [ -f "$env_file" ]; then
-        show_message "Restarting Plane Server ($APP_RELEASE) ✋"
-        sudo docker compose -f $docker_compose_file --env-file=$env_file restart
-        show_message "Plane Server Restarted ($APP_RELEASE) ✅" "replace_last_line" >&2
-    else
-        show_message "Plane Server not installed. Please install Plane first ❌" "replace_last_line" >&2
-    fi
-}
-function show_help() {
-    # print_header
-    show_message "Usage: plane-app [OPTION]" >&2
-    show_message "" >&2
-    show_message "  start                       Start Server" >&2
-    show_message "  stop                        Stop Server" >&2
-    show_message "  restart                     Restart Server" >&2
-    show_message "" >&2
-    show_message "other options" >&2
-    show_message "  -i, --install               Install Plane" >&2
-    show_message "  -c, --configure             Configure Plane" >&2
-    show_message "  -up, --upgrade              Upgrade Plane" >&2
-    show_message "  -un, --uninstall            Uninstall Plane" >&2
-    show_message "  -ui, --update-installer     Update Plane Installer" >&2
-    show_message "  -h, --help                  Show help" >&2
-    show_message "" >&2
-    exit 1
-    
-}
-function update_installer() {
-    show_message "Updating Plane Installer ✋" >&2
-    sudo curl -H 'Cache-Control: no-cache, no-store' \
-        -s -o /usr/local/bin/plane-app  \
-        https://raw.githubusercontent.com/$CODE_REPO/$DEPLOY_BRANCH/deploy/1-click/plane-app?token=$(date +%s) 
-
-    sudo chmod +x /usr/local/bin/plane-app > /dev/null&> /dev/null
-    show_message "Plane Installer Updated ✅" "replace_last_line" >&2
-}
-
-export DEPLOY_BRANCH=${BRANCH:-master}
-export APP_RELEASE=$DEPLOY_BRANCH
-export DOCKERHUB_USER=makeplane
-export PULL_POLICY=always
-
-if [ "$DEPLOY_BRANCH" == "master" ]; then
-    export APP_RELEASE=latest
-fi
-
-PLANE_INSTALL_DIR=/opt/plane
-DATA_DIR=$PLANE_INSTALL_DIR/data
-LOG_DIR=$PLANE_INSTALL_DIR/logs
-CODE_REPO=${GIT_REPO:-makeplane/plane}
-OS_SUPPORTED=false
-CPU_ARCH=$(uname -m)
-PROGRESS_MSG=""
-USE_GLOBAL_IMAGES=0
-PACKAGE_MANAGER=""
-MY_IP=$(curl -s ifconfig.me)
-
-if [[ $CPU_ARCH == "amd64" || $CPU_ARCH == "x86_64" || ( $DEPLOY_BRANCH == "master" && ( $CPU_ARCH == "arm64" || $CPU_ARCH == "aarch64" ) ) ]]; then
-    USE_GLOBAL_IMAGES=1
-fi
-
-sudo mkdir -p $PLANE_INSTALL_DIR/{data,log}
-
-if command -v apt-get &> /dev/null; then
-    PACKAGE_MANAGER="apt-get"
-elif command -v yum &> /dev/null; then
-    PACKAGE_MANAGER="yum"
-elif command -v apk &> /dev/null; then
-    PACKAGE_MANAGER="apk"
-fi
-
-if [ "$1" == "start" ]; then
-    start_server
-elif [ "$1" == "stop" ]; then
-    stop_server
-elif [ "$1" == "restart" ]; then
-    restart_server
-elif [ "$1" == "--install" ] || [ "$1" == "-i" ]; then
-    install
-    start_server
-    show_message "" >&2
-    show_message "To view help, use plane-app --help " >&2
-elif [ "$1" == "--configure" ] || [ "$1" == "-c" ]; then
-    configure_plane
-    printUsageInstructions
-elif [ "$1" == "--upgrade" ] || [ "$1" == "-up" ]; then
-    upgrade
-elif [ "$1" == "--uninstall" ] || [ "$1" == "-un" ]; then
-    uninstall
-elif [ "$1" == "--update-installer" ] || [ "$1" == "-ui" ]; then
-    update_installer
-elif [ "$1" == "--help" ] || [ "$1" == "-h" ]; then
-    show_help
-else
-    show_help
-fi

deploy/selfhost/docker-compose.yml

@@ -38,6 +38,10 @@ x-app-env : &app-env
     - EMAIL_USE_SSL=${EMAIL_USE_SSL:-0}
     - DEFAULT_EMAIL=${DEFAULT_EMAIL:-captain@plane.so}
     - DEFAULT_PASSWORD=${DEFAULT_PASSWORD:-password123}
+    # OPENAI SETTINGS - Deprecated can be configured through admin panel
+    - OPENAI_API_BASE=${OPENAI_API_BASE:-https://api.openai.com/v1}
+    - OPENAI_API_KEY=${OPENAI_API_KEY:-""}
+    - GPT_ENGINE=${GPT_ENGINE:-"gpt-3.5-turbo"}
     # LOGIN/SIGNUP SETTINGS - Deprecated can be configured through admin panel
     - ENABLE_SIGNUP=${ENABLE_SIGNUP:-1}
     - ENABLE_EMAIL_PASSWORD=${ENABLE_EMAIL_PASSWORD:-1}
@@ -56,6 +60,8 @@ x-app-env : &app-env
     - BUCKET_NAME=${BUCKET_NAME:-uploads}
     - FILE_SIZE_LIMIT=${FILE_SIZE_LIMIT:-5242880}
 
+
+
 services:
   web:
     <<: *app-env
@@ -116,18 +122,6 @@ services:
       - plane-db
       - plane-redis
 
-  migrator:
-    <<: *app-env
-    image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-latest}
-    pull_policy: ${PULL_POLICY:-always}
-    restart: no
-    command: >
-        sh -c "python manage.py wait_for_db &&
-             python manage.py migrate"
-    depends_on:
-      - plane-db
-      - plane-redis
-
   plane-db:
     <<: *app-env
     image: postgres:15.2-alpine
@@ -136,6 +130,7 @@ services:
     command: postgres -c 'max_connections=1000'
     volumes:
       - pgdata:/var/lib/postgresql/data
+    
   plane-redis:
     <<: *app-env
     image: redis:6.2.7-alpine

deploy/selfhost/install.sh

@@ -13,23 +13,6 @@ YELLOW='\033[1;33m'
 GREEN='\033[0;32m'
 NC='\033[0m' # No Color
 
-function print_header() {
-clear
-
-cat <<"EOF"
----------------------------------------
- ____  _                  
-|  _ \| | __ _ _ __   ___ 
-| |_) | |/ _` | '_ \ / _ \
-|  __/| | (_| | | | |  __/
-|_|   |_|\__,_|_| |_|\___|    
-
----------------------------------------
-Project management tool from the future
----------------------------------------
-EOF
-}
-
 function buildLocalImage() {
     if [ "$1" == "--force-build" ]; then
         DO_BUILD="1"
@@ -37,8 +20,8 @@ function buildLocalImage() {
         DO_BUILD="2"
     else 
         printf "\n" >&2
-        printf "${YELLOW}You are on ${CPU_ARCH} cpu architecture. ${NC}\n" >&2
-        printf "${YELLOW}Since the prebuilt ${CPU_ARCH} compatible docker images are not available for, we will be running the docker build on this system. ${NC} \n" >&2
+        printf "${YELLOW}You are on ${ARCH} cpu architecture. ${NC}\n" >&2
+        printf "${YELLOW}Since the prebuilt ${ARCH} compatible docker images are not available for, we will be running the docker build on this system. ${NC} \n" >&2
         printf "${YELLOW}This might take ${YELLOW}5-30 min based on your system's hardware configuration. \n ${NC} \n" >&2
         printf "\n" >&2
         printf "${GREEN}Select an option to proceed: ${NC}\n" >&2
@@ -66,7 +49,7 @@ function buildLocalImage() {
         cd $PLANE_TEMP_CODE_DIR
         if [ "$BRANCH" == "master" ];
         then
-            export APP_RELEASE=latest
+            APP_RELEASE=latest
         fi
 
         docker compose -f build.yml build --no-cache  >&2
@@ -127,7 +110,7 @@ function download() {
             exit 0
         fi
     else
-        docker compose -f $DOCKER_FILE_PATH --env-file=$DOCKER_ENV_PATH pull
+        docker compose -f $PLANE_INSTALL_DIR/docker-compose.yaml pull
     fi
     
     echo ""
@@ -138,48 +121,19 @@ function download() {
 
 }
 function startServices() {
-    docker compose -f $DOCKER_FILE_PATH --env-file=$DOCKER_ENV_PATH up -d --quiet-pull
-
-    local migrator_container_id=$(docker container ls -aq -f "name=plane-app-migrator")
-    if [ -n "$migrator_container_id" ]; then
-        local idx=0
-        while docker inspect --format='{{.State.Status}}' $migrator_container_id | grep -q "running"; do
-            local message=">>> Waiting for Data Migration to finish"
-            local dots=$(printf '%*s' $idx | tr ' ' '.')
-            echo -ne "\r$message$dots"
-            ((idx++))
-            sleep 1
-        done
-    fi
-    printf "\r\033[K"
-
-    # if migrator exit status is not 0, show error message and exit
-    if [ -n "$migrator_container_id" ]; then
-        local migrator_exit_code=$(docker inspect --format='{{.State.ExitCode}}' $migrator_container_id)
-        if [ $migrator_exit_code -ne 0 ]; then
-            echo "Plane Server failed to start ❌"
-            stopServices
-            exit 1
-        fi
-    fi
-
-    local api_container_id=$(docker container ls -q -f "name=plane-app-api")
-    local idx2=0
-    while ! docker logs $api_container_id 2>&1 | grep -m 1 -i "Application startup complete" | grep -q ".";
-    do
-        local message=">>> Waiting for API Service to Start"
-        local dots=$(printf '%*s' $idx2 | tr ' ' '.')    
-        echo -ne "\r$message$dots"
-        ((idx2++))
-        sleep 1
-    done
-    printf "\r\033[K"
+    cd $PLANE_INSTALL_DIR
+    docker compose up -d --quiet-pull
+    cd $SCRIPT_DIR
 }
 function stopServices() {
-    docker compose -f $DOCKER_FILE_PATH --env-file=$DOCKER_ENV_PATH down
+    cd $PLANE_INSTALL_DIR
+    docker compose down
+    cd $SCRIPT_DIR
 }
 function restartServices() {
-    docker compose -f $DOCKER_FILE_PATH --env-file=$DOCKER_ENV_PATH restart
+    cd $PLANE_INSTALL_DIR
+    docker compose restart
+    cd $SCRIPT_DIR
 }
 function upgrade() {
     echo "***** STOPPING SERVICES ****"
@@ -190,137 +144,47 @@ function upgrade() {
     download
 
     echo "***** PLEASE VALIDATE AND START SERVICES ****"
-}
-function viewSpecificLogs(){
-    local SERVICE_NAME=$1
 
-    if docker-compose -f $DOCKER_FILE_PATH ps | grep -q "$SERVICE_NAME"; then
-        echo "Service '$SERVICE_NAME' is running."
-    else
-        echo "Service '$SERVICE_NAME' is not running."
-    fi
-
-    docker compose -f $DOCKER_FILE_PATH logs -f $SERVICE_NAME
-}
-function viewLogs(){
-    
-    ARG_SERVICE_NAME=$2
-
-    if [ -z "$ARG_SERVICE_NAME" ];
-    then
-        echo
-        echo "Select a Service you want to view the logs for:"
-        echo "   1) Web"
-        echo "   2) Space"
-        echo "   3) API"
-        echo "   4) Worker"
-        echo "   5) Beat-Worker"
-        echo "   6) Migrator"
-        echo "   7) Proxy"
-        echo "   8) Redis"
-        echo "   9) Postgres"
-        echo "   10) Minio"
-        echo "   0) Back to Main Menu"
-        echo 
-        read -p "Service: " DOCKER_SERVICE_NAME
-
-        until (( DOCKER_SERVICE_NAME >= 0 && DOCKER_SERVICE_NAME <= 10 )); do
-            echo "Invalid selection. Please enter a number between 1 and 11."
-            read -p "Service: " DOCKER_SERVICE_NAME
-        done
-
-        if [ -z "$DOCKER_SERVICE_NAME" ];
-        then
-            echo "INVALID SERVICE NAME SUPPLIED"
-        else
-            case $DOCKER_SERVICE_NAME in
-                1) viewSpecificLogs "web";;
-                2) viewSpecificLogs "space";;
-                3) viewSpecificLogs "api";;
-                4) viewSpecificLogs "worker";;
-                5) viewSpecificLogs "beat-worker";;
-                6) viewSpecificLogs "migrator";;
-                7) viewSpecificLogs "proxy";;
-                8) viewSpecificLogs "plane-redis";;
-                9) viewSpecificLogs "plane-db";;
-                10) viewSpecificLogs "plane-minio";;
-                0) askForAction;;
-                *) echo "INVALID SERVICE NAME SUPPLIED";;
-            esac
-        fi
-    elif [ -n "$ARG_SERVICE_NAME" ];
-    then
-        ARG_SERVICE_NAME=$(echo "$ARG_SERVICE_NAME" | tr '[:upper:]' '[:lower:]')
-        case $ARG_SERVICE_NAME in
-            web) viewSpecificLogs "web";;
-            space) viewSpecificLogs "space";;
-            api) viewSpecificLogs "api";;
-            worker) viewSpecificLogs "worker";;
-            beat-worker) viewSpecificLogs "beat-worker";;
-            migrator) viewSpecificLogs "migrator";;
-            proxy) viewSpecificLogs "proxy";;
-            redis) viewSpecificLogs "plane-redis";;
-            postgres) viewSpecificLogs "plane-db";;
-            minio) viewSpecificLogs "plane-minio";;
-            *) echo "INVALID SERVICE NAME SUPPLIED";;
-        esac
-    else
-        echo "INVALID SERVICE NAME SUPPLIED"
-    fi
 }
 function askForAction() {
-    local DEFAULT_ACTION=$1
-
-    if [ -z "$DEFAULT_ACTION" ];
-    then
-        echo
-        echo "Select a Action you want to perform:"
-        echo "   1) Install (${CPU_ARCH})"
-        echo "   2) Start"
-        echo "   3) Stop"
-        echo "   4) Restart"
-        echo "   5) Upgrade"
-        echo "   6) View Logs"
-        echo "   7) Exit"
-        echo 
+    echo
+    echo "Select a Action you want to perform:"
+    echo "   1) Install (${ARCH})"
+    echo "   2) Start"
+    echo "   3) Stop"
+    echo "   4) Restart"
+    echo "   5) Upgrade"
+    echo "   6) Exit"
+    echo 
+    read -p "Action [2]: " ACTION
+    until [[ -z "$ACTION" || "$ACTION" =~ ^[1-6]$ ]]; do
+        echo "$ACTION: invalid selection."
         read -p "Action [2]: " ACTION
-        until [[ -z "$ACTION" || "$ACTION" =~ ^[1-7]$ ]]; do
-            echo "$ACTION: invalid selection."
-            read -p "Action [2]: " ACTION
-        done
+    done
+    echo
 
-        if [ -z "$ACTION" ];
-        then
-            ACTION=2
-        fi
-        echo
-    fi
 
-    if [ "$ACTION" == "1" ] || [ "$DEFAULT_ACTION" == "install" ]
+    if [ "$ACTION" == "1" ]
     then
         install
         askForAction
-    elif [ "$ACTION" == "2" ] || [ "$DEFAULT_ACTION" == "start" ]
+    elif [ "$ACTION" == "2" ] || [ "$ACTION" == "" ]
     then
         startServices
         askForAction
-    elif [ "$ACTION" == "3" ] || [ "$DEFAULT_ACTION" == "stop" ]
+    elif [ "$ACTION" == "3" ] 
     then
         stopServices
         askForAction
-    elif [ "$ACTION" == "4" ] || [ "$DEFAULT_ACTION" == "restart" ]
+    elif [ "$ACTION" == "4" ] 
     then
         restartServices
         askForAction
-    elif [ "$ACTION" == "5" ]  || [ "$DEFAULT_ACTION" == "upgrade" ]
+    elif [ "$ACTION" == "5" ] 
     then
         upgrade
         askForAction
-    elif [ "$ACTION" == "6" ]  || [ "$DEFAULT_ACTION" == "logs" ]
-    then
-        viewLogs $@
-        askForAction
-    elif [ "$ACTION" == "7" ]
+    elif [ "$ACTION" == "6" ] 
     then
         exit 0
     else
@@ -329,8 +193,8 @@ function askForAction() {
 }
 
 # CPU ARCHITECHTURE BASED SETTINGS
-CPU_ARCH=$(uname -m)
-if [[ $CPU_ARCH == "amd64" || $CPU_ARCH == "x86_64" || ( $BRANCH == "master" && ( $CPU_ARCH == "arm64" || $CPU_ARCH == "aarch64" ) ) ]]; 
+ARCH=$(uname -m)
+if [ $ARCH == "amd64" ] || [ $ARCH == "x86_64" ];
 then
     USE_GLOBAL_IMAGES=1
     DOCKERHUB_USER=makeplane
@@ -341,11 +205,6 @@ else
     PULL_POLICY=never
 fi
 
-if [ "$BRANCH" == "master" ];
-then
-    export APP_RELEASE=latest
-fi
-
 # REMOVE SPECIAL CHARACTERS FROM BRANCH NAME
 if [ "$BRANCH" != "master" ];
 then
@@ -353,8 +212,4 @@ then
 fi
 mkdir -p $PLANE_INSTALL_DIR/archive
 
-DOCKER_FILE_PATH=$PLANE_INSTALL_DIR/docker-compose.yaml
-DOCKER_ENV_PATH=$PLANE_INSTALL_DIR/.env
-
-print_header
-askForAction $@
+askForAction

deploy/selfhost/variables.env

@@ -8,13 +8,13 @@ NGINX_PORT=80
 WEB_URL=http://localhost
 DEBUG=0
 NEXT_PUBLIC_DEPLOY_URL=http://localhost/spaces
-SENTRY_DSN=
-SENTRY_ENVIRONMENT=production
-GOOGLE_CLIENT_ID=
-GITHUB_CLIENT_ID=
-GITHUB_CLIENT_SECRET=
+SENTRY_DSN=""
+SENTRY_ENVIRONMENT="production"
+GOOGLE_CLIENT_ID=""
+GITHUB_CLIENT_ID=""
+GITHUB_CLIENT_SECRET=""
 DOCKERIZED=1 # deprecated
-CORS_ALLOWED_ORIGINS=http://localhost
+CORS_ALLOWED_ORIGINS="http://localhost"
 
 #DB SETTINGS
 PGHOST=plane-db
@@ -31,14 +31,19 @@ REDIS_PORT=6379
 REDIS_URL=redis://${REDIS_HOST}:6379/
 
 # EMAIL SETTINGS
-EMAIL_HOST=
-EMAIL_HOST_USER=
-EMAIL_HOST_PASSWORD=
+EMAIL_HOST=""
+EMAIL_HOST_USER=""
+EMAIL_HOST_PASSWORD=""
 EMAIL_PORT=587
-EMAIL_FROM=Team Plane <team@mailer.plane.so>
+EMAIL_FROM="Team Plane <team@mailer.plane.so>"
 EMAIL_USE_TLS=1
 EMAIL_USE_SSL=0
 
+# OPENAI SETTINGS
+OPENAI_API_BASE=https://api.openai.com/v1 # deprecated
+OPENAI_API_KEY="sk-" # deprecated
+GPT_ENGINE="gpt-3.5-turbo" # deprecated
+
 # LOGIN/SIGNUP SETTINGS
 ENABLE_SIGNUP=1
 ENABLE_EMAIL_PASSWORD=1
@@ -47,13 +52,13 @@ SECRET_KEY=60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5
 
 # DATA STORE SETTINGS
 USE_MINIO=1
-AWS_REGION=
-AWS_ACCESS_KEY_ID=access-key
-AWS_SECRET_ACCESS_KEY=secret-key
+AWS_REGION=""
+AWS_ACCESS_KEY_ID="access-key"
+AWS_SECRET_ACCESS_KEY="secret-key"
 AWS_S3_ENDPOINT_URL=http://plane-minio:9000
 AWS_S3_BUCKET_NAME=uploads
-MINIO_ROOT_USER=access-key
-MINIO_ROOT_PASSWORD=secret-key
+MINIO_ROOT_USER="access-key"
+MINIO_ROOT_PASSWORD="secret-key"
 BUCKET_NAME=uploads
 FILE_SIZE_LIMIT=5242880
 

docker-compose-local.yml

@@ -86,7 +86,7 @@ services:
       - dev_env
     volumes:
       - ./apiserver:/code
-    command: ./bin/takeoff.local
+    # command: /bin/sh -c "python manage.py migrate && python manage.py runserver 0.0.0.0:8000 --settings=plane.settings.local"
     env_file:
       - ./apiserver/.env
     depends_on:
@@ -104,7 +104,7 @@ services:
       - dev_env
     volumes:
       - ./apiserver:/code
-    command: ./bin/worker
+    command: /bin/sh -c "celery -A plane worker -l info"
     env_file:
       - ./apiserver/.env
     depends_on:
@@ -123,7 +123,7 @@ services:
       - dev_env
     volumes:
       - ./apiserver:/code
-    command: ./bin/beat
+    command: /bin/sh -c "celery -A plane beat -l info"
     env_file:
       - ./apiserver/.env
     depends_on:
@@ -131,26 +131,6 @@ services:
       - plane-db
       - plane-redis
 
-  migrator:
-    build:
-      context: ./apiserver
-      dockerfile: Dockerfile.dev
-      args:
-        DOCKER_BUILDKIT: 1
-    restart: "no"
-    networks:
-      - dev_env
-    volumes:
-      - ./apiserver:/code
-    command: >
-        sh -c "python manage.py wait_for_db --settings=plane.settings.local &&
-             python manage.py migrate --settings=plane.settings.local"
-    env_file:
-      - ./apiserver/.env
-    depends_on:
-      - plane-db
-      - plane-redis
-
   proxy:
     build:
       context: ./nginx

package.json

@@ -1,6 +1,6 @@
 {
   "repository": "https://github.com/makeplane/plane.git",
-  "version": "0.16.0",
+  "version": "0.14.0",
   "license": "AGPL-3.0",
   "private": true,
   "workspaces": [
@@ -15,7 +15,7 @@
   ],
   "scripts": {
     "build": "turbo run build",
-    "dev": "turbo run dev --concurrency=13",
+    "dev": "turbo run dev",
     "start": "turbo run start",
     "lint": "turbo run lint",
     "clean": "turbo run clean",

packages/editor/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plane/editor-core",
-  "version": "0.16.0",
+  "version": "0.14.0",
   "description": "Core Editor that powers Plane",
   "private": true,
   "main": "./dist/index.mjs",
@@ -30,6 +30,7 @@
   "dependencies": {
     "@tiptap/core": "^2.1.13",
     "@tiptap/extension-blockquote": "^2.1.13",
+    "@tiptap/extension-code": "^2.1.13",
     "@tiptap/extension-code-block-lowlight": "^2.1.13",
     "@tiptap/extension-color": "^2.1.13",
     "@tiptap/extension-image": "^2.1.13",

packages/editor/core/src/lib/editor-commands.ts

@@ -34,32 +34,8 @@ export const toggleUnderline = (editor: Editor, range?: Range) => {
 };
 
 export const toggleCodeBlock = (editor: Editor, range?: Range) => {
-  // Check if code block is active then toggle code block
-  if (editor.isActive("codeBlock")) {
-    if (range) {
-      editor.chain().focus().deleteRange(range).toggleCodeBlock().run();
-      return;
-    }
-    editor.chain().focus().toggleCodeBlock().run();
-    return;
-  }
-
-  // Check if user hasn't selected any text
-  const isSelectionEmpty = editor.state.selection.empty;
-
-  if (isSelectionEmpty) {
-    if (range) {
-      editor.chain().focus().deleteRange(range).toggleCodeBlock().run();
-      return;
-    }
-    editor.chain().focus().toggleCodeBlock().run();
-  } else {
-    if (range) {
-      editor.chain().focus().deleteRange(range).toggleCode().run();
-      return;
-    }
-    editor.chain().focus().toggleCode().run();
-  }
+  if (range) editor.chain().focus().deleteRange(range).toggleCodeBlock().run();
+  else editor.chain().focus().toggleCodeBlock().run();
 };
 
 export const toggleOrderedList = (editor: Editor, range?: Range) => {
@@ -83,8 +59,8 @@ export const toggleStrike = (editor: Editor, range?: Range) => {
 };
 
 export const toggleBlockquote = (editor: Editor, range?: Range) => {
-  if (range) editor.chain().focus().deleteRange(range).toggleBlockquote().run();
-  else editor.chain().focus().toggleBlockquote().run();
+  if (range) editor.chain().focus().deleteRange(range).toggleNode("paragraph", "paragraph").toggleBlockquote().run();
+  else editor.chain().focus().toggleNode("paragraph", "paragraph").toggleBlockquote().run();
 };
 
 export const insertTableCommand = (editor: Editor, range?: Range) => {
@@ -97,8 +73,8 @@ export const insertTableCommand = (editor: Editor, range?: Range) => {
       }
     }
   }
-  if (range) editor.chain().focus().deleteRange(range).insertTable({ rows: 3, cols: 3 }).run();
-  else editor.chain().focus().insertTable({ rows: 3, cols: 3 }).run();
+  if (range) editor.chain().focus().deleteRange(range).insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run();
+  else editor.chain().focus().insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run();
 };
 
 export const unsetLinkEditor = (editor: Editor) => {

packages/editor/core/src/styles/editor.css

@@ -170,6 +170,68 @@ ul[data-type="taskList"] li[data-checked="true"] > div > p {
   }
 }
 
+#editor-container {
+  table {
+    border-collapse: collapse;
+    table-layout: fixed;
+    margin: 0.5em 0 0.5em 0;
+
+    border: 1px solid rgb(var(--color-border-200));
+    width: 100%;
+
+    td,
+    th {
+      min-width: 1em;
+      border: 1px solid rgb(var(--color-border-200));
+      padding: 10px 15px;
+      vertical-align: top;
+      box-sizing: border-box;
+      position: relative;
+      transition: background-color 0.3s ease;
+
+      > * {
+        margin-bottom: 0;
+      }
+    }
+
+    th {
+      font-weight: bold;
+      text-align: left;
+      background-color: rgb(var(--color-primary-100));
+    }
+
+    td:hover {
+      background-color: rgba(var(--color-primary-300), 0.1);
+    }
+
+    .selectedCell:after {
+      z-index: 2;
+      position: absolute;
+      content: "";
+      left: 0;
+      right: 0;
+      top: 0;
+      bottom: 0;
+      background-color: rgba(var(--color-primary-300), 0.1);
+      pointer-events: none;
+    }
+
+    .column-resize-handle {
+      position: absolute;
+      right: -2px;
+      top: 0;
+      bottom: -2px;
+      width: 2px;
+      background-color: rgb(var(--color-primary-400));
+      pointer-events: none;
+    }
+  }
+}
+
+.tableWrapper {
+  overflow-x: auto;
+}
+
 .resize-cursor {
   cursor: ew-resize;
   cursor: col-resize;

packages/editor/core/src/styles/table.css

@@ -9,15 +9,15 @@
   border-collapse: collapse;
   table-layout: fixed;
   margin: 0;
-  margin-bottom: 1rem;
-  border: 2px solid rgba(var(--color-border-300));
+  margin-bottom: 3rem;
+  border: 1px solid rgba(var(--color-border-200));
   width: 100%;
 }
 
 .tableWrapper table td,
 .tableWrapper table th {
   min-width: 1em;
-  border: 1px solid rgba(var(--color-border-300));
+  border: 1px solid rgba(var(--color-border-200));
   padding: 10px 15px;
   vertical-align: top;
   box-sizing: border-box;
@@ -43,8 +43,7 @@
 .tableWrapper table th {
   font-weight: bold;
   text-align: left;
-  background-color: #d9e4ff;
-  color: #171717;
+  background-color: rgba(var(--color-primary-100));
 }
 
 .tableWrapper table th * {
@@ -63,35 +62,6 @@
   pointer-events: none;
 }
 
-.colorPicker {
-  display: grid;
-  padding: 8px 8px;
-  grid-template-columns: repeat(6, 1fr);
-  gap: 5px;
-}
-
-.colorPickerLabel {
-  font-size: 0.85rem;
-  color: #6b7280;
-  padding: 8px 8px;
-  padding-bottom: 0px;
-}
-
-.colorPickerItem {
-  margin: 2px 0px;
-  width: 24px;
-  height: 24px;
-  border-radius: 4px;
-  border: none;
-  cursor: pointer;
-}
-
-.divider {
-  background-color: #e5e7eb;
-  height: 1px;
-  margin: 3px 0;
-}
-
 .tableWrapper table .column-resize-handle {
   position: absolute;
   right: -2px;
@@ -99,7 +69,7 @@
   bottom: -2px;
   width: 4px;
   z-index: 99;
-  background-color: #d9e4ff;
+  background-color: rgba(var(--color-primary-400));
   pointer-events: none;
 }
 
@@ -142,7 +112,7 @@
 }
 
 .tableWrapper .tableControls .rowsControlDiv {
-  background-color: #d9e4ff;
+  background-color: rgba(var(--color-primary-100));
   border: 1px solid rgba(var(--color-border-200));
   border-radius: 2px;
   background-size: 1.25rem;
@@ -157,7 +127,7 @@
 }
 
 .tableWrapper .tableControls .columnsControlDiv {
-  background-color: #d9e4ff;
+  background-color: rgba(var(--color-primary-100));
   border: 1px solid rgba(var(--color-border-200));
   border-radius: 2px;
   background-size: 1.25rem;
@@ -174,12 +144,10 @@
 .tableWrapper .tableControls .tableColorPickerToolbox {
   border: 1px solid rgba(var(--color-border-300));
   background-color: rgba(var(--color-background-100));
-  border-radius: 5px;
-  box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.1);
   padding: 0.25rem;
   display: flex;
   flex-direction: column;
-  width: max-content;
+  width: 200px;
   gap: 0.25rem;
 }
 
@@ -190,7 +158,7 @@
   align-items: center;
   gap: 0.5rem;
   border: none;
-  padding: 0.3rem 0.5rem 0.1rem 0.1rem;
+  padding: 0.1rem;
   border-radius: 4px;
   cursor: pointer;
   transition: all 0.2s;
@@ -205,7 +173,9 @@
 .tableWrapper .tableControls .tableColorPickerToolbox .toolboxItem .iconContainer,
 .tableWrapper .tableControls .tableToolbox .toolboxItem .colorContainer,
 .tableWrapper .tableControls .tableColorPickerToolbox .toolboxItem .colorContainer {
-  padding: 4px 0px;
+  border: 1px solid rgba(var(--color-border-300));
+  border-radius: 3px;
+  padding: 4px;
   display: flex;
   align-items: center;
   justify-content: center;
@@ -217,8 +187,8 @@
 .tableWrapper .tableControls .tableColorPickerToolbox .toolboxItem .iconContainer svg,
 .tableWrapper .tableControls .tableToolbox .toolboxItem .colorContainer svg,
 .tableWrapper .tableControls .tableColorPickerToolbox .toolboxItem .colorContainer svg {
-  width: 1rem;
-  height: 1rem;
+  width: 2rem;
+  height: 2rem;
 }
 
 .tableToolbox {

packages/editor/core/src/ui/components/editor-container.tsx

@@ -12,7 +12,7 @@ export const EditorContainer = ({ editor, editorClassNames, hideDragHandle, chil
   <div
     id="editor-container"
     onClick={() => {
-      editor?.chain().focus(undefined, { scrollIntoView: false }).run();
+      editor?.chain().focus().run();
     }}
     onMouseLeave={() => {
       hideDragHandle?.();

packages/editor/core/src/ui/extensions/code-inline/index.tsx

@@ -1,80 +1,12 @@
-import { Mark, markInputRule, markPasteRule, mergeAttributes } from "@tiptap/core";
+import { markInputRule, markPasteRule } from "@tiptap/core";
+import Code from "@tiptap/extension-code";
 
-export interface CodeOptions {
-  HTMLAttributes: Record<string, any>;
-}
-
-declare module "@tiptap/core" {
-  interface Commands<ReturnType> {
-    code: {
-      /**
-       * Set a code mark
-       */
-      setCode: () => ReturnType;
-      /**
-       * Toggle inline code
-       */
-      toggleCode: () => ReturnType;
-      /**
-       * Unset a code mark
-       */
-      unsetCode: () => ReturnType;
-    };
-  }
-}
-
-export const inputRegex = /(?:^|\s)((?:`)((?:[^`]+))(?:`))$/;
-export const pasteRegex = /(?:^|\s)((?:`)((?:[^`]+))(?:`))/g;
-
-export const CustomCodeInlineExtension = Mark.create<CodeOptions>({
-  name: "code",
-
-  addOptions() {
-    return {
-      HTMLAttributes: {
-        class: "rounded-md bg-custom-primary-30 mx-1 px-1 py-[2px] font-mono font-medium text-custom-text-1000",
-        spellcheck: "false",
-      },
-    };
-  },
-
-  excludes: "_",
-
-  code: true,
+export const inputRegex = /(?<!`)`([^`]*)`(?!`)/;
+export const pasteRegex = /(?<!`)`([^`]+)`(?!`)/g;
 
+export const CustomCodeInlineExtension = Code.extend({
   exitable: true,
-
-  parseHTML() {
-    return [{ tag: "code" }];
-  },
-
-  renderHTML({ HTMLAttributes }) {
-    return ["code", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-  },
-
-  addCommands() {
-    return {
-      setCode:
-        () =>
-        ({ commands }) =>
-          commands.setMark(this.name),
-      toggleCode:
-        () =>
-        ({ commands }) =>
-          commands.toggleMark(this.name),
-      unsetCode:
-        () =>
-        ({ commands }) =>
-          commands.unsetMark(this.name),
-    };
-  },
-
-  addKeyboardShortcuts() {
-    return {
-      "Mod-e": () => this.editor.commands.toggleCode(),
-    };
-  },
-
+  inclusive: false,
   addInputRules() {
     return [
       markInputRule({
@@ -83,7 +15,6 @@ export const CustomCodeInlineExtension = Mark.create<CodeOptions>({
       }),
     ];
   },
-
   addPasteRules() {
     return [
       markPasteRule({
@@ -92,4 +23,9 @@ export const CustomCodeInlineExtension = Mark.create<CodeOptions>({
       }),
     ];
   },
+}).configure({
+  HTMLAttributes: {
+    class: "rounded-md bg-custom-primary-30 mx-1 px-1 py-[2px] font-mono font-medium text-custom-text-1000",
+    spellcheck: "false",
+  },
 });

packages/editor/core/src/ui/extensions/horizontal-rule.tsx

@@ -0,0 +1,109 @@
+import { TextSelection } from "prosemirror-state";
+
+import { InputRule, mergeAttributes, Node, nodeInputRule, wrappingInputRule } from "@tiptap/core";
+
+/**
+ * Extension based on:
+ * - Tiptap HorizontalRule extension (https://tiptap.dev/api/nodes/horizontal-rule)
+ */
+
+export interface HorizontalRuleOptions {
+  HTMLAttributes: Record<string, any>;
+}
+
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    horizontalRule: {
+      /**
+       * Add a horizontal rule
+       */
+      setHorizontalRule: () => ReturnType;
+    };
+  }
+}
+
+export const HorizontalRule = Node.create<HorizontalRuleOptions>({
+  name: "horizontalRule",
+
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+    };
+  },
+
+  group: "block",
+
+  addAttributes() {
+    return {
+      color: {
+        default: "#dddddd",
+      },
+    };
+  },
+
+  parseHTML() {
+    return [
+      {
+        tag: `div[data-type="${this.name}"]`,
+      },
+    ];
+  },
+
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-type": this.name,
+      }),
+      ["div", {}],
+    ];
+  },
+
+  addCommands() {
+    return {
+      setHorizontalRule:
+        () =>
+        ({ chain }) => {
+          return (
+            chain()
+              .insertContent({ type: this.name })
+              // set cursor after horizontal rule
+              .command(({ tr, dispatch }) => {
+                if (dispatch) {
+                  const { $to } = tr.selection;
+                  const posAfter = $to.end();
+
+                  if ($to.nodeAfter) {
+                    tr.setSelection(TextSelection.create(tr.doc, $to.pos));
+                  } else {
+                    // add node after horizontal rule if it’s the end of the document
+                    const node = $to.parent.type.contentMatch.defaultType?.create();
+
+                    if (node) {
+                      tr.insert(posAfter, node);
+                      tr.setSelection(TextSelection.create(tr.doc, posAfter));
+                    }
+                  }
+
+                  tr.scrollIntoView();
+                }
+
+                return true;
+              })
+              .run()
+          );
+        },
+    };
+  },
+
+  addInputRules() {
+    return [
+      new InputRule({
+        find: /^(?:---|—-|___\s|\*\*\*\s)$/,
+        handler: ({ state, range, match }) => {
+          state.tr.replaceRangeWith(range.from, range.to, this.type.create());
+        },
+      }),
+    ];
+  },
+});

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

@@ -1,32 +1,32 @@
+import StarterKit from "@tiptap/starter-kit";
+import TiptapUnderline from "@tiptap/extension-underline";
+import TextStyle from "@tiptap/extension-text-style";
 import { Color } from "@tiptap/extension-color";
 import TaskItem from "@tiptap/extension-task-item";
 import TaskList from "@tiptap/extension-task-list";
-import TextStyle from "@tiptap/extension-text-style";
-import TiptapUnderline from "@tiptap/extension-underline";
-import StarterKit from "@tiptap/starter-kit";
 import { Markdown } from "tiptap-markdown";
 
+import { TableHeader } from "src/ui/extensions/table/table-header/table-header";
 import { Table } from "src/ui/extensions/table/table";
 import { TableCell } from "src/ui/extensions/table/table-cell/table-cell";
-import { TableHeader } from "src/ui/extensions/table/table-header/table-header";
 import { TableRow } from "src/ui/extensions/table/table-row/table-row";
+import { HorizontalRule } from "src/ui/extensions/horizontal-rule";
 
 import { ImageExtension } from "src/ui/extensions/image";
 
 import { isValidHttpUrl } from "src/lib/utils";
 import { Mentions } from "src/ui/mentions";
 
-import { CustomCodeBlockExtension } from "src/ui/extensions/code";
-import { ListKeymap } from "src/ui/extensions/custom-list-keymap";
 import { CustomKeymap } from "src/ui/extensions/keymap";
+import { CustomCodeBlockExtension } from "src/ui/extensions/code";
 import { CustomQuoteExtension } from "src/ui/extensions/quote";
+import { ListKeymap } from "src/ui/extensions/custom-list-keymap";
 
 import { DeleteImage } from "src/types/delete-image";
 import { IMentionSuggestion } from "src/types/mention-suggestion";
 import { RestoreImage } from "src/types/restore-image";
 import { CustomLinkExtension } from "src/ui/extensions/custom-link";
-import { CustomCodeInlineExtension } from "src/ui/extensions/code-inline";
-import { CustomTypographyExtension } from "src/ui/extensions/typography";
+import { CustomCodeInlineExtension } from "./code-inline";
 
 export const CoreEditorExtensions = (
   mentionConfig: {
@@ -53,11 +53,14 @@ export const CoreEditorExtensions = (
         class: "leading-normal -mb-2",
       },
     },
+    hardBreak: {
+      HTMLAttributes: {
+        class: "p-2",
+      },
+    },
     code: false,
     codeBlock: false,
-    horizontalRule: {
-      HTMLAttributes: { class: "mt-4 mb-4" },
-    },
+    horizontalRule: false,
     blockquote: false,
     dropcursor: {
       color: "rgba(var(--color-text-100))",
@@ -80,7 +83,6 @@ export const CoreEditorExtensions = (
         "text-custom-primary-300 underline underline-offset-[3px] hover:text-custom-primary-500 transition-colors cursor-pointer",
     },
   }),
-  CustomTypographyExtension,
   ImageExtension(deleteFile, restoreFile, cancelUploadImage).configure({
     HTMLAttributes: {
       class: "rounded-lg border border-custom-border-300",
@@ -107,6 +109,7 @@ export const CoreEditorExtensions = (
     transformCopiedText: true,
     transformPastedText: true,
   }),
+  HorizontalRule,
   Table,
   TableHeader,
   TableCell,

packages/editor/core/src/ui/extensions/table/table-cell/table-cell.ts

@@ -13,7 +13,7 @@ export const TableCell = Node.create<TableCellOptions>({
     };
   },
 
-  content: "block+",
+  content: "paragraph+",
 
   addAttributes() {
     return {
@@ -33,10 +33,7 @@ export const TableCell = Node.create<TableCellOptions>({
         },
       },
       background: {
-        default: null,
-      },
-      textColor: {
-        default: null,
+        default: "none",
       },
     };
   },
@@ -53,7 +50,7 @@ export const TableCell = Node.create<TableCellOptions>({
     return [
       "td",
       mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
-        style: `background-color: ${node.attrs.background}; color: ${node.attrs.textColor}`,
+        style: `background-color: ${node.attrs.background}`,
       }),
       0,
     ];

packages/editor/core/src/ui/extensions/table/table-header/table-header.ts

@@ -33,7 +33,7 @@ export const TableHeader = Node.create<TableHeaderOptions>({
         },
       },
       background: {
-        default: "none",
+        default: "rgb(var(--color-primary-100))",
       },
     };
   },

packages/editor/core/src/ui/extensions/table/table-row/table-row.ts

@@ -13,17 +13,6 @@ export const TableRow = Node.create<TableRowOptions>({
     };
   },
 
-  addAttributes() {
-    return {
-      background: {
-        default: null,
-      },
-      textColor: {
-        default: null,
-      },
-    };
-  },
-
   content: "(tableCell | tableHeader)*",
 
   tableRole: "row",
@@ -33,12 +22,6 @@ export const TableRow = Node.create<TableRowOptions>({
   },
 
   renderHTML({ HTMLAttributes }) {
-    const style = HTMLAttributes.background
-      ? `background-color: ${HTMLAttributes.background}; color: ${HTMLAttributes.textColor}`
-      : "";
-
-    const attributes = mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { style });
-
-    return ["tr", attributes, 0];
+    return ["tr", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
   },
 });

packages/editor/core/src/ui/extensions/table/table/icons.ts

@@ -1,7 +1,7 @@
 export const icons = {
   colorPicker: `<svg xmlns="http://www.w3.org/2000/svg" length="24" viewBox="0 0 24 24" style="transform: ;msFilter:;"><path fill="rgb(var(--color-text-300))" d="M20 14c-.092.064-2 2.083-2 3.5 0 1.494.949 2.448 2 2.5.906.044 2-.891 2-2.5 0-1.5-1.908-3.436-2-3.5zM9.586 20c.378.378.88.586 1.414.586s1.036-.208 1.414-.586l7-7-.707-.707L11 4.586 8.707 2.293 7.293 3.707 9.586 6 4 11.586c-.378.378-.586.88-.586 1.414s.208 1.036.586 1.414L9.586 20zM11 7.414 16.586 13H5.414L11 7.414z"></path></svg>`,
-  deleteColumn: `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-trash-2"><path d="M3 6h18"/><path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6"/><path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2"/><line x1="10" x2="10" y1="11" y2="17"/><line x1="14" x2="14" y1="11" y2="17"/></svg>`,
-  deleteRow: `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-trash-2"><path d="M3 6h18"/><path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6"/><path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2"/><line x1="10" x2="10" y1="11" y2="17"/><line x1="14" x2="14" y1="11" y2="17"/></svg>`,
+  deleteColumn: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" length="24"><path fill="#e53e3e" d="M0 0H24V24H0z"/><path d="M12 3c.552 0 1 .448 1 1v8c.835-.628 1.874-1 3-1 2.761 0 5 2.239 5 5s-2.239 5-5 5c-1.032 0-1.99-.313-2.787-.848L13 20c0 .552-.448 1-1 1H6c-.552 0-1-.448-1-1V4c0-.552.448-1 1-1h6zm-1 2H7v14h4V5zm8 10h-6v2h6v-2z"/></svg>`,
+  deleteRow: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" length="24"><path fill="#e53e3e" d="M0 0H24V24H0z"/><path d="M20 5c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1 .628.835 1 1.874 1 3 0 2.761-2.239 5-5 5s-5-2.239-5-5c0-1.126.372-2.165 1-3H4c-.552 0-1-.448-1-1V6c0-.552.448-1 1-1h16zm-7 10v2h6v-2h-6zm6-8H5v4h14V7z"/></svg>`,
   insertLeftTableIcon: `<svg
     xmlns="http://www.w3.org/2000/svg"
     length={24}
@@ -35,8 +35,6 @@ export const icons = {
     />
   </svg>
 `,
-  toggleColumnHeader: `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="rgb(var(--color-text-300))" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-toggle-right"><rect width="20" height="12" x="2" y="6" rx="6" ry="6"/><circle cx="16" cy="12" r="2"/></svg>`,
-  toggleRowHeader: `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="rgb(var(--color-text-300))" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-toggle-right"><rect width="20" height="12" x="2" y="6" rx="6" ry="6"/><circle cx="16" cy="12" r="2"/></svg>`,
   insertBottomTableIcon: `<svg
     xmlns="http://www.w3.org/2000/svg"
     length={24}

packages/editor/core/src/ui/extensions/table/table/table-view.tsx

@@ -81,75 +81,53 @@ const defaultTippyOptions: Partial<Props> = {
   placement: "right",
 };
 
-function setCellsBackgroundColor(editor: Editor, color: { backgroundColor: string; textColor: string }) {
+function setCellsBackgroundColor(editor: Editor, backgroundColor: string) {
   return editor
     .chain()
     .focus()
     .updateAttributes("tableCell", {
-      background: color.backgroundColor,
-      textColor: color.textColor,
+      background: backgroundColor,
+    })
+    .updateAttributes("tableHeader", {
+      background: backgroundColor,
     })
     .run();
 }
 
-function setTableRowBackgroundColor(editor: Editor, color: { backgroundColor: string; textColor: string }) {
-  const { state, dispatch } = editor.view;
-  const { selection } = state;
-  if (!(selection instanceof CellSelection)) {
-    return false;
-  }
-
-  // Get the position of the hovered cell in the selection to determine the row.
-  const hoveredCell = selection.$headCell || selection.$anchorCell;
-
-  // Find the depth of the table row node
-  let rowDepth = hoveredCell.depth;
-  while (rowDepth > 0 && hoveredCell.node(rowDepth).type.name !== "tableRow") {
-    rowDepth--;
-  }
-
-  // If we couldn't find a tableRow node, we can't set the background color
-  if (hoveredCell.node(rowDepth).type.name !== "tableRow") {
-    return false;
-  }
-
-  // Get the position where the table row starts
-  const rowStartPos = hoveredCell.start(rowDepth);
-
-  // Create a transaction that sets the background color on the tableRow node.
-  const tr = state.tr.setNodeMarkup(rowStartPos - 1, null, {
-    ...hoveredCell.node(rowDepth).attrs,
-    background: color.backgroundColor,
-    textColor: color.textColor,
-  });
-
-  dispatch(tr);
-  return true;
-}
-
 const columnsToolboxItems: ToolboxItem[] = [
   {
-    label: "Toggle column header",
-    icon: icons.toggleColumnHeader,
-    action: ({ editor }: { editor: Editor }) => editor.chain().focus().toggleHeaderColumn().run(),
-  },
-  {
-    label: "Add column before",
+    label: "Add Column Before",
     icon: icons.insertLeftTableIcon,
     action: ({ editor }: { editor: Editor }) => editor.chain().focus().addColumnBefore().run(),
   },
   {
-    label: "Add column after",
+    label: "Add Column After",
     icon: icons.insertRightTableIcon,
     action: ({ editor }: { editor: Editor }) => editor.chain().focus().addColumnAfter().run(),
   },
   {
-    label: "Pick color",
-    icon: "", // No icon needed for color picker
-    action: (args: any) => {}, // Placeholder action; actual color picking is handled in `createToolbox`
+    label: "Pick Column Color",
+    icon: icons.colorPicker,
+    action: ({
+      editor,
+      triggerButton,
+      controlsContainer,
+    }: {
+      editor: Editor;
+      triggerButton: HTMLElement;
+      controlsContainer: Element;
+    }) => {
+      createColorPickerToolbox({
+        triggerButton,
+        tippyOptions: {
+          appendTo: controlsContainer,
+        },
+        onSelectColor: (color) => setCellsBackgroundColor(editor, color),
+      });
+    },
   },
   {
-    label: "Delete column",
+    label: "Delete Column",
     icon: icons.deleteColumn,
     action: ({ editor }: { editor: Editor }) => editor.chain().focus().deleteColumn().run(),
   },
@@ -157,24 +135,35 @@ const columnsToolboxItems: ToolboxItem[] = [
 
 const rowsToolboxItems: ToolboxItem[] = [
   {
-    label: "Toggle row header",
-    icon: icons.toggleRowHeader,
-    action: ({ editor }: { editor: Editor }) => editor.chain().focus().toggleHeaderRow().run(),
-  },
-  {
-    label: "Add row above",
+    label: "Add Row Above",
     icon: icons.insertTopTableIcon,
     action: ({ editor }: { editor: Editor }) => editor.chain().focus().addRowBefore().run(),
   },
   {
-    label: "Add row below",
+    label: "Add Row Below",
     icon: icons.insertBottomTableIcon,
     action: ({ editor }: { editor: Editor }) => editor.chain().focus().addRowAfter().run(),
   },
   {
-    label: "Pick color",
-    icon: "",
-    action: (args: any) => {}, // Placeholder action; actual color picking is handled in `createToolbox`
+    label: "Pick Row Color",
+    icon: icons.colorPicker,
+    action: ({
+      editor,
+      triggerButton,
+      controlsContainer,
+    }: {
+      editor: Editor;
+      triggerButton: HTMLButtonElement;
+      controlsContainer: Element | "parent" | ((ref: Element) => Element) | undefined;
+    }) => {
+      createColorPickerToolbox({
+        triggerButton,
+        tippyOptions: {
+          appendTo: controlsContainer,
+        },
+        onSelectColor: (color) => setCellsBackgroundColor(editor, color),
+      });
+    },
   },
   {
     label: "Delete Row",
@@ -187,57 +176,37 @@ function createToolbox({
   triggerButton,
   items,
   tippyOptions,
-  onSelectColor,
   onClickItem,
-  colors,
 }: {
   triggerButton: Element | null;
   items: ToolboxItem[];
   tippyOptions: any;
   onClickItem: (item: ToolboxItem) => void;
-  onSelectColor: (color: { backgroundColor: string; textColor: string }) => void;
-  colors: { [key: string]: { backgroundColor: string; textColor: string; icon?: string } };
 }): Instance<Props> {
   // @ts-expect-error
   const toolbox = tippy(triggerButton, {
     content: h(
       "div",
       { className: "tableToolbox" },
-      items.map((item, index) => {
-        if (item.label === "Pick color") {
-          return h("div", { className: "flex flex-col" }, [
-            h("div", { className: "divider" }),
-            h("div", { className: "colorPickerLabel" }, item.label),
-            h(
-              "div",
-              { className: "colorPicker grid" },
-              Object.entries(colors).map(([colorName, colorValue]) =>
-                h("div", {
-                  className: "colorPickerItem",
-                  style: `background-color: ${colorValue.backgroundColor}; 
-                            color: ${colorValue.textColor || "inherit"};`,
-                  innerHTML: colorValue?.icon || "",
-                  onClick: () => onSelectColor(colorValue),
-                })
-              )
-            ),
-            h("div", { className: "divider" }),
-          ]);
-        } else {
-          return h(
-            "div",
-            {
-              className: "toolboxItem",
-              itemType: "div",
-              onClick: () => onClickItem(item),
+      items.map((item) =>
+        h(
+          "div",
+          {
+            className: "toolboxItem",
+            itemType: "button",
+            onClick() {
+              onClickItem(item);
             },
-            [
-              h("div", { className: "iconContainer", innerHTML: item.icon }),
-              h("div", { className: "label" }, item.label),
-            ]
-          );
-        }
-      })
+          },
+          [
+            h("div", {
+              className: "iconContainer",
+              innerHTML: item.icon,
+            }),
+            h("div", { className: "label" }, item.label),
+          ]
+        )
+      )
     ),
     ...tippyOptions,
   });
@@ -245,6 +214,71 @@ function createToolbox({
   return Array.isArray(toolbox) ? toolbox[0] : toolbox;
 }
 
+function createColorPickerToolbox({
+  triggerButton,
+  tippyOptions,
+  onSelectColor = () => {},
+}: {
+  triggerButton: HTMLElement;
+  tippyOptions: Partial<Props>;
+  onSelectColor?: (color: string) => void;
+}) {
+  const items = {
+    Default: "rgb(var(--color-primary-100))",
+    Orange: "#FFE5D1",
+    Grey: "#F1F1F1",
+    Yellow: "#FEF3C7",
+    Green: "#DCFCE7",
+    Red: "#FFDDDD",
+    Blue: "#D9E4FF",
+    Pink: "#FFE8FA",
+    Purple: "#E8DAFB",
+  };
+
+  const colorPicker = tippy(triggerButton, {
+    ...defaultTippyOptions,
+    content: h(
+      "div",
+      { className: "tableColorPickerToolbox" },
+      Object.entries(items).map(([key, value]) =>
+        h(
+          "div",
+          {
+            className: "toolboxItem",
+            itemType: "button",
+            onClick: () => {
+              onSelectColor(value);
+              colorPicker.hide();
+            },
+          },
+          [
+            h("div", {
+              className: "colorContainer",
+              style: {
+                backgroundColor: value,
+              },
+            }),
+            h(
+              "div",
+              {
+                className: "label",
+              },
+              key
+            ),
+          ]
+        )
+      )
+    ),
+    onHidden: (instance) => {
+      instance.destroy();
+    },
+    showOnCreate: true,
+    ...tippyOptions,
+  });
+
+  return colorPicker;
+}
+
 export class TableView implements NodeView {
   node: ProseMirrorNode;
   cellMinWidth: number;
@@ -313,27 +347,10 @@ export class TableView implements NodeView {
         this.rowsControl,
         this.columnsControl
       );
-      const columnColors = {
-        Blue: { backgroundColor: "#D9E4FF", textColor: "#171717" },
-        Orange: { backgroundColor: "#FFEDD5", textColor: "#171717" },
-        Grey: { backgroundColor: "#F1F1F1", textColor: "#171717" },
-        Yellow: { backgroundColor: "#FEF3C7", textColor: "#171717" },
-        Green: { backgroundColor: "#DCFCE7", textColor: "#171717" },
-        Red: { backgroundColor: "#FFDDDD", textColor: "#171717" },
-        Pink: { backgroundColor: "#FFE8FA", textColor: "#171717" },
-        Purple: { backgroundColor: "#E8DAFB", textColor: "#171717" },
-        None: {
-          backgroundColor: "none",
-          textColor: "none",
-          icon: `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="gray" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-ban"><circle cx="12" cy="12" r="10"/><path d="m4.9 4.9 14.2 14.2"/></svg>`,
-        },
-      };
 
       this.columnsToolbox = createToolbox({
         triggerButton: this.columnsControl.querySelector(".columnsControlDiv"),
         items: columnsToolboxItems,
-        colors: columnColors,
-        onSelectColor: (color) => setCellsBackgroundColor(this.editor, color),
         tippyOptions: {
           ...defaultTippyOptions,
           appendTo: this.controls,
@@ -351,12 +368,10 @@ export class TableView implements NodeView {
       this.rowsToolbox = createToolbox({
         triggerButton: this.rowsControl.firstElementChild,
         items: rowsToolboxItems,
-        colors: columnColors,
         tippyOptions: {
           ...defaultTippyOptions,
           appendTo: this.controls,
         },
-        onSelectColor: (color) => setTableRowBackgroundColor(editor, color),
         onClickItem: (item) => {
           item.action({
             editor: this.editor,
@@ -368,6 +383,8 @@ export class TableView implements NodeView {
       });
     }
 
+    // Table
+
     this.colgroup = h(
       "colgroup",
       null,
@@ -420,19 +437,16 @@ export class TableView implements NodeView {
   }
 
   updateControls() {
-    const { hoveredTable: table, hoveredCell: cell } = Object.values(this.decorations).reduce(
-      (acc, curr) => {
-        if (curr.spec.hoveredCell !== undefined) {
-          acc["hoveredCell"] = curr.spec.hoveredCell;
-        }
+    const { hoveredTable: table, hoveredCell: cell } = Object.values(this.decorations).reduce((acc, curr) => {
+      if (curr.spec.hoveredCell !== undefined) {
+        acc["hoveredCell"] = curr.spec.hoveredCell;
+      }
 
-        if (curr.spec.hoveredTable !== undefined) {
-          acc["hoveredTable"] = curr.spec.hoveredTable;
-        }
-        return acc;
-      },
-      {} as Record<string, HTMLElement>
-    ) as any;
+      if (curr.spec.hoveredTable !== undefined) {
+        acc["hoveredTable"] = curr.spec.hoveredTable;
+      }
+      return acc;
+    }, {} as Record<string, HTMLElement>) as any;
 
     if (table === undefined || cell === undefined) {
       return this.root.classList.add("controls--disabled");
@@ -443,12 +457,12 @@ export class TableView implements NodeView {
 
     const cellDom = this.editor.view.nodeDOM(cell.pos) as HTMLElement;
 
-    if (!this.table || !cellDom) {
+    if (!this.table) {
       return;
     }
 
-    const tableRect = this.table?.getBoundingClientRect();
-    const cellRect = cellDom?.getBoundingClientRect();
+    const tableRect = this.table.getBoundingClientRect();
+    const cellRect = cellDom.getBoundingClientRect();
 
     if (this.columnsControl) {
       this.columnsControl.style.left = `${cellRect.left - tableRect.left - this.table.parentElement!.scrollLeft}px`;