dev: exception handling

dev: hold celery worker and beat when pending migrations
dev: update example file for local dev
2024-01-22 10:11:26 +00:00 · 2024-01-19 12:37:23 +05:30 · 2024-01-19 12:35:59 +05:30 · 2024-01-19 12:35:43 +05:30 · 2024-01-18 12:31:10 +05:30 · 2024-01-17 23:04:53 +05:30
2066 changed files with 52787 additions and 88152 deletions
@@ -0,0 +1,23 @@
+version = 1
+
+exclude_patterns = [  
+  "bin/**",  
+  "**/node_modules/",  
+  "**/*.min.js"  
+]
+
+[[analyzers]]
+name = "shell"
+
+[[analyzers]]
+name = "javascript"
+
+  [analyzers.meta]
+  plugins = ["react"]
+  environment = ["nodejs"]
+
+[[analyzers]]
+name = "python"
+
+  [analyzers.meta]
+  runtime_version = "3.x.x"
@@ -1,8 +1,7 @@
 name: Bug report
 description: Create a bug report to help us improve Plane
 title: "[bug]: "
-labels: [🐛bug]
-assignees: [srinivaspendem, pushya22]
+labels: [bug, need testing]
 body:
 - type: markdown
  attributes:
@@ -45,7 +44,7 @@ body:
      - Deploy preview
  validations:
    required: true
- type: dropdown
+  type: dropdown
  id: browser
  attributes:
    label: Browser
@@ -55,19 +54,12 @@ body:
      - Safari
      - Other
 - type: dropdown
-  id: variant
+  id: version
  attributes:
-    label: Variant
+    label: Version
    options:
      - Cloud
      - Self-hosted
      - Local
-  validations:
-    required: true
- type: input
-  id: version
-  attributes:
-    label: Version
-    placeholder: v0.17.0-dev
  validations:
    required: true
@@ -1,8 +1,7 @@
 name: Feature request
 description: Suggest a feature to improve Plane
 title: "[feature]: "
-labels: [✨feature]
-assignees: [srinivaspendem, pushya22]
+labels: [feature]
 body:
 - type: markdown
  attributes:
@@ -1,84 +0,0 @@
-name: Auto Merge or Create PR on Push
-
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - "sync/**"
-
-env:
-  CURRENT_BRANCH: ${{ github.ref_name }}
-  SOURCE_BRANCH: ${{ secrets.SYNC_SOURCE_BRANCH_NAME }} # The sync branch such as "sync/ce"
-  TARGET_BRANCH: ${{ secrets.SYNC_TARGET_BRANCH_NAME }} # The target branch that you would like to merge changes like develop
-  GITHUB_TOKEN: ${{ secrets.ACCESS_TOKEN }} # Personal access token required to modify contents and workflows
-  REVIEWER: ${{ secrets.SYNC_PR_REVIEWER }}
-
-jobs:
-  Check_Branch:
-    runs-on: ubuntu-latest
-    outputs:
-      BRANCH_MATCH: ${{ steps.check-branch.outputs.MATCH }}
-    steps:
-      - name: Check if current branch matches the secret
-        id: check-branch
-        run: |
-          if [ "$CURRENT_BRANCH" = "$SOURCE_BRANCH" ]; then
-            echo "MATCH=true" >> $GITHUB_OUTPUT
-          else
-            echo "MATCH=false" >> $GITHUB_OUTPUT
-          fi
-
-  Auto_Merge:
-    if: ${{ needs.Check_Branch.outputs.BRANCH_MATCH == 'true' }}
-    needs: [Check_Branch]
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-      contents: write
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4.1.1
-        with:
-          fetch-depth: 0 # Fetch all history for all branches and tags
-
-      - name: Setup Git
-        run: |
-          git config user.name "GitHub Actions"
-          git config user.email "actions@github.com"
-
-      - name: Setup GH CLI and Git Config
-        run: |
-          type -p curl >/dev/null || (sudo apt update && sudo apt install curl -y)
-          curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
-          sudo chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg
-          echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
-          sudo apt update
-          sudo apt install gh -y
-
-      - name: Check for merge conflicts
-        id: conflicts
-        run: |
-          git fetch origin $TARGET_BRANCH
-          git checkout $TARGET_BRANCH
-          # Attempt to merge the main branch into the current branch
-          if $(git merge --no-commit --no-ff $SOURCE_BRANCH); then
-            echo "No merge conflicts detected."
-            echo "HAS_CONFLICTS=false" >> $GITHUB_ENV
-          else
-            echo "Merge conflicts detected."
-            echo "HAS_CONFLICTS=true" >> $GITHUB_ENV
-            git merge --abort
-          fi
-
-      - name: Merge Change to Target Branch
-        if: env.HAS_CONFLICTS == 'false'
-        run: |
-          git commit -m "Merge branch '$SOURCE_BRANCH' into $TARGET_BRANCH"
-          git push origin $TARGET_BRANCH
-
-      - name: Create PR to Target Branch
-        if: env.HAS_CONFLICTS == 'true'
-        run: |
-          # Replace 'username' with the actual GitHub username of the reviewer.
-          PR_URL=$(gh pr create --base $TARGET_BRANCH --head $SOURCE_BRANCH --title "sync: merge conflicts need to be resolved" --body "" --reviewer $REVIEWER)
-          echo "Pull Request created: $PR_URL"
@@ -1,122 +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 == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
    runs-on: ubuntu-20.04
    needs: [branch_build_setup]
    env:
-      FRONTEND_TAG: ${{ 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:
@@ -125,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 == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
    runs-on: ubuntu-20.04
    needs: [branch_build_setup]
    env:
-      SPACE_TAG: ${{ 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:
@@ -177,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 == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
    runs-on: ubuntu-20.04
    needs: [branch_build_setup]
    env:
-      BACKEND_TAG: ${{ 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:
@@ -229,50 +186,41 @@ jobs:
          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}

  branch_build_push_proxy:
-    if: ${{ needs.branch_build_setup.outputs.build_proxy == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
    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:
@@ -1,19 +1,28 @@
-name: Build and Lint on Pull Request
+name: Build Pull Request Contents

 on:
-  workflow_dispatch:
  pull_request:
    types: ["opened", "synchronize"]

 jobs:
-  get-changed-files:
-    runs-on: ubuntu-latest
-    outputs:
-      apiserver_changed: ${{ steps.changed-files.outputs.apiserver_any_changed }}
-      web_changed: ${{ steps.changed-files.outputs.web_any_changed }}
-      space_changed: ${{ steps.changed-files.outputs.deploy_any_changed }}
+  build-pull-request-contents:
+    name: Build Pull Request Contents
+    runs-on: ubuntu-20.04
+    permissions:
+      pull-requests: read
+
    steps:
-      - uses: actions/checkout@v3
+      - name: Checkout Repository to Actions
+        uses: actions/checkout@v3.3.0
+        with:
+          token: ${{ secrets.ACCESS_TOKEN }}
+
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v2
+        with:
+          node-version: 18.x
+          cache: "yarn"
+
      - name: Get changed files
        id: changed-files
        uses: tj-actions/changed-files@v41
@@ -23,82 +32,17 @@ jobs:
              - apiserver/**
            web:
              - web/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
            deploy:
              - space/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'

-  lint-apiserver:
-    needs: get-changed-files
-    runs-on: ubuntu-latest
-    if: needs.get-changed-files.outputs.apiserver_changed == 'true'
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: '3.x' # Specify the Python version you need
-      - name: Install Pylint
-        run: python -m pip install ruff
-      - name: Install Apiserver Dependencies
-        run: cd apiserver && pip install -r requirements.txt
-      - name: Lint apiserver
-        run: ruff check --fix apiserver
+      - name: Build Plane's Main App
+        if: steps.changed-files.outputs.web_any_changed == 'true'
+        run: |
+          yarn
+          yarn build --filter=web

-  lint-web:
-    needs: get-changed-files
-    if: needs.get-changed-files.outputs.web_changed == 'true'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Setup Node.js
-        uses: actions/setup-node@v2
-        with:
-          node-version: 18.x
-      - run: yarn install
-      - run: yarn lint --filter=web
-
-  lint-space:
-    needs: get-changed-files
-    if: needs.get-changed-files.outputs.space_changed == 'true'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Setup Node.js
-        uses: actions/setup-node@v2
-        with:
-          node-version: 18.x
-      - run: yarn install
-      - run: yarn lint --filter=space
-
-  build-web:
-    needs: lint-web
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Setup Node.js
-        uses: actions/setup-node@v2
-        with:
-          node-version: 18.x
-      - run: yarn install
-      - run: yarn build --filter=web
-
-  build-space:
-    needs: lint-space
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Setup Node.js
-        uses: actions/setup-node@v2
-        with:
-          node-version: 18.x
-      - run: yarn install
-      - run: yarn build --filter=space
+      - name: Build Plane's Deploy App
+        if: steps.changed-files.outputs.deploy_any_changed == 'true'
+        run: |
+          yarn 
+          yarn build --filter=space
@@ -1,45 +0,0 @@
-name: Version Change Before Release
-
-on:
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  check-version:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.head_ref }}
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '18'
-
-      - name: Get PR Branch version
-        run: echo "PR_VERSION=$(node -p "require('./package.json').version")" >> $GITHUB_ENV
-
-      - name: Fetch base branch
-        run: git fetch origin master:master
-
-      - name: Get Master Branch version
-        run: |
-          git checkout master
-          echo "MASTER_VERSION=$(node -p "require('./package.json').version")" >> $GITHUB_ENV
-
-      - name: Get master branch version and compare
-        run: |
-          echo "Comparing versions: PR version is $PR_VERSION, Master version is $MASTER_VERSION"
-          if [ "$PR_VERSION" == "$MASTER_VERSION" ]; then
-            echo "Version in PR branch is the same as in master. Failing the CI."
-            exit 1
-          else
-            echo "Version check passed. Versions are different."
-          fi
-        env:
-          PR_VERSION: ${{ env.PR_VERSION }}
-          MASTER_VERSION: ${{ env.MASTER_VERSION }}
@@ -1,13 +1,13 @@
 name: "CodeQL"

 on:
-  workflow_dispatch:
  push:
-    branches: ["preview", "master"]
+    branches: [ 'develop', 'preview', 'master' ]
  pull_request:
-    branches: ["develop", "preview", "master"]
+    # The branches below must be a subset of the branches above
+    branches: [ 'develop', 'preview', 'master' ]
  schedule:
-    - cron: "53 19 * * 5"
+    - cron: '53 19 * * 5'

 jobs:
  analyze:
@@ -21,44 +21,45 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        language: ["python", "javascript"]
+        language: [ 'python', 'javascript' ]
        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
        # Use only 'java' to analyze code written in Java, Kotlin or both
        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support

    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
+    - name: Checkout repository
+      uses: actions/checkout@v3

-      # Initializes the CodeQL tools for scanning.
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
-        with:
-          languages: ${{ matrix.language }}
-          # If you wish to specify custom queries, you can do so here or in a config file.
-          # By default, queries listed here will override any specified in a config file.
-          # Prefix the list here with "+" to use these queries and those in the config file.
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.

-          # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-          # queries: security-extended,security-and-quality
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality

-      # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
-      # If this step fails, then you should remove it and run the build manually (see below)
-      - name: Autobuild
-        uses: github/codeql-action/autobuild@v2

-      # ℹ️ Command-line programs to run using the OS shell.
-      # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+    # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2

-      #   If the Autobuild fails above, remove it and uncomment the following three lines.
-      #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun

-      # - run: |
-      #     echo "Run, Build Application using script"
-      #     ./location_of_script_within_repo/buildscript.sh
+    #   If the Autobuild fails above, remove it and uncomment the following three lines.
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.

-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2
-        with:
-          category: "/language:${{matrix.language}}"
+    # - run: |
+    #     echo "Run, Build Application using script"
+    #     ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+      with:
+        category: "/language:${{matrix.language}}"
@@ -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
@@ -1,199 +0,0 @@
-name: Feature Preview
-
-on:
-  workflow_dispatch:
-    inputs:
-      web-build:
-        required: false
-        description: 'Build Web'
-        type: boolean
-        default: true
-      space-build:
-        required: false
-        description: 'Build Space'
-        type: boolean
-        default: false
-
-env:
-  BUILD_WEB: ${{ github.event.inputs.web-build }}
-  BUILD_SPACE: ${{ github.event.inputs.space-build }}
-
-jobs:
-  setup-feature-build:
-    name: Feature Build Setup
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        run: |
-          echo "BUILD_WEB=$BUILD_WEB" 
-          echo "BUILD_SPACE=$BUILD_SPACE"
-    outputs:
-      web-build: ${{ env.BUILD_WEB}} 
-      space-build: ${{env.BUILD_SPACE}}
-
-  feature-build-web:
-    if: ${{ needs.setup-feature-build.outputs.web-build == 'true' }}
-    needs: setup-feature-build
-    name: Feature Build Web
-    runs-on: ubuntu-latest
-    env:
-      AWS_ACCESS_KEY_ID: ${{ vars.FEATURE_PREVIEW_AWS_ACCESS_KEY_ID }}
-      AWS_SECRET_ACCESS_KEY: ${{ secrets.FEATURE_PREVIEW_AWS_SECRET_ACCESS_KEY }}
-      AWS_BUCKET: ${{ vars.FEATURE_PREVIEW_AWS_BUCKET }}
-      NEXT_PUBLIC_API_BASE_URL: ${{ vars.FEATURE_PREVIEW_NEXT_PUBLIC_API_BASE_URL }}
-    steps:
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '18'
-      - name: Install AWS cli
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y python3-pip
-          pip3 install awscli
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          path: plane
-      - name: Install Dependencies
-        run: |
-          cd $GITHUB_WORKSPACE/plane
-          yarn install
-      - name: Build Web
-        id: build-web
-        run: |
-          cd $GITHUB_WORKSPACE/plane
-          yarn build --filter=web
-          cd $GITHUB_WORKSPACE
-
-          TAR_NAME="web.tar.gz"
-          tar -czf $TAR_NAME ./plane
-
-          FILE_EXPIRY=$(date -u -d "+2 days" +"%Y-%m-%dT%H:%M:%SZ")
-          aws s3 cp $TAR_NAME s3://${{ env.AWS_BUCKET }}/${{github.sha}}/$TAR_NAME --expires $FILE_EXPIRY
-     
-  feature-build-space:
-    if: ${{ needs.setup-feature-build.outputs.space-build == 'true' }}
-    needs: setup-feature-build
-    name: Feature Build Space
-    runs-on: ubuntu-latest
-    env:
-      AWS_ACCESS_KEY_ID: ${{ vars.FEATURE_PREVIEW_AWS_ACCESS_KEY_ID }}
-      AWS_SECRET_ACCESS_KEY: ${{ secrets.FEATURE_PREVIEW_AWS_SECRET_ACCESS_KEY }}
-      AWS_BUCKET: ${{ vars.FEATURE_PREVIEW_AWS_BUCKET }}
-      NEXT_PUBLIC_DEPLOY_WITH_NGINX: 1
-      NEXT_PUBLIC_API_BASE_URL: ${{ vars.FEATURE_PREVIEW_NEXT_PUBLIC_API_BASE_URL }}
-    outputs:
-      do-build: ${{ needs.setup-feature-build.outputs.space-build }}
-      s3-url: ${{ steps.build-space.outputs.S3_PRESIGNED_URL }}
-    steps:
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '18'
-      - name: Install AWS cli
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y python3-pip
-          pip3 install awscli
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          path: plane
-      - name: Install Dependencies
-        run: |
-          cd $GITHUB_WORKSPACE/plane
-          yarn install
-      - name: Build Space
-        id: build-space
-        run: |
-          cd $GITHUB_WORKSPACE/plane
-          yarn build --filter=space
-          cd $GITHUB_WORKSPACE
-
-          TAR_NAME="space.tar.gz"
-          tar -czf $TAR_NAME ./plane
-
-          FILE_EXPIRY=$(date -u -d "+2 days" +"%Y-%m-%dT%H:%M:%SZ")
-          aws s3 cp $TAR_NAME s3://${{ env.AWS_BUCKET }}/${{github.sha}}/$TAR_NAME --expires $FILE_EXPIRY
-
-  feature-deploy:
-    if: ${{ always() && (needs.setup-feature-build.outputs.web-build == 'true' || needs.setup-feature-build.outputs.space-build == 'true') }}
-    needs: [feature-build-web, feature-build-space]
-    name: Feature Deploy
-    runs-on: ubuntu-latest
-    env:
-      AWS_ACCESS_KEY_ID: ${{ vars.FEATURE_PREVIEW_AWS_ACCESS_KEY_ID }}
-      AWS_SECRET_ACCESS_KEY: ${{ secrets.FEATURE_PREVIEW_AWS_SECRET_ACCESS_KEY }}
-      AWS_BUCKET: ${{ vars.FEATURE_PREVIEW_AWS_BUCKET }}
-      KUBE_CONFIG_FILE: ${{ secrets.FEATURE_PREVIEW_KUBE_CONFIG }}
-    steps:
-      - name: Install AWS cli
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y python3-pip
-          pip3 install awscli
-      - name: Tailscale
-        uses: tailscale/github-action@v2
-        with:
-          oauth-client-id: ${{ secrets.TAILSCALE_OAUTH_CLIENT_ID }}
-          oauth-secret: ${{ secrets.TAILSCALE_OAUTH_SECRET }}
-          tags: tag:ci
-      - name: Kubectl Setup
-        run: |
-          curl -LO "https://dl.k8s.io/release/${{ vars.FEATURE_PREVIEW_KUBE_VERSION }}/bin/linux/amd64/kubectl"
-          chmod +x kubectl
-
-          mkdir -p ~/.kube
-          echo "$KUBE_CONFIG_FILE" > ~/.kube/config
-          chmod 600 ~/.kube/config
-      - name: HELM Setup
-        run: |
-          curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
-          chmod 700 get_helm.sh
-          ./get_helm.sh
-      - name: App Deploy
-        run: |
-          WEB_S3_URL=""
-          if [ ${{ env.BUILD_WEB }} == true ]; then
-            WEB_S3_URL=$(aws s3 presign s3://${{ vars.FEATURE_PREVIEW_AWS_BUCKET }}/${{github.sha}}/web.tar.gz --expires-in 3600)
-          fi
-
-          SPACE_S3_URL=""
-          if [ ${{ env.BUILD_SPACE }} == true ]; then
-            SPACE_S3_URL=$(aws s3 presign s3://${{ vars.FEATURE_PREVIEW_AWS_BUCKET }}/${{github.sha}}/space.tar.gz --expires-in 3600)
-          fi
-
-          if [ ${{ env.BUILD_WEB }} == true ] || [ ${{ env.BUILD_SPACE }} == true ]; then
-
-            helm --kube-insecure-skip-tls-verify repo add feature-preview ${{ vars.FEATURE_PREVIEW_HELM_CHART_URL }} 
-
-            APP_NAMESPACE="${{ vars.FEATURE_PREVIEW_NAMESPACE }}"
-            DEPLOY_SCRIPT_URL="${{ vars.FEATURE_PREVIEW_DEPLOY_SCRIPT_URL }}"
-
-            METADATA=$(helm --kube-insecure-skip-tls-verify install feature-preview/${{ vars.FEATURE_PREVIEW_HELM_CHART_NAME }} \
-                --generate-name \
-                --namespace $APP_NAMESPACE \
-                --set ingress.primaryDomain=${{vars.FEATURE_PREVIEW_PRIMARY_DOMAIN || 'feature.plane.tools' }} \
-                --set web.image=${{vars.FEATURE_PREVIEW_DOCKER_BASE}} \
-                --set web.enabled=${{ env.BUILD_WEB || false }} \
-                --set web.artifact_url=$WEB_S3_URL \
-                --set space.image=${{vars.FEATURE_PREVIEW_DOCKER_BASE}} \
-                --set space.enabled=${{ env.BUILD_SPACE || false }} \
-                --set space.artifact_url=$SPACE_S3_URL \
-                --set shared_config.deploy_script_url=$DEPLOY_SCRIPT_URL \
-                --set shared_config.api_base_url=${{vars.FEATURE_PREVIEW_NEXT_PUBLIC_API_BASE_URL}} \
-                --output json \
-                --timeout 1000s)
-
-            APP_NAME=$(echo $METADATA | jq -r '.name')
-
-            INGRESS_HOSTNAME=$(kubectl get ingress -n feature-builds --insecure-skip-tls-verify \
-                -o jsonpath='{.items[?(@.metadata.annotations.meta\.helm\.sh\/release-name=="'$APP_NAME'")]}' | \
-                jq -r '.spec.rules[0].host')
-
-            echo "****************************************"
-            echo "APP NAME ::: $APP_NAME"
-            echo "INGRESS HOSTNAME ::: $INGRESS_HOSTNAME"
-            echo "****************************************"
-          fi
@@ -51,7 +51,6 @@ staticfiles
 mediafiles
 .env
 .DS_Store
-logs/

 node_modules/
 assets/dist/
@@ -50,6 +50,7 @@ chmod +x setup.sh
 docker compose -f docker-compose-local.yml up
 ```

+
 ## Missing a Feature?

 If a feature is missing, you can directly _request_ a new one [here](https://github.com/makeplane/plane/issues/new?assignees=&labels=feature&template=feature_request.yml&title=%F0%9F%9A%80+Feature%3A+). You also can do the same by choosing "🚀 Feature" when raising a [New Issue](https://github.com/makeplane/plane/issues/new/choose) on our GitHub Repository.
@@ -27,7 +27,7 @@ RUN yarn install
 COPY --from=builder /app/out/full/ .
 COPY turbo.json turbo.json
 COPY replace-env-vars.sh /usr/local/bin/
-
+USER root
 RUN chmod +x /usr/local/bin/replace-env-vars.sh

 RUN yarn turbo run build
@@ -89,17 +89,21 @@ RUN chmod -R 777 /code

 WORKDIR /app

+# Don't run production as root
+RUN addgroup --system --gid 1001 plane
+RUN adduser --system --uid 1001 captain
+
 COPY --from=installer /app/apps/app/next.config.js .
 COPY --from=installer /app/apps/app/package.json .
 COPY --from=installer /app/apps/space/next.config.js .
 COPY --from=installer /app/apps/space/package.json .

-COPY --from=installer /app/apps/app/.next/standalone ./
+COPY --from=installer --chown=captain:plane /app/apps/app/.next/standalone ./

-COPY --from=installer /app/apps/app/.next/static ./apps/app/.next/static
+COPY --from=installer --chown=captain:plane /app/apps/app/.next/static ./apps/app/.next/static

-COPY --from=installer /app/apps/space/.next/standalone ./
-COPY --from=installer /app/apps/space/.next ./apps/space/.next
+COPY --from=installer --chown=captain:plane /app/apps/space/.next/standalone ./
+COPY --from=installer --chown=captain:plane /app/apps/space/.next ./apps/space/.next

 ENV NEXT_TELEMETRY_DISABLED 1

@@ -114,6 +118,7 @@ ARG NEXT_PUBLIC_API_BASE_URL=http://localhost:8000
 ENV NEXT_PUBLIC_API_BASE_URL=$NEXT_PUBLIC_API_BASE_URL \
    BUILT_NEXT_PUBLIC_API_BASE_URL=$NEXT_PUBLIC_API_BASE_URL

+USER root
 COPY replace-env-vars.sh /usr/local/bin/
 COPY start.sh /usr/local/bin/
 RUN chmod +x /usr/local/bin/replace-env-vars.sh
@@ -53,6 +53,7 @@ NGINX_PORT=80
 NEXT_PUBLIC_DEPLOY_URL="http://localhost/spaces"
 ```

+
 ## {PROJECT_FOLDER}/apiserver/.env


@@ -7,7 +7,7 @@
 </p>

 <h3 align="center"><b>Plane</b></h3>
-<p align="center"><b>Open-source project management that unlocks customer value.</b></p>
+<p align="center"><b>Flexible, extensible open-source project management</b></p>

 <p align="center">
 <a href="https://discord.com/invite/A92xrEGCge">
@@ -16,13 +16,6 @@
 <img alt="Commit activity per month" src="https://img.shields.io/github/commit-activity/m/makeplane/plane?style=for-the-badge" />
 </p>

-<p align="center">
-    <a href="https://dub.sh/plane-website-readme"><b>Website</b></a> •
-    <a href="https://git.new/releases"><b>Releases</b></a> •
-    <a href="https://dub.sh/planepowershq"><b>Twitter</b></a> •
-    <a href="https://dub.sh/planedocs"><b>Documentation</b></a>
-</p>
-
 <p>
    <a href="https://app.plane.so/#gh-light-mode-only" target="_blank">
      <img
@@ -40,90 +33,56 @@
    </a>
 </p>

-Meet [Plane](https://dub.sh/plane-website-readme). An open-source software development tool to manage issues, sprints, and product roadmaps with peace of mind. 🧘‍♀️
+Meet [Plane](https://plane.so). An open-source software development tool to manage issues, sprints, and product roadmaps with peace of mind 🧘‍♀️.

-> Plane is still in its early days, not everything will be perfect yet, and hiccups may happen. Please let us know of any suggestions, ideas, or bugs that you encounter on our [Discord](https://discord.com/invite/A92xrEGCge) or GitHub issues, and we will use your feedback to improve in our upcoming releases.
+> Plane is still in its early days, not everything will be perfect yet, and hiccups may happen. Please let us know of any suggestions, ideas, or bugs that you encounter on our [Discord](https://discord.com/invite/A92xrEGCge) or GitHub issues, and we will use your feedback to improve on our upcoming releases.

-## ⚡ Installation
+The easiest way to get started with Plane is by creating a [Plane Cloud](https://app.plane.so) account. Plane Cloud offers a hosted solution for Plane. If you prefer to self-host Plane, please refer to our [deployment documentation](https://docs.plane.so/self-hosting/docker-compose).

-The easiest way to get started with Plane is by creating a [Plane Cloud](https://app.plane.so) account where we offer a hosted solution for users.
+## ⚡️ Contributors Quick Start

-If you want more control over your data, prefer to self-host Plane, please refer to our [deployment documentation](https://docs.plane.so/docker-compose).
+### Prerequisite

-| Installation Methods | Documentation Link                                                                                                                                           |
-| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Docker               | [![Docker](https://img.shields.io/badge/docker-%230db7ed.svg?style=for-the-badge&logo=docker&logoColor=white)](https://docs.plane.so/self-hosting/methods/docker-compose)         |
-| Kubernetes           | [![Kubernetes](https://img.shields.io/badge/kubernetes-%23326ce5.svg?style=for-the-badge&logo=kubernetes&logoColor=white)](https://docs.plane.so/kubernetes) |
+Development system must have docker engine installed and running.

-`Instance admin` can configure instance settings using our [God-mode](https://docs.plane.so/instance-admin) feature.
+### Steps

-## 🚀 Features
+Setting up local environment is extremely easy and straight forward. Follow the below step and you will be ready to contribute

- **Issues**: Quickly create issues and add details using a powerful rich text editor that supports file uploads. Add sub-properties and references to problems for better organization and tracking.
+1. Clone the code locally using `git clone https://github.com/makeplane/plane.git`
+1. Switch to the code folder `cd plane`
+1. Create your feature or fix branch you plan to work on using `git checkout -b <feature-branch-name>`
+1. Open terminal and run `./setup.sh`
+1. Open the code on VSCode or similar equivalent IDE
+1. Review the `.env` files available in various folders. Visit [Environment Setup](./ENV_SETUP.md) to know about various environment variables used in system
+1. Run the docker command to initiate various services `docker compose -f docker-compose-local.yml up -d`

- **Cycles**:
-  Keep up your team's momentum with Cycles. Gain insights into your project's progress with burn-down charts and other valuable features.
-
- **Modules**: Break down your large projects into smaller, more manageable modules. Assign modules between teams to track and plan your project's progress easily.
-
- **Views**: Create custom filters to display only the issues that matter to you. Save and share your filters in just a few clicks.
-
- **Pages**: Plane pages, equipped with AI and a rich text editor, let you jot down your thoughts on the fly. Format your text, upload images, hyperlink, or sync your existing ideas into an actionable item or issue.
-
- **Analytics**: Get insights into all your Plane data in real-time. Visualize issue data to spot trends, remove blockers, and progress your work.
-
- **Drive** (_coming soon_): The drive helps you share documents, images, videos, or any other files that make sense to you or your team and align on the problem/solution.
-
-## 🛠️ Quick start for contributors
-
-> Development system must have docker engine installed and running.
-
-Setting up local environment is extremely easy and straight forward. Follow the below step and you will be ready to contribute - 
-
-1. Clone the code locally using:
-   ```
-   git clone https://github.com/makeplane/plane.git
-   ```
-2. Switch to the code folder:
-   ```
-   cd plane
-   ```
-3. Create your feature or fix branch you plan to work on using:
-   ```
-   git checkout -b <feature-branch-name>
-   ```
-4. Open terminal and run:
-   ```
-   ./setup.sh
-   ```
-5. Open the code on VSCode or similar equivalent IDE.
-6. Review the `.env` files available in various folders.
-   Visit [Environment Setup](./ENV_SETUP.md) to know about various environment variables used in system.
-7. Run the docker command to initiate services:
-   ```
-   docker compose -f docker-compose-local.yml up -d
-   ```
-
-You are ready to make changes to the code. Do not forget to refresh the browser (in case it does not auto-reload).
+You are ready to make changes to the code. Do not forget to refresh the browser (in case id does not auto-reload)

 Thats it!

-## ❤️ Community
+## 🍙 Self Hosting

-The Plane community can be found on [GitHub Discussions](https://github.com/orgs/makeplane/discussions), and our [Discord server](https://discord.com/invite/A92xrEGCge). Our [Code of conduct](https://github.com/makeplane/plane/blob/master/CODE_OF_CONDUCT.md) applies to all Plane community chanels.
+For self hosting environment setup, visit the [Self Hosting](https://docs.plane.so/docker-compose) documentation page

-Ask questions, report bugs, join discussions, voice ideas, make feature requests, or share your projects.
+## 🚀 Features

-### Repo Activity
-
-![Plane Repo Activity](https://repobeats.axiom.co/api/embed/2523c6ed2f77c082b7908c33e2ab208981d76c39.svg "Repobeats analytics image")
+- **Issue Planning and Tracking**: Quickly create issues and add details using a powerful rich text editor that supports file uploads. Add sub-properties and references to issues for better organization and tracking.
+- **Issue Attachments**: Collaborate effectively by attaching files to issues, making it easy for your team to find and share important project-related documents.
+- **Layouts**: Customize your project view with your preferred layout - choose from List, Kanban, or Calendar to visualize your project in a way that makes sense to you.
+- **Cycles**: Plan sprints with Cycles to keep your team on track and productive. Gain insights into your project's progress with burn-down charts and other useful features.
+- **Modules**: Break down your large projects into smaller, more manageable modules. Assign modules between teams to easily track and plan your project's progress.
+- **Views**: Create custom filters to display only the issues that matter to you. Save and share your filters in just a few clicks.
+- **Pages**: Plane pages function as an AI-powered notepad, allowing you to easily document issues, cycle plans, and module details, and then synchronize them with your issues.
+- **Command K**: Enjoy a better user experience with the new Command + K menu. Easily manage and navigate through your projects from one convenient location.
+- **GitHub Sync**: Streamline your planning process by syncing your GitHub issues with Plane. Keep all your issues in one place for better tracking and collaboration.

 ## 📸 Screenshots

 <p>
    <a href="https://plane.so" target="_blank">
      <img
-        src="https://ik.imagekit.io/w2okwbtu2/Issues_rNZjrGgFl.png?updatedAt=1709298765880"
+        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_views_dark_mode.webp"
        alt="Plane Views"
        width="100%"
      />
@@ -132,7 +91,8 @@ Ask questions, report bugs, join discussions, voice ideas, make feature requests
 <p>
    <a href="https://plane.so" target="_blank">
      <img
-        src="https://ik.imagekit.io/w2okwbtu2/Cycles_jCDhqmTl9.png?updatedAt=1709298780697"
+        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_issue_detail_dark_mode.webp"
+        alt="Plane Issue Details"
        width="100%"
      />
    </a>
@@ -140,7 +100,7 @@ Ask questions, report bugs, join discussions, voice ideas, make feature requests
  <p>
    <a href="https://plane.so" target="_blank">
      <img
-        src="https://ik.imagekit.io/w2okwbtu2/Modules_PSCVsbSfI.png?updatedAt=1709298796783"
+        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_cycles_modules_dark_mode.webp"
        alt="Plane Cycles and Modules"
        width="100%"
      />
@@ -149,7 +109,7 @@ Ask questions, report bugs, join discussions, voice ideas, make feature requests
  <p>
    <a href="https://plane.so" target="_blank">
      <img
-        src="https://ik.imagekit.io/w2okwbtu2/Views_uxXsRatS4.png?updatedAt=1709298834522"
+        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_analytics_dark_mode.webp"
        alt="Plane Analytics"
        width="100%"
      />
@@ -158,7 +118,7 @@ Ask questions, report bugs, join discussions, voice ideas, make feature requests
   <p>
    <a href="https://plane.so" target="_blank">
      <img
-        src="https://ik.imagekit.io/w2okwbtu2/Analytics_0o22gLRtp.png?updatedAt=1709298834389"
+        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_pages_dark_mode.webp"
        alt="Plane Pages"
        width="100%"
      />
@@ -168,7 +128,7 @@ Ask questions, report bugs, join discussions, voice ideas, make feature requests
   <p>
    <a href="https://plane.so" target="_blank">
      <img
-        src="https://ik.imagekit.io/w2okwbtu2/Drive_LlfeY4xn3.png?updatedAt=1709298837917"
+        src="https://plane-marketing.s3.ap-south-1.amazonaws.com/plane-readme/plane_commad_k_dark_mode.webp"
        alt="Plane Command Menu"
        width="100%"
      />
@@ -176,23 +136,20 @@ Ask questions, report bugs, join discussions, voice ideas, make feature requests
  </p>
 </p>

+## 📚Documentation
+
+For full documentation, visit [docs.plane.so](https://docs.plane.so/)
+
+To see how to Contribute, visit [here](https://github.com/makeplane/plane/blob/master/CONTRIBUTING.md).
+
+## ❤️ Community
+
+The Plane community can be found on GitHub Discussions, where you can ask questions, voice ideas, and share your projects.
+
+To chat with other community members you can join the [Plane Discord](https://discord.com/invite/A92xrEGCge).
+
+Our [Code of Conduct](https://github.com/makeplane/plane/blob/master/CODE_OF_CONDUCT.md) applies to all Plane community channels.
+
 ## ⛓️ Security

-If you believe you have found a security vulnerability in Plane, we encourage you to responsibly disclose this and not open a public issue. We will investigate all legitimate reports.
-
-Email squawk@plane.so to disclose any security vulnerabilities.
-
-## ❤️ Contribute
-
-There are many ways to contribute to Plane, including:
-
- Submitting [bugs](https://github.com/makeplane/plane/issues/new?assignees=srinivaspendem%2Cpushya22&labels=%F0%9F%90%9Bbug&projects=&template=--bug-report.yaml&title=%5Bbug%5D%3A+) and [feature requests](https://github.com/makeplane/plane/issues/new?assignees=srinivaspendem%2Cpushya22&labels=%E2%9C%A8feature&projects=&template=--feature-request.yaml&title=%5Bfeature%5D%3A+) for various components.
- Reviewing [the documentation](https://docs.plane.so/) and submitting [pull requests](https://github.com/makeplane/plane), from fixing typos to adding new features.
- Speaking or writing about Plane or any other ecosystem integration and [letting us know](https://discord.com/invite/A92xrEGCge)!
- Upvoting [popular feature requests](https://github.com/makeplane/plane/issues) to show your support.
-
-### We couldn't have done this without you.
-
-<a href="https://github.com/makeplane/plane/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=makeplane/plane" />
-</a>
+If you believe you have found a security vulnerability in Plane, we encourage you to responsibly disclose this and not open a public issue. We will investigate all legitimate reports. Email engineering@plane.so to disclose any security vulnerabilities.
@@ -1,44 +0,0 @@
-# Security Policy
-
-This document outlines security procedures and vulnerabilities reporting for the Plane project.
-
-At Plane, we safeguarding the security of our systems with top priority. Despite our efforts, vulnerabilities may still exist. We greatly appreciate your assistance in identifying and reporting any such vulnerabilities to help us maintain the integrity of our systems and protect our clients.
-
-To report a security vulnerability, please email us directly at security@plane.so with a detailed description of the vulnerability and steps to reproduce it. Please refrain from disclosing the vulnerability publicly until we have had an opportunity to review and address it.
-
-## Out of Scope Vulnerabilities
-
-We appreciate your help in identifying vulnerabilities. However, please note that the following types of vulnerabilities are considered out of scope:
-
- Attacks requiring MITM or physical access to a user's device.
- Content spoofing and text injection issues without demonstrating an attack vector or ability to modify HTML/CSS.
- Email spoofing.
- Missing DNSSEC, CAA, CSP headers.
- Lack of Secure or HTTP only flag on non-sensitive cookies.
-
-## Reporting Process
-
-If you discover a vulnerability, please adhere to the following reporting process:
-
-1. Email your findings to security@plane.so.
-2. Refrain from running automated scanners on our infrastructure or dashboard without prior consent. Contact us to set up a sandbox environment if necessary.
-3. Do not exploit the vulnerability for malicious purposes, such as downloading excessive data or altering user data.
-4. Maintain confidentiality and refrain from disclosing the vulnerability until it has been resolved.
-5. Avoid using physical security attacks, social engineering, distributed denial of service, spam, or third-party applications.
-
-When reporting a vulnerability, please provide sufficient information to allow us to reproduce and address the issue promptly. Include the IP address or URL of the affected system, along with a detailed description of the vulnerability.
-
-## Our Commitment
-
-We are committed to promptly addressing reported vulnerabilities and maintaining open communication throughout the resolution process. Here's what you can expect from us:
-
- **Response Time:** We will acknowledge receipt of your report within three business days and provide an expected resolution date.
- **Legal Protection:** We will not pursue legal action against you for reporting vulnerabilities, provided you adhere to the reporting guidelines.
- **Confidentiality:** Your report will be treated with strict confidentiality. We will not disclose your personal information to third parties without your consent.
- **Progress Updates:** We will keep you informed of our progress in resolving the reported vulnerability.
- **Recognition:** With your permission, we will publicly acknowledge you as the discoverer of the vulnerability.
- **Timely Resolution:** We strive to resolve all reported vulnerabilities promptly and will actively participate in the publication process once the issue is resolved.
-
-We appreciate your cooperation in helping us maintain the security of our systems and protecting our clients. Thank you for your contributions to our security efforts.
-
-reference: https://supabase.com/.well-known/security.txt
@@ -14,6 +14,10 @@ POSTGRES_HOST="plane-db"
 POSTGRES_DB="plane"
 DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}/${POSTGRES_DB}

+# Oauth variables
+GOOGLE_CLIENT_ID=""
+GITHUB_CLIENT_ID=""
+GITHUB_CLIENT_SECRET=""

 # Redis Settings
 REDIS_HOST="plane-redis"
@@ -30,6 +34,11 @@ AWS_S3_BUCKET_NAME="uploads"
 # Maximum file upload limit
 FILE_SIZE_LIMIT=5242880

+# GPT settings
+OPENAI_API_BASE="https://api.openai.com/v1" # deprecated
+OPENAI_API_KEY="sk-" # deprecated
+GPT_ENGINE="gpt-3.5-turbo" # deprecated
+
 # Settings related to Docker
 DOCKERIZED=1 # deprecated

@@ -39,8 +48,19 @@ USE_MINIO=1
 # Nginx Configuration
 NGINX_PORT=80

+
+# SignUps
+ENABLE_SIGNUP="1"
+
+# Enable Email/Password Signup
+ENABLE_EMAIL_PASSWORD="1"
+
+# Enable Magic link Login
+ENABLE_MAGIC_LINK_LOGIN="0"
+
 # Email redirections and minio domain settings
 WEB_URL="http://localhost"

 # Gunicorn Workers
 GUNICORN_WORKERS=2
+
@@ -32,19 +32,27 @@ RUN apk add --no-cache --virtual .build-deps \
    apk del .build-deps


+RUN addgroup -S plane && \
+    adduser -S captain -G plane
+
+RUN chown captain.plane /code
+
+USER captain
+
 # Add in Django deps and generate Django's static files
 COPY manage.py manage.py
 COPY plane plane/
 COPY templates templates/
 COPY package.json package.json
-
+USER root
 RUN apk --no-cache add "bash~=5.2"
 COPY ./bin ./bin/

-RUN mkdir -p /code/plane/logs
 RUN chmod +x ./bin/takeoff ./bin/worker ./bin/beat
 RUN chmod -R 777 /code

+USER captain
+
 # Expose container port and run entry point script
 EXPOSE 8000

@@ -30,13 +30,21 @@ ADD requirements ./requirements
 # Install the local development settings
 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 mkdir -p /code/plane/logs
-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

 # Expose container port and run entry point script
 EXPOSE 8000
@@ -182,7 +182,7 @@ def update_label_color():
        labels = Label.objects.filter(color="")
        updated_labels = []
        for label in labels:
-            label.color = f"#{random.randint(0, 0xFFFFFF+1):06X}"
+            label.color = "#" + "%06x" % random.randint(0, 0xFFFFFF)
            updated_labels.append(label)

        Label.objects.bulk_update(updated_labels, ["color"], batch_size=100)
@@ -2,7 +2,5 @@
 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
@@ -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 safe_migrate

 # Create the default bucket
 #!/bin/bash
@@ -21,15 +20,11 @@ SIGNATURE=$(echo "$HOSTNAME$MAC_ADDRESS$CPU_INFO$MEMORY_INFO$DISK_INFO" | sha256
 export MACHINE_SIGNATURE=$SIGNATURE

 # Register instance
-python manage.py register_instance "$MACHINE_SIGNATURE"
-
+python manage.py register_instance $MACHINE_SIGNATURE
 # Load the configuration variable
 python manage.py configure_instance

 # Create the default bucket
 python manage.py create_bucket

-# Clear Cache before starting to remove stale values
-python manage.py clear_cache
-
-exec gunicorn -w "$GUNICORN_WORKERS" -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:"${PORT:-8000}" --max-requests 1200 --max-requests-jitter 1000 --access-logfile -
+exec gunicorn -w $GUNICORN_WORKERS -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:${PORT:-8000} --max-requests 1200 --max-requests-jitter 1000 --access-logfile -
@@ -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 safe_migrate

 # Create the default bucket
 #!/bin/bash
@@ -21,15 +20,12 @@ SIGNATURE=$(echo "$HOSTNAME$MAC_ADDRESS$CPU_INFO$MEMORY_INFO$DISK_INFO" | sha256
 export MACHINE_SIGNATURE=$SIGNATURE

 # Register instance
-python manage.py register_instance "$MACHINE_SIGNATURE"
+python manage.py register_instance $MACHINE_SIGNATURE
 # Load the configuration variable
 python manage.py configure_instance

 # Create the default bucket
 python manage.py create_bucket

-# Clear Cache before starting to remove stale values
-python manage.py clear_cache
-
 python manage.py runserver 0.0.0.0:8000 --settings=plane.settings.local

@@ -2,7 +2,5 @@
 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
@@ -1,4 +1,4 @@
 {
  "name": "plane-api",
-  "version": "0.18.0"
+  "version": "0.14.0"
 }
@@ -66,11 +66,11 @@ class BaseSerializer(serializers.ModelSerializer):
                if expand in self.fields:
                    # Import all the expandable serializers
                    from . import (
-                        IssueSerializer,
-                        ProjectLiteSerializer,
-                        StateLiteSerializer,
-                        UserLiteSerializer,
                        WorkspaceLiteSerializer,
+                        ProjectLiteSerializer,
+                        UserLiteSerializer,
+                        StateLiteSerializer,
+                        IssueSerializer,
                    )

                    # Expansion mapper
@@ -1,33 +1,31 @@
-from django.core.exceptions import ValidationError
-from django.core.validators import URLValidator
+from lxml import html
+

 # Django imports
 from django.utils import timezone
-from lxml import html

 #  Third party imports
 from rest_framework import serializers

 # Module imports
 from plane.db.models import (
+    User,
    Issue,
-    IssueActivity,
+    State,
    IssueAssignee,
-    IssueAttachment,
-    IssueComment,
+    Label,
    IssueLabel,
    IssueLink,
-    Label,
+    IssueComment,
+    IssueAttachment,
+    IssueActivity,
    ProjectMember,
-    State,
-    User,
 )
-
 from .base import BaseSerializer
-from .cycle import CycleLiteSerializer, CycleSerializer
-from .module import ModuleLiteSerializer, ModuleSerializer
-from .state import StateLiteSerializer
+from .cycle import CycleSerializer, CycleLiteSerializer
+from .module import ModuleSerializer, ModuleLiteSerializer
 from .user import UserLiteSerializer
+from .state import StateLiteSerializer


 class IssueSerializer(BaseSerializer):
@@ -79,8 +77,8 @@ class IssueSerializer(BaseSerializer):
                parsed_str = html.tostring(parsed, encoding="unicode")
                data["description_html"] = parsed_str

-        except Exception:
-            raise serializers.ValidationError("Invalid HTML passed")
+        except Exception as e:
+            raise serializers.ValidationError(f"Invalid HTML: {str(e)}")

        # Validate assignees are from project
        if data.get("assignees", []):
@@ -286,20 +284,6 @@ class IssueLinkSerializer(BaseSerializer):
            "updated_at",
        ]

-    def validate_url(self, value):
-        # Check URL format
-        validate_url = URLValidator()
-        try:
-            validate_url(value)
-        except ValidationError:
-            raise serializers.ValidationError("Invalid URL format.")
-
-        # Check URL scheme
-        if not value.startswith(("http://", "https://")):
-            raise serializers.ValidationError("Invalid URL scheme.")
-
-        return value
-
    # Validation if url already exists
    def create(self, validated_data):
        if IssueLink.objects.filter(
@@ -311,17 +295,6 @@ class IssueLinkSerializer(BaseSerializer):
            )
        return IssueLink.objects.create(**validated_data)

-    def update(self, instance, validated_data):
-        if IssueLink.objects.filter(
-            url=validated_data.get("url"),
-            issue_id=instance.issue_id,
-        ).exists():
-            raise serializers.ValidationError(
-                {"error": "URL already exists for this Issue"}
-            )
-
-        return super().update(instance, validated_data)
-

 class IssueAttachmentSerializer(BaseSerializer):
    class Meta:
@@ -366,8 +339,8 @@ class IssueCommentSerializer(BaseSerializer):
                parsed_str = html.tostring(parsed, encoding="unicode")
                data["comment_html"] = parsed_str

-        except Exception:
-            raise serializers.ValidationError("Invalid HTML passed")
+        except Exception as e:
+            raise serializers.ValidationError(f"Invalid HTML: {str(e)}")
        return data


@@ -6,8 +6,9 @@ from plane.db.models import (
    Project,
    ProjectIdentifier,
    WorkspaceMember,
+    State,
+    Estimate,
 )
-
 from .base import BaseSerializer


@@ -1,6 +1,5 @@
 # Module imports
 from plane.db.models import User
-
 from .base import BaseSerializer


@@ -11,9 +10,7 @@ class UserLiteSerializer(BaseSerializer):
            "id",
            "first_name",
            "last_name",
-            "email",
            "avatar",
            "display_name",
-            "email",
        ]
        read_only_fields = fields
@@ -4,7 +4,6 @@ from plane.api.views.cycle import (
    CycleAPIEndpoint,
    CycleIssueAPIEndpoint,
    TransferCycleIssueAPIEndpoint,
-    CycleArchiveUnarchiveAPIEndpoint,
 )

 urlpatterns = [
@@ -33,14 +32,4 @@ urlpatterns = [
        TransferCycleIssueAPIEndpoint.as_view(),
        name="transfer-issues",
    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/archive/",
-        CycleArchiveUnarchiveAPIEndpoint.as_view(),
-        name="cycle-archive-unarchive",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-cycles/",
-        CycleArchiveUnarchiveAPIEndpoint.as_view(),
-        name="cycle-archive-unarchive",
-    ),
 ]
@@ -1,10 +1,6 @@
 from django.urls import path

-from plane.api.views import (
-    ModuleAPIEndpoint,
-    ModuleIssueAPIEndpoint,
-    ModuleArchiveUnarchiveAPIEndpoint,
-)
+from plane.api.views import ModuleAPIEndpoint, ModuleIssueAPIEndpoint

 urlpatterns = [
    path(
@@ -27,14 +23,4 @@ urlpatterns = [
        ModuleIssueAPIEndpoint.as_view(),
        name="module-issues",
    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:pk>/archive/",
-        ModuleArchiveUnarchiveAPIEndpoint.as_view(),
-        name="module-archive-unarchive",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-modules/",
-        ModuleArchiveUnarchiveAPIEndpoint.as_view(),
-        name="module-archive-unarchive",
-    ),
 ]
@@ -1,9 +1,6 @@
 from django.urls import path

-from plane.api.views import (
-    ProjectAPIEndpoint,
-    ProjectArchiveUnarchiveAPIEndpoint,
-)
+from plane.api.views import ProjectAPIEndpoint

 urlpatterns = [
    path(
@@ -12,13 +9,8 @@ urlpatterns = [
        name="project",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/",
        ProjectAPIEndpoint.as_view(),
        name="project",
    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/archive/",
-        ProjectArchiveUnarchiveAPIEndpoint.as_view(),
-        name="project-archive-unarchive",
-    ),
 ]
@@ -1,4 +1,4 @@
-from .project import ProjectAPIEndpoint, ProjectArchiveUnarchiveAPIEndpoint
+from .project import ProjectAPIEndpoint

 from .state import StateAPIEndpoint

@@ -14,13 +14,8 @@ from .cycle import (
    CycleAPIEndpoint,
    CycleIssueAPIEndpoint,
    TransferCycleIssueAPIEndpoint,
-    CycleArchiveUnarchiveAPIEndpoint,
 )

-from .module import (
-    ModuleAPIEndpoint,
-    ModuleIssueAPIEndpoint,
-    ModuleArchiveUnarchiveAPIEndpoint,
-)
+from .module import ModuleAPIEndpoint, ModuleIssueAPIEndpoint

 from .inbox import InboxIssueAPIEndpoint
@@ -1,27 +1,25 @@
 # Python imports
-from urllib.parse import urlparse
-
 import zoneinfo
+import json

 # Django imports
 from django.conf import settings
-from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.db import IntegrityError
-from django.urls import resolve
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.utils import timezone
-from rest_framework import status
-from rest_framework.permissions import IsAuthenticated
-from rest_framework.response import Response

 # Third party imports
 from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+from rest_framework import status
+from sentry_sdk import capture_exception

 # Module imports
 from plane.api.middleware.api_authentication import APIKeyAuthentication
 from plane.api.rate_limit import ApiKeyRateThrottle
-from plane.bgtasks.webhook_task import send_webhook
-from plane.utils.exception_logger import log_exception
 from plane.utils.paginator import BasePaginator
+from plane.bgtasks.webhook_task import send_webhook


 class TimezoneMixin:
@@ -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
@@ -107,23 +99,27 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):

            if isinstance(e, ValidationError):
                return Response(
-                    {"error": "Please provide valid detail"},
+                    {
+                        "error": "The provided payload is not valid please try with a valid payload"
+                    },
                    status=status.HTTP_400_BAD_REQUEST,
                )

            if isinstance(e, ObjectDoesNotExist):
                return Response(
-                    {"error": "The requested resource does not exist."},
+                    {"error": f"The required object does not exist."},
                    status=status.HTTP_404_NOT_FOUND,
                )

            if isinstance(e, KeyError):
                return Response(
-                    {"error": "The required key does not exist."},
+                    {"error": f" The required key does not exist."},
                    status=status.HTTP_400_BAD_REQUEST,
                )

-            log_exception(e)
+            if settings.DEBUG:
+                print(e)
+            capture_exception(e)
            return Response(
                {"error": "Something went wrong please try again later"},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -166,12 +162,7 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):

    @property
    def project_id(self):
-        project_id = self.kwargs.get("project_id", None)
-        if project_id:
-            return project_id
-
-        if resolve(self.request.path_info).url_name == "project":
-            return self.kwargs.get("pk", None)
+        return self.kwargs.get("project_id", None)

    @property
    def fields(self):
@@ -2,31 +2,29 @@
 import json

 # Django imports
-from django.core import serializers
-from django.db.models import Count, F, Func, OuterRef, Q, Sum
+from django.db.models import Q, Count, Sum, Prefetch, F, OuterRef, Func
 from django.utils import timezone
+from django.core import serializers

 # Third party imports
-from rest_framework import status
 from rest_framework.response import Response
+from rest_framework import status

 # Module imports
-from plane.api.serializers import (
-    CycleIssueSerializer,
-    CycleSerializer,
-)
-from plane.app.permissions import ProjectEntityPermission
-from plane.bgtasks.issue_activites_task import issue_activity
+from .base import BaseAPIView, WebhookMixin
 from plane.db.models import (
    Cycle,
-    CycleIssue,
    Issue,
-    IssueAttachment,
+    CycleIssue,
    IssueLink,
+    IssueAttachment,
 )
-from plane.utils.analytics_plot import burndown_plot
-
-from .base import BaseAPIView, WebhookMixin
+from plane.app.permissions import ProjectEntityPermission
+from plane.api.serializers import (
+    CycleSerializer,
+    CycleIssueSerializer,
+)
+from plane.bgtasks.issue_activites_task import issue_activity


 class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
@@ -47,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")
@@ -142,9 +137,7 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):

    def get(self, request, slug, project_id, pk=None):
        if pk:
-            queryset = (
-                self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
-            )
+            queryset = self.get_queryset().get(pk=pk)
            data = CycleSerializer(
                queryset,
                fields=self.fields,
@@ -154,7 +147,7 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
                data,
                status=status.HTTP_200_OK,
            )
-        queryset = self.get_queryset().filter(archived_at__isnull=True)
+        queryset = self.get_queryset()
        cycle_view = request.GET.get("cycle_view", "all")

        # Current Cycle
@@ -250,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,
@@ -295,11 +265,6 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
        cycle = Cycle.objects.get(
            workspace__slug=slug, project_id=project_id, pk=pk
        )
-        if cycle.archived_at:
-            return Response(
-                {"error": "Archived cycle cannot be edited"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

        request_data = request.data

@@ -324,25 +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)
@@ -377,144 +323,6 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
        return Response(status=status.HTTP_204_NO_CONTENT)


-class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        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(archived_at__isnull=False)
-            .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()
-        )
-
-    def get(self, request, slug, project_id):
-        return self.paginate(
-            request=request,
-            queryset=(self.get_queryset()),
-            on_results=lambda cycles: CycleSerializer(
-                cycles,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id, cycle_id):
-        cycle = Cycle.objects.get(
-            pk=cycle_id, project_id=project_id, workspace__slug=slug
-        )
-        if cycle.end_date >= timezone.now().date():
-            return Response(
-                {"error": "Only completed cycles can be archived"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        cycle.archived_at = timezone.now()
-        cycle.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    def delete(self, request, slug, project_id, cycle_id):
-        cycle = Cycle.objects.get(
-            pk=cycle_id, project_id=project_id, workspace__slug=slug
-        )
-        cycle.archived_at = None
-        cycle.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
 class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
    """
    This viewset automatically provides `list`, `create`,
@@ -542,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")
@@ -556,21 +361,7 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
            .distinct()
        )

-    def get(self, request, slug, project_id, cycle_id, issue_id=None):
-        # Get
-        if issue_id:
-            cycle_issue = CycleIssue.objects.get(
-                workspace__slug=slug,
-                project_id=project_id,
-                cycle_id=cycle_id,
-                issue_id=issue_id,
-            )
-            serializer = CycleIssueSerializer(
-                cycle_issue, fields=self.fields, expand=self.expand
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-
-        # List
+    def get(self, request, slug, project_id, cycle_id):
        order_by = request.GET.get("order_by", "created_at")
        issues = (
            Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
@@ -746,7 +537,7 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):

 class TransferCycleIssueAPIEndpoint(BaseAPIView):
    """
-    This viewset provides `create` actions for transferring the issues into a particular cycle.
+    This viewset provides `create` actions for transfering the issues into a particular cycle.

    """

@@ -767,209 +558,6 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
            workspace__slug=slug, project_id=project_id, pk=new_cycle_id
        )

-        old_cycle = (
-            Cycle.objects.filter(
-                workspace__slug=slug, project_id=project_id, pk=cycle_id
-            )
-            .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,
-                    ),
-                )
-            )
-        )
-
-        # Pass the new_cycle queryset to burndown_plot
-        completion_chart = burndown_plot(
-            queryset=old_cycle.first(),
-            slug=slug,
-            project_id=project_id,
-            cycle_id=cycle_id,
-        )
-
-        # Get the assignee distribution
-        assignee_distribution = (
-            Issue.objects.filter(
-                issue_cycle__cycle_id=cycle_id,
-                workspace__slug=slug,
-                project_id=project_id,
-            )
-            .annotate(display_name=F("assignees__display_name"))
-            .annotate(assignee_id=F("assignees__id"))
-            .annotate(avatar=F("assignees__avatar"))
-            .values("display_name", "assignee_id", "avatar")
-            .annotate(
-                total_issues=Count(
-                    "id",
-                    filter=Q(archived_at__isnull=True, is_draft=False),
-                ),
-            )
-            .annotate(
-                completed_issues=Count(
-                    "id",
-                    filter=Q(
-                        completed_at__isnull=False,
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                pending_issues=Count(
-                    "id",
-                    filter=Q(
-                        completed_at__isnull=True,
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                )
-            )
-            .order_by("display_name")
-        )
-        # assignee distribution serialized
-        assignee_distribution_data = [
-            {
-                "display_name": item["display_name"],
-                "assignee_id": (
-                    str(item["assignee_id"]) if item["assignee_id"] else None
-                ),
-                "avatar": item["avatar"],
-                "total_issues": item["total_issues"],
-                "completed_issues": item["completed_issues"],
-                "pending_issues": item["pending_issues"],
-            }
-            for item in assignee_distribution
-        ]
-
-        # Get the label distribution
-        label_distribution = (
-            Issue.objects.filter(
-                issue_cycle__cycle_id=cycle_id,
-                workspace__slug=slug,
-                project_id=project_id,
-            )
-            .annotate(label_name=F("labels__name"))
-            .annotate(color=F("labels__color"))
-            .annotate(label_id=F("labels__id"))
-            .values("label_name", "color", "label_id")
-            .annotate(
-                total_issues=Count(
-                    "id",
-                    filter=Q(archived_at__isnull=True, is_draft=False),
-                )
-            )
-            .annotate(
-                completed_issues=Count(
-                    "id",
-                    filter=Q(
-                        completed_at__isnull=False,
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                pending_issues=Count(
-                    "id",
-                    filter=Q(
-                        completed_at__isnull=True,
-                        archived_at__isnull=True,
-                        is_draft=False,
-                    ),
-                )
-            )
-            .order_by("label_name")
-        )
-
-        # Label distribution serilization
-        label_distribution_data = [
-            {
-                "label_name": item["label_name"],
-                "color": item["color"],
-                "label_id": (
-                    str(item["label_id"]) if item["label_id"] else None
-                ),
-                "total_issues": item["total_issues"],
-                "completed_issues": item["completed_issues"],
-                "pending_issues": item["pending_issues"],
-            }
-            for item in label_distribution
-        ]
-
-        current_cycle = Cycle.objects.filter(
-            workspace__slug=slug, project_id=project_id, pk=cycle_id
-        ).first()
-
-        if current_cycle:
-            current_cycle.progress_snapshot = {
-                "total_issues": old_cycle.first().total_issues,
-                "completed_issues": old_cycle.first().completed_issues,
-                "cancelled_issues": old_cycle.first().cancelled_issues,
-                "started_issues": old_cycle.first().started_issues,
-                "unstarted_issues": old_cycle.first().unstarted_issues,
-                "backlog_issues": old_cycle.first().backlog_issues,
-                "distribution": {
-                    "labels": label_distribution_data,
-                    "assignees": assignee_distribution_data,
-                    "completion_chart": completion_chart,
-                },
-            }
-            # Save the snapshot of the current cycle
-            current_cycle.save(update_fields=["progress_snapshot"])
-
        if (
            new_cycle.end_date is not None
            and new_cycle.end_date < timezone.now().date()
@@ -2,28 +2,27 @@
 import json

 # Django improts
-from django.core.serializers.json import DjangoJSONEncoder
-from django.db.models import Q
 from django.utils import timezone
+from django.db.models import Q
+from django.core.serializers.json import DjangoJSONEncoder

 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response

 # Module imports
-from plane.api.serializers import InboxIssueSerializer, IssueSerializer
+from .base import BaseAPIView
 from plane.app.permissions import ProjectLitePermission
-from plane.bgtasks.issue_activites_task import issue_activity
+from plane.api.serializers import InboxIssueSerializer, IssueSerializer
 from plane.db.models import (
-    Inbox,
    InboxIssue,
    Issue,
-    Project,
-    ProjectMember,
    State,
+    ProjectMember,
+    Project,
+    Inbox,
 )
-
-from .base import BaseAPIView
+from plane.bgtasks.issue_activites_task import issue_activity


 class InboxIssueAPIEndpoint(BaseAPIView):
@@ -120,7 +119,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
            )

        # Check for valid priority
-        if request.data.get("issue", {}).get("priority", "none") not in [
+        if not request.data.get("issue", {}).get("priority", "none") in [
            "low",
            "medium",
            "high",
@@ -135,11 +134,10 @@ class InboxIssueAPIEndpoint(BaseAPIView):
        # Create or get state
        state, _ = State.objects.get_or_create(
            name="Triage",
-            group="triage",
+            group="backlog",
            description="Default state for managing all Inbox Issues",
            project_id=project_id,
            color="#ff7700",
-            is_triage=True,
        )

        # create an issue
@@ -272,9 +270,6 @@ class InboxIssueAPIEndpoint(BaseAPIView):
            serializer = InboxIssueSerializer(
                inbox_issue, data=request.data, partial=True
            )
-            current_instance = json.dumps(
-                InboxIssueSerializer(inbox_issue).data, cls=DjangoJSONEncoder
-            )

            if serializer.is_valid():
                serializer.save()
@@ -303,7 +298,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                    )

                    # Update the issue state only if it is in triage state
-                    if issue.state.is_triage:
+                    if issue.state.name == "Triage":
                        # Move to default state
                        state = State.objects.filter(
                            workspace__slug=slug,
@@ -314,21 +309,6 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                            issue.state = state
                            issue.save()

-                # create a activity for status change
-                issue_activity.delay(
-                    type="inbox.activity.created",
-                    requested_data=json.dumps(
-                        request.data, cls=DjangoJSONEncoder
-                    ),
-                    actor_id=str(request.user.id),
-                    issue_id=str(issue_id),
-                    project_id=str(project_id),
-                    current_instance=current_instance,
-                    epoch=int(timezone.now().timestamp()),
-                    notification=False,
-                    origin=request.META.get("HTTP_ORIGIN"),
-                )
-
                return Response(serializer.data, status=status.HTTP_200_OK)
            return Response(
                serializer.errors, status=status.HTTP_400_BAD_REQUEST
@@ -1,22 +1,22 @@
 # Python imports
 import json
-
-from django.core.serializers.json import DjangoJSONEncoder
+from itertools import chain

 # Django imports
 from django.db import IntegrityError
 from django.db.models import (
-    Case,
-    CharField,
-    Exists,
-    F,
-    Func,
-    Max,
    OuterRef,
+    Func,
    Q,
-    Value,
+    F,
+    Case,
    When,
+    Value,
+    CharField,
+    Max,
+    Exists,
 )
+from django.core.serializers.json import DjangoJSONEncoder
 from django.utils import timezone

 # Third party imports
@@ -24,31 +24,30 @@ from rest_framework import status
 from rest_framework.response import Response

 # Module imports
-from plane.api.serializers import (
-    IssueActivitySerializer,
-    IssueCommentSerializer,
-    IssueLinkSerializer,
-    IssueSerializer,
-    LabelSerializer,
-)
+from .base import BaseAPIView, WebhookMixin
 from plane.app.permissions import (
    ProjectEntityPermission,
-    ProjectLitePermission,
    ProjectMemberPermission,
+    ProjectLitePermission,
 )
-from plane.bgtasks.issue_activites_task import issue_activity
 from plane.db.models import (
    Issue,
-    IssueActivity,
    IssueAttachment,
-    IssueComment,
    IssueLink,
-    Label,
    Project,
+    Label,
    ProjectMember,
+    IssueComment,
+    IssueActivity,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from plane.api.serializers import (
+    IssueSerializer,
+    LabelSerializer,
+    IssueLinkSerializer,
+    IssueCommentSerializer,
+    IssueActivitySerializer,
 )
-
-from .base import BaseAPIView, WebhookMixin


 class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
@@ -221,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
@@ -281,26 +256,6 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
            partial=True,
        )
        if serializer.is_valid():
-            if (
-                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",
@@ -351,11 +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__archived_at__isnull=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 (
-                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,11 +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__archived_at__isnull=True)
+            .filter(project__project_projectmember__member=self.request.user)
            .order_by(self.kwargs.get("order_by", "-created_at"))
            .distinct()
        )
@@ -614,12 +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,
-            )
-            .filter(project__archived_at__isnull=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(
@@ -655,31 +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,31 +585,6 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
            IssueCommentSerializer(issue_comment).data,
            cls=DjangoJSONEncoder,
        )
-
-        # Validation check if the issue already exists
-        if (
-            request.data.get("external_id")
-            and (
-                issue_comment.external_id
-                != str(request.data.get("external_id"))
-            )
-            and IssueComment.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
        )
@@ -792,9 +639,7 @@ class IssueActivityAPIEndpoint(BaseAPIView):
            .filter(
                ~Q(field__in=["comment", "vote", "reaction", "draft"]),
                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
            )
-            .filter(project__archived_at__isnull=True)
            .select_related("actor", "workspace", "issue", "project")
        ).order_by(request.GET.get("order_by", "created_at"))

@@ -2,33 +2,32 @@
 import json

 # Django imports
-from django.core import serializers
-from django.db.models import Count, F, Func, OuterRef, Prefetch, Q
+from django.db.models import Count, Prefetch, Q, F, Func, OuterRef
 from django.utils import timezone
+from django.core import serializers

 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response

 # Module imports
-from plane.api.serializers import (
-    IssueSerializer,
-    ModuleIssueSerializer,
-    ModuleSerializer,
-)
+from .base import BaseAPIView, WebhookMixin
 from plane.app.permissions import ProjectEntityPermission
-from plane.bgtasks.issue_activites_task import issue_activity
 from plane.db.models import (
+    Project,
+    Module,
+    ModuleLink,
    Issue,
+    ModuleIssue,
    IssueAttachment,
    IssueLink,
-    Module,
-    ModuleIssue,
-    ModuleLink,
-    Project,
 )
-
-from .base import BaseAPIView, WebhookMixin
+from plane.api.serializers import (
+    ModuleSerializer,
+    ModuleIssueSerializer,
+    IssueSerializer,
+)
+from plane.bgtasks.issue_activites_task import issue_activity


 class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
@@ -68,7 +67,6 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
                    ),
-                    distinct=True,
                ),
            )
            .annotate(
@@ -79,7 +77,6 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
                    ),
-                    distinct=True,
                )
            )
            .annotate(
@@ -90,7 +87,6 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
                    ),
-                    distinct=True,
                )
            )
            .annotate(
@@ -101,7 +97,6 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
                    ),
-                    distinct=True,
                )
            )
            .annotate(
@@ -112,7 +107,6 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
                    ),
-                    distinct=True,
                )
            )
            .annotate(
@@ -123,7 +117,6 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                        issue_module__issue__archived_at__isnull=True,
                        issue_module__issue__is_draft=False,
                    ),
-                    distinct=True,
                )
            )
            .order_by(self.kwargs.get("order_by", "-created_at"))
@@ -139,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,11 +142,6 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
        module = Module.objects.get(
            pk=pk, project_id=project_id, workspace__slug=slug
        )
-        if module.archived_at:
-            return Response(
-                {"error": "Archived module cannot be edited"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
        serializer = ModuleSerializer(
            module,
            data=request.data,
@@ -184,34 +149,13 @@ 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):
        if pk:
-            queryset = (
-                self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
-            )
+            queryset = self.get_queryset().get(pk=pk)
            data = ModuleSerializer(
                queryset,
                fields=self.fields,
@@ -223,7 +167,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
            )
        return self.paginate(
            request=request,
-            queryset=(self.get_queryset().filter(archived_at__isnull=True)),
+            queryset=(self.get_queryset()),
            on_results=lambda modules: ModuleSerializer(
                modules,
                many=True,
@@ -289,11 +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__archived_at__isnull=True)
+            .filter(project__project_projectmember__member=self.request.user)
            .select_related("project")
            .select_related("workspace")
            .select_related("module")
@@ -461,130 +401,3 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
            epoch=int(timezone.now().timestamp()),
        )
        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            Module.objects.filter(project_id=self.kwargs.get("project_id"))
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(archived_at__isnull=False)
-            .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,
-                    ),
-                    distinct=True,
-                ),
-            )
-            .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,
-                    ),
-                    distinct=True,
-                )
-            )
-            .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,
-                    ),
-                    distinct=True,
-                )
-            )
-            .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,
-                    ),
-                    distinct=True,
-                )
-            )
-            .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,
-                    ),
-                    distinct=True,
-                )
-            )
-            .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,
-                    ),
-                    distinct=True,
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-        )
-
-    def get(self, request, slug, project_id, pk):
-        return self.paginate(
-            request=request,
-            queryset=(self.get_queryset()),
-            on_results=lambda modules: ModuleSerializer(
-                modules,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id, pk):
-        module = Module.objects.get(
-            pk=pk, project_id=project_id, workspace__slug=slug
-        )
-        if module.status not in ["completed", "cancelled"]:
-            return Response(
-                {
-                    "error": "Only completed or cancelled modules can be archived"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        module.archived_at = timezone.now()
-        module.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    def delete(self, request, slug, project_id, pk):
-        module = Module.objects.get(
-            pk=pk, project_id=project_id, workspace__slug=slug
-        )
-        module.archived_at = None
-        module.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,29 +1,27 @@
 # Django imports
 from django.db import IntegrityError
-from django.db.models import Exists, F, Func, OuterRef, Prefetch, Q, Subquery
-from django.utils import timezone
+from django.db.models import Exists, OuterRef, Q, F, Func, Subquery, Prefetch

 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
 from rest_framework.serializers import ValidationError

-from plane.api.serializers import ProjectSerializer
-from plane.app.permissions import ProjectBasePermission
-
 # Module imports
 from plane.db.models import (
-    Cycle,
-    Inbox,
-    IssueProperty,
-    Module,
-    Project,
-    ProjectDeployBoard,
-    ProjectMember,
-    State,
    Workspace,
+    Project,
+    ProjectFavorite,
+    ProjectMember,
+    ProjectDeployBoard,
+    State,
+    Cycle,
+    Module,
+    IssueProperty,
+    Inbox,
 )
-
+from plane.app.permissions import ProjectBasePermission
+from plane.api.serializers import ProjectSerializer
 from .base import BaseAPIView, WebhookMixin


@@ -42,10 +40,7 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
        return (
            Project.objects.filter(workspace__slug=self.kwargs.get("slug"))
            .filter(
-                Q(
-                    project_projectmember__member=self.request.user,
-                    project_projectmember__is_active=True,
-                )
+                Q(project_projectmember__member=self.request.user)
                | Q(network=2)
            )
            .select_related(
@@ -105,8 +100,8 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
            .distinct()
        )

-    def get(self, request, slug, pk=None):
-        if pk is None:
+    def get(self, request, slug, project_id=None):
+        if project_id is None:
            sort_order_query = ProjectMember.objects.filter(
                member=request.user,
                project_id=OuterRef("pk"),
@@ -137,7 +132,7 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                    expand=self.expand,
                ).data,
            )
-        project = self.get_queryset().get(workspace__slug=slug, pk=pk)
+        project = self.get_queryset().get(workspace__slug=slug, pk=project_id)
        serializer = ProjectSerializer(
            project,
            fields=self.fields,
@@ -155,7 +150,7 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                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,
@@ -250,27 +245,21 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                    {"name": "The project name is already taken"},
                    status=status.HTTP_410_GONE,
                )
-        except Workspace.DoesNotExist:
+        except Workspace.DoesNotExist as e:
            return Response(
                {"error": "Workspace does not exist"},
                status=status.HTTP_404_NOT_FOUND,
            )
-        except ValidationError:
+        except ValidationError as e:
            return Response(
                {"identifier": "The project identifier is already taken"},
                status=status.HTTP_410_GONE,
            )

-    def patch(self, request, slug, pk):
+    def patch(self, request, slug, project_id=None):
        try:
            workspace = Workspace.objects.get(slug=slug)
-            project = Project.objects.get(pk=pk)
-
-            if project.archived_at:
-                return Response(
-                    {"error": "Archived project cannot be updated"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
+            project = Project.objects.get(pk=project_id)

            serializer = ProjectSerializer(
                project,
@@ -291,11 +280,10 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                    # Create the triage state in Backlog group
                    State.objects.get_or_create(
                        name="Triage",
-                        group="triage",
+                        group="backlog",
                        description="Default state for managing all Inbox Issues",
-                        project_id=pk,
+                        project_id=project_id,
                        color="#ff7700",
-                        is_triage=True,
                    )

                project = (
@@ -319,32 +307,13 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                {"error": "Project does not exist"},
                status=status.HTTP_404_NOT_FOUND,
            )
-        except ValidationError:
+        except ValidationError as e:
            return Response(
                {"identifier": "The project identifier is already taken"},
                status=status.HTTP_410_GONE,
            )

-    def delete(self, request, slug, pk):
-        project = Project.objects.get(pk=pk, workspace__slug=slug)
-        project.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class ProjectArchiveUnarchiveAPIEndpoint(BaseAPIView):
-
-    permission_classes = [
-        ProjectBasePermission,
-    ]
-
-    def post(self, request, slug, project_id):
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-        project.archived_at = timezone.now()
-        project.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
    def delete(self, request, slug, project_id):
        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-        project.archived_at = None
-        project.save()
+        project.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,16 +1,18 @@
+# Python imports
+from itertools import groupby
+
 # Django imports
-from django.db import IntegrityError
+from django.db.models import Q

 # Third party imports
-from rest_framework import status
 from rest_framework.response import Response
-
-from plane.api.serializers import StateSerializer
-from plane.app.permissions import ProjectEntityPermission
-from plane.db.models import Issue, State
+from rest_framework import status

 # Module imports
 from .base import BaseAPIView
+from plane.api.serializers import StateSerializer
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import State, Issue


 class StateAPIEndpoint(BaseAPIView):
@@ -24,73 +26,25 @@ 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(is_triage=False)
-            .filter(project__archived_at__isnull=True)
+            .filter(project__project_projectmember__member=self.request.user)
+            .filter(~Q(name="Triage"))
            .select_related("project")
            .select_related("workspace")
            .distinct()
        )

    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:
-            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:
-            serializer = StateSerializer(
-                self.get_queryset().get(pk=state_id),
-                fields=self.fields,
-                expand=self.expand,
-            )
+            serializer = StateSerializer(self.get_queryset().get(pk=state_id))
            return Response(serializer.data, status=status.HTTP_200_OK)
        return self.paginate(
            request=request,
@@ -105,7 +59,7 @@ class StateAPIEndpoint(BaseAPIView):

    def delete(self, request, slug, project_id, state_id):
        state = State.objects.get(
-            is_triage=False,
+            ~Q(name="Triage"),
            pk=state_id,
            project_id=project_id,
            workspace__slug=slug,
@@ -137,25 +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)
@@ -1,8 +1,8 @@
 # Third Party imports
-from rest_framework.permissions import SAFE_METHODS, BasePermission
+from rest_framework.permissions import BasePermission, SAFE_METHODS

 # Module import
-from plane.db.models import ProjectMember, WorkspaceMember
+from plane.db.models import WorkspaceMember, ProjectMember

 # Permission Mappings
 Admin = 20
@@ -59,7 +59,6 @@ from .issue import (
    IssueFlatSerializer,
    IssueStateSerializer,
    IssueLinkSerializer,
-    IssueInboxSerializer,
    IssueLiteSerializer,
    IssueAttachmentSerializer,
    IssueSubscriberSerializer,
@@ -69,14 +68,10 @@ from .issue import (
    IssueRelationSerializer,
    RelatedIssueSerializer,
    IssuePublicSerializer,
-    IssueDetailSerializer,
-    IssueReactionLiteSerializer,
-    IssueAttachmentLiteSerializer,
-    IssueLinkLiteSerializer,
+    IssueRelationLiteSerializer,
 )

 from .module import (
-    ModuleDetailSerializer,
    ModuleWriteSerializer,
    ModuleSerializer,
    ModuleIssueSerializer,
@@ -87,13 +82,22 @@ from .module import (

 from .api import APITokenSerializer, APITokenReadSerializer

+from .integration import (
+    IntegrationSerializer,
+    WorkspaceIntegrationSerializer,
+    GithubIssueSyncSerializer,
+    GithubRepositorySerializer,
+    GithubRepositorySyncSerializer,
+    GithubCommentSyncSerializer,
+    SlackProjectSyncSerializer,
+)
+
 from .importer import ImporterSerializer

 from .page import (
    PageSerializer,
    PageLogSerializer,
    SubPageSerializer,
-    PageDetailSerializer,
    PageFavoriteSerializer,
 )

@@ -101,26 +105,18 @@ from .estimate import (
    EstimateSerializer,
    EstimatePointSerializer,
    EstimateReadSerializer,
-    WorkspaceEstimateSerializer,
 )

 from .inbox import (
    InboxSerializer,
    InboxIssueSerializer,
    IssueStateInboxSerializer,
-    InboxIssueLiteSerializer,
-    InboxIssueDetailSerializer,
 )

 from .analytic import AnalyticViewSerializer

-from .notification import (
-    NotificationSerializer,
-    UserNotificationPreferenceSerializer,
-)
+from .notification import NotificationSerializer

 from .exporter import ExporterHistorySerializer

 from .webhook import WebhookSerializer, WebhookLogSerializer
-
-from .dashboard import DashboardSerializer, WidgetSerializer
@@ -58,12 +58,7 @@ class DynamicBaseSerializer(BaseSerializer):
                    IssueSerializer,
                    LabelSerializer,
                    CycleIssueSerializer,
-                    IssueLiteSerializer,
-                    IssueRelationSerializer,
-                    InboxIssueLiteSerializer,
-                    IssueReactionLiteSerializer,
-                    IssueAttachmentLiteSerializer,
-                    IssueLinkLiteSerializer,
+                    IssueFlatSerializer,
                )

                # Expansion mapper
@@ -82,33 +77,14 @@ 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,
                }

                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
-                    )
+                    many=True
+                    if field
+                    in ["members", "assignees", "labels", "issue_cycle"]
+                    else False
                )

        return self.fields
@@ -129,12 +105,6 @@ class DynamicBaseSerializer(BaseSerializer):
                        IssueSerializer,
                        LabelSerializer,
                        CycleIssueSerializer,
-                        IssueRelationSerializer,
-                        InboxIssueLiteSerializer,
-                        IssueLiteSerializer,
-                        IssueReactionLiteSerializer,
-                        IssueAttachmentLiteSerializer,
-                        IssueLinkLiteSerializer,
                    )

                    # Expansion mapper
@@ -153,13 +123,7 @@ 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,
                    }
                    # Check if field in expansion then expand the field
                    if expand in expansion:
@@ -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,
@@ -27,57 +30,66 @@ class CycleWriteSerializer(BaseSerializer):
    class Meta:
        model = Cycle
        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "owned_by",
-            "archived_at",
-        ]


 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):
@@ -1,21 +0,0 @@
-# Module imports
-from .base import BaseSerializer
-from plane.db.models import Dashboard, Widget
-
-# Third party frameworks
-from rest_framework import serializers
-
-
-class DashboardSerializer(BaseSerializer):
-    class Meta:
-        model = Dashboard
-        fields = "__all__"
-
-
-class WidgetSerializer(BaseSerializer):
-    is_visible = serializers.BooleanField(read_only=True)
-    widget_filters = serializers.JSONField(read_only=True)
-
-    class Meta:
-        model = Widget
-        fields = ["id", "key", "is_visible", "widget_filters"]
@@ -61,16 +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",
-        ]
@@ -3,11 +3,7 @@ from rest_framework import serializers

 # Module imports
 from .base import BaseSerializer
-from .issue import (
-    IssueInboxSerializer,
-    LabelLiteSerializer,
-    IssueDetailSerializer,
-)
+from .issue import IssueFlatSerializer, LabelLiteSerializer
 from .project import ProjectLiteSerializer
 from .state import StateLiteSerializer
 from .user import UserLiteSerializer
@@ -28,62 +24,17 @@ class InboxSerializer(BaseSerializer):


 class InboxIssueSerializer(BaseSerializer):
-    issue = IssueInboxSerializer(read_only=True)
+    issue_detail = IssueFlatSerializer(source="issue", read_only=True)
+    project_detail = ProjectLiteSerializer(source="project", read_only=True)

    class Meta:
        model = InboxIssue
-        fields = [
-            "id",
-            "status",
-            "duplicate_to",
-            "snoozed_till",
-            "source",
-            "issue",
-            "created_by",
-        ]
+        fields = "__all__"
        read_only_fields = [
            "project",
            "workspace",
        ]

-    def to_representation(self, instance):
-        # Pass the annotated fields to the Issue instance if they exist
-        if hasattr(instance, "label_ids"):
-            instance.issue.label_ids = instance.label_ids
-        return super().to_representation(instance)
-
-
-class InboxIssueDetailSerializer(BaseSerializer):
-    issue = IssueDetailSerializer(read_only=True)
-    duplicate_issue_detail = IssueInboxSerializer(
-        read_only=True, source="duplicate_to"
-    )
-
-    class Meta:
-        model = InboxIssue
-        fields = [
-            "id",
-            "status",
-            "duplicate_to",
-            "snoozed_till",
-            "duplicate_issue_detail",
-            "source",
-            "issue",
-        ]
-        read_only_fields = [
-            "project",
-            "workspace",
-        ]
-
-    def to_representation(self, instance):
-        # Pass the annotated fields to the Issue instance if they exist
-        if hasattr(instance, "assignee_ids"):
-            instance.issue.assignee_ids = instance.assignee_ids
-        if hasattr(instance, "label_ids"):
-            instance.issue.label_ids = instance.label_ids
-
-        return super().to_representation(instance)
-

 class InboxIssueLiteSerializer(BaseSerializer):
    class Meta:
@@ -0,0 +1,8 @@
+from .base import IntegrationSerializer, WorkspaceIntegrationSerializer
+from .github import (
+    GithubRepositorySerializer,
+    GithubRepositorySyncSerializer,
+    GithubIssueSyncSerializer,
+    GithubCommentSyncSerializer,
+)
+from .slack import SlackProjectSyncSerializer
@@ -0,0 +1,22 @@
+# Module imports
+from plane.app.serializers import BaseSerializer
+from plane.db.models import Integration, WorkspaceIntegration
+
+
+class IntegrationSerializer(BaseSerializer):
+    class Meta:
+        model = Integration
+        fields = "__all__"
+        read_only_fields = [
+            "verified",
+        ]
+
+
+class WorkspaceIntegrationSerializer(BaseSerializer):
+    integration_detail = IntegrationSerializer(
+        read_only=True, source="integration"
+    )
+
+    class Meta:
+        model = WorkspaceIntegration
+        fields = "__all__"
@@ -0,0 +1,45 @@
+# Module imports
+from plane.app.serializers import BaseSerializer
+from plane.db.models import (
+    GithubIssueSync,
+    GithubRepository,
+    GithubRepositorySync,
+    GithubCommentSync,
+)
+
+
+class GithubRepositorySerializer(BaseSerializer):
+    class Meta:
+        model = GithubRepository
+        fields = "__all__"
+
+
+class GithubRepositorySyncSerializer(BaseSerializer):
+    repo_detail = GithubRepositorySerializer(source="repository")
+
+    class Meta:
+        model = GithubRepositorySync
+        fields = "__all__"
+
+
+class GithubIssueSyncSerializer(BaseSerializer):
+    class Meta:
+        model = GithubIssueSync
+        fields = "__all__"
+        read_only_fields = [
+            "project",
+            "workspace",
+            "repository_sync",
+        ]
+
+
+class GithubCommentSyncSerializer(BaseSerializer):
+    class Meta:
+        model = GithubCommentSync
+        fields = "__all__"
+        read_only_fields = [
+            "project",
+            "workspace",
+            "repository_sync",
+            "issue_sync",
+        ]
@@ -0,0 +1,14 @@
+# Module imports
+from plane.app.serializers import BaseSerializer
+from plane.db.models import SlackProjectSync
+
+
+class SlackProjectSyncSerializer(BaseSerializer):
+    class Meta:
+        model = SlackProjectSync
+        fields = "__all__"
+        read_only_fields = [
+            "project",
+            "workspace",
+            "workspace_integration",
+        ]
@@ -1,7 +1,5 @@
 # Django imports
 from django.utils import timezone
-from django.core.validators import URLValidator
-from django.core.exceptions import ValidationError

 # Third Party imports
 from rest_framework import serializers
@@ -9,7 +7,7 @@ from rest_framework import serializers
 # Module imports
 from .base import BaseSerializer, DynamicBaseSerializer
 from .user import UserLiteSerializer
-from .state import StateLiteSerializer
+from .state import StateSerializer, StateLiteSerializer
 from .project import ProjectLiteSerializer
 from .workspace import WorkspaceLiteSerializer
 from plane.db.models import (
@@ -33,6 +31,7 @@ from plane.db.models import (
    IssueVote,
    IssueRelation,
    State,
+    Project,
 )


@@ -260,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",
@@ -297,25 +293,31 @@ 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)
-    relation_type = serializers.CharField(read_only=True)
+class IssueRelationLiteSerializer(DynamicBaseSerializer):
+    project_id = serializers.PrimaryKeyRelatedField(read_only=True)

    class Meta:
-        model = IssueRelation
+        model = Issue
        fields = [
            "id",
            "project_id",
            "sequence_id",
-            "relation_type",
-            "name",
+        ]
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]
+
+
+class IssueRelationSerializer(BaseSerializer):
+    issue_detail = IssueRelationLiteSerializer(
+        read_only=True, source="related_issue"
+    )
+
+    class Meta:
+        model = IssueRelation
+        fields = [
+            "issue_detail",
        ]
        read_only_fields = [
            "workspace",
@@ -324,24 +326,12 @@ 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)
-    relation_type = serializers.CharField(read_only=True)
+    issue_detail = IssueRelationLiteSerializer(read_only=True, source="issue")

    class Meta:
        model = IssueRelation
        fields = [
-            "id",
-            "project_id",
-            "sequence_id",
-            "relation_type",
-            "name",
+            "issue_detail",
        ]
        read_only_fields = [
            "workspace",
@@ -433,20 +423,6 @@ class IssueLinkSerializer(BaseSerializer):
            "issue",
        ]

-    def validate_url(self, value):
-        # Check URL format
-        validate_url = URLValidator()
-        try:
-            validate_url(value)
-        except ValidationError:
-            raise serializers.ValidationError("Invalid URL format.")
-
-        # Check URL scheme
-        if not value.startswith(('http://', 'https://')):
-            raise serializers.ValidationError("Invalid URL scheme.")
-
-        return value
-
    # Validation if url already exists
    def create(self, validated_data):
        if IssueLink.objects.filter(
@@ -458,32 +434,6 @@ class IssueLinkSerializer(BaseSerializer):
            )
        return IssueLink.objects.create(**validated_data)

-    def update(self, instance, validated_data):
-        if IssueLink.objects.filter(
-            url=validated_data.get("url"),
-            issue_id=instance.issue_id,
-        ).exists():
-            raise serializers.ValidationError(
-                {"error": "URL already exists for this Issue"}
-            )
-
-        return super().update(instance, 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:
@@ -500,20 +450,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")

@@ -528,14 +464,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",
-            "issue",
            "reaction",
+            "comment",
+            "actor_detail",
        ]


@@ -569,7 +507,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:
@@ -620,42 +560,20 @@ class IssueStateSerializer(DynamicBaseSerializer):
        fields = "__all__"


-class IssueInboxSerializer(DynamicBaseSerializer):
-    label_ids = serializers.ListField(
-        child=serializers.UUIDField(),
-        required=False,
-    )
-
-    class Meta:
-        model = Issue
-        fields = [
-            "id",
-            "name",
-            "priority",
-            "sequence_id",
-            "project_id",
-            "created_at",
-            "label_ids",
-        ]
-        read_only_fields = fields
-
-
 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
@@ -663,12 +581,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",
@@ -679,7 +601,7 @@ class IssueSerializer(DynamicBaseSerializer):
            "project_id",
            "parent_id",
            "cycle_id",
-            "module_ids",
+            "module_id",
            "label_ids",
            "assignee_ids",
            "sub_issues_count",
@@ -689,6 +611,7 @@ class IssueSerializer(DynamicBaseSerializer):
            "updated_by",
            "attachment_count",
            "link_count",
+            "is_subscribed",
            "is_draft",
            "archived_at",
        ]
@@ -696,26 +619,38 @@ class IssueSerializer(DynamicBaseSerializer):


 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(read_only=True)
-
-    class Meta(IssueSerializer.Meta):
-        fields = IssueSerializer.Meta.fields + [
-            "description_html",
-            "is_subscribed",
-        ]
-        read_only_fields = fields


 class IssuePublicSerializer(BaseSerializer):
@@ -3,7 +3,9 @@ from rest_framework import serializers

 # Module imports
 from .base import BaseSerializer, DynamicBaseSerializer
+from .user import UserLiteSerializer
 from .project import ProjectLiteSerializer
+from .workspace import WorkspaceLiteSerializer

 from plane.db.models import (
    User,
@@ -17,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__"
@@ -39,14 +40,11 @@ class ModuleWriteSerializer(BaseSerializer):
            "updated_by",
            "created_at",
            "updated_at",
-            "archived_at",
        ]

    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,8 @@ class ModuleIssueSerializer(BaseSerializer):


 class ModuleLinkSerializer(BaseSerializer):
+    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
+
    class Meta:
        model = ModuleLink
        fields = "__all__"
@@ -168,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)
@@ -181,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",
-            "archived_at",
        ]
-        read_only_fields = fields
-
-
-class ModuleDetailSerializer(ModuleSerializer):
-    link_module = ModuleLinkSerializer(read_only=True, many=True)
-    sub_issues = serializers.IntegerField(read_only=True)
-
-    class Meta(ModuleSerializer.Meta):
-        fields = ModuleSerializer.Meta.fields + ["link_module", "sub_issues"]


 class ModuleFavoriteSerializer(BaseSerializer):
@@ -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,9 +12,3 @@ class NotificationSerializer(BaseSerializer):
    class Meta:
        model = Notification
        fields = "__all__"
-
-
-class UserNotificationPreferenceSerializer(BaseSerializer):
-    class Meta:
-        model = UserNotificationPreference
-        fields = "__all__"
@@ -3,44 +3,38 @@ from rest_framework import serializers

 # Module imports
 from .base import BaseSerializer
+from .issue import IssueFlatSerializer, LabelLiteSerializer
+from .workspace import WorkspaceLiteSerializer
+from .project import ProjectLiteSerializer
 from plane.db.models import (
    Page,
    PageLog,
    PageFavorite,
    PageLabel,
    Label,
+    Issue,
+    Module,
 )


 class PageSerializer(BaseSerializer):
    is_favorite = serializers.BooleanField(read_only=True)
+    label_details = LabelLiteSerializer(
+        read_only=True, source="labels", many=True
+    )
    labels = serializers.ListField(
        child=serializers.PrimaryKeyRelatedField(queryset=Label.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 = Page
-        fields = [
-            "id",
-            "name",
-            "owned_by",
-            "access",
-            "color",
-            "labels",
-            "parent",
-            "is_favorite",
-            "is_locked",
-            "archived_at",
-            "workspace",
-            "project",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-            "view_props",
-        ]
+        fields = "__all__"
        read_only_fields = [
            "workspace",
            "project",
@@ -56,12 +50,8 @@ class PageSerializer(BaseSerializer):
        labels = validated_data.pop("labels", None)
        project_id = self.context["project_id"]
        owned_by_id = self.context["owned_by_id"]
-        description_html = self.context["description_html"]
        page = Page.objects.create(
-            **validated_data,
-            description_html=description_html,
-            project_id=project_id,
-            owned_by_id=owned_by_id,
+            **validated_data, project_id=project_id, owned_by_id=owned_by_id
        )

        if labels is not None:
@@ -103,13 +93,6 @@ class PageSerializer(BaseSerializer):
        return super().update(instance, validated_data)


-class PageDetailSerializer(PageSerializer):
-    description_html = serializers.CharField()
-
-    class Meta(PageSerializer.Meta):
-        fields = PageSerializer.Meta.fields + ["description_html"]
-
-
 class SubPageSerializer(BaseSerializer):
    entity_details = serializers.SerializerMethodField()

@@ -95,19 +95,14 @@ class ProjectLiteSerializer(BaseSerializer):
            "identifier",
            "name",
            "cover_image",
-            "logo_props",
+            "icon_prop",
+            "emoji",
            "description",
        ]
        read_only_fields = fields


 class ProjectListSerializer(DynamicBaseSerializer):
-    total_issues = serializers.IntegerField(read_only=True)
-    archived_issues = serializers.IntegerField(read_only=True)
-    archived_sub_issues = serializers.IntegerField(read_only=True)
-    draft_issues = serializers.IntegerField(read_only=True)
-    draft_sub_issues = serializers.IntegerField(read_only=True)
-    sub_issues = serializers.IntegerField(read_only=True)
    is_favorite = serializers.BooleanField(read_only=True)
    total_members = serializers.IntegerField(read_only=True)
    total_cycles = serializers.IntegerField(read_only=True)
@@ -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",
@@ -4,6 +4,7 @@ from rest_framework import serializers
 # Module import
 from .base import BaseSerializer
 from plane.db.models import User, Workspace, WorkspaceMemberInvite
+from plane.license.models import InstanceAdmin, Instance


 class UserSerializer(BaseSerializer):
@@ -98,13 +99,13 @@ class UserMeSettingsSerializer(BaseSerializer):
            ).first()
            return {
                "last_workspace_id": obj.last_workspace_id,
-                "last_workspace_slug": (
-                    workspace.slug if workspace is not None else ""
-                ),
+                "last_workspace_slug": workspace.slug
+                if workspace is not None
+                else "",
                "fallback_workspace_id": obj.last_workspace_id,
-                "fallback_workspace_slug": (
-                    workspace.slug if workspace is not None else ""
-                ),
+                "fallback_workspace_slug": workspace.slug
+                if workspace is not None
+                else "",
                "invites": workspace_invites,
            }
        else:
@@ -119,16 +120,12 @@ class UserMeSettingsSerializer(BaseSerializer):
            return {
                "last_workspace_id": None,
                "last_workspace_slug": None,
-                "fallback_workspace_id": (
-                    fallback_workspace.id
-                    if fallback_workspace is not None
-                    else None
-                ),
-                "fallback_workspace_slug": (
-                    fallback_workspace.slug
-                    if fallback_workspace is not None
-                    else None
-                ),
+                "fallback_workspace_id": fallback_workspace.id
+                if fallback_workspace is not None
+                else None,
+                "fallback_workspace_slug": fallback_workspace.slug
+                if fallback_workspace is not None
+                else None,
                "invites": workspace_invites,
            }

@@ -1,4 +1,5 @@
 # Python imports
+import urllib
 import socket
 import ipaddress
 from urllib.parse import urlparse
@@ -3,10 +3,11 @@ from .asset import urlpatterns as asset_urls
 from .authentication import urlpatterns as authentication_urls
 from .config import urlpatterns as configuration_urls
 from .cycle import urlpatterns as cycle_urls
-from .dashboard import urlpatterns as dashboard_urls
 from .estimate import urlpatterns as estimate_urls
 from .external import urlpatterns as external_urls
+from .importer import urlpatterns as importer_urls
 from .inbox import urlpatterns as inbox_urls
+from .integration import urlpatterns as integration_urls
 from .issue import urlpatterns as issue_urls
 from .module import urlpatterns as module_urls
 from .notification import urlpatterns as notification_urls
@@ -27,10 +28,11 @@ urlpatterns = [
    *authentication_urls,
    *configuration_urls,
    *cycle_urls,
-    *dashboard_urls,
    *estimate_urls,
    *external_urls,
+    *importer_urls,
    *inbox_urls,
+    *integration_urls,
    *issue_urls,
    *module_urls,
    *notification_urls,
@@ -8,11 +8,16 @@ from plane.app.views import (
    CycleFavoriteViewSet,
    TransferCycleIssueEndpoint,
    CycleUserPropertiesEndpoint,
-    CycleArchiveUnarchiveEndpoint,
+    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(
@@ -91,19 +96,4 @@ urlpatterns = [
        CycleUserPropertiesEndpoint.as_view(),
        name="cycle-user-filters",
    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/archive/",
-        CycleArchiveUnarchiveEndpoint.as_view(),
-        name="cycle-archive-unarchive",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-cycles/",
-        CycleArchiveUnarchiveEndpoint.as_view(),
-        name="cycle-archive-unarchive",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-cycles/<uuid:pk>/",
-        CycleArchiveUnarchiveEndpoint.as_view(),
-        name="cycle-archive-unarchive",
-    ),
 ]
@@ -1,23 +0,0 @@
-from django.urls import path
-
-
-from plane.app.views import DashboardEndpoint, WidgetsEndpoint
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/dashboard/",
-        DashboardEndpoint.as_view(),
-        name="dashboard",
-    ),
-    path(
-        "workspaces/<str:slug>/dashboard/<uuid:dashboard_id>/",
-        DashboardEndpoint.as_view(),
-        name="dashboard",
-    ),
-    path(
-        "dashboard/<uuid:dashboard_id>/widgets/<uuid:widget_id>/",
-        WidgetsEndpoint.as_view(),
-        name="widgets",
-    ),
-]
@@ -2,6 +2,7 @@ from django.urls import path


 from plane.app.views import UnsplashEndpoint
+from plane.app.views import ReleaseNotesEndpoint
 from plane.app.views import GPTIntegrationEndpoint


@@ -11,6 +12,11 @@ urlpatterns = [
        UnsplashEndpoint.as_view(),
        name="unsplash",
    ),
+    path(
+        "release-notes/",
+        ReleaseNotesEndpoint.as_view(),
+        name="release-notes",
+    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/ai-assistant/",
        GPTIntegrationEndpoint.as_view(),
@@ -0,0 +1,37 @@
+from django.urls import path
+
+
+from plane.app.views import (
+    ServiceIssueImportSummaryEndpoint,
+    ImportServiceEndpoint,
+    UpdateServiceImportStatusEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/importers/<str:service>/",
+        ServiceIssueImportSummaryEndpoint.as_view(),
+        name="importer-summary",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/importers/<str:service>/",
+        ImportServiceEndpoint.as_view(),
+        name="importer",
+    ),
+    path(
+        "workspaces/<str:slug>/importers/",
+        ImportServiceEndpoint.as_view(),
+        name="importer",
+    ),
+    path(
+        "workspaces/<str:slug>/importers/<str:service>/<uuid:pk>/",
+        ImportServiceEndpoint.as_view(),
+        name="importer",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/service/<str:service>/importers/<uuid:importer_id>/",
+        UpdateServiceImportStatusEndpoint.as_view(),
+        name="importer-status",
+    ),
+]
@@ -30,7 +30,7 @@ urlpatterns = [
        name="inbox",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/",
        InboxIssueViewSet.as_view(
            {
                "get": "list",
@@ -40,7 +40,7 @@ urlpatterns = [
        name="inbox-issue",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:issue_id>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/<uuid:issue_id>/",
        InboxIssueViewSet.as_view(
            {
                "get": "retrieve",
@@ -0,0 +1,150 @@
+from django.urls import path
+
+
+from plane.app.views import (
+    IntegrationViewSet,
+    WorkspaceIntegrationViewSet,
+    GithubRepositoriesEndpoint,
+    GithubRepositorySyncViewSet,
+    GithubIssueSyncViewSet,
+    GithubCommentSyncViewSet,
+    BulkCreateGithubIssueSyncEndpoint,
+    SlackProjectSyncViewSet,
+)
+
+
+urlpatterns = [
+    path(
+        "integrations/",
+        IntegrationViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="integrations",
+    ),
+    path(
+        "integrations/<uuid:pk>/",
+        IntegrationViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="integrations",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-integrations/",
+        WorkspaceIntegrationViewSet.as_view(
+            {
+                "get": "list",
+            }
+        ),
+        name="workspace-integrations",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-integrations/<str:provider>/",
+        WorkspaceIntegrationViewSet.as_view(
+            {
+                "post": "create",
+            }
+        ),
+        name="workspace-integrations",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-integrations/<uuid:pk>/provider/",
+        WorkspaceIntegrationViewSet.as_view(
+            {
+                "get": "retrieve",
+                "delete": "destroy",
+            }
+        ),
+        name="workspace-integrations",
+    ),
+    # Github Integrations
+    path(
+        "workspaces/<str:slug>/workspace-integrations/<uuid:workspace_integration_id>/github-repositories/",
+        GithubRepositoriesEndpoint.as_view(),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/github-repository-sync/",
+        GithubRepositorySyncViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/github-repository-sync/<uuid:pk>/",
+        GithubRepositorySyncViewSet.as_view(
+            {
+                "get": "retrieve",
+                "delete": "destroy",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/",
+        GithubIssueSyncViewSet.as_view(
+            {
+                "post": "create",
+                "get": "list",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/bulk-create-github-issue-sync/",
+        BulkCreateGithubIssueSyncEndpoint.as_view(),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:pk>/",
+        GithubIssueSyncViewSet.as_view(
+            {
+                "get": "retrieve",
+                "delete": "destroy",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:issue_sync_id>/github-comment-sync/",
+        GithubCommentSyncViewSet.as_view(
+            {
+                "post": "create",
+                "get": "list",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:issue_sync_id>/github-comment-sync/<uuid:pk>/",
+        GithubCommentSyncViewSet.as_view(
+            {
+                "get": "retrieve",
+                "delete": "destroy",
+            }
+        ),
+    ),
+    ## End Github Integrations
+    # Slack Integration
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/project-slack-sync/",
+        SlackProjectSyncViewSet.as_view(
+            {
+                "post": "create",
+                "get": "list",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/project-slack-sync/<uuid:pk>/",
+        SlackProjectSyncViewSet.as_view(
+            {
+                "delete": "destroy",
+                "get": "retrieve",
+            }
+        ),
+    ),
+    ## End Slack Integration
+]
@@ -1,32 +1,30 @@
 from django.urls import path

+
 from plane.app.views import (
+    IssueViewSet,
+    LabelViewSet,
    BulkCreateIssueLabelsEndpoint,
    BulkDeleteIssuesEndpoint,
+    BulkImportIssuesEndpoint,
+    UserWorkSpaceIssues,
    SubIssuesEndpoint,
    IssueLinkViewSet,
    IssueAttachmentEndpoint,
-    CommentReactionViewSet,
    ExportIssuesEndpoint,
    IssueActivityEndpoint,
-    IssueArchiveViewSet,
    IssueCommentViewSet,
-    IssueDraftViewSet,
-    IssueListEndpoint,
-    IssueReactionViewSet,
-    IssueRelationViewSet,
    IssueSubscriberViewSet,
+    IssueReactionViewSet,
+    CommentReactionViewSet,
    IssueUserDisplayPropertyEndpoint,
-    IssueViewSet,
-    LabelViewSet,
+    IssueArchiveViewSet,
+    IssueRelationViewSet,
+    IssueDraftViewSet,
 )

+
 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(
@@ -81,7 +79,16 @@ urlpatterns = [
        BulkDeleteIssuesEndpoint.as_view(),
        name="project-issues-bulk",
    ),
-    ##
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-import-issues/<str:service>/",
+        BulkImportIssuesEndpoint.as_view(),
+        name="project-issues-bulk",
+    ),
+    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(),
@@ -244,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
@@ -6,8 +6,8 @@ from plane.app.views import (
    ModuleIssueViewSet,
    ModuleLinkViewSet,
    ModuleFavoriteViewSet,
+    BulkImportModulesEndpoint,
    ModuleUserPropertiesEndpoint,
-    ModuleArchiveUnarchiveEndpoint,
 )


@@ -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",
@@ -106,24 +97,14 @@ urlpatterns = [
        ),
        name="user-favorite-module",
    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-import-modules/<str:service>/",
+        BulkImportModulesEndpoint.as_view(),
+        name="bulk-modules-create",
+    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/user-properties/",
        ModuleUserPropertiesEndpoint.as_view(),
        name="cycle-user-filters",
    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/archive/",
-        ModuleArchiveUnarchiveEndpoint.as_view(),
-        name="module-archive-unarchive",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-modules/",
-        ModuleArchiveUnarchiveEndpoint.as_view(),
-        name="module-archive-unarchive",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-modules/<uuid:pk>/",
-        ModuleArchiveUnarchiveEndpoint.as_view(),
-        name="module-archive-unarchive",
-    ),
 ]
@@ -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",
-    ),
 ]
@@ -31,51 +31,102 @@ urlpatterns = [
        ),
        name="project-pages",
    ),
-    # favorite pages
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/favorite-pages/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-pages/",
        PageFavoriteViewSet.as_view(
            {
+                "get": "list",
                "post": "create",
+            }
+        ),
+        name="user-favorite-pages",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-pages/<uuid:page_id>/",
+        PageFavoriteViewSet.as_view(
+            {
                "delete": "destroy",
            }
        ),
        name="user-favorite-pages",
    ),
-    # archived pages
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/archive/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/",
+        PageViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-pages",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/",
+        PageViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-pages",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/archive/",
        PageViewSet.as_view(
            {
                "post": "archive",
-                "delete": "unarchive",
            }
        ),
-        name="project-page-archive-unarchive",
+        name="project-page-archive",
    ),
-    # lock and unlock
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/lock/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/unarchive/",
+        PageViewSet.as_view(
+            {
+                "post": "unarchive",
+            }
+        ),
+        name="project-page-unarchive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-pages/",
+        PageViewSet.as_view(
+            {
+                "get": "archive_list",
+            }
+        ),
+        name="project-pages",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/lock/",
        PageViewSet.as_view(
            {
                "post": "lock",
-                "delete": "unlock",
            }
        ),
-        name="project-pages-lock-unlock",
+        name="project-pages",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/transactions/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/unlock/",
+        PageViewSet.as_view(
+            {
+                "post": "unlock",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/transactions/",
        PageLogEndpoint.as_view(),
        name="page-transactions",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/transactions/<uuid:transaction>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/transactions/<uuid:transaction>/",
        PageLogEndpoint.as_view(),
        name="page-transactions",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/sub-pages/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/sub-pages/",
        SubPagesEndpoint.as_view(),
        name="sub-page",
    ),
@@ -14,7 +14,6 @@ from plane.app.views import (
    ProjectPublicCoverImagesEndpoint,
    ProjectDeployBoardViewSet,
    UserProjectRolesEndpoint,
-    ProjectArchiveUnarchiveEndpoint,
 )


@@ -176,9 +175,4 @@ urlpatterns = [
        ),
        name="project-deploy-board",
    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/archive/",
-        ProjectArchiveUnarchiveEndpoint.as_view(),
-        name="project-archive-unarchive",
-    ),
 ]
@@ -20,11 +20,6 @@ from plane.app.views import (
    WorkspaceLabelsEndpoint,
    WorkspaceProjectMemberEndpoint,
    WorkspaceUserPropertiesEndpoint,
-    WorkspaceStatesEndpoint,
-    WorkspaceEstimatesEndpoint,
-    ExportWorkspaceUserActivityEndpoint,
-    WorkspaceModulesEndpoint,
-    WorkspaceCyclesEndpoint,
 )


@@ -192,11 +187,6 @@ urlpatterns = [
        WorkspaceUserActivityEndpoint.as_view(),
        name="workspace-user-activity",
    ),
-    path(
-        "workspaces/<str:slug>/user-activity/<uuid:user_id>/export/",
-        ExportWorkspaceUserActivityEndpoint.as_view(),
-        name="export-workspace-user-activity",
-    ),
    path(
        "workspaces/<str:slug>/user-profile/<uuid:user_id>/",
        WorkspaceUserProfileEndpoint.as_view(),
@@ -217,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",
-    ),
 ]
@@ -1,27 +1,19 @@
-from .project.base import (
+from .project import (
    ProjectViewSet,
+    ProjectMemberViewSet,
+    UserProjectInvitationsViewset,
+    ProjectInvitationsViewset,
+    AddTeamToProjectEndpoint,
    ProjectIdentifierEndpoint,
+    ProjectJoinEndpoint,
    ProjectUserViewsEndpoint,
+    ProjectMemberUserEndpoint,
    ProjectFavoritesViewSet,
    ProjectPublicCoverImagesEndpoint,
    ProjectDeployBoardViewSet,
-    ProjectArchiveUnarchiveEndpoint,
-)
-
-from .project.invite import (
-    UserProjectInvitationsViewset,
-    ProjectInvitationsViewset,
-    ProjectJoinEndpoint,
-)
-
-from .project.member import (
-    ProjectMemberViewSet,
-    AddTeamToProjectEndpoint,
-    ProjectMemberUserEndpoint,
    UserProjectRolesEndpoint,
 )
-
-from .user.base import (
+from .user import (
    UserEndpoint,
    UpdateUserOnBoardedEndpoint,
    UpdateUserTourCompletedEndpoint,
@@ -32,124 +24,66 @@ from .oauth import OauthEndpoint

 from .base import BaseAPIView, BaseViewSet, WebhookMixin

-from .workspace.base import (
+from .workspace import (
    WorkSpaceViewSet,
    UserWorkSpacesEndpoint,
    WorkSpaceAvailabilityCheckEndpoint,
-    UserWorkspaceDashboardEndpoint,
-    WorkspaceThemeViewSet,
-    ExportWorkspaceUserActivityEndpoint,
-)
-
-from .workspace.member import (
+    WorkspaceJoinEndpoint,
    WorkSpaceMemberViewSet,
    TeamMemberViewSet,
-    WorkspaceMemberUserEndpoint,
-    WorkspaceProjectMemberEndpoint,
-    WorkspaceMemberUserViewsEndpoint,
-)
-from .workspace.invite import (
    WorkspaceInvitationsViewset,
-    WorkspaceJoinEndpoint,
    UserWorkspaceInvitationsViewSet,
-)
-from .workspace.label import (
-    WorkspaceLabelsEndpoint,
-)
-from .workspace.state import (
-    WorkspaceStatesEndpoint,
-)
-from .workspace.user import (
    UserLastProjectWithWorkspaceEndpoint,
-    WorkspaceUserProfileIssuesEndpoint,
-    WorkspaceUserPropertiesEndpoint,
-    WorkspaceUserProfileEndpoint,
-    WorkspaceUserActivityEndpoint,
-    WorkspaceUserProfileStatsEndpoint,
+    WorkspaceMemberUserEndpoint,
+    WorkspaceMemberUserViewsEndpoint,
    UserActivityGraphEndpoint,
    UserIssueCompletedGraphEndpoint,
+    UserWorkspaceDashboardEndpoint,
+    WorkspaceThemeViewSet,
+    WorkspaceUserProfileStatsEndpoint,
+    WorkspaceUserActivityEndpoint,
+    WorkspaceUserProfileEndpoint,
+    WorkspaceUserProfileIssuesEndpoint,
+    WorkspaceLabelsEndpoint,
+    WorkspaceProjectMemberEndpoint,
+    WorkspaceUserPropertiesEndpoint,
 )
-from .workspace.estimate import (
-    WorkspaceEstimatesEndpoint,
-)
-from .workspace.module import (
-    WorkspaceModulesEndpoint,
-)
-from .workspace.cycle import (
-    WorkspaceCyclesEndpoint,
-)
-
-from .state.base import StateViewSet
-from .view.base import (
+from .state import StateViewSet
+from .view import (
    GlobalViewViewSet,
    GlobalViewIssuesViewSet,
    IssueViewViewSet,
    IssueViewFavoriteViewSet,
 )
-from .cycle.base import (
+from .cycle import (
    CycleViewSet,
+    CycleIssueViewSet,
    CycleDateCheckEndpoint,
    CycleFavoriteViewSet,
    TransferCycleIssueEndpoint,
    CycleUserPropertiesEndpoint,
+    ActiveCycleEndpoint,
 )
-from .cycle.issue import (
-    CycleIssueViewSet,
-)
-from .cycle.archive import (
-    CycleArchiveUnarchiveEndpoint,
-)
-
-from .asset.base import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
-from .issue.base import (
-    IssueListEndpoint,
+from .asset import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
+from .issue import (
    IssueViewSet,
-    IssueUserDisplayPropertyEndpoint,
-    BulkDeleteIssuesEndpoint,
-)
-
-from .issue.activity import (
+    WorkSpaceIssuesEndpoint,
    IssueActivityEndpoint,
-)
-
-from .issue.archive import (
-    IssueArchiveViewSet,
-)
-
-from .issue.attachment import (
-    IssueAttachmentEndpoint,
-)
-
-from .issue.comment import (
    IssueCommentViewSet,
-    CommentReactionViewSet,
-)
-
-from .issue.draft import IssueDraftViewSet
-
-from .issue.label import (
+    IssueUserDisplayPropertyEndpoint,
    LabelViewSet,
-    BulkCreateIssueLabelsEndpoint,
-)
-
-from .issue.link import (
-    IssueLinkViewSet,
-)
-
-from .issue.relation import (
-    IssueRelationViewSet,
-)
-
-from .issue.reaction import (
-    IssueReactionViewSet,
-)
-
-from .issue.sub_issue import (
+    BulkDeleteIssuesEndpoint,
+    UserWorkSpaceIssues,
    SubIssuesEndpoint,
-)
-
-from .issue.subscriber import (
+    IssueLinkViewSet,
+    BulkCreateIssueLabelsEndpoint,
+    IssueAttachmentEndpoint,
+    IssueArchiveViewSet,
    IssueSubscriberViewSet,
+    CommentReactionViewSet,
+    IssueReactionViewSet,
+    IssueRelationViewSet,
+    IssueDraftViewSet,
 )

 from .auth_extended import (
@@ -168,25 +102,36 @@ from .authentication import (
    MagicSignInEndpoint,
 )

-from .module.base import (
+from .module import (
    ModuleViewSet,
+    ModuleIssueViewSet,
    ModuleLinkViewSet,
    ModuleFavoriteViewSet,
    ModuleUserPropertiesEndpoint,
 )

-from .module.issue import (
-    ModuleIssueViewSet,
-)
-
-from .module.archive import (
-    ModuleArchiveUnarchiveEndpoint,
-)
-
 from .api import ApiTokenEndpoint

+from .integration import (
+    WorkspaceIntegrationViewSet,
+    IntegrationViewSet,
+    GithubIssueSyncViewSet,
+    GithubRepositorySyncViewSet,
+    GithubCommentSyncViewSet,
+    GithubRepositoriesEndpoint,
+    BulkCreateGithubIssueSyncEndpoint,
+    SlackProjectSyncViewSet,
+)

-from .page.base import (
+from .importer import (
+    ServiceIssueImportSummaryEndpoint,
+    ImportServiceEndpoint,
+    UpdateServiceImportStatusEndpoint,
+    BulkImportIssuesEndpoint,
+    BulkImportModulesEndpoint,
+)
+
+from .page import (
    PageViewSet,
    PageFavoriteViewSet,
    PageLogEndpoint,
@@ -196,19 +141,20 @@ from .page.base import (
 from .search import GlobalSearchEndpoint, IssueSearchEndpoint


-from .external.base import (
+from .external import (
    GPTIntegrationEndpoint,
+    ReleaseNotesEndpoint,
    UnsplashEndpoint,
 )

-from .estimate.base import (
+from .estimate import (
    ProjectEstimatePointEndpoint,
    BulkEstimatePointEndpoint,
 )

-from .inbox.base import InboxViewSet, InboxIssueViewSet
+from .inbox import InboxViewSet, InboxIssueViewSet

-from .analytic.base import (
+from .analytic import (
    AnalyticsEndpoint,
    AnalyticViewViewset,
    SavedAnalyticEndpoint,
@@ -216,23 +162,18 @@ from .analytic.base import (
    DefaultAnalyticsEndpoint,
 )

-from .notification.base import (
+from .notification import (
    NotificationViewSet,
    UnreadNotificationEndpoint,
    MarkAllReadNotificationViewSet,
-    UserNotificationPreferenceEndpoint,
 )

-from .exporter.base import ExportIssuesEndpoint
+from .exporter import ExportIssuesEndpoint

 from .config import ConfigurationEndpoint, MobileConfigurationEndpoint

-from .webhook.base import (
+from .webhook import (
    WebhookEndpoint,
    WebhookLogsEndpoint,
    WebhookSecretRegenerateEndpoint,
 )
-
-from .dashboard.base import DashboardEndpoint, WidgetsEndpoint
-
-from .error_404 import custom_404_view
@@ -1,7 +1,6 @@
 # Django imports
-from django.db.models import Count, Sum, F
+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
@@ -10,7 +9,7 @@ from rest_framework.response import Response
 # Module imports
 from plane.app.views import BaseAPIView, BaseViewSet
 from plane.app.permissions import WorkSpaceAdminPermission
-from plane.db.models import Issue, AnalyticView, Workspace
+from plane.db.models import Issue, AnalyticView, Workspace, State, Label
 from plane.app.serializers import AnalyticViewSerializer
 from plane.utils.analytics_plot import build_graph_plot
 from plane.bgtasks.analytic_plot_export import analytic_export_task
@@ -51,8 +50,8 @@ class AnalyticsEndpoint(BaseAPIView):
        if (
            not x_axis
            or not y_axis
-            or x_axis not in valid_xaxis_segment
-            or y_axis not in valid_yaxis
+            or not x_axis in valid_xaxis_segment
+            or not y_axis in valid_yaxis
        ):
            return Response(
                {
@@ -266,8 +265,8 @@ class ExportAnalyticsEndpoint(BaseAPIView):
        if (
            not x_axis
            or not y_axis
-            or x_axis not in valid_xaxis_segment
-            or y_axis not in valid_yaxis
+            or not x_axis in valid_xaxis_segment
+            or not y_axis in valid_yaxis
        ):
            return Response(
                {
@@ -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("*"))
@@ -43,7 +43,7 @@ class ApiTokenEndpoint(BaseAPIView):
        )

    def get(self, request, slug, pk=None):
-        if pk is None:
+        if pk == None:
            api_tokens = APIToken.objects.filter(
                user=request.user, workspace__slug=slug
            )
@@ -4,7 +4,7 @@ from rest_framework.response import Response
 from rest_framework.parsers import MultiPartParser, FormParser, JSONParser

 # Module imports
-from ..base import BaseAPIView, BaseViewSet
+from .base import BaseAPIView, BaseViewSet
 from plane.db.models import FileAsset, Workspace
 from plane.app.serializers import FileAssetSerializer

@@ -16,6 +16,7 @@ from django.contrib.auth.hashers import make_password
 from django.utils.http import urlsafe_base64_decode, urlsafe_base64_encode
 from django.core.validators import validate_email
 from django.core.exceptions import ValidationError
+from django.conf import settings

 ## Third Party Imports
 from rest_framework import status
@@ -171,7 +172,7 @@ class ResetPasswordEndpoint(BaseAPIView):
                serializer.errors, status=status.HTTP_400_BAD_REQUEST
            )

-        except DjangoUnicodeDecodeError:
+        except DjangoUnicodeDecodeError as indentifier:
            return Response(
                {"error": "token is not valid, please check the new one"},
                status=status.HTTP_401_UNAUTHORIZED,
@@ -400,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)
@@ -437,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,
                )

@@ -467,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,
                )

@@ -7,6 +7,7 @@ import json
 from django.utils import timezone
 from django.core.exceptions import ValidationError
 from django.core.validators import validate_email
+from django.conf import settings
 from django.contrib.auth.hashers import make_password

 # Third party imports
@@ -64,7 +65,7 @@ class SignUpEndpoint(BaseAPIView):
        email = email.strip().lower()
        try:
            validate_email(email)
-        except ValidationError:
+        except ValidationError as e:
            return Response(
                {"error": "Please provide a valid email address."},
                status=status.HTTP_400_BAD_REQUEST,
@@ -150,7 +151,7 @@ class SignInEndpoint(BaseAPIView):
        email = email.strip().lower()
        try:
            validate_email(email)
-        except ValidationError:
+        except ValidationError as e:
            return Response(
                {"error": "Please provide a valid email address."},
                status=status.HTTP_400_BAD_REQUEST,
@@ -237,11 +238,9 @@ class SignInEndpoint(BaseAPIView):
            [
                WorkspaceMember(
                    workspace_id=project_member_invite.workspace_id,
-                    role=(
-                        project_member_invite.role
-                        if project_member_invite.role in [5, 10, 15]
-                        else 15
-                    ),
+                    role=project_member_invite.role
+                    if project_member_invite.role in [5, 10, 15]
+                    else 15,
                    member=user,
                    created_by_id=project_member_invite.created_by_id,
                )
@@ -255,11 +254,9 @@ class SignInEndpoint(BaseAPIView):
            [
                ProjectMember(
                    workspace_id=project_member_invite.workspace_id,
-                    role=(
-                        project_member_invite.role
-                        if project_member_invite.role in [5, 10, 15]
-                        else 15
-                    ),
+                    role=project_member_invite.role
+                    if project_member_invite.role in [5, 10, 15]
+                    else 15,
                    member=user,
                    created_by_id=project_member_invite.created_by_id,
                )
@@ -277,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,
        )

@@ -328,7 +325,7 @@ class MagicSignInEndpoint(BaseAPIView):
            )

        user_token = request.data.get("token", "").strip()
-        key = request.data.get("key", "").strip().lower()
+        key = request.data.get("key", False).strip().lower()

        if not key or user_token == "":
            return Response(
@@ -352,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,
                )

@@ -395,11 +392,9 @@ class MagicSignInEndpoint(BaseAPIView):
                    [
                        WorkspaceMember(
                            workspace_id=project_member_invite.workspace_id,
-                            role=(
-                                project_member_invite.role
-                                if project_member_invite.role in [5, 10, 15]
-                                else 15
-                            ),
+                            role=project_member_invite.role
+                            if project_member_invite.role in [5, 10, 15]
+                            else 15,
                            member=user,
                            created_by_id=project_member_invite.created_by_id,
                        )
@@ -413,11 +408,9 @@ class MagicSignInEndpoint(BaseAPIView):
                    [
                        ProjectMember(
                            workspace_id=project_member_invite.workspace_id,
-                            role=(
-                                project_member_invite.role
-                                if project_member_invite.role in [5, 10, 15]
-                                else 15
-                            ),
+                            role=project_member_invite.role
+                            if project_member_invite.role in [5, 10, 15]
+                            else 15,
                            member=user,
                            created_by_id=project_member_invite.created_by_id,
                        )
@@ -1,27 +1,30 @@
 # Python imports
 import zoneinfo
-from django.conf import settings
-from django.core.exceptions import ObjectDoesNotExist, ValidationError
-from django.db import IntegrityError
+import json

 # Django imports
 from django.urls import resolve
+from django.conf import settings
 from django.utils import timezone
-from django_filters.rest_framework import DjangoFilterBackend
+from django.db import IntegrityError
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.core.serializers.json import DjangoJSONEncoder

 # Third part imports
 from rest_framework import status
+from rest_framework import status
+from rest_framework.viewsets import ModelViewSet
+from rest_framework.response import Response
 from rest_framework.exceptions import APIException
+from rest_framework.views import APIView
 from rest_framework.filters import SearchFilter
 from rest_framework.permissions import IsAuthenticated
-from rest_framework.response import Response
-from rest_framework.views import APIView
-from rest_framework.viewsets import ModelViewSet
+from sentry_sdk import capture_exception
+from django_filters.rest_framework import DjangoFilterBackend

 # Module imports
-from plane.bgtasks.webhook_task import send_webhook
-from plane.utils.exception_logger import log_exception
 from plane.utils.paginator import BasePaginator
+from plane.bgtasks.webhook_task import send_webhook


 class TimezoneMixin:
@@ -61,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
@@ -87,7 +89,7 @@ class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
        try:
            return self.model.objects.all()
        except Exception as e:
-            log_exception(e)
+            capture_exception(e)
            raise APIException(
                "Please check the view", status.HTTP_400_BAD_REQUEST
            )
@@ -116,18 +118,18 @@ class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):

            if isinstance(e, ObjectDoesNotExist):
                return Response(
-                    {"error": "The required object does not exist."},
+                    {"error": f"The required object does not exist."},
                    status=status.HTTP_404_NOT_FOUND,
                )

            if isinstance(e, KeyError):
-                log_exception(e)
+                capture_exception(e)
                return Response(
-                    {"error": "The required key does not exist."},
+                    {"error": f"The required key does not exist."},
                    status=status.HTTP_400_BAD_REQUEST,
                )

-            log_exception(e)
+            capture_exception(e)
            return Response(
                {"error": "Something went wrong please try again later"},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -223,17 +225,19 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):

            if isinstance(e, ObjectDoesNotExist):
                return Response(
-                    {"error": "The required object does not exist."},
+                    {"error": f"The required object does not exist."},
                    status=status.HTTP_404_NOT_FOUND,
                )

            if isinstance(e, KeyError):
                return Response(
-                    {"error": "The required key does not exist."},
+                    {"error": f"The required key does not exist."},
                    status=status.HTTP_400_BAD_REQUEST,
                )

-            log_exception(e)
+            if settings.DEBUG:
+                print(e)
+            capture_exception(e)
            return Response(
                {"error": "Something went wrong please try again later"},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -2,6 +2,7 @@
 import os

 # Django imports
+from django.conf import settings

 # Third party imports
 from rest_framework.permissions import AllowAny
@@ -11,14 +12,13 @@ from rest_framework.response import Response
 # Module imports
 from .base import BaseAPIView
 from plane.license.utils.instance_value import get_configuration_value
-from plane.utils.cache import cache_response
+

 class ConfigurationEndpoint(BaseAPIView):
    permission_classes = [
        AllowAny,
    ]

-    @cache_response(60 * 60 * 2, user=False)
    def get(self, request):
        # Get all the configuration
        (
@@ -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",
@@ -136,7 +136,6 @@ class MobileConfigurationEndpoint(BaseAPIView):
        AllowAny,
    ]

-    @cache_response(60 * 60 * 2, user=False)
    def get(self, request):
        (
            GOOGLE_CLIENT_ID,
@@ -182,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",
@@ -1,409 +0,0 @@
-# Django imports
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models import (
-    Case,
-    CharField,
-    Count,
-    Exists,
-    F,
-    Func,
-    OuterRef,
-    Prefetch,
-    Q,
-    UUIDField,
-    Value,
-    When,
-)
-from django.db.models.functions import Coalesce
-from django.utils import timezone
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from plane.app.permissions import ProjectEntityPermission
-from plane.db.models import (
-    Cycle,
-    CycleFavorite,
-    Issue,
-    Label,
-    User,
-)
-from plane.utils.analytics_plot import burndown_plot
-
-# Module imports
-from .. import BaseAPIView
-
-
-class CycleArchiveUnarchiveEndpoint(BaseAPIView):
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        favorite_subquery = CycleFavorite.objects.filter(
-            user=self.request.user,
-            cycle_id=OuterRef("pk"),
-            project_id=self.kwargs.get("project_id"),
-            workspace__slug=self.kwargs.get("slug"),
-        )
-        return (
-            Cycle.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(archived_at__isnull=False)
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-            )
-            .filter(project__archived_at__isnull=True)
-            .select_related("project", "workspace", "owned_by")
-            .prefetch_related(
-                Prefetch(
-                    "issue_cycle__issue__assignees",
-                    queryset=User.objects.only(
-                        "avatar", "first_name", "id"
-                    ).distinct(),
-                )
-            )
-            .prefetch_related(
-                Prefetch(
-                    "issue_cycle__issue__labels",
-                    queryset=Label.objects.only(
-                        "name", "color", "id"
-                    ).distinct(),
-                )
-            )
-            .annotate(is_favorite=Exists(favorite_subquery))
-            .annotate(
-                total_issues=Count(
-                    "issue_cycle__issue__id",
-                    distinct=True,
-                    filter=Q(
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                completed_issues=Count(
-                    "issue_cycle__issue__id",
-                    distinct=True,
-                    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__id",
-                    distinct=True,
-                    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__id",
-                    distinct=True,
-                    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__id",
-                    distinct=True,
-                    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__id",
-                    distinct=True,
-                    filter=Q(
-                        issue_cycle__issue__state__group="backlog",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                status=Case(
-                    When(
-                        Q(start_date__lte=timezone.now())
-                        & Q(end_date__gte=timezone.now()),
-                        then=Value("CURRENT"),
-                    ),
-                    When(
-                        start_date__gt=timezone.now(), then=Value("UPCOMING")
-                    ),
-                    When(end_date__lt=timezone.now(), then=Value("COMPLETED")),
-                    When(
-                        Q(start_date__isnull=True) & Q(end_date__isnull=True),
-                        then=Value("DRAFT"),
-                    ),
-                    default=Value("DRAFT"),
-                    output_field=CharField(),
-                )
-            )
-            .annotate(
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "issue_cycle__issue__assignees__id",
-                        distinct=True,
-                        filter=~Q(
-                            issue_cycle__issue__assignees__id__isnull=True
-                        ),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                )
-            )
-            .order_by("-is_favorite", "name")
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id, pk=None):
-        if pk is None:
-            queryset = (
-                self.get_queryset()
-                .annotate(
-                    total_issues=Count(
-                        "issue_cycle",
-                        filter=Q(
-                            issue_cycle__issue__archived_at__isnull=True,
-                            issue_cycle__issue__is_draft=False,
-                        ),
-                    )
-                )
-                .values(
-                    # 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
-                    "total_issues",
-                    "is_favorite",
-                    "cancelled_issues",
-                    "completed_issues",
-                    "started_issues",
-                    "unstarted_issues",
-                    "backlog_issues",
-                    "assignee_ids",
-                    "status",
-                    "archived_at",
-                )
-            ).order_by("-is_favorite", "-created_at")
-            return Response(queryset, status=status.HTTP_200_OK)
-        else:
-            queryset = (
-                self.get_queryset()
-                .filter(archived_at__isnull=False)
-                .filter(pk=pk)
-            )
-            data = (
-                self.get_queryset()
-                .filter(pk=pk)
-                .annotate(
-                    sub_issues=Issue.issue_objects.filter(
-                        project_id=self.kwargs.get("project_id"),
-                        parent__isnull=False,
-                        issue_cycle__cycle_id=pk,
-                    )
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .values(
-                    # 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",
-                    "sub_issues",
-                    # meta fields
-                    "is_favorite",
-                    "total_issues",
-                    "cancelled_issues",
-                    "completed_issues",
-                    "started_issues",
-                    "unstarted_issues",
-                    "backlog_issues",
-                    "assignee_ids",
-                    "status",
-                )
-                .first()
-            )
-            queryset = queryset.first()
-
-            if data is None:
-                return Response(
-                    {"error": "Cycle does not exist"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            # Assignee Distribution
-            assignee_distribution = (
-                Issue.objects.filter(
-                    issue_cycle__cycle_id=pk,
-                    workspace__slug=slug,
-                    project_id=project_id,
-                )
-                .annotate(first_name=F("assignees__first_name"))
-                .annotate(last_name=F("assignees__last_name"))
-                .annotate(assignee_id=F("assignees__id"))
-                .annotate(avatar=F("assignees__avatar"))
-                .annotate(display_name=F("assignees__display_name"))
-                .values(
-                    "first_name",
-                    "last_name",
-                    "assignee_id",
-                    "avatar",
-                    "display_name",
-                )
-                .annotate(
-                    total_issues=Count(
-                        "id",
-                        filter=Q(archived_at__isnull=True, is_draft=False),
-                    ),
-                )
-                .annotate(
-                    completed_issues=Count(
-                        "id",
-                        filter=Q(
-                            completed_at__isnull=False,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    pending_issues=Count(
-                        "id",
-                        filter=Q(
-                            completed_at__isnull=True,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .order_by("first_name", "last_name")
-            )
-
-            # Label Distribution
-            label_distribution = (
-                Issue.objects.filter(
-                    issue_cycle__cycle_id=pk,
-                    workspace__slug=slug,
-                    project_id=project_id,
-                )
-                .annotate(label_name=F("labels__name"))
-                .annotate(color=F("labels__color"))
-                .annotate(label_id=F("labels__id"))
-                .values("label_name", "color", "label_id")
-                .annotate(
-                    total_issues=Count(
-                        "id",
-                        filter=Q(archived_at__isnull=True, is_draft=False),
-                    ),
-                )
-                .annotate(
-                    completed_issues=Count(
-                        "id",
-                        filter=Q(
-                            completed_at__isnull=False,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    pending_issues=Count(
-                        "id",
-                        filter=Q(
-                            completed_at__isnull=True,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .order_by("label_name")
-            )
-
-            data["distribution"] = {
-                "assignees": assignee_distribution,
-                "labels": label_distribution,
-                "completion_chart": {},
-            }
-
-            if queryset.start_date and queryset.end_date:
-                data["distribution"]["completion_chart"] = burndown_plot(
-                    queryset=queryset,
-                    slug=slug,
-                    project_id=project_id,
-                    cycle_id=pk,
-                )
-
-            return Response(
-                data,
-                status=status.HTTP_200_OK,
-            )
-
-    def post(self, request, slug, project_id, cycle_id):
-        cycle = Cycle.objects.get(
-            pk=cycle_id, project_id=project_id, workspace__slug=slug
-        )
-
-        if cycle.end_date >= timezone.now().date():
-            return Response(
-                {"error": "Only completed cycles can be archived"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        cycle.archived_at = timezone.now()
-        cycle.save()
-        return Response(
-            {"archived_at": str(cycle.archived_at)},
-            status=status.HTTP_200_OK,
-        )
-
-    def delete(self, request, slug, project_id, cycle_id):
-        cycle = Cycle.objects.get(
-            pk=cycle_id, project_id=project_id, workspace__slug=slug
-        )
-        cycle.archived_at = None
-        cycle.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,314 +0,0 @@
-# Python imports
-import json
-
-# Django imports
-from django.db.models import (
-    Func,
-    F,
-    Q,
-    OuterRef,
-    Value,
-    UUIDField,
-)
-from django.core import serializers
-from django.utils import timezone
-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.functions import Coalesce
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-
-# Module imports
-from .. import BaseViewSet, WebhookMixin
-from plane.app.serializers import (
-    IssueSerializer,
-    CycleIssueSerializer,
-)
-from plane.app.permissions import ProjectEntityPermission
-from plane.db.models import (
-    Cycle,
-    CycleIssue,
-    Issue,
-    IssueLink,
-    IssueAttachment,
-)
-from plane.bgtasks.issue_activites_task import issue_activity
-from plane.utils.issue_filters import issue_filters
-
-
-class CycleIssueViewSet(WebhookMixin, BaseViewSet):
-    serializer_class = CycleIssueSerializer
-    model = CycleIssue
-
-    webhook_event = "cycle_issue"
-    bulk = True
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    filterset_fields = [
-        "issue__labels__id",
-        "issue__assignees__id",
-    ]
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("issue_id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .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__archived_at__isnull=True)
-            .filter(cycle_id=self.kwargs.get("cycle_id"))
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("cycle")
-            .select_related("issue", "issue__state", "issue__project")
-            .prefetch_related("issue__assignees", "issue__labels")
-            .distinct()
-        )
-
-    @method_decorator(gzip_page)
-    def list(self, request, slug, project_id, cycle_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")
-        queryset = (
-            Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
-            .filter(project_id=project_id)
-            .filter(workspace__slug=slug)
-            .filter(**filters)
-            .select_related("workspace", "project", "state", "parent")
-            .prefetch_related(
-                "assignees",
-                "labels",
-                "issue_module__module",
-                "issue_cycle__cycle",
-            )
-            .order_by(order_by)
-            .filter(**filters)
-            .annotate(cycle_id=F("issue_cycle__cycle_id"))
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=~Q(labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=~Q(assignees__id__isnull=True)
-                        & Q(assignees__member_project__is_active=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "issue_module__module_id",
-                        distinct=True,
-                        filter=~Q(issue_module__module_id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-            .order_by(order_by)
-        )
-        if self.fields:
-            issues = IssueSerializer(
-                queryset, many=True, fields=fields if fields else None
-            ).data
-        else:
-            issues = 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)
-
-    def create(self, request, slug, project_id, cycle_id):
-        issues = request.data.get("issues", [])
-
-        if not issues:
-            return Response(
-                {"error": "Issues are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        cycle = Cycle.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=cycle_id
-        )
-
-        if (
-            cycle.end_date is not None
-            and cycle.end_date < timezone.now().date()
-        ):
-            return Response(
-                {
-                    "error": "The Cycle has already been completed so no new issues can be added"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get all CycleIssues already created
-        cycle_issues = list(
-            CycleIssue.objects.filter(
-                ~Q(cycle_id=cycle_id), issue_id__in=issues
-            )
-        )
-        existing_issues = [
-            str(cycle_issue.issue_id) for cycle_issue in cycle_issues
-        ]
-        new_issues = list(set(issues) - set(existing_issues))
-
-        # New issues to create
-        created_records = CycleIssue.objects.bulk_create(
-            [
-                CycleIssue(
-                    project_id=project_id,
-                    workspace_id=cycle.workspace_id,
-                    created_by_id=request.user.id,
-                    updated_by_id=request.user.id,
-                    cycle_id=cycle_id,
-                    issue_id=issue,
-                )
-                for issue in new_issues
-            ],
-            batch_size=10,
-        )
-
-        # Updated Issues
-        updated_records = []
-        update_cycle_issue_activity = []
-        # Iterate over each cycle_issue in cycle_issues
-        for cycle_issue in cycle_issues:
-            # Update the cycle_issue's cycle_id
-            cycle_issue.cycle_id = cycle_id
-            # Add the modified cycle_issue to the records_to_update list
-            updated_records.append(cycle_issue)
-            # Record the update activity
-            update_cycle_issue_activity.append(
-                {
-                    "old_cycle_id": str(cycle_issue.cycle_id),
-                    "new_cycle_id": str(cycle_id),
-                    "issue_id": str(cycle_issue.issue_id),
-                }
-            )
-
-        # Update the cycle issues
-        CycleIssue.objects.bulk_update(
-            updated_records, ["cycle_id"], batch_size=100
-        )
-        # Capture Issue Activity
-        issue_activity.delay(
-            type="cycle.activity.created",
-            requested_data=json.dumps({"cycles_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_cycle_issues": update_cycle_issue_activity,
-                    "created_cycle_issues": serializers.serialize(
-                        "json", created_records
-                    ),
-                }
-            ),
-            epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
-
-    def destroy(self, request, slug, project_id, cycle_id, issue_id):
-        cycle_issue = CycleIssue.objects.get(
-            issue_id=issue_id,
-            workspace__slug=slug,
-            project_id=project_id,
-            cycle_id=cycle_id,
-        )
-        issue_activity.delay(
-            type="cycle.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "cycle_id": str(self.kwargs.get("cycle_id")),
-                    "issues": [str(issue_id)],
-                }
-            ),
-            actor_id=str(self.request.user.id),
-            issue_id=str(issue_id),
-            project_id=str(self.kwargs.get("project_id", None)),
-            current_instance=None,
-            epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-        cycle_issue.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,772 +0,0 @@
-# Django imports
-from django.db.models import (
-    Q,
-    Case,
-    When,
-    Value,
-    CharField,
-    Count,
-    F,
-    Exists,
-    OuterRef,
-    Subquery,
-    JSONField,
-    Func,
-    Prefetch,
-    IntegerField,
-)
-from django.contrib.postgres.aggregates import ArrayAgg
-from django.contrib.postgres.fields import ArrayField
-from django.db.models import UUIDField
-from django.db.models.functions import Coalesce
-from django.utils import timezone
-
-# Third Party imports
-from rest_framework.response import Response
-from rest_framework import status
-
-# Module imports
-from .. import BaseAPIView
-from plane.db.models import (
-    Issue,
-    IssueActivity,
-    ProjectMember,
-    Widget,
-    DashboardWidget,
-    Dashboard,
-    Project,
-    IssueLink,
-    IssueAttachment,
-    IssueRelation,
-    User,
-)
-from plane.app.serializers import (
-    IssueActivitySerializer,
-    IssueSerializer,
-    DashboardSerializer,
-    WidgetSerializer,
-)
-from plane.utils.issue_filters import issue_filters
-
-
-def dashboard_overview_stats(self, request, slug):
-    assigned_issues = Issue.issue_objects.filter(
-        project__project_projectmember__is_active=True,
-        project__project_projectmember__member=request.user,
-        workspace__slug=slug,
-        assignees__in=[request.user],
-    ).count()
-
-    pending_issues_count = Issue.issue_objects.filter(
-        ~Q(state__group__in=["completed", "cancelled"]),
-        target_date__lt=timezone.now().date(),
-        project__project_projectmember__is_active=True,
-        project__project_projectmember__member=request.user,
-        workspace__slug=slug,
-        assignees__in=[request.user],
-    ).count()
-
-    created_issues_count = Issue.issue_objects.filter(
-        workspace__slug=slug,
-        project__project_projectmember__is_active=True,
-        project__project_projectmember__member=request.user,
-        created_by_id=request.user.id,
-    ).count()
-
-    completed_issues_count = Issue.issue_objects.filter(
-        workspace__slug=slug,
-        project__project_projectmember__is_active=True,
-        project__project_projectmember__member=request.user,
-        assignees__in=[request.user],
-        state__group="completed",
-    ).count()
-
-    return Response(
-        {
-            "assigned_issues_count": assigned_issues,
-            "pending_issues_count": pending_issues_count,
-            "completed_issues_count": completed_issues_count,
-            "created_issues_count": created_issues_count,
-        },
-        status=status.HTTP_200_OK,
-    )
-
-
-def dashboard_assigned_issues(self, request, slug):
-    filters = issue_filters(request.query_params, "GET")
-    issue_type = request.GET.get("issue_type", None)
-
-    # get all the assigned issues
-    assigned_issues = (
-        Issue.issue_objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True,
-            assignees__in=[request.user],
-        )
-        .filter(**filters)
-        .select_related("workspace", "project", "state", "parent")
-        .prefetch_related("assignees", "labels", "issue_module__module")
-        .prefetch_related(
-            Prefetch(
-                "issue_relation",
-                queryset=IssueRelation.objects.select_related(
-                    "related_issue"
-                ).select_related("issue"),
-            )
-        )
-        .annotate(cycle_id=F("issue_cycle__cycle_id"))
-        .annotate(
-            link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-            .order_by()
-            .annotate(count=Func(F("id"), function="Count"))
-            .values("count")
-        )
-        .annotate(
-            attachment_count=IssueAttachment.objects.filter(
-                issue=OuterRef("id")
-            )
-            .order_by()
-            .annotate(count=Func(F("id"), function="Count"))
-            .values("count")
-        )
-        .annotate(
-            sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-            .order_by()
-            .annotate(count=Func(F("id"), function="Count"))
-            .values("count")
-        )
-        .annotate(
-            label_ids=Coalesce(
-                ArrayAgg(
-                    "labels__id",
-                    distinct=True,
-                    filter=~Q(labels__id__isnull=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            assignee_ids=Coalesce(
-                ArrayAgg(
-                    "assignees__id",
-                    distinct=True,
-                    filter=~Q(assignees__id__isnull=True)
-                    & Q(assignees__member_project__is_active=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            module_ids=Coalesce(
-                ArrayAgg(
-                    "issue_module__module_id",
-                    distinct=True,
-                    filter=~Q(issue_module__module_id__isnull=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-        )
-    )
-
-    # Priority Ordering
-    priority_order = ["urgent", "high", "medium", "low", "none"]
-    assigned_issues = assigned_issues.annotate(
-        priority_order=Case(
-            *[
-                When(priority=p, then=Value(i))
-                for i, p in enumerate(priority_order)
-            ],
-            output_field=CharField(),
-        )
-    ).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"]
-        ).count()
-        completed_issues = assigned_issues.filter(
-            state__group__in=["completed"]
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(
-                    completed_issues, many=True, expand=self.expand
-                ).data,
-                "count": completed_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    if issue_type == "overdue":
-        overdue_issues_count = assigned_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now(),
-        ).count()
-        overdue_issues = assigned_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now(),
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(
-                    overdue_issues, many=True, expand=self.expand
-                ).data,
-                "count": overdue_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    if issue_type == "upcoming":
-        upcoming_issues_count = assigned_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now(),
-        ).count()
-        upcoming_issues = assigned_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now(),
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(
-                    upcoming_issues, many=True, expand=self.expand
-                ).data,
-                "count": upcoming_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    return Response(
-        {"error": "Please specify a valid issue type"},
-        status=status.HTTP_400_BAD_REQUEST,
-    )
-
-
-def dashboard_created_issues(self, request, slug):
-    filters = issue_filters(request.query_params, "GET")
-    issue_type = request.GET.get("issue_type", None)
-
-    # get all the assigned issues
-    created_issues = (
-        Issue.issue_objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True,
-            created_by=request.user,
-        )
-        .filter(**filters)
-        .select_related("workspace", "project", "state", "parent")
-        .prefetch_related("assignees", "labels", "issue_module__module")
-        .annotate(cycle_id=F("issue_cycle__cycle_id"))
-        .annotate(
-            link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-            .order_by()
-            .annotate(count=Func(F("id"), function="Count"))
-            .values("count")
-        )
-        .annotate(
-            attachment_count=IssueAttachment.objects.filter(
-                issue=OuterRef("id")
-            )
-            .order_by()
-            .annotate(count=Func(F("id"), function="Count"))
-            .values("count")
-        )
-        .annotate(
-            sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-            .order_by()
-            .annotate(count=Func(F("id"), function="Count"))
-            .values("count")
-        )
-        .annotate(
-            label_ids=Coalesce(
-                ArrayAgg(
-                    "labels__id",
-                    distinct=True,
-                    filter=~Q(labels__id__isnull=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            assignee_ids=Coalesce(
-                ArrayAgg(
-                    "assignees__id",
-                    distinct=True,
-                    filter=~Q(assignees__id__isnull=True)
-                    & Q(assignees__member_project__is_active=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-            module_ids=Coalesce(
-                ArrayAgg(
-                    "issue_module__module_id",
-                    distinct=True,
-                    filter=~Q(issue_module__module_id__isnull=True),
-                ),
-                Value([], output_field=ArrayField(UUIDField())),
-            ),
-        )
-        .order_by("created_at")
-    )
-
-    # Priority Ordering
-    priority_order = ["urgent", "high", "medium", "low", "none"]
-    created_issues = created_issues.annotate(
-        priority_order=Case(
-            *[
-                When(priority=p, then=Value(i))
-                for i, p in enumerate(priority_order)
-            ],
-            output_field=CharField(),
-        )
-    ).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"]
-        ).count()
-        completed_issues = created_issues.filter(
-            state__group__in=["completed"]
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(completed_issues, many=True).data,
-                "count": completed_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    if issue_type == "overdue":
-        overdue_issues_count = created_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now(),
-        ).count()
-        overdue_issues = created_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__lt=timezone.now(),
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(overdue_issues, many=True).data,
-                "count": overdue_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    if issue_type == "upcoming":
-        upcoming_issues_count = created_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now(),
-        ).count()
-        upcoming_issues = created_issues.filter(
-            state__group__in=["backlog", "unstarted", "started"],
-            target_date__gte=timezone.now(),
-        )[:5]
-        return Response(
-            {
-                "issues": IssueSerializer(upcoming_issues, many=True).data,
-                "count": upcoming_issues_count,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    return Response(
-        {"error": "Please specify a valid issue type"},
-        status=status.HTTP_400_BAD_REQUEST,
-    )
-
-
-def dashboard_issues_by_state_groups(self, request, slug):
-    filters = issue_filters(request.query_params, "GET")
-    state_order = ["backlog", "unstarted", "started", "completed", "cancelled"]
-    issues_by_state_groups = (
-        Issue.issue_objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__is_active=True,
-            project__project_projectmember__member=request.user,
-            assignees__in=[request.user],
-        )
-        .filter(**filters)
-        .values("state__group")
-        .annotate(count=Count("id"))
-    )
-
-    # default state
-    all_groups = {state: 0 for state in state_order}
-
-    # Update counts for existing groups
-    for entry in issues_by_state_groups:
-        all_groups[entry["state__group"]] = entry["count"]
-
-    # Prepare output including all groups with their counts
-    output_data = [
-        {"state": group, "count": count} for group, count in all_groups.items()
-    ]
-
-    return Response(output_data, status=status.HTTP_200_OK)
-
-
-def dashboard_issues_by_priority(self, request, slug):
-    filters = issue_filters(request.query_params, "GET")
-    priority_order = ["urgent", "high", "medium", "low", "none"]
-
-    issues_by_priority = (
-        Issue.issue_objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__is_active=True,
-            project__project_projectmember__member=request.user,
-            assignees__in=[request.user],
-        )
-        .filter(**filters)
-        .values("priority")
-        .annotate(count=Count("id"))
-    )
-
-    # default priority
-    all_groups = {priority: 0 for priority in priority_order}
-
-    # Update counts for existing groups
-    for entry in issues_by_priority:
-        all_groups[entry["priority"]] = entry["count"]
-
-    # Prepare output including all groups with their counts
-    output_data = [
-        {"priority": group, "count": count}
-        for group, count in all_groups.items()
-    ]
-
-    return Response(output_data, status=status.HTTP_200_OK)
-
-
-def dashboard_recent_activity(self, request, slug):
-    queryset = IssueActivity.objects.filter(
-        ~Q(field__in=["comment", "vote", "reaction", "draft"]),
-        workspace__slug=slug,
-        project__project_projectmember__member=request.user,
-        project__project_projectmember__is_active=True,
-        project__archived_at__isnull=True,
-        actor=request.user,
-    ).select_related("actor", "workspace", "issue", "project")[:8]
-
-    return Response(
-        IssueActivitySerializer(queryset, many=True).data,
-        status=status.HTTP_200_OK,
-    )
-
-
-def dashboard_recent_projects(self, request, slug):
-    project_ids = (
-        IssueActivity.objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True,
-            project__archived_at__isnull=True,
-            actor=request.user,
-        )
-        .values_list("project_id", flat=True)
-        .distinct()
-    )
-
-    # Extract project IDs from the recent projects
-    unique_project_ids = set(project_id for project_id in project_ids)
-
-    # Fetch additional projects only if needed
-    if len(unique_project_ids) < 4:
-        additional_projects = Project.objects.filter(
-            project_projectmember__member=request.user,
-            project_projectmember__is_active=True,
-            archived_at__isnull=True,
-            workspace__slug=slug,
-        ).exclude(id__in=unique_project_ids)
-
-        # Append additional project IDs to the existing list
-        unique_project_ids.update(
-            additional_projects.values_list("id", flat=True)
-        )
-
-    return Response(
-        list(unique_project_ids)[:4],
-        status=status.HTTP_200_OK,
-    )
-
-
-def dashboard_recent_collaborators(self, request, slug):
-    # Subquery to count activities for each project member
-    activity_count_subquery = (
-        IssueActivity.objects.filter(
-            workspace__slug=slug,
-            actor=OuterRef("member"),
-            project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True,
-            project__archived_at__isnull=True,
-        )
-        .values("actor")
-        .annotate(num_activities=Count("pk"))
-        .values("num_activities")
-    )
-
-    # Get all project members and annotate them with activity counts
-    project_members_with_activities = (
-        ProjectMember.objects.filter(
-            workspace__slug=slug,
-            project__project_projectmember__member=request.user,
-            project__project_projectmember__is_active=True,
-            project__archived_at__isnull=True,
-        )
-        .annotate(
-            num_activities=Coalesce(
-                Subquery(activity_count_subquery),
-                Value(0),
-                output_field=IntegerField(),
-            ),
-            is_current_user=Case(
-                When(member=request.user, then=Value(0)),
-                default=Value(1),
-                output_field=IntegerField(),
-            ),
-        )
-        .values_list("member", flat=True)
-        .order_by("is_current_user", "-num_activities")
-        .distinct()
-    )
-    search = request.query_params.get("search", None)
-    if search:
-        project_members_with_activities = (
-            project_members_with_activities.filter(
-                Q(member__display_name__icontains=search)
-                | Q(member__first_name__icontains=search)
-                | Q(member__last_name__icontains=search)
-            )
-        )
-
-    return self.paginate(
-        request=request,
-        queryset=project_members_with_activities,
-        controller=lambda qs: self.get_results_controller(qs, slug),
-    )
-
-
-class DashboardEndpoint(BaseAPIView):
-    def get_results_controller(self, project_members_with_activities, slug):
-        user_active_issue_counts = (
-            User.objects.filter(
-                id__in=project_members_with_activities,
-            )
-            .annotate(
-                active_issue_count=Count(
-                    Case(
-                        When(
-                            issue_assignee__issue__state__group__in=[
-                                "unstarted",
-                                "started",
-                            ],
-                            issue_assignee__issue__workspace__slug=slug,
-                            issue_assignee__issue__project__project_projectmember__is_active=True,
-                            then=F("issue_assignee__issue__id"),
-                        ),
-                        output_field=IntegerField(),
-                    ),
-                    distinct=True,
-                )
-            )
-            .values("active_issue_count", user_id=F("id"))
-        )
-        # Create a dictionary to store the active issue counts by user ID
-        active_issue_counts_dict = {
-            user["user_id"]: user["active_issue_count"]
-            for user in user_active_issue_counts
-        }
-
-        # Preserve the sequence of project members with activities
-        paginated_results = [
-            {
-                "user_id": member_id,
-                "active_issue_count": active_issue_counts_dict.get(
-                    member_id, 0
-                ),
-            }
-            for member_id in project_members_with_activities
-        ]
-        return paginated_results
-
-    def create(self, request, slug):
-        serializer = DashboardSerializer(data=request.data)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def patch(self, request, slug, pk):
-        serializer = DashboardSerializer(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)
-
-    def delete(self, request, slug, pk):
-        serializer = DashboardSerializer(data=request.data, partial=True)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_204_NO_CONTENT)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def get(self, request, slug, dashboard_id=None):
-        if not dashboard_id:
-            dashboard_type = request.GET.get("dashboard_type", None)
-            if dashboard_type == "home":
-                dashboard, created = Dashboard.objects.get_or_create(
-                    type_identifier=dashboard_type,
-                    owned_by=request.user,
-                    is_default=True,
-                )
-
-                if created:
-                    widgets_to_fetch = [
-                        "overview_stats",
-                        "assigned_issues",
-                        "created_issues",
-                        "issues_by_state_groups",
-                        "issues_by_priority",
-                        "recent_activity",
-                        "recent_projects",
-                        "recent_collaborators",
-                    ]
-
-                    updated_dashboard_widgets = []
-                    for widget_key in widgets_to_fetch:
-                        widget = Widget.objects.filter(
-                            key=widget_key
-                        ).values_list("id", flat=True)
-                        if widget:
-                            updated_dashboard_widgets.append(
-                                DashboardWidget(
-                                    widget_id=widget,
-                                    dashboard_id=dashboard.id,
-                                )
-                            )
-
-                    DashboardWidget.objects.bulk_create(
-                        updated_dashboard_widgets, batch_size=100
-                    )
-
-                widgets = (
-                    Widget.objects.annotate(
-                        is_visible=Exists(
-                            DashboardWidget.objects.filter(
-                                widget_id=OuterRef("pk"),
-                                dashboard_id=dashboard.id,
-                                is_visible=True,
-                            )
-                        )
-                    )
-                    .annotate(
-                        dashboard_filters=Subquery(
-                            DashboardWidget.objects.filter(
-                                widget_id=OuterRef("pk"),
-                                dashboard_id=dashboard.id,
-                                filters__isnull=False,
-                            )
-                            .exclude(filters={})
-                            .values("filters")[:1]
-                        )
-                    )
-                    .annotate(
-                        widget_filters=Case(
-                            When(
-                                dashboard_filters__isnull=False,
-                                then=F("dashboard_filters"),
-                            ),
-                            default=F("filters"),
-                            output_field=JSONField(),
-                        )
-                    )
-                )
-                return Response(
-                    {
-                        "dashboard": DashboardSerializer(dashboard).data,
-                        "widgets": WidgetSerializer(widgets, many=True).data,
-                    },
-                    status=status.HTTP_200_OK,
-                )
-            return Response(
-                {"error": "Please specify a valid dashboard type"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        widget_key = request.GET.get("widget_key", "overview_stats")
-
-        WIDGETS_MAPPER = {
-            "overview_stats": dashboard_overview_stats,
-            "assigned_issues": dashboard_assigned_issues,
-            "created_issues": dashboard_created_issues,
-            "issues_by_state_groups": dashboard_issues_by_state_groups,
-            "issues_by_priority": dashboard_issues_by_priority,
-            "recent_activity": dashboard_recent_activity,
-            "recent_projects": dashboard_recent_projects,
-            "recent_collaborators": dashboard_recent_collaborators,
-        }
-
-        func = WIDGETS_MAPPER.get(widget_key)
-        if func is not None:
-            response = func(
-                self,
-                request=request,
-                slug=slug,
-            )
-            if isinstance(response, Response):
-                return response
-
-        return Response(
-            {"error": "Please specify a valid widget key"},
-            status=status.HTTP_400_BAD_REQUEST,
-        )
-
-
-class WidgetsEndpoint(BaseAPIView):
-    def patch(self, request, dashboard_id, widget_id):
-        dashboard_widget = DashboardWidget.objects.filter(
-            widget_id=widget_id,
-            dashboard_id=dashboard_id,
-        ).first()
-        dashboard_widget.is_visible = request.data.get(
-            "is_visible", dashboard_widget.is_visible
-        )
-        dashboard_widget.sort_order = request.data.get(
-            "sort_order", dashboard_widget.sort_order
-        )
-        dashboard_widget.filters = request.data.get(
-            "filters", dashboard_widget.filters
-        )
-        dashboard_widget.save()
-        return Response(
-            {"message": "successfully updated"}, status=status.HTTP_200_OK
-        )
@@ -1,5 +0,0 @@
-# views.py
-from django.http import JsonResponse
-
-def custom_404_view(request, exception=None):
-    return JsonResponse({"error": "Page not found."}, status=404)
@@ -3,7 +3,7 @@ from rest_framework.response import Response
 from rest_framework import status

 # Module imports
-from ..base import BaseViewSet, BaseAPIView
+from .base import BaseViewSet, BaseAPIView
 from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import Project, Estimate, EstimatePoint
 from plane.app.serializers import (
@@ -11,7 +11,7 @@ from plane.app.serializers import (
    EstimatePointSerializer,
    EstimateReadSerializer,
 )
-from plane.utils.cache import invalidate_cache
+

 class ProjectEstimatePointEndpoint(BaseAPIView):
    permission_classes = [
@@ -49,7 +49,6 @@ class BulkEstimatePointEndpoint(BaseViewSet):
        serializer = EstimateReadSerializer(estimates, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

-    @invalidate_cache(path="/api/workspaces/:slug/estimates/", url_params=True, user=False)
    def create(self, request, slug, project_id):
        if not request.data.get("estimate", False):
            return Response(
@@ -115,7 +114,6 @@ class BulkEstimatePointEndpoint(BaseViewSet):
            status=status.HTTP_200_OK,
        )

-    @invalidate_cache(path="/api/workspaces/:slug/estimates/", url_params=True, user=False)
    def partial_update(self, request, slug, project_id, estimate_id):
        if not request.data.get("estimate", False):
            return Response(
@@ -184,7 +182,6 @@ class BulkEstimatePointEndpoint(BaseViewSet):
            status=status.HTTP_200_OK,
        )

-    @invalidate_cache(path="/api/workspaces/:slug/estimates/", url_params=True, user=False)
    def destroy(self, request, slug, project_id, estimate_id):
        estimate = Estimate.objects.get(
            pk=estimate_id, workspace__slug=slug, project_id=project_id
@@ -3,7 +3,7 @@ from rest_framework.response import Response
 from rest_framework import status

 # Module imports
-from .. import BaseAPIView
+from . import BaseAPIView
 from plane.app.permissions import WorkSpaceAdminPermission
 from plane.bgtasks.export_task import issue_export_task
 from plane.db.models import Project, ExporterHistory, Workspace
@@ -29,10 +29,7 @@ class ExportIssuesEndpoint(BaseAPIView):
        if provider in ["csv", "xlsx", "json"]:
            if not project_ids:
                project_ids = Project.objects.filter(
-                    workspace__slug=slug,
-                    project_projectmember__member=request.user,
-                    project_projectmember__is_active=True,
-                    archived_at__isnull=True,
+                    workspace__slug=slug
                ).values_list("id", flat=True)
                project_ids = [str(project_id) for project_id in project_ids]

@@ -53,7 +50,7 @@ class ExportIssuesEndpoint(BaseAPIView):
            )
            return Response(
                {
-                    "message": "Once the export is ready you will be able to download it"
+                    "message": f"Once the export is ready you will be able to download it"
                },
                status=status.HTTP_200_OK,
            )
@@ -8,15 +8,17 @@ from rest_framework.response import Response
 from rest_framework import status

 # Django imports
+from django.conf import settings

 # Module imports
-from ..base import BaseAPIView
+from .base import BaseAPIView
 from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import Workspace, Project
 from plane.app.serializers import (
    ProjectLiteSerializer,
    WorkspaceLiteSerializer,
 )
+from plane.utils.integrations.github import get_release_notes
 from plane.license.utils.instance_value import get_configuration_value


@@ -83,6 +85,12 @@ class GPTIntegrationEndpoint(BaseAPIView):
        )


+class ReleaseNotesEndpoint(BaseAPIView):
+    def get(self, request):
+        release_notes = get_release_notes()
+        return Response(release_notes, status=status.HTTP_200_OK)
+
+
 class UnsplashEndpoint(BaseAPIView):
    def get(self, request):
        (UNSPLASH_ACCESS_KEY,) = get_configuration_value(
@@ -0,0 +1,558 @@
+# Python imports
+import uuid
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Django imports
+from django.db.models import Max, Q
+
+# Module imports
+from plane.app.views import BaseAPIView
+from plane.db.models import (
+    WorkspaceIntegration,
+    Importer,
+    APIToken,
+    Project,
+    State,
+    IssueSequence,
+    Issue,
+    IssueActivity,
+    IssueComment,
+    IssueLink,
+    IssueLabel,
+    Workspace,
+    IssueAssignee,
+    Module,
+    ModuleLink,
+    ModuleIssue,
+    Label,
+)
+from plane.app.serializers import (
+    ImporterSerializer,
+    IssueFlatSerializer,
+    ModuleSerializer,
+)
+from plane.utils.integrations.github import get_github_repo_details
+from plane.utils.importers.jira import (
+    jira_project_issue_summary,
+    is_allowed_hostname,
+)
+from plane.bgtasks.importer_task import service_importer
+from plane.utils.html_processor import strip_tags
+from plane.app.permissions import WorkSpaceAdminPermission
+
+
+class ServiceIssueImportSummaryEndpoint(BaseAPIView):
+    def get(self, request, slug, service):
+        if service == "github":
+            owner = request.GET.get("owner", False)
+            repo = request.GET.get("repo", False)
+
+            if not owner or not repo:
+                return Response(
+                    {"error": "Owner and repo are required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            workspace_integration = WorkspaceIntegration.objects.get(
+                integration__provider="github", workspace__slug=slug
+            )
+
+            access_tokens_url = workspace_integration.metadata.get(
+                "access_tokens_url", False
+            )
+
+            if not access_tokens_url:
+                return Response(
+                    {
+                        "error": "There was an error during the installation of the GitHub app. To resolve this issue, we recommend reinstalling the GitHub app."
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            issue_count, labels, collaborators = get_github_repo_details(
+                access_tokens_url, owner, repo
+            )
+            return Response(
+                {
+                    "issue_count": issue_count,
+                    "labels": labels,
+                    "collaborators": collaborators,
+                },
+                status=status.HTTP_200_OK,
+            )
+
+        if service == "jira":
+            # Check for all the keys
+            params = {
+                "project_key": "Project key is required",
+                "api_token": "API token is required",
+                "email": "Email is required",
+                "cloud_hostname": "Cloud hostname is required",
+            }
+
+            for key, error_message in params.items():
+                if not request.GET.get(key, False):
+                    return Response(
+                        {"error": error_message},
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+
+            project_key = request.GET.get("project_key", "")
+            api_token = request.GET.get("api_token", "")
+            email = request.GET.get("email", "")
+            cloud_hostname = request.GET.get("cloud_hostname", "")
+
+            response = jira_project_issue_summary(
+                email, api_token, project_key, cloud_hostname
+            )
+            if "error" in response:
+                return Response(response, status=status.HTTP_400_BAD_REQUEST)
+            else:
+                return Response(
+                    response,
+                    status=status.HTTP_200_OK,
+                )
+        return Response(
+            {"error": "Service not supported yet"},
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
+
+class ImportServiceEndpoint(BaseAPIView):
+    permission_classes = [
+        WorkSpaceAdminPermission,
+    ]
+
+    def post(self, request, slug, service):
+        project_id = request.data.get("project_id", False)
+
+        if not project_id:
+            return Response(
+                {"error": "Project ID is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace = Workspace.objects.get(slug=slug)
+
+        if service == "github":
+            data = request.data.get("data", False)
+            metadata = request.data.get("metadata", False)
+            config = request.data.get("config", False)
+            if not data or not metadata or not config:
+                return Response(
+                    {"error": "Data, config and metadata are required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            api_token = APIToken.objects.filter(
+                user=request.user, workspace=workspace
+            ).first()
+            if api_token is None:
+                api_token = APIToken.objects.create(
+                    user=request.user,
+                    label="Importer",
+                    workspace=workspace,
+                )
+
+            importer = Importer.objects.create(
+                service=service,
+                project_id=project_id,
+                status="queued",
+                initiated_by=request.user,
+                data=data,
+                metadata=metadata,
+                token=api_token,
+                config=config,
+                created_by=request.user,
+                updated_by=request.user,
+            )
+
+            service_importer.delay(service, importer.id)
+            serializer = ImporterSerializer(importer)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+        if service == "jira":
+            data = request.data.get("data", False)
+            metadata = request.data.get("metadata", False)
+            config = request.data.get("config", False)
+
+            cloud_hostname = metadata.get("cloud_hostname", False)
+
+            if not cloud_hostname:
+                return Response(
+                    {"error": "Cloud hostname is required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if not is_allowed_hostname(cloud_hostname):
+                return Response(
+                    {"error": "Hostname is not a valid hostname."},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if not data or not metadata:
+                return Response(
+                    {"error": "Data, config and metadata are required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+            api_token = APIToken.objects.filter(
+                user=request.user, workspace=workspace
+            ).first()
+            if api_token is None:
+                api_token = APIToken.objects.create(
+                    user=request.user,
+                    label="Importer",
+                    workspace=workspace,
+                )
+
+            importer = Importer.objects.create(
+                service=service,
+                project_id=project_id,
+                status="queued",
+                initiated_by=request.user,
+                data=data,
+                metadata=metadata,
+                token=api_token,
+                config=config,
+                created_by=request.user,
+                updated_by=request.user,
+            )
+
+            service_importer.delay(service, importer.id)
+            serializer = ImporterSerializer(importer)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+        return Response(
+            {"error": "Servivce not supported yet"},
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
+    def get(self, request, slug):
+        imports = (
+            Importer.objects.filter(workspace__slug=slug)
+            .order_by("-created_at")
+            .select_related("initiated_by", "project", "workspace")
+        )
+        serializer = ImporterSerializer(imports, many=True)
+        return Response(serializer.data)
+
+    def delete(self, request, slug, service, pk):
+        importer = Importer.objects.get(
+            pk=pk, service=service, workspace__slug=slug
+        )
+
+        if importer.imported_data is not None:
+            # Delete all imported Issues
+            imported_issues = importer.imported_data.get("issues", [])
+            Issue.issue_objects.filter(id__in=imported_issues).delete()
+
+            # Delete all imported Labels
+            imported_labels = importer.imported_data.get("labels", [])
+            Label.objects.filter(id__in=imported_labels).delete()
+
+            if importer.service == "jira":
+                imported_modules = importer.imported_data.get("modules", [])
+                Module.objects.filter(id__in=imported_modules).delete()
+        importer.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def patch(self, request, slug, service, pk):
+        importer = Importer.objects.get(
+            pk=pk, service=service, workspace__slug=slug
+        )
+        serializer = ImporterSerializer(
+            importer, 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)
+
+
+class UpdateServiceImportStatusEndpoint(BaseAPIView):
+    def post(self, request, slug, project_id, service, importer_id):
+        importer = Importer.objects.get(
+            pk=importer_id,
+            workspace__slug=slug,
+            project_id=project_id,
+            service=service,
+        )
+        importer.status = request.data.get("status", "processing")
+        importer.save()
+        return Response(status.HTTP_200_OK)
+
+
+class BulkImportIssuesEndpoint(BaseAPIView):
+    def post(self, request, slug, project_id, service):
+        # Get the project
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+
+        # Get the default state
+        default_state = State.objects.filter(
+            ~Q(name="Triage"), project_id=project_id, default=True
+        ).first()
+        # if there is no default state assign any random state
+        if default_state is None:
+            default_state = State.objects.filter(
+                ~Q(name="Triage"), project_id=project_id
+            ).first()
+
+        # Get the maximum sequence_id
+        last_id = IssueSequence.objects.filter(
+            project_id=project_id
+        ).aggregate(largest=Max("sequence"))["largest"]
+
+        last_id = 1 if last_id is None else last_id + 1
+
+        # Get the maximum sort order
+        largest_sort_order = Issue.objects.filter(
+            project_id=project_id, state=default_state
+        ).aggregate(largest=Max("sort_order"))["largest"]
+
+        largest_sort_order = (
+            65535 if largest_sort_order is None else largest_sort_order + 10000
+        )
+
+        # Get the issues_data
+        issues_data = request.data.get("issues_data", [])
+
+        if not len(issues_data):
+            return Response(
+                {"error": "Issue data is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Issues
+        bulk_issues = []
+        for issue_data in issues_data:
+            bulk_issues.append(
+                Issue(
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    state_id=issue_data.get("state")
+                    if issue_data.get("state", False)
+                    else default_state.id,
+                    name=issue_data.get("name", "Issue Created through Bulk"),
+                    description_html=issue_data.get(
+                        "description_html", "<p></p>"
+                    ),
+                    description_stripped=(
+                        None
+                        if (
+                            issue_data.get("description_html") == ""
+                            or issue_data.get("description_html") is None
+                        )
+                        else strip_tags(issue_data.get("description_html"))
+                    ),
+                    sequence_id=last_id,
+                    sort_order=largest_sort_order,
+                    start_date=issue_data.get("start_date", None),
+                    target_date=issue_data.get("target_date", None),
+                    priority=issue_data.get("priority", "none"),
+                    created_by=request.user,
+                )
+            )
+
+            largest_sort_order = largest_sort_order + 10000
+            last_id = last_id + 1
+
+        issues = Issue.objects.bulk_create(
+            bulk_issues,
+            batch_size=100,
+            ignore_conflicts=True,
+        )
+
+        # Sequences
+        _ = IssueSequence.objects.bulk_create(
+            [
+                IssueSequence(
+                    issue=issue,
+                    sequence=issue.sequence_id,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                )
+                for issue in issues
+            ],
+            batch_size=100,
+        )
+
+        # Attach Labels
+        bulk_issue_labels = []
+        for issue, issue_data in zip(issues, issues_data):
+            labels_list = issue_data.get("labels_list", [])
+            bulk_issue_labels = bulk_issue_labels + [
+                IssueLabel(
+                    issue=issue,
+                    label_id=label_id,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                )
+                for label_id in labels_list
+            ]
+
+        _ = IssueLabel.objects.bulk_create(
+            bulk_issue_labels, batch_size=100, ignore_conflicts=True
+        )
+
+        # Attach Assignees
+        bulk_issue_assignees = []
+        for issue, issue_data in zip(issues, issues_data):
+            assignees_list = issue_data.get("assignees_list", [])
+            bulk_issue_assignees = bulk_issue_assignees + [
+                IssueAssignee(
+                    issue=issue,
+                    assignee_id=assignee_id,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                )
+                for assignee_id in assignees_list
+            ]
+
+        _ = IssueAssignee.objects.bulk_create(
+            bulk_issue_assignees, batch_size=100, ignore_conflicts=True
+        )
+
+        # Track the issue activities
+        IssueActivity.objects.bulk_create(
+            [
+                IssueActivity(
+                    issue=issue,
+                    actor=request.user,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    comment=f"imported the issue from {service}",
+                    verb="created",
+                    created_by=request.user,
+                )
+                for issue in issues
+            ],
+            batch_size=100,
+        )
+
+        # Create Comments
+        bulk_issue_comments = []
+        for issue, issue_data in zip(issues, issues_data):
+            comments_list = issue_data.get("comments_list", [])
+            bulk_issue_comments = bulk_issue_comments + [
+                IssueComment(
+                    issue=issue,
+                    comment_html=comment.get("comment_html", "<p></p>"),
+                    actor=request.user,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                )
+                for comment in comments_list
+            ]
+
+        _ = IssueComment.objects.bulk_create(
+            bulk_issue_comments, batch_size=100
+        )
+
+        # Attach Links
+        _ = IssueLink.objects.bulk_create(
+            [
+                IssueLink(
+                    issue=issue,
+                    url=issue_data.get("link", {}).get(
+                        "url", "https://github.com"
+                    ),
+                    title=issue_data.get("link", {}).get(
+                        "title", "Original Issue"
+                    ),
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                )
+                for issue, issue_data in zip(issues, issues_data)
+            ]
+        )
+
+        return Response(
+            {"issues": IssueFlatSerializer(issues, many=True).data},
+            status=status.HTTP_201_CREATED,
+        )
+
+
+class BulkImportModulesEndpoint(BaseAPIView):
+    def post(self, request, slug, project_id, service):
+        modules_data = request.data.get("modules_data", [])
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+
+        modules = Module.objects.bulk_create(
+            [
+                Module(
+                    name=module.get("name", uuid.uuid4().hex),
+                    description=module.get("description", ""),
+                    start_date=module.get("start_date", None),
+                    target_date=module.get("target_date", None),
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                )
+                for module in modules_data
+            ],
+            batch_size=100,
+            ignore_conflicts=True,
+        )
+
+        modules = Module.objects.filter(
+            id__in=[module.id for module in modules]
+        )
+
+        if len(modules) == len(modules_data):
+            _ = ModuleLink.objects.bulk_create(
+                [
+                    ModuleLink(
+                        module=module,
+                        url=module_data.get("link", {}).get(
+                            "url", "https://plane.so"
+                        ),
+                        title=module_data.get("link", {}).get(
+                            "title", "Original Issue"
+                        ),
+                        project_id=project_id,
+                        workspace_id=project.workspace_id,
+                        created_by=request.user,
+                    )
+                    for module, module_data in zip(modules, modules_data)
+                ],
+                batch_size=100,
+                ignore_conflicts=True,
+            )
+
+            bulk_module_issues = []
+            for module, module_data in zip(modules, modules_data):
+                module_issues_list = module_data.get("module_issues_list", [])
+                bulk_module_issues = bulk_module_issues + [
+                    ModuleIssue(
+                        issue_id=issue,
+                        module=module,
+                        project_id=project_id,
+                        workspace_id=project.workspace_id,
+                        created_by=request.user,
+                    )
+                    for issue in module_issues_list
+                ]
+
+            _ = ModuleIssue.objects.bulk_create(
+                bulk_module_issues, batch_size=100, ignore_conflicts=True
+            )
+
+            serializer = ModuleSerializer(modules, many=True)
+            return Response(
+                {"modules": serializer.data}, status=status.HTTP_201_CREATED
+            )
+
+        else:
+            return Response(
+                {
+                    "message": "Modules created but issues could not be imported"
+                },
+                status=status.HTTP_200_OK,
+            )
@@ -0,0 +1,379 @@
+# Python imports
+import json
+
+# Django import
+from django.utils import timezone
+from django.db.models import Q, Count, OuterRef, Func, F, Prefetch
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from .base import BaseViewSet
+from plane.app.permissions import ProjectBasePermission, ProjectLitePermission
+from plane.db.models import (
+    Inbox,
+    InboxIssue,
+    Issue,
+    State,
+    IssueLink,
+    IssueAttachment,
+    ProjectMember,
+)
+from plane.app.serializers import (
+    IssueSerializer,
+    InboxSerializer,
+    InboxIssueSerializer,
+    IssueCreateSerializer,
+    IssueStateInboxSerializer,
+)
+from plane.utils.issue_filters import issue_filters
+from plane.bgtasks.issue_activites_task import issue_activity
+
+
+class InboxViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    serializer_class = InboxSerializer
+    model = Inbox
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(
+                workspace__slug=self.kwargs.get("slug"),
+                project_id=self.kwargs.get("project_id"),
+            )
+            .annotate(
+                pending_issue_count=Count(
+                    "issue_inbox",
+                    filter=Q(issue_inbox__status=-2),
+                )
+            )
+            .select_related("workspace", "project")
+        )
+
+    def perform_create(self, serializer):
+        serializer.save(project_id=self.kwargs.get("project_id"))
+
+    def destroy(self, request, slug, project_id, pk):
+        inbox = Inbox.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
+        # Handle default inbox delete
+        if inbox.is_default:
+            return Response(
+                {"error": "You cannot delete the default inbox"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        inbox.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class InboxIssueViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectLitePermission,
+    ]
+
+    serializer_class = InboxIssueSerializer
+    model = InboxIssue
+
+    filterset_fields = [
+        "status",
+    ]
+
+    def get_queryset(self):
+        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"),
+                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")
+            .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(
+                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")
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_inbox",
+                    queryset=InboxIssue.objects.only(
+                        "status", "duplicate_to", "snoozed_till", "source"
+                    ),
+                )
+            )
+        )
+        issues_data = IssueStateInboxSerializer(issues, many=True).data
+        return Response(
+            issues_data,
+            status=status.HTTP_200_OK,
+        )
+
+    def create(self, request, slug, project_id, inbox_id):
+        if not request.data.get("issue", {}).get("name", False):
+            return Response(
+                {"error": "Name is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check for valid priority
+        if not request.data.get("issue", {}).get("priority", "none") in [
+            "low",
+            "medium",
+            "high",
+            "urgent",
+            "none",
+        ]:
+            return Response(
+                {"error": "Invalid priority"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Create or get state
+        state, _ = State.objects.get_or_create(
+            name="Triage",
+            group="backlog",
+            description="Default state for managing all Inbox Issues",
+            project_id=project_id,
+            color="#ff7700",
+        )
+
+        # create an issue
+        issue = Issue.objects.create(
+            name=request.data.get("issue", {}).get("name"),
+            description=request.data.get("issue", {}).get("description", {}),
+            description_html=request.data.get("issue", {}).get(
+                "description_html", "<p></p>"
+            ),
+            priority=request.data.get("issue", {}).get("priority", "low"),
+            project_id=project_id,
+            state=state,
+        )
+
+        # Create an Issue Activity
+        issue_activity.delay(
+            type="issue.activity.created",
+            requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+            actor_id=str(request.user.id),
+            issue_id=str(issue.id),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+        )
+        # create an inbox issue
+        InboxIssue.objects.create(
+            inbox_id=inbox_id,
+            project_id=project_id,
+            issue=issue,
+            source=request.data.get("source", "in-app"),
+        )
+
+        serializer = IssueStateInboxSerializer(issue)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def partial_update(self, request, slug, project_id, inbox_id, issue_id):
+        inbox_issue = InboxIssue.objects.get(
+            issue_id=issue_id,
+            workspace__slug=slug,
+            project_id=project_id,
+            inbox_id=inbox_id,
+        )
+        # Get the project member
+        project_member = ProjectMember.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            member=request.user,
+            is_active=True,
+        )
+        # Only project members admins and created_by users can access this endpoint
+        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
+            request.user.id
+        ):
+            return Response(
+                {"error": "You cannot edit inbox issues"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get issue data
+        issue_data = request.data.pop("issue", False)
+
+        if bool(issue_data):
+            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
+                issue_data = {
+                    "name": issue_data.get("name", issue.name),
+                    "description_html": issue_data.get(
+                        "description_html", issue.description_html
+                    ),
+                    "description": issue_data.get(
+                        "description", issue.description
+                    ),
+                }
+
+            issue_serializer = IssueCreateSerializer(
+                issue, data=issue_data, partial=True
+            )
+
+            if issue_serializer.is_valid():
+                current_instance = issue
+                # Log all the updates
+                requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
+                if issue is not None:
+                    issue_activity.delay(
+                        type="issue.activity.updated",
+                        requested_data=requested_data,
+                        actor_id=str(request.user.id),
+                        issue_id=str(issue.id),
+                        project_id=str(project_id),
+                        current_instance=json.dumps(
+                            IssueSerializer(current_instance).data,
+                            cls=DjangoJSONEncoder,
+                        ),
+                        epoch=int(timezone.now().timestamp()),
+                    )
+                issue_serializer.save()
+            else:
+                return Response(
+                    issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
+                )
+
+        # Only project admins and members can edit inbox issue attributes
+        if project_member.role > 10:
+            serializer = InboxIssueSerializer(
+                inbox_issue, data=request.data, partial=True
+            )
+
+            if serializer.is_valid():
+                serializer.save()
+                # Update the issue state if the issue is rejected or marked as duplicate
+                if serializer.data["status"] in [-1, 2]:
+                    issue = Issue.objects.get(
+                        pk=inbox_issue.issue_id,
+                        workspace__slug=slug,
+                        project_id=project_id,
+                    )
+                    state = State.objects.filter(
+                        group="cancelled",
+                        workspace__slug=slug,
+                        project_id=project_id,
+                    ).first()
+                    if state is not None:
+                        issue.state = state
+                        issue.save()
+
+                # Update the issue state if it is accepted
+                if serializer.data["status"] in [1]:
+                    issue = Issue.objects.get(
+                        pk=inbox_issue.issue_id,
+                        workspace__slug=slug,
+                        project_id=project_id,
+                    )
+
+                    # Update the issue state only if it is in triage state
+                    if issue.state.name == "Triage":
+                        # Move to default state
+                        state = State.objects.filter(
+                            workspace__slug=slug,
+                            project_id=project_id,
+                            default=True,
+                        ).first()
+                        if state is not None:
+                            issue.state = state
+                            issue.save()
+
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(
+                serializer.errors, status=status.HTTP_400_BAD_REQUEST
+            )
+        else:
+            return Response(
+                InboxIssueSerializer(inbox_issue).data,
+                status=status.HTTP_200_OK,
+            )
+
+    def retrieve(self, request, slug, project_id, inbox_id, issue_id):
+        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):
+        inbox_issue = InboxIssue.objects.get(
+            issue_id=issue_id,
+            workspace__slug=slug,
+            project_id=project_id,
+            inbox_id=inbox_id,
+        )
+        # Get the project member
+        project_member = ProjectMember.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            member=request.user,
+            is_active=True,
+        )
+
+        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
+            request.user.id
+        ):
+            return Response(
+                {"error": "You cannot delete inbox issue"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check the issue status
+        if inbox_issue.status in [-2, -1, 0, 2]:
+            # Delete the issue also
+            Issue.objects.filter(
+                workspace__slug=slug, project_id=project_id, pk=issue_id
+            ).delete()
+
+        inbox_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,566 +0,0 @@
-# Python imports
-import json
-
-# Django import
-from django.utils import timezone
-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
-from rest_framework.response import Response
-
-# Module imports
-from ..base import BaseViewSet
-from plane.app.permissions import ProjectBasePermission, ProjectLitePermission
-from plane.db.models import (
-    Inbox,
-    InboxIssue,
-    Issue,
-    State,
-    IssueLink,
-    IssueAttachment,
-    Project,
-    ProjectMember,
-)
-from plane.app.serializers import (
-    IssueCreateSerializer,
-    IssueSerializer,
-    InboxSerializer,
-    InboxIssueSerializer,
-    InboxIssueDetailSerializer,
-)
-from plane.utils.issue_filters import issue_filters
-from plane.bgtasks.issue_activites_task import issue_activity
-
-
-class InboxViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectBasePermission,
-    ]
-
-    serializer_class = InboxSerializer
-    model = Inbox
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .filter(
-                workspace__slug=self.kwargs.get("slug"),
-                project_id=self.kwargs.get("project_id"),
-            )
-            .annotate(
-                pending_issue_count=Count(
-                    "issue_inbox",
-                    filter=Q(issue_inbox__status=-2),
-                )
-            )
-            .select_related("workspace", "project")
-        )
-
-    def list(self, request, slug, project_id):
-        inbox = self.get_queryset().first()
-        return Response(
-            InboxSerializer(inbox).data,
-            status=status.HTTP_200_OK,
-        )
-
-    def perform_create(self, serializer):
-        serializer.save(project_id=self.kwargs.get("project_id"))
-
-    def destroy(self, request, slug, project_id, pk):
-        inbox = Inbox.objects.filter(
-            workspace__slug=slug, project_id=project_id, pk=pk
-        ).first()
-        # Handle default inbox delete
-        if inbox.is_default:
-            return Response(
-                {"error": "You cannot delete the default inbox"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        inbox.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class InboxIssueViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectLitePermission,
-    ]
-
-    serializer_class = InboxIssueSerializer
-    model = InboxIssue
-
-    filterset_fields = [
-        "status",
-    ]
-
-    def get_queryset(self):
-        return (
-            Issue.objects.filter(
-                project_id=self.kwargs.get("project_id"),
-                workspace__slug=self.kwargs.get("slug"),
-            )
-            .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"
-                    ),
-                )
-            )
-            .annotate(cycle_id=F("issue_cycle__cycle_id"))
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=~Q(labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=~Q(assignees__id__isnull=True)
-                        & Q(assignees__member_project__is_active=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "issue_module__module_id",
-                        distinct=True,
-                        filter=~Q(issue_module__module_id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-        ).distinct()
-
-    def list(self, request, slug, project_id):
-        inbox_id = Inbox.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-        filters = issue_filters(request.GET, "GET", "issue__")
-        inbox_issue = (
-            InboxIssue.objects.filter(
-                inbox_id=inbox_id.id, project_id=project_id, **filters
-            )
-            .select_related("issue")
-            .prefetch_related(
-                "issue__labels",
-            )
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "issue__labels__id",
-                        distinct=True,
-                        filter=~Q(issue__labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                )
-            )
-        ).order_by(request.GET.get("order_by", "-issue__created_at"))
-        # inbox status filter
-        inbox_status = [
-            item
-            for item in request.GET.get("status", "-2").split(",")
-            if item != "null"
-        ]
-        if inbox_status:
-            inbox_issue = inbox_issue.filter(status__in=inbox_status)
-
-        return self.paginate(
-            request=request,
-            queryset=(inbox_issue),
-            on_results=lambda inbox_issues: InboxIssueSerializer(
-                inbox_issues,
-                many=True,
-            ).data,
-        )
-
-    def create(self, request, slug, project_id):
-        if not request.data.get("issue", {}).get("name", False):
-            return Response(
-                {"error": "Name is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Check for valid priority
-        if request.data.get("issue", {}).get("priority", "none") not in [
-            "low",
-            "medium",
-            "high",
-            "urgent",
-            "none",
-        ]:
-            return Response(
-                {"error": "Invalid priority"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Create or get state
-        state, _ = State.objects.get_or_create(
-            name="Triage",
-            group="triage",
-            description="Default state for managing all Inbox Issues",
-            project_id=project_id,
-            color="#ff7700",
-            is_triage=True,
-        )
-
-        # create an issue
-        project = Project.objects.get(pk=project_id)
-        serializer = IssueCreateSerializer(
-            data=request.data.get("issue"),
-            context={
-                "project_id": project_id,
-                "workspace_id": project.workspace_id,
-                "default_assignee_id": project.default_assignee_id,
-            },
-        )
-        if serializer.is_valid():
-            serializer.save()
-            # Create an Issue Activity
-            issue_activity.delay(
-                type="issue.activity.created",
-                requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
-                actor_id=str(request.user.id),
-                issue_id=str(serializer.data["id"]),
-                project_id=str(project_id),
-                current_instance=None,
-                epoch=int(timezone.now().timestamp()),
-                notification=True,
-                origin=request.META.get("HTTP_ORIGIN"),
-            )
-            inbox_id = Inbox.objects.filter(
-                workspace__slug=slug, project_id=project_id
-            ).first()
-            # create an inbox issue
-            inbox_issue = InboxIssue.objects.create(
-                inbox_id=inbox_id.id,
-                project_id=project_id,
-                issue_id=serializer.data["id"],
-                source=request.data.get("source", "in-app"),
-            )
-            inbox_issue = (
-                InboxIssue.objects.select_related("issue")
-                .prefetch_related(
-                    "issue__labels",
-                    "issue__assignees",
-                )
-                .annotate(
-                    label_ids=Coalesce(
-                        ArrayAgg(
-                            "issue__labels__id",
-                            distinct=True,
-                            filter=~Q(issue__labels__id__isnull=True),
-                        ),
-                        Value([], output_field=ArrayField(UUIDField())),
-                    ),
-                    assignee_ids=Coalesce(
-                        ArrayAgg(
-                            "issue__assignees__id",
-                            distinct=True,
-                            filter=~Q(issue__assignees__id__isnull=True),
-                        ),
-                        Value([], output_field=ArrayField(UUIDField())),
-                    ),
-                )
-                .get(
-                    inbox_id=inbox_id.id,
-                    issue_id=serializer.data["id"],
-                    project_id=project_id,
-                )
-            )
-            serializer = InboxIssueDetailSerializer(inbox_issue)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        else:
-            return Response(
-                serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            )
-
-    def partial_update(self, request, slug, project_id, issue_id):
-        inbox_id = Inbox.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-        inbox_issue = InboxIssue.objects.get(
-            issue_id=issue_id,
-            workspace__slug=slug,
-            project_id=project_id,
-            inbox_id=inbox_id,
-        )
-        # Get the project member
-        project_member = ProjectMember.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            member=request.user,
-            is_active=True,
-        )
-        # Only project members admins and created_by users can access this endpoint
-        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
-            request.user.id
-        ):
-            return Response(
-                {"error": "You cannot edit inbox issues"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get issue data
-        issue_data = request.data.pop("issue", False)
-        if bool(issue_data):
-            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
-                issue_data = {
-                    "name": issue_data.get("name", issue.name),
-                    "description_html": issue_data.get(
-                        "description_html", issue.description_html
-                    ),
-                    "description": issue_data.get(
-                        "description", issue.description
-                    ),
-                }
-
-            issue_serializer = IssueCreateSerializer(
-                issue, data=issue_data, partial=True
-            )
-
-            if issue_serializer.is_valid():
-                current_instance = issue
-                # Log all the updates
-                requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
-                if issue is not None:
-                    issue_activity.delay(
-                        type="issue.activity.updated",
-                        requested_data=requested_data,
-                        actor_id=str(request.user.id),
-                        issue_id=str(issue.id),
-                        project_id=str(project_id),
-                        current_instance=json.dumps(
-                            IssueSerializer(current_instance).data,
-                            cls=DjangoJSONEncoder,
-                        ),
-                        epoch=int(timezone.now().timestamp()),
-                        notification=True,
-                        origin=request.META.get("HTTP_ORIGIN"),
-                    )
-                issue_serializer.save()
-            else:
-                return Response(
-                    issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
-                )
-
-        # Only project admins and members can edit inbox issue attributes
-        if project_member.role > 10:
-            serializer = InboxIssueSerializer(
-                inbox_issue, data=request.data, partial=True
-            )
-            current_instance = json.dumps(
-                InboxIssueSerializer(inbox_issue).data, cls=DjangoJSONEncoder
-            )
-            if serializer.is_valid():
-                serializer.save()
-                # Update the issue state if the issue is rejected or marked as duplicate
-                if serializer.data["status"] in [-1, 2]:
-                    issue = Issue.objects.get(
-                        pk=inbox_issue.issue_id,
-                        workspace__slug=slug,
-                        project_id=project_id,
-                    )
-                    state = State.objects.filter(
-                        group="cancelled",
-                        workspace__slug=slug,
-                        project_id=project_id,
-                    ).first()
-                    if state is not None:
-                        issue.state = state
-                        issue.save()
-
-                # Update the issue state if it is accepted
-                if serializer.data["status"] in [1]:
-                    issue = Issue.objects.get(
-                        pk=inbox_issue.issue_id,
-                        workspace__slug=slug,
-                        project_id=project_id,
-                    )
-
-                    # Update the issue state only if it is in triage state
-                    if issue.state.is_triage:
-                        # Move to default state
-                        state = State.objects.filter(
-                            workspace__slug=slug,
-                            project_id=project_id,
-                            default=True,
-                        ).first()
-                        if state is not None:
-                            issue.state = state
-                            issue.save()
-                # create a activity for status change
-                issue_activity.delay(
-                    type="inbox.activity.created",
-                    requested_data=json.dumps(
-                        request.data, cls=DjangoJSONEncoder
-                    ),
-                    actor_id=str(request.user.id),
-                    issue_id=str(issue_id),
-                    project_id=str(project_id),
-                    current_instance=current_instance,
-                    epoch=int(timezone.now().timestamp()),
-                    notification=False,
-                    origin=request.META.get("HTTP_ORIGIN"),
-                )
-
-                inbox_issue = (
-                    InboxIssue.objects.filter(
-                        inbox_id=inbox_id.id,
-                        issue_id=serializer.data["id"],
-                        project_id=project_id,
-                    )
-                    .select_related("issue")
-                    .prefetch_related(
-                        "issue__labels",
-                        "issue__assignees",
-                    )
-                    .annotate(
-                        label_ids=Coalesce(
-                            ArrayAgg(
-                                "issue__labels__id",
-                                distinct=True,
-                                filter=~Q(issue__labels__id__isnull=True),
-                            ),
-                            Value(
-                                [],
-                                output_field=ArrayField(UUIDField()),
-                            ),
-                        ),
-                        assignee_ids=Coalesce(
-                            ArrayAgg(
-                                "issue__assignees__id",
-                                distinct=True,
-                                filter=~Q(issue__assignees__id__isnull=True),
-                            ),
-                            Value(
-                                [],
-                                output_field=ArrayField(UUIDField()),
-                            ),
-                        ),
-                    ).first()
-                )
-                serializer = InboxIssueDetailSerializer(inbox_issue).data
-                return Response(serializer, status=status.HTTP_200_OK)
-            return Response(
-                serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            )
-        else:
-            serializer = InboxIssueDetailSerializer(inbox_issue).data
-            return Response(serializer, status=status.HTTP_200_OK)
-
-    def retrieve(self, request, slug, project_id, issue_id):
-        inbox_id = Inbox.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-        inbox_issue = (
-            InboxIssue.objects.select_related("issue")
-            .prefetch_related(
-                "issue__labels",
-                "issue__assignees",
-            )
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "issue__labels__id",
-                        distinct=True,
-                        filter=~Q(issue__labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "issue__assignees__id",
-                        distinct=True,
-                        filter=~Q(issue__assignees__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-            .get(
-                inbox_id=inbox_id.id, issue_id=issue_id, project_id=project_id
-            )
-        )
-        issue = InboxIssueDetailSerializer(inbox_issue).data
-        return Response(
-            issue,
-            status=status.HTTP_200_OK,
-        )
-
-    def destroy(self, request, slug, project_id, issue_id):
-        inbox_id = Inbox.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-        inbox_issue = InboxIssue.objects.get(
-            issue_id=issue_id,
-            workspace__slug=slug,
-            project_id=project_id,
-            inbox_id=inbox_id,
-        )
-        # Get the project member
-        project_member = ProjectMember.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            member=request.user,
-            is_active=True,
-        )
-
-        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
-            request.user.id
-        ):
-            return Response(
-                {"error": "You cannot delete inbox issue"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Check the issue status
-        if inbox_issue.status in [-2, -1, 0, 2]:
-            # Delete the issue also
-            Issue.objects.filter(
-                workspace__slug=slug, project_id=project_id, pk=issue_id
-            ).delete()
-
-        inbox_issue.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -0,0 +1,9 @@
+from .base import IntegrationViewSet, WorkspaceIntegrationViewSet
+from .github import (
+    GithubRepositorySyncViewSet,
+    GithubIssueSyncViewSet,
+    BulkCreateGithubIssueSyncEndpoint,
+    GithubCommentSyncViewSet,
+    GithubRepositoriesEndpoint,
+)
+from .slack import SlackProjectSyncViewSet
@@ -0,0 +1,181 @@
+# Python improts
+import uuid
+import requests
+
+# Django imports
+from django.contrib.auth.hashers import make_password
+
+# Third party imports
+from rest_framework.response import Response
+from rest_framework import status
+from sentry_sdk import capture_exception
+
+# Module imports
+from plane.app.views import BaseViewSet
+from plane.db.models import (
+    Integration,
+    WorkspaceIntegration,
+    Workspace,
+    User,
+    WorkspaceMember,
+    APIToken,
+)
+from plane.app.serializers import (
+    IntegrationSerializer,
+    WorkspaceIntegrationSerializer,
+)
+from plane.utils.integrations.github import (
+    get_github_metadata,
+    delete_github_installation,
+)
+from plane.app.permissions import WorkSpaceAdminPermission
+from plane.utils.integrations.slack import slack_oauth
+
+
+class IntegrationViewSet(BaseViewSet):
+    serializer_class = IntegrationSerializer
+    model = Integration
+
+    def create(self, request):
+        serializer = IntegrationSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def partial_update(self, request, pk):
+        integration = Integration.objects.get(pk=pk)
+        if integration.verified:
+            return Response(
+                {"error": "Verified integrations cannot be updated"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        serializer = IntegrationSerializer(
+            integration, 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)
+
+    def destroy(self, request, pk):
+        integration = Integration.objects.get(pk=pk)
+        if integration.verified:
+            return Response(
+                {"error": "Verified integrations cannot be updated"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        integration.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WorkspaceIntegrationViewSet(BaseViewSet):
+    serializer_class = WorkspaceIntegrationSerializer
+    model = WorkspaceIntegration
+
+    permission_classes = [
+        WorkSpaceAdminPermission,
+    ]
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("integration")
+        )
+
+    def create(self, request, slug, provider):
+        workspace = Workspace.objects.get(slug=slug)
+        integration = Integration.objects.get(provider=provider)
+        config = {}
+        if provider == "github":
+            installation_id = request.data.get("installation_id", None)
+            if not installation_id:
+                return Response(
+                    {"error": "Installation ID is required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+            metadata = get_github_metadata(installation_id)
+            config = {"installation_id": installation_id}
+
+        if provider == "slack":
+            code = request.data.get("code", False)
+
+            if not code:
+                return Response(
+                    {"error": "Code is required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            slack_response = slack_oauth(code=code)
+
+            metadata = slack_response
+            access_token = metadata.get("access_token", False)
+            team_id = metadata.get("team", {}).get("id", False)
+            if not metadata or not access_token or not team_id:
+                return Response(
+                    {
+                        "error": "Slack could not be installed. Please try again later"
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+            config = {"team_id": team_id, "access_token": access_token}
+
+        # Create a bot user
+        bot_user = User.objects.create(
+            email=f"{uuid.uuid4().hex}@plane.so",
+            username=uuid.uuid4().hex,
+            password=make_password(uuid.uuid4().hex),
+            is_password_autoset=True,
+            is_bot=True,
+            first_name=integration.title,
+            avatar=integration.avatar_url
+            if integration.avatar_url is not None
+            else "",
+        )
+
+        # Create an API Token for the bot user
+        api_token = APIToken.objects.create(
+            user=bot_user,
+            user_type=1,  # bot user
+            workspace=workspace,
+        )
+
+        workspace_integration = WorkspaceIntegration.objects.create(
+            workspace=workspace,
+            integration=integration,
+            actor=bot_user,
+            api_token=api_token,
+            metadata=metadata,
+            config=config,
+        )
+
+        # Add bot user as a member of workspace
+        _ = WorkspaceMember.objects.create(
+            workspace=workspace_integration.workspace,
+            member=bot_user,
+            role=20,
+        )
+        return Response(
+            WorkspaceIntegrationSerializer(workspace_integration).data,
+            status=status.HTTP_201_CREATED,
+        )
+
+    def destroy(self, request, slug, pk):
+        workspace_integration = WorkspaceIntegration.objects.get(
+            pk=pk, workspace__slug=slug
+        )
+
+        if workspace_integration.integration.provider == "github":
+            installation_id = workspace_integration.config.get(
+                "installation_id", False
+            )
+            if installation_id:
+                delete_github_installation(installation_id=installation_id)
+
+        workspace_integration.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -0,0 +1,202 @@
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from sentry_sdk import capture_exception
+
+# Module imports
+from plane.app.views import BaseViewSet, BaseAPIView
+from plane.db.models import (
+    GithubIssueSync,
+    GithubRepositorySync,
+    GithubRepository,
+    WorkspaceIntegration,
+    ProjectMember,
+    Label,
+    GithubCommentSync,
+    Project,
+)
+from plane.app.serializers import (
+    GithubIssueSyncSerializer,
+    GithubRepositorySyncSerializer,
+    GithubCommentSyncSerializer,
+)
+from plane.utils.integrations.github import get_github_repos
+from plane.app.permissions import (
+    ProjectBasePermission,
+    ProjectEntityPermission,
+)
+
+
+class GithubRepositoriesEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    def get(self, request, slug, workspace_integration_id):
+        page = request.GET.get("page", 1)
+        workspace_integration = WorkspaceIntegration.objects.get(
+            workspace__slug=slug, pk=workspace_integration_id
+        )
+
+        if workspace_integration.integration.provider != "github":
+            return Response(
+                {"error": "Not a github integration"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        access_tokens_url = workspace_integration.metadata["access_tokens_url"]
+        repositories_url = (
+            workspace_integration.metadata["repositories_url"]
+            + f"?per_page=100&page={page}"
+        )
+        repositories = get_github_repos(access_tokens_url, repositories_url)
+        return Response(repositories, status=status.HTTP_200_OK)
+
+
+class GithubRepositorySyncViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    serializer_class = GithubRepositorySyncSerializer
+    model = GithubRepositorySync
+
+    def perform_create(self, serializer):
+        serializer.save(project_id=self.kwargs.get("project_id"))
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+        )
+
+    def create(self, request, slug, project_id, workspace_integration_id):
+        name = request.data.get("name", False)
+        url = request.data.get("url", False)
+        config = request.data.get("config", {})
+        repository_id = request.data.get("repository_id", False)
+        owner = request.data.get("owner", False)
+
+        if not name or not url or not repository_id or not owner:
+            return Response(
+                {"error": "Name, url, repository_id and owner are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the workspace integration
+        workspace_integration = WorkspaceIntegration.objects.get(
+            pk=workspace_integration_id
+        )
+
+        # Delete the old repository object
+        GithubRepositorySync.objects.filter(
+            project_id=project_id, workspace__slug=slug
+        ).delete()
+        GithubRepository.objects.filter(
+            project_id=project_id, workspace__slug=slug
+        ).delete()
+
+        # Create repository
+        repo = GithubRepository.objects.create(
+            name=name,
+            url=url,
+            config=config,
+            repository_id=repository_id,
+            owner=owner,
+            project_id=project_id,
+        )
+
+        # Create a Label for github
+        label = Label.objects.filter(
+            name="GitHub",
+            project_id=project_id,
+        ).first()
+
+        if label is None:
+            label = Label.objects.create(
+                name="GitHub",
+                project_id=project_id,
+                description="Label to sync Plane issues with GitHub issues",
+                color="#003773",
+            )
+
+        # Create repo sync
+        repo_sync = GithubRepositorySync.objects.create(
+            repository=repo,
+            workspace_integration=workspace_integration,
+            actor=workspace_integration.actor,
+            credentials=request.data.get("credentials", {}),
+            project_id=project_id,
+            label=label,
+        )
+
+        # Add bot as a member in the project
+        _ = ProjectMember.objects.get_or_create(
+            member=workspace_integration.actor, role=20, project_id=project_id
+        )
+
+        # Return Response
+        return Response(
+            GithubRepositorySyncSerializer(repo_sync).data,
+            status=status.HTTP_201_CREATED,
+        )
+
+
+class GithubIssueSyncViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    serializer_class = GithubIssueSyncSerializer
+    model = GithubIssueSync
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"),
+            repository_sync_id=self.kwargs.get("repo_sync_id"),
+        )
+
+
+class BulkCreateGithubIssueSyncEndpoint(BaseAPIView):
+    def post(self, request, slug, project_id, repo_sync_id):
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+
+        github_issue_syncs = request.data.get("github_issue_syncs", [])
+        github_issue_syncs = GithubIssueSync.objects.bulk_create(
+            [
+                GithubIssueSync(
+                    issue_id=github_issue_sync.get("issue"),
+                    repo_issue_id=github_issue_sync.get("repo_issue_id"),
+                    issue_url=github_issue_sync.get("issue_url"),
+                    github_issue_id=github_issue_sync.get("github_issue_id"),
+                    repository_sync_id=repo_sync_id,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for github_issue_sync in github_issue_syncs
+            ],
+            batch_size=100,
+            ignore_conflicts=True,
+        )
+
+        serializer = GithubIssueSyncSerializer(github_issue_syncs, many=True)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+
+class GithubCommentSyncViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    serializer_class = GithubCommentSyncSerializer
+    model = GithubCommentSync
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"),
+            issue_sync_id=self.kwargs.get("issue_sync_id"),
+        )
@@ -0,0 +1,93 @@
+# Django import
+from django.db import IntegrityError
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from sentry_sdk import capture_exception
+
+# Module imports
+from plane.app.views import BaseViewSet, BaseAPIView
+from plane.db.models import (
+    SlackProjectSync,
+    WorkspaceIntegration,
+    ProjectMember,
+)
+from plane.app.serializers import SlackProjectSyncSerializer
+from plane.app.permissions import (
+    ProjectBasePermission,
+    ProjectEntityPermission,
+)
+from plane.utils.integrations.slack import slack_oauth
+
+
+class SlackProjectSyncViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+    serializer_class = SlackProjectSyncSerializer
+    model = SlackProjectSync
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(
+                workspace__slug=self.kwargs.get("slug"),
+                project_id=self.kwargs.get("project_id"),
+            )
+            .filter(project__project_projectmember__member=self.request.user)
+        )
+
+    def create(self, request, slug, project_id, workspace_integration_id):
+        try:
+            code = request.data.get("code", False)
+
+            if not code:
+                return Response(
+                    {"error": "Code is required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            slack_response = slack_oauth(code=code)
+
+            workspace_integration = WorkspaceIntegration.objects.get(
+                workspace__slug=slug, pk=workspace_integration_id
+            )
+
+            workspace_integration = WorkspaceIntegration.objects.get(
+                pk=workspace_integration_id, workspace__slug=slug
+            )
+            slack_project_sync = SlackProjectSync.objects.create(
+                access_token=slack_response.get("access_token"),
+                scopes=slack_response.get("scope"),
+                bot_user_id=slack_response.get("bot_user_id"),
+                webhook_url=slack_response.get("incoming_webhook", {}).get(
+                    "url"
+                ),
+                data=slack_response,
+                team_id=slack_response.get("team", {}).get("id"),
+                team_name=slack_response.get("team", {}).get("name"),
+                workspace_integration=workspace_integration,
+                project_id=project_id,
+            )
+            _ = ProjectMember.objects.get_or_create(
+                member=workspace_integration.actor,
+                role=20,
+                project_id=project_id,
+            )
+            serializer = SlackProjectSyncSerializer(slack_project_sync)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"error": "Slack is already installed for the project"},
+                    status=status.HTTP_410_GONE,
+                )
+            capture_exception(e)
+            return Response(
+                {
+                    "error": "Slack could not be installed. Please try again later"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
@@ -1,87 +0,0 @@
-# Python imports
-from itertools import chain
-
-# Django imports
-from django.db.models import (
-    Prefetch,
-    Q,
-)
-from django.utils.decorators import method_decorator
-from django.views.decorators.gzip import gzip_page
-
-# Third Party imports
-from rest_framework.response import Response
-from rest_framework import status
-
-# Module imports
-from .. import BaseAPIView
-from plane.app.serializers import (
-    IssueActivitySerializer,
-    IssueCommentSerializer,
-)
-from plane.app.permissions import ProjectEntityPermission
-from plane.db.models import (
-    IssueActivity,
-    IssueComment,
-    CommentReaction,
-)
-
-
-class IssueActivityEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    @method_decorator(gzip_page)
-    def get(self, request, slug, project_id, issue_id):
-        filters = {}
-        if request.GET.get("created_at__gt", None) is not None:
-            filters = {"created_at__gt": request.GET.get("created_at__gt")}
-
-        issue_activities = (
-            IssueActivity.objects.filter(issue_id=issue_id)
-            .filter(
-                ~Q(field__in=["comment", "vote", "reaction", "draft"]),
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-                project__archived_at__isnull=True,
-                workspace__slug=slug,
-            )
-            .filter(**filters)
-            .select_related("actor", "workspace", "issue", "project")
-        ).order_by("created_at")
-        issue_comments = (
-            IssueComment.objects.filter(issue_id=issue_id)
-            .filter(
-                project__project_projectmember__member=self.request.user,
-                project__project_projectmember__is_active=True,
-                project__archived_at__isnull=True,
-                workspace__slug=slug,
-            )
-            .filter(**filters)
-            .order_by("created_at")
-            .select_related("actor", "issue", "project", "workspace")
-            .prefetch_related(
-                Prefetch(
-                    "comment_reactions",
-                    queryset=CommentReaction.objects.select_related("actor"),
-                )
-            )
-        )
-        issue_activities = IssueActivitySerializer(
-            issue_activities, many=True
-        ).data
-        issue_comments = IssueCommentSerializer(issue_comments, many=True).data
-
-        if request.GET.get("activity_type", None) == "issue-property":
-            return Response(issue_activities, status=status.HTTP_200_OK)
-
-        if request.GET.get("activity_type", None) == "issue-comment":
-            return Response(issue_comments, status=status.HTTP_200_OK)
-
-        result_list = sorted(
-            chain(issue_activities, issue_comments),
-            key=lambda instance: instance["created_at"],
-        )
-
-        return Response(result_list, status=status.HTTP_200_OK)
@@ -1,348 +0,0 @@
-# Python imports
-import json
-
-# Django imports
-from django.utils import timezone
-from django.db.models import (
-    Prefetch,
-    OuterRef,
-    Func,
-    F,
-    Q,
-    Case,
-    Value,
-    CharField,
-    When,
-    Exists,
-    Max,
-    UUIDField,
-)
-from django.core.serializers.json import DjangoJSONEncoder
-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.functions import Coalesce
-
-# Third Party imports
-from rest_framework.response import Response
-from rest_framework import status
-
-# Module imports
-from .. import BaseViewSet
-from plane.app.serializers import (
-    IssueSerializer,
-    IssueFlatSerializer,
-    IssueDetailSerializer,
-)
-from plane.app.permissions import (
-    ProjectEntityPermission,
-)
-from plane.db.models import (
-    Issue,
-    IssueLink,
-    IssueAttachment,
-    IssueSubscriber,
-    IssueReaction,
-)
-from plane.bgtasks.issue_activites_task import issue_activity
-from plane.utils.issue_filters import issue_filters
-
-
-class IssueArchiveViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-    serializer_class = IssueFlatSerializer
-    model = Issue
-
-    def get_queryset(self):
-        return (
-            Issue.objects.annotate(
-                sub_issues_count=Issue.objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .filter(archived_at__isnull=False)
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .select_related("workspace", "project", "state", "parent")
-            .prefetch_related("assignees", "labels", "issue_module__module")
-            .annotate(cycle_id=F("issue_cycle__cycle_id"))
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=IssueAttachment.objects.filter(
-                    issue=OuterRef("id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(
-                    parent=OuterRef("id")
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                label_ids=Coalesce(
-                    ArrayAgg(
-                        "labels__id",
-                        distinct=True,
-                        filter=~Q(labels__id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                assignee_ids=Coalesce(
-                    ArrayAgg(
-                        "assignees__id",
-                        distinct=True,
-                        filter=~Q(assignees__id__isnull=True)
-                        & Q(assignees__member_project__is_active=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-                module_ids=Coalesce(
-                    ArrayAgg(
-                        "issue_module__module_id",
-                        distinct=True,
-                        filter=~Q(issue_module__module_id__isnull=True),
-                    ),
-                    Value([], output_field=ArrayField(UUIDField())),
-                ),
-            )
-        )
-
-    @method_decorator(gzip_page)
-    def list(self, request, slug, project_id):
-        filters = issue_filters(request.query_params, "GET")
-        show_sub_issues = request.GET.get("show_sub_issues", "true")
-
-        # Custom ordering for priority and state
-        priority_order = ["urgent", "high", "medium", "low", "none"]
-        state_order = [
-            "backlog",
-            "unstarted",
-            "started",
-            "completed",
-            "cancelled",
-        ]
-
-        order_by_param = request.GET.get("order_by", "-created_at")
-
-        issue_queryset = self.get_queryset().filter(**filters)
-
-        # Priority Ordering
-        if order_by_param == "priority" or order_by_param == "-priority":
-            priority_order = (
-                priority_order
-                if order_by_param == "priority"
-                else priority_order[::-1]
-            )
-            issue_queryset = issue_queryset.annotate(
-                priority_order=Case(
-                    *[
-                        When(priority=p, then=Value(i))
-                        for i, p in enumerate(priority_order)
-                    ],
-                    output_field=CharField(),
-                )
-            ).order_by("priority_order")
-
-        # State Ordering
-        elif order_by_param in [
-            "state__name",
-            "state__group",
-            "-state__name",
-            "-state__group",
-        ]:
-            state_order = (
-                state_order
-                if order_by_param in ["state__name", "state__group"]
-                else state_order[::-1]
-            )
-            issue_queryset = issue_queryset.annotate(
-                state_order=Case(
-                    *[
-                        When(state__group=state_group, then=Value(i))
-                        for i, state_group in enumerate(state_order)
-                    ],
-                    default=Value(len(state_order)),
-                    output_field=CharField(),
-                )
-            ).order_by("state_order")
-        # assignee and label ordering
-        elif order_by_param in [
-            "labels__name",
-            "-labels__name",
-            "assignees__first_name",
-            "-assignees__first_name",
-        ]:
-            issue_queryset = issue_queryset.annotate(
-                max_values=Max(
-                    order_by_param[1::]
-                    if order_by_param.startswith("-")
-                    else order_by_param
-                )
-            ).order_by(
-                "-max_values"
-                if order_by_param.startswith("-")
-                else "max_values"
-            )
-        else:
-            issue_queryset = issue_queryset.order_by(order_by_param)
-
-        issue_queryset = (
-            issue_queryset
-            if show_sub_issues == "true"
-            else issue_queryset.filter(parent__isnull=True)
-        )
-        if self.expand or 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)
-
-    def retrieve(self, request, slug, project_id, pk=None):
-        issue = (
-            self.get_queryset()
-            .filter(pk=pk)
-            .prefetch_related(
-                Prefetch(
-                    "issue_reactions",
-                    queryset=IssueReaction.objects.select_related(
-                        "issue", "actor"
-                    ),
-                )
-            )
-            .prefetch_related(
-                Prefetch(
-                    "issue_attachment",
-                    queryset=IssueAttachment.objects.select_related("issue"),
-                )
-            )
-            .prefetch_related(
-                Prefetch(
-                    "issue_link",
-                    queryset=IssueLink.objects.select_related("created_by"),
-                )
-            )
-            .annotate(
-                is_subscribed=Exists(
-                    IssueSubscriber.objects.filter(
-                        workspace__slug=slug,
-                        project_id=project_id,
-                        issue_id=OuterRef("pk"),
-                        subscriber=request.user,
-                    )
-                )
-            )
-        ).first()
-        if not issue:
-            return Response(
-                {"error": "The required object does not exist."},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-        serializer = IssueDetailSerializer(issue, expand=self.expand)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def archive(self, request, slug, project_id, pk=None):
-        issue = Issue.issue_objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            pk=pk,
-        )
-        if issue.state.group not in ["completed", "cancelled"]:
-            return Response(
-                {
-                    "error": "Can only archive completed or cancelled state group issue"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        issue_activity.delay(
-            type="issue.activity.updated",
-            requested_data=json.dumps(
-                {
-                    "archived_at": str(timezone.now().date()),
-                    "automation": False,
-                }
-            ),
-            actor_id=str(request.user.id),
-            issue_id=str(issue.id),
-            project_id=str(project_id),
-            current_instance=json.dumps(
-                IssueSerializer(issue).data, cls=DjangoJSONEncoder
-            ),
-            epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-        issue.archived_at = timezone.now().date()
-        issue.save()
-
-        return Response(
-            {"archived_at": str(issue.archived_at)}, status=status.HTTP_200_OK
-        )
-
-    def unarchive(self, request, slug, project_id, pk=None):
-        issue = Issue.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            archived_at__isnull=False,
-            pk=pk,
-        )
-        issue_activity.delay(
-            type="issue.activity.updated",
-            requested_data=json.dumps({"archived_at": None}),
-            actor_id=str(request.user.id),
-            issue_id=str(issue.id),
-            project_id=str(project_id),
-            current_instance=json.dumps(
-                IssueSerializer(issue).data, cls=DjangoJSONEncoder
-            ),
-            epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-        issue.archived_at = None
-        issue.save()
-
-        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,73 +0,0 @@
-# Python imports
-import json
-
-# Django imports
-from django.utils import timezone
-from django.core.serializers.json import DjangoJSONEncoder
-
-# Third Party imports
-from rest_framework.response import Response
-from rest_framework import status
-from rest_framework.parsers import MultiPartParser, FormParser
-
-# Module imports
-from .. import BaseAPIView
-from plane.app.serializers import IssueAttachmentSerializer
-from plane.app.permissions import ProjectEntityPermission
-from plane.db.models import IssueAttachment
-from plane.bgtasks.issue_activites_task import issue_activity
-
-
-class IssueAttachmentEndpoint(BaseAPIView):
-    serializer_class = IssueAttachmentSerializer
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-    model = IssueAttachment
-    parser_classes = (MultiPartParser, FormParser)
-
-    def post(self, request, slug, project_id, issue_id):
-        serializer = IssueAttachmentSerializer(data=request.data)
-        if serializer.is_valid():
-            serializer.save(project_id=project_id, issue_id=issue_id)
-            issue_activity.delay(
-                type="attachment.activity.created",
-                requested_data=None,
-                actor_id=str(self.request.user.id),
-                issue_id=str(self.kwargs.get("issue_id", None)),
-                project_id=str(self.kwargs.get("project_id", None)),
-                current_instance=json.dumps(
-                    serializer.data,
-                    cls=DjangoJSONEncoder,
-                ),
-                epoch=int(timezone.now().timestamp()),
-                notification=True,
-                origin=request.META.get("HTTP_ORIGIN"),
-            )
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def delete(self, request, slug, project_id, issue_id, pk):
-        issue_attachment = IssueAttachment.objects.get(pk=pk)
-        issue_attachment.asset.delete(save=False)
-        issue_attachment.delete()
-        issue_activity.delay(
-            type="attachment.activity.deleted",
-            requested_data=None,
-            actor_id=str(self.request.user.id),
-            issue_id=str(self.kwargs.get("issue_id", None)),
-            project_id=str(self.kwargs.get("project_id", None)),
-            current_instance=None,
-            epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    def get(self, request, slug, project_id, issue_id):
-        issue_attachments = IssueAttachment.objects.filter(
-            issue_id=issue_id, workspace__slug=slug, project_id=project_id
-        )
-        serializer = IssueAttachmentSerializer(issue_attachments, many=True)
-        return Response(serializer.data, status=status.HTTP_200_OK)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
pablohashescobar	e6c8d513ed	dev: exception handling	2024-01-22 10:11:26 +00:00
pablohashescobar	dd95dd9f5e	dev: hold celery worker and beat when pending migrations	2024-01-19 12:37:23 +05:30
pablohashescobar	e43139726f	dev: update example file for local dev	2024-01-19 12:35:59 +05:30
pablohashescobar	020fe91267	dev: create safe migration script so that the migration doesn't fail when running in replicas	2024-01-19 12:35:43 +05:30
Prateek Shourya	6e1cd4194a	fix: stack integration disable button mutation issue in project settings. (#3402 )	2024-01-18 12:31:10 +05:30
Anmol Singh Bhatia	615ccf9459	chore: workspace active cycles improvement (#3396 )	2024-01-17 23:04:53 +05:30
sriram veeraghanta	13362590b6	fix: resolved merge conflicts while moving changes from preview to develop	2024-01-17 19:13:47 +05:30
Prateek Shourya	7833ca7bea	fix: project views bugs related to store refactor. (#3391 ) * chore: remove debounce logic to fix create/ update view modal bugs. * fix: bug in delete views not mutating the store. * chore: replace `Project Empty State` with `Project Views Empty State`. * chore: add issue peek overview. * refactor: issue update, delete actions for project views layout. fix: issue update and delete action throwing error bug. fix: issue quick add throwing error bug.	2024-01-17 18:37:46 +05:30
M. Palanikannan	a1d27a1bf0	[chore]: Removed explicit dependencies and cleaned up turbo config (#3388 ) * Removed explicit dependencies and cleaned up turbo config * fix: upgrade turbo --------- Co-authored-by: sriram veeraghanta <veeraghanta.sriram@gmail.com>	2024-01-17 17:24:56 +05:30
rahulramesha	8fbd4a059b	fix: refactor related bugs (#3384 ) * fix sub issues inside issue detail * close peek over view after opening issue detail * fix error while opening peek overview * fix saving project views --------- Co-authored-by: Rahul R <rahulr@Rahuls-MacBook-Pro.local>	2024-01-16 21:16:12 +05:30
Anmol Singh Bhatia	e751686683	chore: filter and display properties improvement (#3382 )	2024-01-16 20:57:55 +05:30
Anmol Singh Bhatia	8ee5ba96ce	dev: workspace active cycles (#3378 ) * chore: workspace active cycles * fix: active cycles tab implementation * chore: added distribution graph for active cycles * chore: removed distribution graph and issues * Revert "chore: removed issues" This reverts commit `7d977ac8b0`. * chore: workspace active cycles implementation * chore: code refactor --------- Co-authored-by: NarayanBavisetti <narayan3119@gmail.com> Co-authored-by: sriram veeraghanta <veeraghanta.sriram@gmail.com>	2024-01-16 19:54:32 +05:30
Anmol Singh Bhatia	9e8885df5f	chore: esc to close peek overview added (#3380 )	2024-01-16 18:23:42 +05:30
Anmol Singh Bhatia	bc48010377	fix: drag and delete issue (#3379 )	2024-01-16 18:22:53 +05:30
Lakhan Baheti	9fde539b1d	chore webhook create page removed (#3376 ) * chore webhook create page removed * fix: removed unused variables	2024-01-16 14:22:48 +05:30
guru_sainath	ec26bf6e68	chore: update in sub-issues component and property validation and issue loaders (#3375 ) * fix: handled undefined issue_id in list layout * chore: refactor peek overview and user role validation. * chore: sub issues * fix: sub issues state distribution changed * chore: sub_issues implementation in issue detail page * chore: fixes in cycle/ module layout. * Fix progress chart * Module issues's update/ delete. * Peek Overview for Modules/ Cycle. * Fix Cycle Filters not applying bug. --------- Co-authored-by: Prateek Shourya <prateekshourya29@gmail.com> Co-authored-by: NarayanBavisetti <narayan3119@gmail.com>	2024-01-16 12:46:03 +05:30
sriram veeraghanta	e9ef3fb32a	chore: formatting all python files using black formatter (#3366 )	2024-01-13 19:05:06 +05:30
rahulramesha	ee2c7c5fa1	enable peekoverview for spreadsheet and minor refactor for faster opening of the peekoverview component (#3361 ) Co-authored-by: Rahul R <rahulr@Rahuls-MacBook-Pro.local>	2024-01-12 13:52:04 +05:30
rahulramesha	d64ae9a2e4	fix: project loaders for mobx store (#3356 ) * add loaders to all the dropdowns outside project wrpper * fix build errors * minor refactor for project states color --------- Co-authored-by: Rahul R <rahulr@Rahuls-MacBook-Pro.local>	2024-01-12 13:51:00 +05:30
Henit Chobisa	f58a00a4ab	[FIX] Pages Malfunctioning on Load and Recent Pages Computation (#3359 ) * fix: fixed `usePage` hook returning context instead of IPageStore * fix: updated recent pages with `updated_at` instead of `created_at` * fix: thown error instead of returning empty array	2024-01-12 13:26:48 +05:30
sriram veeraghanta	a3e5284f71	Merge branch 'preview' of github.com:makeplane/plane into develop	2024-01-12 12:25:57 +05:30
sriram veeraghanta	1c06c3f43e	fix: create more toggle fixes in create issue modal (#3355 ) * fix: create more issue bugfixes * fix: removing all warning	2024-01-11 21:01:05 +05:30
sriram veeraghanta	da1496fe65	fix: create sync action (#3353 ) * fix: create sync action changes * fix: typo changes	2024-01-11 18:40:26 +05:30
M. Palanikannan	3d489e186f	fix: inline code blocks, code blocks and links have saner behaviour (#3318 ) * fix: removed backticks in inline code blocks * added better error handling while cancelling uploads * fix: inline code blocks, code blocks and links have saner behaviour - Inline code blocks are now exitable, don't have backticks, have better padding vertically and better regex matching - Code blocks on the top and bottom of the document are now exitable via Up and Down Arrow keys - Links are now exitable while being autolinkable via a custom re-write of the tiptap-link-extension * fix: more robust link checking	2024-01-11 18:29:41 +05:30
guru_sainath	57d5ff7646	chore: Error Handling and Validation Updates (#3351 ) * fix: handled undefined issue_id in list layout * chore: updated label select dropdown in the issue detail * fix: peekoverview issue is resolved * chore: user role validation for issue details. * fix: Link, Attachement, parent mutation * build-error: build error resolved in peekoverview * chore: user role validation for issue details. * chore: user role validation for `issue description`, `parent`, `relation` and `subscription`. * chore: issue subscription mutation * chore: user role validation for `labels` in issue details. --------- Co-authored-by: Prateek Shourya <prateekshourya29@gmail.com>	2024-01-11 18:26:58 +05:30
rahulramesha	3c9926d383	update swr config to not fetch everything on focus (#3350 ) Co-authored-by: Rahul R <rahulr@Rahuls-MacBook-Pro.local>	2024-01-11 18:21:41 +05:30
rahulramesha	ece4d5b1ed	chore: Refactor Spreadsheet view for better code maintainability and performance (#3322 ) * refcator spreadsheet to use table and roow based approach rather than column based * update spreadsheet and optimized layout * fix issues in spread sheet * close quick action menu on click --------- Co-authored-by: Rahul R <rahulr@Rahuls-MacBook-Pro.local>	2024-01-11 18:19:19 +05:30
guru_sainath	73eed69aa6	chore: refactored and resolved build issues on the issues and issue detail page (#3340 ) * fix: handled undefined issue_id in list layout * dev: issue detail store and optimization * dev: issue filter and list operations * fix: typo on labels update * dev: Handled all issues in the list layout in project issues * dev: handled kanban and auick add issue in swimlanes * chore: fixed peekoverview in kanban * chore: fixed peekoverview in calendar * chore: fixed peekoverview in gantt * chore: updated quick add in the gantt chart * chore: handled issue detail properties and resolved build issues --------- Co-authored-by: pablohashescobar <nikhilschacko@gmail.com>	2024-01-10 20:09:45 +05:30
Henit Chobisa	09603cf189	fix: link preview editor (#3335 ) * feat: added link preview plugin in document editor * fix: readonly editor page renderer css * fix: autolink issue with links * chore: added floating UI * feat: added link preview components * feat: added floating UI to page renderer for link previews * feat: added actionCompleteHandler to page renderer * chore: Lock file changes * fix: regex security error * chore: updated radix with lucid icons --------- Co-authored-by: pablohashescobar <nikhilschacko@gmail.com>	2024-01-10 18:18:09 +05:30
Nikhil	23e53df3ad	dev: fix smtp configuration (#3339 )	2024-01-10 18:16:28 +05:30
Nikhil	57594aac4e	dev: update the instance urls (#3329 )	2024-01-10 12:22:20 +05:30
Anmol Singh Bhatia	8b884ab681	chore: modal and dropdown improvement (#3332 ) * dev: dropdown key down custom hook added * chore: plane ui dropdowns updated * chore: cycle and module tab index added in modals * chore: view and page tab index added in modals * chore: issue modal tab indexing added * chore: project modal tab indexing added * fix: build fix * build-error: build error in pages new structure and reverted back to old page structure --------- Co-authored-by: gurusainath <gurusainath007@gmail.com>	2024-01-10 12:21:24 +05:30
sriram veeraghanta	08e5f2b156	Merge branch 'preview' of github.com:makeplane/plane into develop	2024-01-09 22:51:51 +05:30
sriram veeraghanta	cb3a73e515	Merge branch 'preview' of github.com:makeplane/plane into develop	2024-01-09 20:41:49 +05:30
sriram veeraghanta	cb2a7d0930	Merge branch 'preview' of github.com:makeplane/plane into develop	2024-01-08 23:29:36 +05:30
sriram veeraghanta	c38e048ce8	Merge branches 'fix/pages-store' and 'develop' of github.com:makeplane/plane into develop	2024-01-08 23:28:12 +05:30
Bavisetti Narayan	94b72effbf	chore: mobile configs (#3328 ) * chore: mobile configs * chore: mobile configurations changed * chore: removed the slack id * chore: reversed google client id	2024-01-08 23:25:14 +05:30
rahulramesha	eccb1f5d10	fix: breaking cycle issues and replacing router.push with Links (#3330 ) * fix cycle creation and active cycle map * minor fix in cycle store * create cycle breaking fix * replace last possible bits of router.push with Link --------- Co-authored-by: Rahul R <rahulr@Rahuls-MacBook-Pro.local>	2024-01-08 19:20:42 +05:30
Prateek Shourya	a71491ecb9	fix: estimate order not maintained in create/ update modal. (#3326 ) * fix: estimate order not maintained in create/ update modal. * fix: estimate points mutation on update.	2024-01-08 16:16:45 +05:30
sriram veeraghanta	455c2cc787	fix: pages store structure changes	2024-01-07 12:05:52 +05:30
Anmol Singh Bhatia	81f6557908	fix: workspace invitations response updated (#3321 )	2024-01-05 23:42:52 +05:30
Anmol Singh Bhatia	2f10f35191	chore: bug fixes and improvement (#3303 ) * refactor: updated preloaded function for the list view quick add * fix: resolved bug in the assignee dropdown * chore: issue sidebar link improvement * fix: resolved subscription store bug * chore: updated preloaded function for the kanban layout quick add * chore: resolved issues in the list filters and component * chore: filter store updated * fix: issue serializer changed * chore: quick add preload function updated * fix: build error * fix: serializer changed * fix: minor request change * chore: resolved build issues and updated the prepopulated data in the quick add issue. * fix: build fix and code refactor * fix: spreadsheet layout quick add fix * fix: issue peek overview link section updated * fix: cycle status bug fix * fix: serializer changes * fix: assignee and labels listing * chore: issue modal parent_id default value updated * fix: cycle and module issue serializer change * fix: cycle list serializer changed * chore: prepopulated validation in both list and kanban for quick add and group header add issues * chore: group header validation added * fix: issue response payload change * dev: make cycle and module issue create response simillar * chore: custom control link component added * dev: make issue create and update response simillar to list and retrieve * fix: build error * chore: control link component improvement * chore: globalise issue peek overview * chore: control link component improvement * chore: made changes and optimised the issue peek overview root * build-error: resolved build erros for issueId dependancy from issue detail store * chore: peek overview link fix * dev: update state nullable rule --------- Co-authored-by: gurusainath <gurusainath007@gmail.com> Co-authored-by: NarayanBavisetti <narayan3119@gmail.com> Co-authored-by: pablohashescobar <nikhilschacko@gmail.com>	2024-01-05 23:37:13 +05:30
Prateek Shourya	cf64c7bbc6	fix: project identifier cursor behaviour in create project modal. (#3320 )	2024-01-05 14:38:09 +05:30
Prateek Shourya	9dd8c8ba14	chore: UI/UX improvements (#3319 ) * chore: add proper message for cycle/ module having start & end date but isn't active yet. * fix: infinite loader after updating workspace settings. * fix: user profile icon dropdown doesn't closes automatically. * style: fix inconsistent padding in cycle empty state. * chore: remove multiple `empty state` in labels settings and improve add label logic. * style: fix inconsistent padding in project label, integration and estimates empty state. * style: fix integrations settings breadcrumb title. * style: add proper `disabled` styles for email field in profile settings. * style: fix cycle layout height.	2024-01-05 14:13:04 +05:30
sriram veeraghanta	d98b688342	fix: merge conflicts resolved	2024-01-04 17:28:11 +05:30
sriram veeraghanta	ce21630388	Merge branch 'preview' of github.com:makeplane/plane into develop	2024-01-04 17:27:22 +05:30
M. Palanikannan	0927fa150c	✨ chore: Updated TableView component in table extension to solve sentry (#3309 ) error of table not being defined while getting getBoundingClientRect() and solve other TS issues - Added ResolvedPos import from @tiptap/pm/model - Updated setCellsBackgroundColor function parameter type to string - Declared ToolboxItem type for toolbox items - Modified columnsToolboxItems and rowsToolboxItems to use the ToolboxItem type - Updated createToolbox function parameters to specify Element or null for triggerButton and ToolboxItem[] for items - Added ts-expect-error comment above the toolbox variable declaration - Updated update method parameter type to readonly Decoration[] - Changed destructuring assignment of hoveredTable and hoveredCell in updateControls method to use Object.values and reduce method - Added null check for this.table in updateControls method - Wrapped the code that updates columnsControl and rowsControl with null checks for each control - Replaced ts-ignore comments with proper dispatch calls in selectColumn and selectRow methods Co-authored-by: sriram veeraghanta <veeraghanta.sriram@gmail.com>	2024-01-04 16:30:10 +05:30
Aaryan Khandelwal	eec411baaf	dev: new create issue modal (#3312 )	2024-01-04 16:29:18 +05:30
sriram veeraghanta	ecc8fbd79b	fix: Login workflow depending on smtp is configured (#3307 )	2024-01-04 16:27:17 +05:30
sriram veeraghanta	c9b628e578	Merge branch 'preview' of github.com:makeplane/plane into develop	2024-01-04 16:25:27 +05:30