chore: issue patch external api

* fix: activity responsiveness

* fix: activity icon placement

* fix: build

.deepsource.toml

@@ -1,23 +0,0 @@
-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"

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

@@ -55,12 +55,19 @@ body:
       - Safari
       - Other
 - type: dropdown
-  id: version
+  id: variant
   attributes:
-    label: Version
+    label: Variant
     options:
       - Cloud
       - Self-hosted
       - Local
+  validations:
+    required: true
+- type: input
+  id: version
+  attributes:
+    label: Version
+    placeholder: v0.17.0-dev
   validations:
     required: true

.github/workflows/auto-merge.yml

@@ -8,13 +8,13 @@ on:
 
 env:
   CURRENT_BRANCH: ${{ github.ref_name }}
-  SOURCE_BRANCH: ${{ secrets.SYNC_TARGET_BRANCH_NAME }} # The sync branch such as "sync/ce"
-  TARGET_BRANCH: ${{ secrets.TARGET_BRANCH }} # The target branch that you would like to merge changes like develop
+  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.REVIEWER }}
+  REVIEWER: ${{ secrets.SYNC_PR_REVIEWER }}
 
 jobs:
-  Check_Branch: 
+  Check_Branch:
     runs-on: ubuntu-latest
     outputs:
       BRANCH_MATCH: ${{ steps.check-branch.outputs.MATCH }}
@@ -27,7 +27,7 @@ jobs:
           else
             echo "MATCH=false" >> $GITHUB_OUTPUT
           fi
-      
+
   Auto_Merge:
     if: ${{ needs.Check_Branch.outputs.BRANCH_MATCH == 'true' }}
     needs: [Check_Branch]
@@ -41,6 +41,11 @@ jobs:
         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)
@@ -50,20 +55,6 @@ jobs:
           sudo apt update
           sudo apt install gh -y
 
-      - id: git-author
-        name: Setup Git CLI from Github Token
-        run: |
-          VIEWER_JSON=$(gh api graphql -f query='query { viewer { name login databaseId }}' --jq '.data.viewer')
-          VIEWER_NAME=$(jq --raw-output '.name | values' <<< "${VIEWER_JSON}")
-          VIEWER_LOGIN=$(jq --raw-output '.login' <<< "${VIEWER_JSON}")
-          VIEWER_DATABASE_ID=$(jq --raw-output '.databaseId' <<< "${VIEWER_JSON}")
-
-          USER_NAME="${VIEWER_NAME:-${VIEWER_LOGIN}}"
-          USER_EMAIL="${VIEWER_DATABASE_ID}+${VIEWER_LOGIN}@users.noreply.github.com"
-
-          git config --global user.name ${USER_NAME}
-          git config --global user.email ${USER_EMAIL}
-
       - name: Check for merge conflicts
         id: conflicts
         run: |
@@ -88,10 +79,6 @@ jobs:
       - name: Create PR to Target Branch
         if: env.HAS_CONFLICTS == 'true'
         run: |
-          # Use GitHub CLI to create PR and specify author and committer
-          PR_URL=$(gh pr create --base $TARGET_BRANCH --head $SOURCE_BRANCH \
-            --title "sync: merge conflicts need to be resolved" \
-            --body "" \
-            --reviewer $REVIEWER )
+          # 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"
-

.github/workflows/build-branch.yml

@@ -6,7 +6,6 @@ on:
     branches:
       - master
       - preview
-      - develop
   release:
     types: [released, prereleased]
 
@@ -18,7 +17,7 @@ jobs:
     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_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 }}
@@ -74,7 +73,7 @@ jobs:
               - nginx/**
 
   branch_build_push_frontend:
-    if: ${{ needs.branch_build_setup.outputs.build_frontend == 'true' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    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:
@@ -126,7 +125,7 @@ jobs:
           DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
 
   branch_build_push_space:
-    if: ${{ needs.branch_build_setup.outputs.build_space == 'true' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    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:
@@ -178,7 +177,7 @@ jobs:
           DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
 
   branch_build_push_backend:
-    if: ${{ needs.branch_build_setup.outputs.build_backend == 'true' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    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:
@@ -230,7 +229,7 @@ jobs:
           DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
 
   branch_build_push_proxy:
-    if: ${{ needs.branch_build_setup.outputs.build_proxy == 'true' || github.event_name == 'release' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
+    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:
@@ -280,4 +279,3 @@ jobs:
           DOCKER_BUILDKIT: 1
           DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
           DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
-

.github/workflows/codeql.yml

@@ -1,13 +1,13 @@
 name: "CodeQL"
 
 on:
+  workflow_dispatch:
   push:
-    branches: [ 'develop', 'preview', 'master' ]
+    branches: ["preview", "master"]
   pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ 'develop', 'preview', 'master' ]
+    branches: ["develop", "preview", "master"]
   schedule:
-    - cron: '53 19 * * 5'
+    - cron: "53 19 * * 5"
 
 jobs:
   analyze:
@@ -21,45 +21,44 @@ 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
 
-    # 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
 
-    # ℹ️ 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
+      #   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.
 
-    #   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.
+      # - run: |
+      #     echo "Run, Build Application using script"
+      #     ./location_of_script_within_repo/buildscript.sh
 
-    # - 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}}"
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2
+        with:
+          category: "/language:${{matrix.language}}"

.github/workflows/feature-deployment.yml

@@ -4,70 +4,196 @@ on:
   workflow_dispatch:
     inputs:
       web-build:
-        required: true
+        required: false
+        description: 'Build Web'
         type: boolean
         default: true
       space-build:
-        required: true
+        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:
-      KUBE_CONFIG_FILE: ${{ secrets.KUBE_CONFIG }}
-      BUILD_WEB: ${{ (github.event.inputs.web-build == '' && true) || github.event.inputs.web-build }}
-      BUILD_SPACE: ${{ (github.event.inputs.space-build == '' && false) || github.event.inputs.space-build }}
-
+      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/${{secrets.KUBE_VERSION}}/bin/linux/amd64/kubectl"
+          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: |
-          helm --kube-insecure-skip-tls-verify repo add feature-preview ${{ secrets.FEATURE_PREVIEW_HELM_CHART_URL }} 
-          GIT_BRANCH=${{ github.ref_name }}
-          APP_NAMESPACE=${{ secrets.FEATURE_PREVIEW_NAMESPACE }}
+          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
 
-          METADATA=$(helm install feature-preview/${{ secrets.FEATURE_PREVIEW_HELM_CHART_NAME }} \
-              --kube-insecure-skip-tls-verify \
-              --generate-name \
-              --namespace $APP_NAMESPACE \
-              --set shared_config.git_repo=${{github.server_url}}/${{ github.repository }}.git \
-              --set shared_config.git_branch="$GIT_BRANCH" \
-              --set web.enabled=${{ env.BUILD_WEB }} \
-              --set space.enabled=${{ env.BUILD_SPACE }} \
-              --output json \
-              --timeout 1000s)
+          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
 
-          APP_NAME=$(echo $METADATA | jq -r '.name')
+          if [ ${{ env.BUILD_WEB }} == true ] || [ ${{ env.BUILD_SPACE }} == true ]; then
 
-          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')
+            helm --kube-insecure-skip-tls-verify repo add feature-preview ${{ vars.FEATURE_PREVIEW_HELM_CHART_URL }} 
 
-          echo "****************************************"
-          echo "APP NAME ::: $APP_NAME"
-          echo "INGRESS HOSTNAME ::: $INGRESS_HOSTNAME"
-          echo "****************************************"
+            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

.gitignore

@@ -51,6 +51,7 @@ staticfiles
 mediafiles
 .env
 .DS_Store
+logs/
 
 node_modules/
 assets/dist/

Dockerfile

@@ -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,21 +89,17 @@ 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 --chown=captain:plane /app/apps/app/.next/standalone ./
+COPY --from=installer /app/apps/app/.next/standalone ./
 
-COPY --from=installer --chown=captain:plane /app/apps/app/.next/static ./apps/app/.next/static
+COPY --from=installer /app/apps/app/.next/static ./apps/app/.next/static
 
-COPY --from=installer --chown=captain:plane /app/apps/space/.next/standalone ./
-COPY --from=installer --chown=captain:plane /app/apps/space/.next ./apps/space/.next
+COPY --from=installer /app/apps/space/.next/standalone ./
+COPY --from=installer /app/apps/space/.next ./apps/space/.next
 
 ENV NEXT_TELEMETRY_DISABLED 1
 
@@ -118,7 +114,6 @@ 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

README.md

@@ -17,10 +17,10 @@
 </p>
 
 <p align="center">
-    <a href="http://www.plane.so"><b>Website</b></a> •
-    <a href="https://github.com/makeplane/plane/releases"><b>Releases</b></a> •
-    <a href="https://twitter.com/planepowers"><b>Twitter</b></a> •
-    <a href="https://docs.plane.so/"><b>Documentation</b></a>
+    <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>
@@ -40,28 +40,28 @@
     </a>
 </p>
 
-Meet [Plane](https://plane.so). An open-source software development tool to manage issues, sprints, and product roadmaps with peace of mind. 🧘‍♀️
+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. 🧘‍♀️
 
-> 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.
+> 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.
 
 ## ⚡ Installation
 
 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.
 
-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).
+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).
 
 | 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/docker-compose)         |
+| 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) |
 
 `Instance admin` can configure instance settings using our [God-mode](https://docs.plane.so/instance-admin) feature.
 
 ## 🚀 Features
 
-- **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.
+- **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.
 
-- **Cycles**
+- **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.
@@ -74,11 +74,11 @@ If you want more control over your data prefer to self-host Plane, please refer
 
 - **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.
 
-## 🛠️ Contributors Quick Start
+## 🛠️ 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
+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:
    ```

SECURITY.md

@@ -0,0 +1,44 @@
+# 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

apiserver/.env.example

@@ -14,10 +14,6 @@ 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"
@@ -34,11 +30,6 @@ 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
 
@@ -48,19 +39,8 @@ 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
-

apiserver/Dockerfile.api

@@ -32,27 +32,19 @@ 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
 

apiserver/Dockerfile.dev

@@ -30,16 +30,13 @@ 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 -R captain.plane /code
+RUN mkdir -p /code/plane/logs
 RUN chmod -R +x /code/bin
 RUN chmod -R 777 /code
 
-USER captain
 
 # Expose container port and run entry point script
 EXPOSE 8000

apiserver/back_migration.py

@@ -182,7 +182,7 @@ def update_label_color():
         labels = Label.objects.filter(color="")
         updated_labels = []
         for label in labels:
-            label.color = "#" + "%06x" % random.randint(0, 0xFFFFFF)
+            label.color = f"#{random.randint(0, 0xFFFFFF+1):06X}"
             updated_labels.append(label)
 
         Label.objects.bulk_update(updated_labels, ["color"], batch_size=100)

apiserver/bin/takeoff

@@ -21,11 +21,15 @@ 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
 
-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 -
+# 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 -

apiserver/bin/takeoff.local

@@ -21,12 +21,15 @@ 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
 

apiserver/package.json

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

apiserver/plane/api/serializers/base.py

@@ -66,11 +66,11 @@ class BaseSerializer(serializers.ModelSerializer):
                 if expand in self.fields:
                     # Import all the expandable serializers
                     from . import (
-                        WorkspaceLiteSerializer,
-                        ProjectLiteSerializer,
-                        UserLiteSerializer,
-                        StateLiteSerializer,
                         IssueSerializer,
+                        ProjectLiteSerializer,
+                        StateLiteSerializer,
+                        UserLiteSerializer,
+                        WorkspaceLiteSerializer,
                     )
 
                     # Expansion mapper

apiserver/plane/api/serializers/issue.py

@@ -1,32 +1,33 @@
-from lxml import html
+from django.core.exceptions import ValidationError
+from django.core.validators import URLValidator
 
 # Django imports
 from django.utils import timezone
-from django.core.validators import URLValidator
-from django.core.exceptions import ValidationError
+from lxml import html
 
 #  Third party imports
 from rest_framework import serializers
 
 # Module imports
 from plane.db.models import (
-    User,
     Issue,
-    State,
+    IssueActivity,
     IssueAssignee,
-    Label,
+    IssueAttachment,
+    IssueComment,
     IssueLabel,
     IssueLink,
-    IssueComment,
-    IssueAttachment,
-    IssueActivity,
+    Label,
     ProjectMember,
+    State,
+    User,
 )
+
 from .base import BaseSerializer
-from .cycle import CycleSerializer, CycleLiteSerializer
-from .module import ModuleSerializer, ModuleLiteSerializer
-from .user import UserLiteSerializer
+from .cycle import CycleLiteSerializer, CycleSerializer
+from .module import ModuleLiteSerializer, ModuleSerializer
 from .state import StateLiteSerializer
+from .user import UserLiteSerializer
 
 
 class IssueSerializer(BaseSerializer):
@@ -78,8 +79,8 @@ class IssueSerializer(BaseSerializer):
                 parsed_str = html.tostring(parsed, encoding="unicode")
                 data["description_html"] = parsed_str
 
-        except Exception as e:
-            raise serializers.ValidationError(f"Invalid HTML: {str(e)}")
+        except Exception:
+            raise serializers.ValidationError("Invalid HTML passed")
 
         # Validate assignees are from project
         if data.get("assignees", []):
@@ -294,7 +295,7 @@ class IssueLinkSerializer(BaseSerializer):
             raise serializers.ValidationError("Invalid URL format.")
 
         # Check URL scheme
-        if not value.startswith(('http://', 'https://')):
+        if not value.startswith(("http://", "https://")):
             raise serializers.ValidationError("Invalid URL scheme.")
 
         return value
@@ -365,8 +366,8 @@ class IssueCommentSerializer(BaseSerializer):
                 parsed_str = html.tostring(parsed, encoding="unicode")
                 data["comment_html"] = parsed_str
 
-        except Exception as e:
-            raise serializers.ValidationError(f"Invalid HTML: {str(e)}")
+        except Exception:
+            raise serializers.ValidationError("Invalid HTML passed")
         return data
 
 

apiserver/plane/api/serializers/project.py

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

apiserver/plane/api/serializers/user.py

@@ -1,5 +1,6 @@
 # Module imports
 from plane.db.models import User
+
 from .base import BaseSerializer
 
 
@@ -10,7 +11,9 @@ class UserLiteSerializer(BaseSerializer):
             "id",
             "first_name",
             "last_name",
+            "email",
             "avatar",
             "display_name",
+            "email",
         ]
         read_only_fields = fields

apiserver/plane/api/urls/cycle.py

@@ -4,6 +4,7 @@ from plane.api.views.cycle import (
     CycleAPIEndpoint,
     CycleIssueAPIEndpoint,
     TransferCycleIssueAPIEndpoint,
+    CycleArchiveUnarchiveAPIEndpoint,
 )
 
 urlpatterns = [
@@ -32,4 +33,14 @@ 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",
+    ),
 ]

apiserver/plane/api/urls/module.py

@@ -1,6 +1,10 @@
 from django.urls import path
 
-from plane.api.views import ModuleAPIEndpoint, ModuleIssueAPIEndpoint
+from plane.api.views import (
+    ModuleAPIEndpoint,
+    ModuleIssueAPIEndpoint,
+    ModuleArchiveUnarchiveAPIEndpoint,
+)
 
 urlpatterns = [
     path(
@@ -23,4 +27,14 @@ 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",
+    ),
 ]

apiserver/plane/api/urls/project.py

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

apiserver/plane/api/views/__init__.py

@@ -1,4 +1,4 @@
-from .project import ProjectAPIEndpoint
+from .project import ProjectAPIEndpoint, ProjectArchiveUnarchiveAPIEndpoint
 
 from .state import StateAPIEndpoint
 
@@ -14,8 +14,13 @@ from .cycle import (
     CycleAPIEndpoint,
     CycleIssueAPIEndpoint,
     TransferCycleIssueAPIEndpoint,
+    CycleArchiveUnarchiveAPIEndpoint,
 )
 
-from .module import ModuleAPIEndpoint, ModuleIssueAPIEndpoint
+from .module import (
+    ModuleAPIEndpoint,
+    ModuleIssueAPIEndpoint,
+    ModuleArchiveUnarchiveAPIEndpoint,
+)
 
 from .inbox import InboxIssueAPIEndpoint

apiserver/plane/api/views/base.py

@@ -1,27 +1,27 @@
 # Python imports
-import zoneinfo
-import json
 from urllib.parse import urlparse
 
+import zoneinfo
 
 # Django imports
 from django.conf import settings
-from django.db import IntegrityError
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.db import IntegrityError
+from django.urls import resolve
 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.utils.paginator import BasePaginator
 from plane.bgtasks.webhook_task import send_webhook
+from plane.utils.exception_logger import log_exception
+from plane.utils.paginator import BasePaginator
 
 
 class TimezoneMixin:
@@ -107,27 +107,23 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
 
             if isinstance(e, ValidationError):
                 return Response(
-                    {
-                        "error": "The provided payload is not valid please try with a valid payload"
-                    },
+                    {"error": "Please provide valid detail"},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
             if isinstance(e, ObjectDoesNotExist):
                 return Response(
-                    {"error": f"The required object does not exist."},
+                    {"error": "The requested resource does not exist."},
                     status=status.HTTP_404_NOT_FOUND,
                 )
 
             if isinstance(e, KeyError):
                 return Response(
-                    {"error": f" The required key does not exist."},
+                    {"error": "The required key does not exist."},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            if settings.DEBUG:
-                print(e)
-            capture_exception(e)
+            log_exception(e)
             return Response(
                 {"error": "Something went wrong please try again later"},
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -170,7 +166,12 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
 
     @property
     def project_id(self):
-        return self.kwargs.get("project_id", None)
+        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)
 
     @property
     def fields(self):

apiserver/plane/api/views/cycle.py

@@ -2,29 +2,31 @@
 import json
 
 # Django imports
-from django.db.models import Q, Count, Sum, Prefetch, F, OuterRef, Func
-from django.utils import timezone
 from django.core import serializers
+from django.db.models import Count, F, Func, OuterRef, Q, Sum
+from django.utils import timezone
 
 # Third party imports
-from rest_framework.response import Response
 from rest_framework import status
+from rest_framework.response import Response
 
 # Module imports
-from .base import BaseAPIView, WebhookMixin
-from plane.db.models import (
-    Cycle,
-    Issue,
-    CycleIssue,
-    IssueLink,
-    IssueAttachment,
+from plane.api.serializers import (
+    CycleIssueSerializer,
+    CycleSerializer,
 )
 from plane.app.permissions import ProjectEntityPermission
-from plane.api.serializers import (
-    CycleSerializer,
-    CycleIssueSerializer,
-)
 from plane.bgtasks.issue_activites_task import issue_activity
+from plane.db.models import (
+    Cycle,
+    CycleIssue,
+    Issue,
+    IssueAttachment,
+    IssueLink,
+)
+from plane.utils.analytics_plot import burndown_plot
+
+from .base import BaseAPIView, WebhookMixin
 
 
 class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
@@ -140,7 +142,9 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
 
     def get(self, request, slug, project_id, pk=None):
         if pk:
-            queryset = self.get_queryset().get(pk=pk)
+            queryset = (
+                self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
+            )
             data = CycleSerializer(
                 queryset,
                 fields=self.fields,
@@ -150,7 +154,7 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
                 data,
                 status=status.HTTP_200_OK,
             )
-        queryset = self.get_queryset()
+        queryset = self.get_queryset().filter(archived_at__isnull=True)
         cycle_view = request.GET.get("cycle_view", "all")
 
         # Current Cycle
@@ -291,6 +295,11 @@ 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
 
@@ -321,7 +330,9 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
                 and Cycle.objects.filter(
                     project_id=project_id,
                     workspace__slug=slug,
-                    external_source=request.data.get("external_source", cycle.external_source),
+                    external_source=request.data.get(
+                        "external_source", cycle.external_source
+                    ),
                     external_id=request.data.get("external_id"),
                 ).exists()
             ):
@@ -366,6 +377,144 @@ 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`,
@@ -407,7 +556,21 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
             .distinct()
         )
 
-    def get(self, request, slug, project_id, cycle_id):
+    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
         order_by = request.GET.get("order_by", "created_at")
         issues = (
             Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
@@ -583,7 +746,7 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
 
 class TransferCycleIssueAPIEndpoint(BaseAPIView):
     """
-    This viewset provides `create` actions for transfering the issues into a particular cycle.
+    This viewset provides `create` actions for transferring the issues into a particular cycle.
 
     """
 
@@ -604,6 +767,209 @@ 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()

apiserver/plane/api/views/inbox.py

@@ -2,27 +2,28 @@
 import json
 
 # Django improts
-from django.utils import timezone
-from django.db.models import Q
 from django.core.serializers.json import DjangoJSONEncoder
+from django.db.models import Q
+from django.utils import timezone
 
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
 
 # Module imports
-from .base import BaseAPIView
-from plane.app.permissions import ProjectLitePermission
 from plane.api.serializers import InboxIssueSerializer, IssueSerializer
+from plane.app.permissions import ProjectLitePermission
+from plane.bgtasks.issue_activites_task import issue_activity
 from plane.db.models import (
+    Inbox,
     InboxIssue,
     Issue,
-    State,
-    ProjectMember,
     Project,
-    Inbox,
+    ProjectMember,
+    State,
 )
-from plane.bgtasks.issue_activites_task import issue_activity
+
+from .base import BaseAPIView
 
 
 class InboxIssueAPIEndpoint(BaseAPIView):
@@ -119,7 +120,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
             )
 
         # Check for valid priority
-        if not request.data.get("issue", {}).get("priority", "none") in [
+        if request.data.get("issue", {}).get("priority", "none") not in [
             "low",
             "medium",
             "high",
@@ -134,10 +135,11 @@ class InboxIssueAPIEndpoint(BaseAPIView):
         # Create or get state
         state, _ = State.objects.get_or_create(
             name="Triage",
-            group="backlog",
+            group="triage",
             description="Default state for managing all Inbox Issues",
             project_id=project_id,
             color="#ff7700",
+            is_triage=True,
         )
 
         # create an issue
@@ -270,6 +272,9 @@ 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()
@@ -298,7 +303,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                     )
 
                     # Update the issue state only if it is in triage state
-                    if issue.state.name == "Triage":
+                    if issue.state.is_triage:
                         # Move to default state
                         state = State.objects.filter(
                             workspace__slug=slug,
@@ -309,6 +314,21 @@ 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

apiserver/plane/api/views/issue.py

@@ -1,22 +1,22 @@
 # Python imports
 import json
-from itertools import chain
+
+from django.core.serializers.json import DjangoJSONEncoder
 
 # Django imports
 from django.db import IntegrityError
 from django.db.models import (
-    OuterRef,
-    Func,
-    Q,
-    F,
     Case,
-    When,
-    Value,
     CharField,
-    Max,
     Exists,
+    F,
+    Func,
+    Max,
+    OuterRef,
+    Q,
+    Value,
+    When,
 )
-from django.core.serializers.json import DjangoJSONEncoder
 from django.utils import timezone
 
 # Third party imports
@@ -24,30 +24,31 @@ from rest_framework import status
 from rest_framework.response import Response
 
 # Module imports
-from .base import BaseAPIView, WebhookMixin
-from plane.app.permissions import (
-    ProjectEntityPermission,
-    ProjectMemberPermission,
-    ProjectLitePermission,
-)
-from plane.db.models import (
-    Issue,
-    IssueAttachment,
-    IssueLink,
-    Project,
-    Label,
-    ProjectMember,
-    IssueComment,
-    IssueActivity,
-)
-from plane.bgtasks.issue_activites_task import issue_activity
 from plane.api.serializers import (
+    IssueActivitySerializer,
+    IssueCommentSerializer,
+    IssueLinkSerializer,
     IssueSerializer,
     LabelSerializer,
-    IssueLinkSerializer,
-    IssueCommentSerializer,
-    IssueActivitySerializer,
 )
+from plane.app.permissions import (
+    ProjectEntityPermission,
+    ProjectLitePermission,
+    ProjectMemberPermission,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from plane.db.models import (
+    Issue,
+    IssueActivity,
+    IssueAttachment,
+    IssueComment,
+    IssueLink,
+    Label,
+    Project,
+    ProjectMember,
+)
+
+from .base import BaseAPIView, WebhookMixin
 
 
 class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
@@ -281,7 +282,7 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
         )
         if serializer.is_valid():
             if (
-                str(request.data.get("external_id"))
+                request.data.get("external_id")
                 and (issue.external_id != str(request.data.get("external_id")))
                 and Issue.objects.filter(
                     project_id=project_id,
@@ -307,8 +308,6 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
                 actor_id=str(request.user.id),
                 issue_id=str(pk),
                 project_id=str(project_id),
-                external_id__isnull=False,
-                external_source__isnull=False,
                 current_instance=current_instance,
                 epoch=int(timezone.now().timestamp()),
             )
@@ -356,6 +355,7 @@ class LabelAPIEndpoint(BaseAPIView):
                 project__project_projectmember__member=self.request.user,
                 project__project_projectmember__is_active=True,
             )
+            .filter(project__archived_at__isnull=True)
             .select_related("project")
             .select_related("workspace")
             .select_related("parent")
@@ -437,7 +437,7 @@ class LabelAPIEndpoint(BaseAPIView):
         serializer = LabelSerializer(label, data=request.data, partial=True)
         if serializer.is_valid():
             if (
-                str(request.data.get("external_id"))
+                request.data.get("external_id")
                 and (label.external_id != str(request.data.get("external_id")))
                 and Issue.objects.filter(
                     project_id=project_id,
@@ -488,6 +488,7 @@ class IssueLinkAPIEndpoint(BaseAPIView):
                 project__project_projectmember__member=self.request.user,
                 project__project_projectmember__is_active=True,
             )
+            .filter(project__archived_at__isnull=True)
             .order_by(self.kwargs.get("order_by", "-created_at"))
             .distinct()
         )
@@ -617,6 +618,7 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
                 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")
             .annotate(
                 is_member=Exists(
@@ -653,7 +655,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")
@@ -679,7 +680,6 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
                 status=status.HTTP_409_CONFLICT,
             )
 
-
         serializer = IssueCommentSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save(
@@ -717,7 +717,10 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
         # 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 (
+                issue_comment.external_id
+                != str(request.data.get("external_id"))
+            )
             and IssueComment.objects.filter(
                 project_id=project_id,
                 workspace__slug=slug,
@@ -735,7 +738,6 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
                 status=status.HTTP_409_CONFLICT,
             )
 
-
         serializer = IssueCommentSerializer(
             issue_comment, data=request.data, partial=True
         )
@@ -792,6 +794,7 @@ class IssueActivityAPIEndpoint(BaseAPIView):
                 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"))
 

apiserver/plane/api/views/module.py

@@ -2,32 +2,33 @@
 import json
 
 # Django imports
-from django.db.models import Count, Prefetch, Q, F, Func, OuterRef
-from django.utils import timezone
 from django.core import serializers
+from django.db.models import Count, F, Func, OuterRef, Prefetch, Q
+from django.utils import timezone
 
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
 
 # Module imports
-from .base import BaseAPIView, WebhookMixin
+from plane.api.serializers import (
+    IssueSerializer,
+    ModuleIssueSerializer,
+    ModuleSerializer,
+)
 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 plane.api.serializers import (
-    ModuleSerializer,
-    ModuleIssueSerializer,
-    IssueSerializer,
-)
-from plane.bgtasks.issue_activites_task import issue_activity
+
+from .base import BaseAPIView, WebhookMixin
 
 
 class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
@@ -67,6 +68,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
                     ),
+                    distinct=True,
                 ),
             )
             .annotate(
@@ -77,6 +79,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
                     ),
+                    distinct=True,
                 )
             )
             .annotate(
@@ -87,6 +90,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
                     ),
+                    distinct=True,
                 )
             )
             .annotate(
@@ -97,6 +101,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
                     ),
+                    distinct=True,
                 )
             )
             .annotate(
@@ -107,6 +112,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                         issue_module__issue__archived_at__isnull=True,
                         issue_module__issue__is_draft=False,
                     ),
+                    distinct=True,
                 )
             )
             .annotate(
@@ -117,6 +123,7 @@ 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"))
@@ -165,6 +172,11 @@ 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,
@@ -178,7 +190,9 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                 and Module.objects.filter(
                     project_id=project_id,
                     workspace__slug=slug,
-                    external_source=request.data.get("external_source", module.external_source),
+                    external_source=request.data.get(
+                        "external_source", module.external_source
+                    ),
                     external_id=request.data.get("external_id"),
                 ).exists()
             ):
@@ -195,7 +209,9 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
 
     def get(self, request, slug, project_id, pk=None):
         if pk:
-            queryset = self.get_queryset().get(pk=pk)
+            queryset = (
+                self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
+            )
             data = ModuleSerializer(
                 queryset,
                 fields=self.fields,
@@ -207,7 +223,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
             )
         return self.paginate(
             request=request,
-            queryset=(self.get_queryset()),
+            queryset=(self.get_queryset().filter(archived_at__isnull=True)),
             on_results=lambda modules: ModuleSerializer(
                 modules,
                 many=True,
@@ -277,6 +293,7 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
                 project__project_projectmember__member=self.request.user,
                 project__project_projectmember__is_active=True,
             )
+            .filter(project__archived_at__isnull=True)
             .select_related("project")
             .select_related("workspace")
             .select_related("module")
@@ -444,3 +461,130 @@ 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)

apiserver/plane/api/views/project.py

@@ -1,27 +1,29 @@
 # Django imports
 from django.db import IntegrityError
-from django.db.models import Exists, OuterRef, Q, F, Func, Subquery, Prefetch
+from django.db.models import Exists, F, Func, OuterRef, Prefetch, Q, Subquery
+from django.utils import timezone
 
 # 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 (
-    Workspace,
-    Project,
-    ProjectFavorite,
-    ProjectMember,
-    ProjectDeployBoard,
-    State,
     Cycle,
-    Module,
-    IssueProperty,
     Inbox,
+    IssueProperty,
+    Module,
+    Project,
+    ProjectDeployBoard,
+    ProjectMember,
+    State,
+    Workspace,
 )
-from plane.app.permissions import ProjectBasePermission
-from plane.api.serializers import ProjectSerializer
+
 from .base import BaseAPIView, WebhookMixin
 
 
@@ -40,7 +42,10 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
         return (
             Project.objects.filter(workspace__slug=self.kwargs.get("slug"))
             .filter(
-                Q(project_projectmember__member=self.request.user)
+                Q(
+                    project_projectmember__member=self.request.user,
+                    project_projectmember__is_active=True,
+                )
                 | Q(network=2)
             )
             .select_related(
@@ -100,8 +105,8 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
             .distinct()
         )
 
-    def get(self, request, slug, project_id=None):
-        if project_id is None:
+    def get(self, request, slug, pk=None):
+        if pk is None:
             sort_order_query = ProjectMember.objects.filter(
                 member=request.user,
                 project_id=OuterRef("pk"),
@@ -132,7 +137,7 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                     expand=self.expand,
                 ).data,
             )
-        project = self.get_queryset().get(workspace__slug=slug, pk=project_id)
+        project = self.get_queryset().get(workspace__slug=slug, pk=pk)
         serializer = ProjectSerializer(
             project,
             fields=self.fields,
@@ -150,7 +155,7 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                 serializer.save()
 
                 # Add the user as Administrator to the project
-                project_member = ProjectMember.objects.create(
+                _ = ProjectMember.objects.create(
                     project_id=serializer.data["id"],
                     member=request.user,
                     role=20,
@@ -245,21 +250,27 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                     {"name": "The project name is already taken"},
                     status=status.HTTP_410_GONE,
                 )
-        except Workspace.DoesNotExist as e:
+        except Workspace.DoesNotExist:
             return Response(
                 {"error": "Workspace does not exist"},
                 status=status.HTTP_404_NOT_FOUND,
             )
-        except ValidationError as e:
+        except ValidationError:
             return Response(
                 {"identifier": "The project identifier is already taken"},
                 status=status.HTTP_410_GONE,
             )
 
-    def patch(self, request, slug, project_id=None):
+    def patch(self, request, slug, pk):
         try:
             workspace = Workspace.objects.get(slug=slug)
-            project = Project.objects.get(pk=project_id)
+            project = Project.objects.get(pk=pk)
+
+            if project.archived_at:
+                return Response(
+                    {"error": "Archived project cannot be updated"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
 
             serializer = ProjectSerializer(
                 project,
@@ -280,10 +291,11 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                     # Create the triage state in Backlog group
                     State.objects.get_or_create(
                         name="Triage",
-                        group="backlog",
+                        group="triage",
                         description="Default state for managing all Inbox Issues",
-                        project_id=project_id,
+                        project_id=pk,
                         color="#ff7700",
+                        is_triage=True,
                     )
 
                 project = (
@@ -307,13 +319,32 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                 {"error": "Project does not exist"},
                 status=status.HTTP_404_NOT_FOUND,
             )
-        except ValidationError as e:
+        except ValidationError:
             return Response(
                 {"identifier": "The project identifier is already taken"},
                 status=status.HTTP_410_GONE,
             )
 
-    def delete(self, request, slug, project_id):
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+    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()
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/state.py

@@ -1,16 +1,16 @@
 # Django imports
 from django.db import IntegrityError
-from django.db.models import Q
 
 # Third party imports
-from rest_framework.response import Response
 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
 
 # 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):
@@ -28,7 +28,8 @@ class StateAPIEndpoint(BaseAPIView):
                 project__project_projectmember__member=self.request.user,
                 project__project_projectmember__is_active=True,
             )
-            .filter(~Q(name="Triage"))
+            .filter(is_triage=False)
+            .filter(project__archived_at__isnull=True)
             .select_related("project")
             .select_related("workspace")
             .distinct()
@@ -66,8 +67,10 @@ class StateAPIEndpoint(BaseAPIView):
 
                 serializer.save(project_id=project_id)
                 return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError as e:
+            return Response(
+                serializer.errors, status=status.HTTP_400_BAD_REQUEST
+            )
+        except IntegrityError:
             state = State.objects.filter(
                 workspace__slug=slug,
                 project_id=project_id,
@@ -83,7 +86,11 @@ class StateAPIEndpoint(BaseAPIView):
 
     def get(self, request, slug, project_id, state_id=None):
         if state_id:
-            serializer = StateSerializer(self.get_queryset().get(pk=state_id))
+            serializer = StateSerializer(
+                self.get_queryset().get(pk=state_id),
+                fields=self.fields,
+                expand=self.expand,
+            )
             return Response(serializer.data, status=status.HTTP_200_OK)
         return self.paginate(
             request=request,
@@ -98,7 +105,7 @@ class StateAPIEndpoint(BaseAPIView):
 
     def delete(self, request, slug, project_id, state_id):
         state = State.objects.get(
-            ~Q(name="Triage"),
+            is_triage=False,
             pk=state_id,
             project_id=project_id,
             workspace__slug=slug,
@@ -136,7 +143,9 @@ class StateAPIEndpoint(BaseAPIView):
                 and State.objects.filter(
                     project_id=project_id,
                     workspace__slug=slug,
-                    external_source=request.data.get("external_source", state.external_source),
+                    external_source=request.data.get(
+                        "external_source", state.external_source
+                    ),
                     external_id=request.data.get("external_id"),
                 ).exists()
             ):

apiserver/plane/app/permissions/project.py

@@ -1,8 +1,8 @@
 # Third Party imports
-from rest_framework.permissions import BasePermission, SAFE_METHODS
+from rest_framework.permissions import SAFE_METHODS, BasePermission
 
 # Module import
-from plane.db.models import WorkspaceMember, ProjectMember
+from plane.db.models import ProjectMember, WorkspaceMember
 
 # Permission Mappings
 Admin = 20

apiserver/plane/app/serializers/__init__.py

@@ -59,6 +59,7 @@ from .issue import (
     IssueFlatSerializer,
     IssueStateSerializer,
     IssueLinkSerializer,
+    IssueInboxSerializer,
     IssueLiteSerializer,
     IssueAttachmentSerializer,
     IssueSubscriberSerializer,
@@ -86,22 +87,13 @@ 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,
 )
 
@@ -117,11 +109,15 @@ from .inbox import (
     InboxIssueSerializer,
     IssueStateInboxSerializer,
     InboxIssueLiteSerializer,
+    InboxIssueDetailSerializer,
 )
 
 from .analytic import AnalyticViewSerializer
 
-from .notification import NotificationSerializer, UserNotificationPreferenceSerializer
+from .notification import (
+    NotificationSerializer,
+    UserNotificationPreferenceSerializer,
+)
 
 from .exporter import ExporterHistorySerializer
 

apiserver/plane/app/serializers/cycle.py

@@ -11,6 +11,7 @@ from plane.db.models import (
     CycleUserProperties,
 )
 
+
 class CycleWriteSerializer(BaseSerializer):
     def validate(self, data):
         if (
@@ -30,6 +31,7 @@ class CycleWriteSerializer(BaseSerializer):
             "workspace",
             "project",
             "owned_by",
+            "archived_at",
         ]
 
 
@@ -47,7 +49,6 @@ class CycleSerializer(BaseSerializer):
     # active | draft | upcoming | completed
     status = serializers.CharField(read_only=True)
 
-
     class Meta:
         model = Cycle
         fields = [

apiserver/plane/app/serializers/dashboard.py

@@ -18,9 +18,4 @@ class WidgetSerializer(BaseSerializer):
 
     class Meta:
         model = Widget
-        fields = [
-            "id",
-            "key",
-            "is_visible",
-            "widget_filters"
-        ]
+        fields = ["id", "key", "is_visible", "widget_filters"]

apiserver/plane/app/serializers/estimate.py

@@ -74,5 +74,3 @@ class WorkspaceEstimateSerializer(BaseSerializer):
             "name",
             "description",
         ]
-
-

apiserver/plane/app/serializers/inbox.py

@@ -3,7 +3,11 @@ from rest_framework import serializers
 
 # Module imports
 from .base import BaseSerializer
-from .issue import IssueFlatSerializer, LabelLiteSerializer
+from .issue import (
+    IssueInboxSerializer,
+    LabelLiteSerializer,
+    IssueDetailSerializer,
+)
 from .project import ProjectLiteSerializer
 from .state import StateLiteSerializer
 from .user import UserLiteSerializer
@@ -24,17 +28,62 @@ class InboxSerializer(BaseSerializer):
 
 
 class InboxIssueSerializer(BaseSerializer):
-    issue_detail = IssueFlatSerializer(source="issue", read_only=True)
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+    issue = IssueInboxSerializer(read_only=True)
 
     class Meta:
         model = InboxIssue
-        fields = "__all__"
+        fields = [
+            "id",
+            "status",
+            "duplicate_to",
+            "snoozed_till",
+            "source",
+            "issue",
+            "created_by",
+        ]
         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:

apiserver/plane/app/serializers/integration/__init__.py

@@ -1,8 +0,0 @@
-from .base import IntegrationSerializer, WorkspaceIntegrationSerializer
-from .github import (
-    GithubRepositorySerializer,
-    GithubRepositorySyncSerializer,
-    GithubIssueSyncSerializer,
-    GithubCommentSyncSerializer,
-)
-from .slack import SlackProjectSyncSerializer

apiserver/plane/app/serializers/integration/base.py

@@ -1,22 +0,0 @@
-# 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__"

apiserver/plane/app/serializers/integration/github.py

@@ -1,45 +0,0 @@
-# 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",
-        ]

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

@@ -1,14 +0,0 @@
-# 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",
-        ]

apiserver/plane/app/serializers/issue.py

@@ -9,7 +9,7 @@ from rest_framework import serializers
 # Module imports
 from .base import BaseSerializer, DynamicBaseSerializer
 from .user import UserLiteSerializer
-from .state import StateSerializer, StateLiteSerializer
+from .state import StateLiteSerializer
 from .project import ProjectLiteSerializer
 from .workspace import WorkspaceLiteSerializer
 from plane.db.models import (
@@ -33,7 +33,6 @@ from plane.db.models import (
     IssueVote,
     IssueRelation,
     State,
-    Project,
 )
 
 
@@ -472,7 +471,6 @@ class IssueLinkSerializer(BaseSerializer):
 
 
 class IssueLinkLiteSerializer(BaseSerializer):
-
     class Meta:
         model = IssueLink
         fields = [
@@ -503,7 +501,6 @@ class IssueAttachmentSerializer(BaseSerializer):
 
 
 class IssueAttachmentLiteSerializer(DynamicBaseSerializer):
-
     class Meta:
         model = IssueAttachment
         fields = [
@@ -532,13 +529,12 @@ class IssueReactionSerializer(BaseSerializer):
 
 
 class IssueReactionLiteSerializer(DynamicBaseSerializer):
-
     class Meta:
         model = IssueReaction
         fields = [
             "id",
-            "actor_id",
-            "issue_id",
+            "actor",
+            "issue",
             "reaction",
         ]
 
@@ -624,19 +620,42 @@ 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
     cycle_id = serializers.PrimaryKeyRelatedField(read_only=True)
     module_ids = serializers.ListField(
-        child=serializers.UUIDField(), required=False,
+        child=serializers.UUIDField(),
+        required=False,
     )
 
     # Many to many
     label_ids = serializers.ListField(
-        child=serializers.UUIDField(), required=False,
+        child=serializers.UUIDField(),
+        required=False,
     )
     assignee_ids = serializers.ListField(
-        child=serializers.UUIDField(), required=False,
+        child=serializers.UUIDField(),
+        required=False,
     )
 
     # Count items
@@ -676,19 +695,7 @@ class IssueSerializer(DynamicBaseSerializer):
         read_only_fields = fields
 
 
-class IssueDetailSerializer(IssueSerializer):
-    description_html = serializers.CharField()
-    is_subscribed = serializers.BooleanField(read_only=True)
-
-    class Meta(IssueSerializer.Meta):
-        fields = IssueSerializer.Meta.fields + [
-            "description_html",
-            "is_subscribed",
-        ]
-
-
 class IssueLiteSerializer(DynamicBaseSerializer):
-
     class Meta:
         model = Issue
         fields = [
@@ -701,7 +708,7 @@ class IssueLiteSerializer(DynamicBaseSerializer):
 
 class IssueDetailSerializer(IssueSerializer):
     description_html = serializers.CharField()
-    is_subscribed = serializers.BooleanField()
+    is_subscribed = serializers.BooleanField(read_only=True)
 
     class Meta(IssueSerializer.Meta):
         fields = IssueSerializer.Meta.fields + [

apiserver/plane/app/serializers/module.py

@@ -3,7 +3,6 @@ from rest_framework import serializers
 
 # Module imports
 from .base import BaseSerializer, DynamicBaseSerializer
-from .user import UserLiteSerializer
 from .project import ProjectLiteSerializer
 
 from plane.db.models import (
@@ -40,6 +39,7 @@ class ModuleWriteSerializer(BaseSerializer):
             "updated_by",
             "created_at",
             "updated_at",
+            "archived_at",
         ]
 
     def to_representation(self, instance):
@@ -142,7 +142,6 @@ class ModuleIssueSerializer(BaseSerializer):
 
 
 class ModuleLinkSerializer(BaseSerializer):
-
     class Meta:
         model = ModuleLink
         fields = "__all__"
@@ -211,17 +210,17 @@ class ModuleSerializer(DynamicBaseSerializer):
             "backlog_issues",
             "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']
+        fields = ModuleSerializer.Meta.fields + ["link_module", "sub_issues"]
 
 
 class ModuleFavoriteSerializer(BaseSerializer):

apiserver/plane/app/serializers/notification.py

@@ -15,7 +15,6 @@ class NotificationSerializer(BaseSerializer):
 
 
 class UserNotificationPreferenceSerializer(BaseSerializer):
-
     class Meta:
         model = UserNotificationPreference
         fields = "__all__"

apiserver/plane/app/serializers/page.py

@@ -3,38 +3,44 @@ 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 = "__all__"
+        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",
+        ]
         read_only_fields = [
             "workspace",
             "project",
@@ -50,8 +56,12 @@ 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, project_id=project_id, owned_by_id=owned_by_id
+            **validated_data,
+            description_html=description_html,
+            project_id=project_id,
+            owned_by_id=owned_by_id,
         )
 
         if labels is not None:
@@ -93,6 +103,13 @@ 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()
 

apiserver/plane/app/serializers/project.py

@@ -102,6 +102,12 @@ class ProjectLiteSerializer(BaseSerializer):
 
 
 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)

apiserver/plane/app/serializers/user.py

@@ -4,7 +4,6 @@ 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):
@@ -99,13 +98,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:
@@ -120,12 +119,16 @@ 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,
             }
 

apiserver/plane/app/serializers/webhook.py

@@ -1,5 +1,4 @@
 # Python imports
-import urllib
 import socket
 import ipaddress
 from urllib.parse import urlparse

apiserver/plane/app/urls/__init__.py

@@ -6,9 +6,7 @@ from .cycle import urlpatterns as cycle_urls
 from .dashboard import urlpatterns as dashboard_urls
 from .estimate import urlpatterns as estimate_urls
 from .external import urlpatterns as external_urls
-from .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
@@ -32,9 +30,7 @@ urlpatterns = [
     *dashboard_urls,
     *estimate_urls,
     *external_urls,
-    *importer_urls,
     *inbox_urls,
-    *integration_urls,
     *issue_urls,
     *module_urls,
     *notification_urls,

apiserver/plane/app/urls/cycle.py

@@ -8,6 +8,7 @@ from plane.app.views import (
     CycleFavoriteViewSet,
     TransferCycleIssueEndpoint,
     CycleUserPropertiesEndpoint,
+    CycleArchiveUnarchiveEndpoint,
 )
 
 
@@ -90,4 +91,19 @@ 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",
+    ),
 ]

apiserver/plane/app/urls/external.py

@@ -2,7 +2,6 @@ from django.urls import path
 
 
 from plane.app.views import UnsplashEndpoint
-from plane.app.views import ReleaseNotesEndpoint
 from plane.app.views import GPTIntegrationEndpoint
 
 
@@ -12,11 +11,6 @@ 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(),

apiserver/plane/app/urls/importer.py

@@ -1,37 +0,0 @@
-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",
-    ),
-]

apiserver/plane/app/urls/inbox.py

@@ -30,7 +30,7 @@ urlpatterns = [
         name="inbox",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
         InboxIssueViewSet.as_view(
             {
                 "get": "list",
@@ -40,7 +40,7 @@ urlpatterns = [
         name="inbox-issue",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/<uuid:issue_id>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:issue_id>/",
         InboxIssueViewSet.as_view(
             {
                 "get": "retrieve",

apiserver/plane/app/urls/integration.py

@@ -1,150 +0,0 @@
-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
-]

apiserver/plane/app/urls/issue.py

@@ -1,30 +1,26 @@
 from django.urls import path
 
-
 from plane.app.views import (
-    IssueListEndpoint,
-    IssueViewSet,
-    LabelViewSet,
     BulkCreateIssueLabelsEndpoint,
     BulkDeleteIssuesEndpoint,
-    BulkImportIssuesEndpoint,
-    UserWorkSpaceIssues,
     SubIssuesEndpoint,
     IssueLinkViewSet,
     IssueAttachmentEndpoint,
+    CommentReactionViewSet,
     ExportIssuesEndpoint,
     IssueActivityEndpoint,
-    IssueCommentViewSet,
-    IssueSubscriberViewSet,
-    IssueReactionViewSet,
-    CommentReactionViewSet,
-    IssueUserDisplayPropertyEndpoint,
     IssueArchiveViewSet,
-    IssueRelationViewSet,
+    IssueCommentViewSet,
     IssueDraftViewSet,
+    IssueListEndpoint,
+    IssueReactionViewSet,
+    IssueRelationViewSet,
+    IssueSubscriberViewSet,
+    IssueUserDisplayPropertyEndpoint,
+    IssueViewSet,
+    LabelViewSet,
 )
 
-
 urlpatterns = [
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/list/",
@@ -85,18 +81,7 @@ 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",
-    ),
-    # deprecated endpoint TODO: remove once confirmed
-    path(
-        "workspaces/<str:slug>/my-issues/",
-        UserWorkSpaceIssues.as_view(),
-        name="workspace-issues",
-    ),
-    ## 
+    ##
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/sub-issues/",
         SubIssuesEndpoint.as_view(),

apiserver/plane/app/urls/module.py

@@ -6,8 +6,8 @@ from plane.app.views import (
     ModuleIssueViewSet,
     ModuleLinkViewSet,
     ModuleFavoriteViewSet,
-    BulkImportModulesEndpoint,
     ModuleUserPropertiesEndpoint,
+    ModuleArchiveUnarchiveEndpoint,
 )
 
 
@@ -106,14 +106,24 @@ 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",
+    ),
 ]

apiserver/plane/app/urls/page.py

@@ -31,102 +31,51 @@ urlpatterns = [
         ),
         name="project-pages",
     ),
+    # favorite pages
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-pages/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/favorite-pages/<uuid:pk>/",
         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/",
-        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/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/archive/",
         PageViewSet.as_view(
             {
                 "post": "archive",
+                "delete": "unarchive",
             }
         ),
-        name="project-page-archive",
+        name="project-page-archive-unarchive",
     ),
+    # lock and unlock
     path(
-        "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/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/lock/",
         PageViewSet.as_view(
             {
                 "post": "lock",
+                "delete": "unlock",
             }
         ),
-        name="project-pages",
+        name="project-pages-lock-unlock",
     ),
     path(
-        "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/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/transactions/",
         PageLogEndpoint.as_view(),
         name="page-transactions",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/transactions/<uuid:transaction>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/transactions/<uuid:transaction>/",
         PageLogEndpoint.as_view(),
         name="page-transactions",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/sub-pages/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/sub-pages/",
         SubPagesEndpoint.as_view(),
         name="sub-page",
     ),

apiserver/plane/app/urls/project.py

@@ -14,6 +14,7 @@ from plane.app.views import (
     ProjectPublicCoverImagesEndpoint,
     ProjectDeployBoardViewSet,
     UserProjectRolesEndpoint,
+    ProjectArchiveUnarchiveEndpoint,
 )
 
 
@@ -175,4 +176,9 @@ urlpatterns = [
         ),
         name="project-deploy-board",
     ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archive/",
+        ProjectArchiveUnarchiveEndpoint.as_view(),
+        name="project-archive-unarchive",
+    ),
 ]

apiserver/plane/app/views/__init__.py

@@ -1,19 +1,27 @@
-from .project import (
+from .project.base 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 import (
+
+from .user.base import (
     UserEndpoint,
     UpdateUserOnBoardedEndpoint,
     UpdateUserTourCompletedEndpoint,
@@ -24,71 +32,124 @@ from .oauth import OauthEndpoint
 
 from .base import BaseAPIView, BaseViewSet, WebhookMixin
 
-from .workspace import (
+from .workspace.base import (
     WorkSpaceViewSet,
     UserWorkSpacesEndpoint,
     WorkSpaceAvailabilityCheckEndpoint,
-    WorkspaceJoinEndpoint,
-    WorkSpaceMemberViewSet,
-    TeamMemberViewSet,
-    WorkspaceInvitationsViewset,
-    UserWorkspaceInvitationsViewSet,
-    UserLastProjectWithWorkspaceEndpoint,
-    WorkspaceMemberUserEndpoint,
-    WorkspaceMemberUserViewsEndpoint,
-    UserActivityGraphEndpoint,
-    UserIssueCompletedGraphEndpoint,
     UserWorkspaceDashboardEndpoint,
     WorkspaceThemeViewSet,
-    WorkspaceUserProfileStatsEndpoint,
-    WorkspaceUserActivityEndpoint,
-    WorkspaceUserProfileEndpoint,
-    WorkspaceUserProfileIssuesEndpoint,
-    WorkspaceLabelsEndpoint,
-    WorkspaceProjectMemberEndpoint,
-    WorkspaceUserPropertiesEndpoint,
-    WorkspaceStatesEndpoint,
-    WorkspaceEstimatesEndpoint,
     ExportWorkspaceUserActivityEndpoint,
+)
+
+from .workspace.member import (
+    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,
+    UserActivityGraphEndpoint,
+    UserIssueCompletedGraphEndpoint,
+)
+from .workspace.estimate import (
+    WorkspaceEstimatesEndpoint,
+)
+from .workspace.module import (
     WorkspaceModulesEndpoint,
+)
+from .workspace.cycle import (
     WorkspaceCyclesEndpoint,
 )
-from .state import StateViewSet
-from .view import (
+
+from .state.base import StateViewSet
+from .view.base import (
     GlobalViewViewSet,
     GlobalViewIssuesViewSet,
     IssueViewViewSet,
     IssueViewFavoriteViewSet,
 )
-from .cycle import (
+from .cycle.base import (
     CycleViewSet,
-    CycleIssueViewSet,
     CycleDateCheckEndpoint,
     CycleFavoriteViewSet,
     TransferCycleIssueEndpoint,
     CycleUserPropertiesEndpoint,
 )
-from .asset import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
-from .issue import (
+from .cycle.issue import (
+    CycleIssueViewSet,
+)
+from .cycle.archive import (
+    CycleArchiveUnarchiveEndpoint,
+)
+
+from .asset.base import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
+from .issue.base import (
     IssueListEndpoint,
     IssueViewSet,
-    WorkSpaceIssuesEndpoint,
-    IssueActivityEndpoint,
-    IssueCommentViewSet,
     IssueUserDisplayPropertyEndpoint,
-    LabelViewSet,
     BulkDeleteIssuesEndpoint,
-    UserWorkSpaceIssues,
-    SubIssuesEndpoint,
-    IssueLinkViewSet,
-    BulkCreateIssueLabelsEndpoint,
-    IssueAttachmentEndpoint,
+)
+
+from .issue.activity import (
+    IssueActivityEndpoint,
+)
+
+from .issue.archive import (
     IssueArchiveViewSet,
-    IssueSubscriberViewSet,
+)
+
+from .issue.attachment import (
+    IssueAttachmentEndpoint,
+)
+
+from .issue.comment import (
+    IssueCommentViewSet,
     CommentReactionViewSet,
-    IssueReactionViewSet,
+)
+
+from .issue.draft import IssueDraftViewSet
+
+from .issue.label import (
+    LabelViewSet,
+    BulkCreateIssueLabelsEndpoint,
+)
+
+from .issue.link import (
+    IssueLinkViewSet,
+)
+
+from .issue.relation import (
     IssueRelationViewSet,
-    IssueDraftViewSet,
+)
+
+from .issue.reaction import (
+    IssueReactionViewSet,
+)
+
+from .issue.sub_issue import (
+    SubIssuesEndpoint,
+)
+
+from .issue.subscriber import (
+    IssueSubscriberViewSet,
 )
 
 from .auth_extended import (
@@ -107,36 +168,25 @@ from .authentication import (
     MagicSignInEndpoint,
 )
 
-from .module import (
+from .module.base 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 .importer import (
-    ServiceIssueImportSummaryEndpoint,
-    ImportServiceEndpoint,
-    UpdateServiceImportStatusEndpoint,
-    BulkImportIssuesEndpoint,
-    BulkImportModulesEndpoint,
-)
-
-from .page import (
+from .page.base import (
     PageViewSet,
     PageFavoriteViewSet,
     PageLogEndpoint,
@@ -146,20 +196,19 @@ from .page import (
 from .search import GlobalSearchEndpoint, IssueSearchEndpoint
 
 
-from .external import (
+from .external.base import (
     GPTIntegrationEndpoint,
-    ReleaseNotesEndpoint,
     UnsplashEndpoint,
 )
 
-from .estimate import (
+from .estimate.base import (
     ProjectEstimatePointEndpoint,
     BulkEstimatePointEndpoint,
 )
 
-from .inbox import InboxViewSet, InboxIssueViewSet
+from .inbox.base import InboxViewSet, InboxIssueViewSet
 
-from .analytic import (
+from .analytic.base import (
     AnalyticsEndpoint,
     AnalyticViewViewset,
     SavedAnalyticEndpoint,
@@ -167,26 +216,23 @@ from .analytic import (
     DefaultAnalyticsEndpoint,
 )
 
-from .notification import (
+from .notification.base import (
     NotificationViewSet,
     UnreadNotificationEndpoint,
     MarkAllReadNotificationViewSet,
     UserNotificationPreferenceEndpoint,
 )
 
-from .exporter import ExportIssuesEndpoint
+from .exporter.base import ExportIssuesEndpoint
 
 from .config import ConfigurationEndpoint, MobileConfigurationEndpoint
 
-from .webhook import (
+from .webhook.base import (
     WebhookEndpoint,
     WebhookLogsEndpoint,
     WebhookSecretRegenerateEndpoint,
 )
 
-from .dashboard import (
-    DashboardEndpoint,
-    WidgetsEndpoint
-)
+from .dashboard.base import DashboardEndpoint, WidgetsEndpoint
 
 from .error_404 import custom_404_view

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

@@ -1,5 +1,5 @@
 # Django imports
-from django.db.models import Count, Sum, F, Q
+from django.db.models import Count, Sum, F
 from django.db.models.functions import ExtractMonth
 from django.utils import timezone
 
@@ -10,7 +10,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, State, Label
+from plane.db.models import Issue, AnalyticView, Workspace
 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 +51,8 @@ class AnalyticsEndpoint(BaseAPIView):
         if (
             not x_axis
             or not y_axis
-            or not x_axis in valid_xaxis_segment
-            or not y_axis in valid_yaxis
+            or x_axis not in valid_xaxis_segment
+            or y_axis not in valid_yaxis
         ):
             return Response(
                 {
@@ -266,8 +266,8 @@ class ExportAnalyticsEndpoint(BaseAPIView):
         if (
             not x_axis
             or not y_axis
-            or not x_axis in valid_xaxis_segment
-            or not y_axis in valid_yaxis
+            or x_axis not in valid_xaxis_segment
+            or y_axis not in valid_yaxis
         ):
             return Response(
                 {

apiserver/plane/app/views/api.py

@@ -43,7 +43,7 @@ class ApiTokenEndpoint(BaseAPIView):
         )
 
     def get(self, request, slug, pk=None):
-        if pk == None:
+        if pk is None:
             api_tokens = APIToken.objects.filter(
                 user=request.user, workspace__slug=slug
             )

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

@@ -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
 

apiserver/plane/app/views/auth_extended.py

@@ -16,7 +16,6 @@ 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
@@ -172,7 +171,7 @@ class ResetPasswordEndpoint(BaseAPIView):
                 serializer.errors, status=status.HTTP_400_BAD_REQUEST
             )
 
-        except DjangoUnicodeDecodeError as indentifier:
+        except DjangoUnicodeDecodeError:
             return Response(
                 {"error": "token is not valid, please check the new one"},
                 status=status.HTTP_401_UNAUTHORIZED,

apiserver/plane/app/views/authentication.py

@@ -7,7 +7,6 @@ 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
@@ -65,7 +64,7 @@ class SignUpEndpoint(BaseAPIView):
         email = email.strip().lower()
         try:
             validate_email(email)
-        except ValidationError as e:
+        except ValidationError:
             return Response(
                 {"error": "Please provide a valid email address."},
                 status=status.HTTP_400_BAD_REQUEST,
@@ -151,7 +150,7 @@ class SignInEndpoint(BaseAPIView):
         email = email.strip().lower()
         try:
             validate_email(email)
-        except ValidationError as e:
+        except ValidationError:
             return Response(
                 {"error": "Please provide a valid email address."},
                 status=status.HTTP_400_BAD_REQUEST,
@@ -238,9 +237,11 @@ 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,
                 )
@@ -254,9 +255,11 @@ 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,
                 )
@@ -392,9 +395,11 @@ 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,
                         )
@@ -408,9 +413,11 @@ 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,
                         )

apiserver/plane/app/views/base.py

@@ -1,30 +1,27 @@
 # Python imports
 import zoneinfo
-import json
+from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.db import IntegrityError
 
 # Django imports
 from django.urls import resolve
-from django.conf import settings
 from django.utils import timezone
-from django.db import IntegrityError
-from django.core.exceptions import ObjectDoesNotExist, ValidationError
-from django.core.serializers.json import DjangoJSONEncoder
+from django_filters.rest_framework import DjangoFilterBackend
 
 # 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 sentry_sdk import capture_exception
-from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from rest_framework.viewsets import ModelViewSet
 
 # Module imports
-from plane.utils.paginator import BasePaginator
 from plane.bgtasks.webhook_task import send_webhook
+from plane.utils.exception_logger import log_exception
+from plane.utils.paginator import BasePaginator
 
 
 class TimezoneMixin:
@@ -90,7 +87,7 @@ class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
         try:
             return self.model.objects.all()
         except Exception as e:
-            capture_exception(e)
+            log_exception(e)
             raise APIException(
                 "Please check the view", status.HTTP_400_BAD_REQUEST
             )
@@ -119,18 +116,18 @@ class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
 
             if isinstance(e, ObjectDoesNotExist):
                 return Response(
-                    {"error": f"The required object does not exist."},
+                    {"error": "The required object does not exist."},
                     status=status.HTTP_404_NOT_FOUND,
                 )
 
             if isinstance(e, KeyError):
-                capture_exception(e)
+                log_exception(e)
                 return Response(
-                    {"error": f"The required key does not exist."},
+                    {"error": "The required key does not exist."},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            capture_exception(e)
+            log_exception(e)
             return Response(
                 {"error": "Something went wrong please try again later"},
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -226,19 +223,17 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
 
             if isinstance(e, ObjectDoesNotExist):
                 return Response(
-                    {"error": f"The required object does not exist."},
+                    {"error": "The required object does not exist."},
                     status=status.HTTP_404_NOT_FOUND,
                 )
 
             if isinstance(e, KeyError):
                 return Response(
-                    {"error": f"The required key does not exist."},
+                    {"error": "The required key does not exist."},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            if settings.DEBUG:
-                print(e)
-            capture_exception(e)
+            log_exception(e)
             return Response(
                 {"error": "Something went wrong please try again later"},
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR,

apiserver/plane/app/views/config.py

@@ -2,7 +2,6 @@
 import os
 
 # Django imports
-from django.conf import settings
 
 # Third party imports
 from rest_framework.permissions import AllowAny
@@ -12,13 +11,14 @@ 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
         (
@@ -136,6 +136,7 @@ class MobileConfigurationEndpoint(BaseAPIView):
         AllowAny,
     ]
 
+    @cache_response(60 * 60 * 2, user=False)
     def get(self, request):
         (
             GOOGLE_CLIENT_ID,

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

@@ -0,0 +1,409 @@
+# 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)

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

@@ -2,62 +2,53 @@
 import json
 
 # Django imports
-from django.db.models import (
-    Func,
-    F,
-    Q,
-    Exists,
-    OuterRef,
-    Count,
-    Prefetch,
-    Sum,
-    Case,
-    When,
-    Value,
-    CharField,
-)
-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 import Value, UUIDField
+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.response import Response
 from rest_framework import status
-
-# Module imports
-from . import BaseViewSet, BaseAPIView, WebhookMixin
-from plane.app.serializers import (
-    CycleSerializer,
-    CycleIssueSerializer,
-    CycleFavoriteSerializer,
-    IssueSerializer,
-    CycleWriteSerializer,
-    CycleUserPropertiesSerializer,
-)
+from rest_framework.response import Response
 from plane.app.permissions import (
     ProjectEntityPermission,
     ProjectLitePermission,
 )
-from plane.db.models import (
-    User,
-    Cycle,
-    CycleIssue,
-    Issue,
-    CycleFavorite,
-    IssueLink,
-    IssueAttachment,
-    Label,
-    CycleUserProperties,
+from plane.app.serializers import (
+    CycleFavoriteSerializer,
+    CycleSerializer,
+    CycleUserPropertiesSerializer,
+    CycleWriteSerializer,
 )
 from plane.bgtasks.issue_activites_task import issue_activity
-from plane.utils.issue_filters import issue_filters
+from plane.db.models import (
+    Cycle,
+    CycleFavorite,
+    CycleIssue,
+    CycleUserProperties,
+    Issue,
+    Label,
+    User,
+)
 from plane.utils.analytics_plot import burndown_plot
 
+# Module imports
+from .. import BaseAPIView, BaseViewSet, WebhookMixin
+
 
 class CycleViewSet(WebhookMixin, BaseViewSet):
     serializer_class = CycleSerializer
@@ -89,6 +80,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                 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(
@@ -109,7 +101,8 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
             .annotate(is_favorite=Exists(favorite_subquery))
             .annotate(
                 total_issues=Count(
-                    "issue_cycle",
+                    "issue_cycle__issue__id",
+                    distinct=True,
                     filter=Q(
                         issue_cycle__issue__archived_at__isnull=True,
                         issue_cycle__issue__is_draft=False,
@@ -118,7 +111,8 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
             )
             .annotate(
                 completed_issues=Count(
-                    "issue_cycle__issue__state__group",
+                    "issue_cycle__issue__id",
+                    distinct=True,
                     filter=Q(
                         issue_cycle__issue__state__group="completed",
                         issue_cycle__issue__archived_at__isnull=True,
@@ -128,7 +122,8 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
             )
             .annotate(
                 cancelled_issues=Count(
-                    "issue_cycle__issue__state__group",
+                    "issue_cycle__issue__id",
+                    distinct=True,
                     filter=Q(
                         issue_cycle__issue__state__group="cancelled",
                         issue_cycle__issue__archived_at__isnull=True,
@@ -138,7 +133,8 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
             )
             .annotate(
                 started_issues=Count(
-                    "issue_cycle__issue__state__group",
+                    "issue_cycle__issue__id",
+                    distinct=True,
                     filter=Q(
                         issue_cycle__issue__state__group="started",
                         issue_cycle__issue__archived_at__isnull=True,
@@ -148,7 +144,8 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
             )
             .annotate(
                 unstarted_issues=Count(
-                    "issue_cycle__issue__state__group",
+                    "issue_cycle__issue__id",
+                    distinct=True,
                     filter=Q(
                         issue_cycle__issue__state__group="unstarted",
                         issue_cycle__issue__archived_at__isnull=True,
@@ -158,7 +155,8 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
             )
             .annotate(
                 backlog_issues=Count(
-                    "issue_cycle__issue__state__group",
+                    "issue_cycle__issue__id",
+                    distinct=True,
                     filter=Q(
                         issue_cycle__issue__state__group="backlog",
                         issue_cycle__issue__archived_at__isnull=True,
@@ -202,7 +200,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
         )
 
     def list(self, request, slug, project_id):
-        queryset = self.get_queryset()
+        queryset = self.get_queryset().filter(archived_at__isnull=True)
         cycle_view = request.GET.get("cycle_view", "all")
 
         # Update the order by
@@ -403,8 +401,8 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                         "progress_snapshot",
                         # meta fields
                         "is_favorite",
-                        "total_issues",
                         "cancelled_issues",
+                        "total_issues",
                         "completed_issues",
                         "started_issues",
                         "unstarted_issues",
@@ -427,11 +425,15 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
             )
 
     def partial_update(self, request, slug, project_id, pk):
-        queryset = (
-            self.get_queryset()
-            .filter(workspace__slug=slug, project_id=project_id, pk=pk)
+        queryset = self.get_queryset().filter(
+            workspace__slug=slug, project_id=project_id, pk=pk
         )
         cycle = queryset.first()
+        if cycle.archived_at:
+            return Response(
+                {"error": "Archived cycle cannot be updated"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
         request_data = request.data
 
         if (
@@ -489,10 +491,22 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def retrieve(self, request, slug, project_id, pk):
-        queryset = self.get_queryset().filter(pk=pk)
+        queryset = (
+            self.get_queryset().filter(archived_at__isnull=True).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",
@@ -509,6 +523,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                 "external_source",
                 "external_id",
                 "progress_snapshot",
+                "sub_issues",
                 # meta fields
                 "is_favorite",
                 "total_issues",
@@ -523,6 +538,13 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
             .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(
@@ -662,276 +684,6 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
-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(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),
-                    ),
-                    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)
-
-
 class CycleDateCheckEndpoint(BaseAPIView):
     permission_classes = [
         ProjectEntityPermission,

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

@@ -0,0 +1,314 @@
+# 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)

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

@@ -9,7 +9,6 @@ from django.db.models import (
     F,
     Exists,
     OuterRef,
-    Max,
     Subquery,
     JSONField,
     Func,
@@ -18,7 +17,7 @@ from django.db.models import (
 )
 from django.contrib.postgres.aggregates import ArrayAgg
 from django.contrib.postgres.fields import ArrayField
-from django.db.models import Value, UUIDField
+from django.db.models import UUIDField
 from django.db.models.functions import Coalesce
 from django.utils import timezone
 
@@ -27,7 +26,7 @@ from rest_framework.response import Response
 from rest_framework import status
 
 # Module imports
-from . import BaseAPIView
+from .. import BaseAPIView
 from plane.db.models import (
     Issue,
     IssueActivity,
@@ -39,7 +38,6 @@ from plane.db.models import (
     IssueLink,
     IssueAttachment,
     IssueRelation,
-    IssueAssignee,
     User,
 )
 from plane.app.serializers import (
@@ -151,7 +149,8 @@ def dashboard_assigned_issues(self, request, slug):
                 ArrayAgg(
                     "assignees__id",
                     distinct=True,
-                    filter=~Q(assignees__id__isnull=True),
+                    filter=~Q(assignees__id__isnull=True)
+                    & Q(assignees__member_project__is_active=True),
                 ),
                 Value([], output_field=ArrayField(UUIDField())),
             ),
@@ -305,7 +304,8 @@ def dashboard_created_issues(self, request, slug):
                 ArrayAgg(
                     "assignees__id",
                     distinct=True,
-                    filter=~Q(assignees__id__isnull=True),
+                    filter=~Q(assignees__id__isnull=True)
+                    & Q(assignees__member_project__is_active=True),
                 ),
                 Value([], output_field=ArrayField(UUIDField())),
             ),
@@ -473,6 +473,7 @@ def dashboard_recent_activity(self, request, slug):
         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]
 
@@ -488,6 +489,7 @@ def dashboard_recent_projects(self, request, slug):
             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)
@@ -502,6 +504,7 @@ def dashboard_recent_projects(self, request, slug):
         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)
 
@@ -524,6 +527,7 @@ def dashboard_recent_collaborators(self, request, 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"))
@@ -536,6 +540,7 @@ def dashboard_recent_collaborators(self, request, slug):
             workspace__slug=slug,
             project__project_projectmember__member=request.user,
             project__project_projectmember__is_active=True,
+            project__archived_at__isnull=True,
         )
         .annotate(
             num_activities=Coalesce(
@@ -566,14 +571,16 @@ def dashboard_recent_collaborators(self, request, slug):
     return self.paginate(
         request=request,
         queryset=project_members_with_activities,
-        controller=self.get_results_controller,
+        controller=lambda qs: self.get_results_controller(qs, slug),
     )
 
 
 class DashboardEndpoint(BaseAPIView):
-    def get_results_controller(self, project_members_with_activities):
+    def get_results_controller(self, project_members_with_activities, slug):
         user_active_issue_counts = (
-            User.objects.filter(id__in=project_members_with_activities)
+            User.objects.filter(
+                id__in=project_members_with_activities,
+            )
             .annotate(
                 active_issue_count=Count(
                     Case(
@@ -582,10 +589,13 @@ class DashboardEndpoint(BaseAPIView):
                                 "unstarted",
                                 "started",
                             ],
-                            then=1,
+                            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"))

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

@@ -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,6 +49,7 @@ 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(
@@ -114,6 +115,7 @@ 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(
@@ -182,6 +184,7 @@ 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

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

@@ -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,7 +29,10 @@ class ExportIssuesEndpoint(BaseAPIView):
         if provider in ["csv", "xlsx", "json"]:
             if not project_ids:
                 project_ids = Project.objects.filter(
-                    workspace__slug=slug
+                    workspace__slug=slug,
+                    project_projectmember__member=request.user,
+                    project_projectmember__is_active=True,
+                    archived_at__isnull=True,
                 ).values_list("id", flat=True)
                 project_ids = [str(project_id) for project_id in project_ids]
 
@@ -50,7 +53,7 @@ class ExportIssuesEndpoint(BaseAPIView):
             )
             return Response(
                 {
-                    "message": f"Once the export is ready you will be able to download it"
+                    "message": "Once the export is ready you will be able to download it"
                 },
                 status=status.HTTP_200_OK,
             )

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

@@ -8,17 +8,15 @@ 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
 
 
@@ -85,12 +83,6 @@ 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(

apiserver/plane/app/views/importer.py

@@ -1,558 +0,0 @@
-# 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,
-            )

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

@@ -3,7 +3,7 @@ import json
 
 # Django import
 from django.utils import timezone
-from django.db.models import Q, Count, OuterRef, Func, F, Prefetch, Exists
+from django.db.models import Q, Count, OuterRef, Func, F, Prefetch
 from django.core.serializers.json import DjangoJSONEncoder
 from django.contrib.postgres.aggregates import ArrayAgg
 from django.contrib.postgres.fields import ArrayField
@@ -15,7 +15,7 @@ from rest_framework import status
 from rest_framework.response import Response
 
 # Module imports
-from .base import BaseViewSet
+from ..base import BaseViewSet
 from plane.app.permissions import ProjectBasePermission, ProjectLitePermission
 from plane.db.models import (
     Inbox,
@@ -24,16 +24,15 @@ from plane.db.models import (
     State,
     IssueLink,
     IssueAttachment,
+    Project,
     ProjectMember,
-    IssueReaction,
-    IssueSubscriber,
 )
 from plane.app.serializers import (
     IssueCreateSerializer,
     IssueSerializer,
     InboxSerializer,
     InboxIssueSerializer,
-    IssueDetailSerializer,
+    InboxIssueDetailSerializer,
 )
 from plane.utils.issue_filters import issue_filters
 from plane.bgtasks.issue_activites_task import issue_activity
@@ -64,13 +63,20 @@ class InboxViewSet(BaseViewSet):
             .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.get(
+        inbox = Inbox.objects.filter(
             workspace__slug=slug, project_id=project_id, pk=pk
-        )
+        ).first()
         # Handle default inbox delete
         if inbox.is_default:
             return Response(
@@ -98,7 +104,6 @@ class InboxIssueViewSet(BaseViewSet):
             Issue.objects.filter(
                 project_id=self.kwargs.get("project_id"),
                 workspace__slug=self.kwargs.get("slug"),
-                issue_inbox__inbox_id=self.kwargs.get("inbox_id"),
             )
             .select_related("workspace", "project", "state", "parent")
             .prefetch_related("assignees", "labels", "issue_module__module")
@@ -146,7 +151,8 @@ class InboxIssueViewSet(BaseViewSet):
                     ArrayAgg(
                         "assignees__id",
                         distinct=True,
-                        filter=~Q(assignees__id__isnull=True),
+                        filter=~Q(assignees__id__isnull=True)
+                        & Q(assignees__member_project__is_active=True),
                     ),
                     Value([], output_field=ArrayField(UUIDField())),
                 ),
@@ -161,51 +167,49 @@ class InboxIssueViewSet(BaseViewSet):
             )
         ).distinct()
 
-    def list(self, request, slug, project_id, inbox_id):
-        filters = issue_filters(request.query_params, "GET")
-        issue_queryset = (
-            self.get_queryset()
-            .filter(**filters)
-            .order_by("issue_inbox__snoozed_till", "issue_inbox__status")
-        )
-        if self.expand:
-            issues = IssueSerializer(
-                issue_queryset, expand=self.expand, many=True
-            ).data
-        else:
-            issues = issue_queryset.values(
-                "id",
-                "name",
-                "state_id",
-                "sort_order",
-                "completed_at",
-                "estimate_point",
-                "priority",
-                "start_date",
-                "target_date",
-                "sequence_id",
-                "project_id",
-                "parent_id",
-                "cycle_id",
-                "module_ids",
-                "label_ids",
-                "assignee_ids",
-                "sub_issues_count",
-                "created_at",
-                "updated_at",
-                "created_by",
-                "updated_by",
-                "attachment_count",
-                "link_count",
-                "is_draft",
-                "archived_at",
+    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
             )
-        return Response(
-            issues,
-            status=status.HTTP_200_OK,
+            .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, inbox_id):
+    def create(self, request, slug, project_id):
         if not request.data.get("issue", {}).get("name", False):
             return Response(
                 {"error": "Name is required"},
@@ -213,7 +217,7 @@ class InboxIssueViewSet(BaseViewSet):
             )
 
         # Check for valid priority
-        if not request.data.get("issue", {}).get("priority", "none") in [
+        if request.data.get("issue", {}).get("priority", "none") not in [
             "low",
             "medium",
             "high",
@@ -228,49 +232,88 @@ class InboxIssueViewSet(BaseViewSet):
         # Create or get state
         state, _ = State.objects.get_or_create(
             name="Triage",
-            group="backlog",
+            group="triage",
             description="Default state for managing all Inbox Issues",
             project_id=project_id,
             color="#ff7700",
+            is_triage=True,
         )
 
         # 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,
+        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
+            )
 
-        # 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()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-        # create an inbox issue
-        InboxIssue.objects.create(
-            inbox_id=inbox_id,
-            project_id=project_id,
-            issue=issue,
-            source=request.data.get("source", "in-app"),
-        )
-
-        issue = self.get_queryset().filter(pk=issue.id).first()
-        serializer = IssueSerializer(issue, expand=self.expand)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def partial_update(self, request, slug, project_id, inbox_id, issue_id):
+    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,
@@ -295,9 +338,12 @@ class InboxIssueViewSet(BaseViewSet):
 
         # Get issue data
         issue_data = request.data.pop("issue", False)
-
         if bool(issue_data):
-            issue = self.get_queryset().filter(pk=inbox_issue.issue_id).first()
+            issue = Issue.objects.get(
+                pk=inbox_issue.issue_id,
+                workspace__slug=slug,
+                project_id=project_id,
+            )
             # Only allow guests and viewers to edit name and description
             if project_member.role <= 10:
                 # viewers and guests since only viewers and guests
@@ -345,7 +391,9 @@ class InboxIssueViewSet(BaseViewSet):
             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
@@ -373,7 +421,7 @@ class InboxIssueViewSet(BaseViewSet):
                     )
 
                     # Update the issue state only if it is in triage state
-                    if issue.state.name == "Triage":
+                    if issue.state.is_triage:
                         # Move to default state
                         state = State.objects.filter(
                             workspace__slug=slug,
@@ -383,57 +431,108 @@ class InboxIssueViewSet(BaseViewSet):
                         if state is not None:
                             issue.state = state
                             issue.save()
-                return Response(status=status.HTTP_204_NO_CONTENT)
+                # 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:
-            issue = self.get_queryset().filter(pk=issue_id).first()
-            serializer = IssueSerializer(issue, expand=self.expand)
-            return Response(serializer.data, status=status.HTTP_200_OK)
+            serializer = InboxIssueDetailSerializer(inbox_issue).data
+            return Response(serializer, status=status.HTTP_200_OK)
 
-    def retrieve(self, request, slug, project_id, inbox_id, issue_id):
-        issue = (
-            self.get_queryset()
-            .filter(pk=issue_id)
+    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(
-                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"),
-                )
+                "issue__labels",
+                "issue__assignees",
             )
             .annotate(
-                is_subscribed=Exists(
-                    IssueSubscriber.objects.filter(
-                        workspace__slug=slug,
-                        project_id=project_id,
-                        issue_id=OuterRef("pk"),
-                        subscriber=request.user,
-                    )
-                )
+                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()
-        if issue is None:
-            return Response({"error": "Requested object was not found"}, status=status.HTTP_404_NOT_FOUND)
-        
-        serializer = IssueDetailSerializer(issue)
-        return Response(serializer.data, status=status.HTTP_200_OK)
+            .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, inbox_id, issue_id):
+    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,

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

@@ -1,9 +0,0 @@
-from .base import IntegrationViewSet, WorkspaceIntegrationViewSet
-from .github import (
-    GithubRepositorySyncViewSet,
-    GithubIssueSyncViewSet,
-    BulkCreateGithubIssueSyncEndpoint,
-    GithubCommentSyncViewSet,
-    GithubRepositoriesEndpoint,
-)
-from .slack import SlackProjectSyncViewSet

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

@@ -1,181 +0,0 @@
-# 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)

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

@@ -1,202 +0,0 @@
-# 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"),
-        )

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

@@ -1,96 +0,0 @@
-# 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,
-                project__project_projectmember__is_active=True,
-            )
-        )
-
-    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,
-            )

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

@@ -0,0 +1,87 @@
+# 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)

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

@@ -0,0 +1,348 @@
+# 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)

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

@@ -0,0 +1,73 @@
+# 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)

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

@@ -0,0 +1,663 @@
+# Python imports
+import json
+
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.core.serializers.json import DjangoJSONEncoder
+from django.db.models import (
+    Case,
+    CharField,
+    Exists,
+    F,
+    Func,
+    Max,
+    OuterRef,
+    Prefetch,
+    Q,
+    UUIDField,
+    Value,
+    When,
+)
+from django.db.models.functions import Coalesce
+
+# Django imports
+from django.utils import timezone
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+from rest_framework import status
+
+# Third Party imports
+from rest_framework.response import Response
+
+from plane.app.permissions import (
+    ProjectEntityPermission,
+    ProjectLitePermission,
+)
+from plane.app.serializers import (
+    IssueCreateSerializer,
+    IssueDetailSerializer,
+    IssuePropertySerializer,
+    IssueSerializer,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from plane.db.models import (
+    Issue,
+    IssueAttachment,
+    IssueLink,
+    IssueProperty,
+    IssueReaction,
+    IssueSubscriber,
+    Project,
+)
+from plane.utils.issue_filters import issue_filters
+
+# Module imports
+from .. import BaseAPIView, BaseViewSet, WebhookMixin
+
+
+class IssueListEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get(self, request, slug, project_id):
+        issue_ids = request.GET.get("issues", False)
+
+        if not issue_ids:
+            return Response(
+                {"error": "Issues are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        issue_ids = [
+            issue_id for issue_id in issue_ids.split(",") if issue_id != ""
+        ]
+
+        queryset = (
+            Issue.issue_objects.filter(
+                workspace__slug=slug, project_id=project_id, pk__in=issue_ids
+            )
+            .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())),
+                ),
+            )
+        ).distinct()
+
+        filters = issue_filters(request.query_params, "GET")
+
+        # 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 = 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)
+
+        if self.fields or self.expand:
+            issues = IssueSerializer(
+                queryset, many=True, fields=self.fields, expand=self.expand
+            ).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)
+
+
+class IssueViewSet(WebhookMixin, BaseViewSet):
+    def get_serializer_class(self):
+        return (
+            IssueCreateSerializer
+            if self.action in ["create", "update", "partial_update"]
+            else IssueSerializer
+        )
+
+    model = Issue
+    webhook_event = "issue"
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    search_fields = [
+        "name",
+    ]
+
+    filterset_fields = [
+        "state__name",
+        "assignees__id",
+        "workspace__id",
+    ]
+
+    def get_queryset(self):
+        return (
+            Issue.issue_objects.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())),
+                ),
+            )
+        ).distinct()
+
+    @method_decorator(gzip_page)
+    def list(self, request, slug, project_id):
+        filters = issue_filters(request.query_params, "GET")
+        order_by_param = request.GET.get("order_by", "-created_at")
+
+        issue_queryset = self.get_queryset().filter(**filters)
+        # Custom ordering for priority and state
+        priority_order = ["urgent", "high", "medium", "low", "none"]
+        state_order = [
+            "backlog",
+            "unstarted",
+            "started",
+            "completed",
+            "cancelled",
+        ]
+
+        # 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)
+
+        # Only use serializer when expand or fields else return by values
+        if self.expand or self.fields:
+            issues = IssueSerializer(
+                issue_queryset,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+            ).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 create(self, request, slug, project_id):
+        project = Project.objects.get(pk=project_id)
+
+        serializer = IssueCreateSerializer(
+            data=request.data,
+            context={
+                "project_id": project_id,
+                "workspace_id": project.workspace_id,
+                "default_assignee_id": project.default_assignee_id,
+            },
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+
+            # Track the issue
+            issue_activity.delay(
+                type="issue.activity.created",
+                requested_data=json.dumps(
+                    self.request.data, cls=DjangoJSONEncoder
+                ),
+                actor_id=str(request.user.id),
+                issue_id=str(serializer.data.get("id", None)),
+                project_id=str(project_id),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            issue = (
+                self.get_queryset()
+                .filter(pk=serializer.data["id"])
+                .values(
+                    "id",
+                    "name",
+                    "state_id",
+                    "sort_order",
+                    "completed_at",
+                    "estimate_point",
+                    "priority",
+                    "start_date",
+                    "target_date",
+                    "sequence_id",
+                    "project_id",
+                    "parent_id",
+                    "cycle_id",
+                    "module_ids",
+                    "label_ids",
+                    "assignee_ids",
+                    "sub_issues_count",
+                    "created_at",
+                    "updated_at",
+                    "created_by",
+                    "updated_by",
+                    "attachment_count",
+                    "link_count",
+                    "is_draft",
+                    "archived_at",
+                )
+                .first()
+            )
+            return Response(issue, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def 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 partial_update(self, request, slug, project_id, pk=None):
+        issue = self.get_queryset().filter(pk=pk).first()
+
+        if not issue:
+            return Response(
+                {"error": "Issue not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        current_instance = json.dumps(
+            IssueSerializer(issue).data, cls=DjangoJSONEncoder
+        )
+
+        requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
+        serializer = IssueCreateSerializer(
+            issue, data=request.data, partial=True
+        )
+        if serializer.is_valid():
+            serializer.save()
+            issue_activity.delay(
+                type="issue.activity.updated",
+                requested_data=requested_data,
+                actor_id=str(request.user.id),
+                issue_id=str(pk),
+                project_id=str(project_id),
+                current_instance=current_instance,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            issue = self.get_queryset().filter(pk=pk).first()
+            return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def destroy(self, request, slug, project_id, pk=None):
+        issue = Issue.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
+        issue.delete()
+        issue_activity.delay(
+            type="issue.activity.deleted",
+            requested_data=json.dumps({"issue_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(pk),
+            project_id=str(project_id),
+            current_instance={},
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class IssueUserDisplayPropertyEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectLitePermission,
+    ]
+
+    def patch(self, request, slug, project_id):
+        issue_property = IssueProperty.objects.get(
+            user=request.user,
+            project_id=project_id,
+        )
+
+        issue_property.filters = request.data.get(
+            "filters", issue_property.filters
+        )
+        issue_property.display_filters = request.data.get(
+            "display_filters", issue_property.display_filters
+        )
+        issue_property.display_properties = request.data.get(
+            "display_properties", issue_property.display_properties
+        )
+        issue_property.save()
+        serializer = IssuePropertySerializer(issue_property)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    def get(self, request, slug, project_id):
+        issue_property, _ = IssueProperty.objects.get_or_create(
+            user=request.user, project_id=project_id
+        )
+        serializer = IssuePropertySerializer(issue_property)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class BulkDeleteIssuesEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def delete(self, request, slug, project_id):
+        issue_ids = request.data.get("issue_ids", [])
+
+        if not len(issue_ids):
+            return Response(
+                {"error": "Issue IDs are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        issues = Issue.issue_objects.filter(
+            workspace__slug=slug, project_id=project_id, pk__in=issue_ids
+        )
+
+        total_issues = len(issues)
+
+        issues.delete()
+
+        return Response(
+            {"message": f"{total_issues} issues were deleted"},
+            status=status.HTTP_200_OK,
+        )

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

@@ -0,0 +1,221 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.db.models import Exists
+from django.core.serializers.json import DjangoJSONEncoder
+
+# 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 (
+    IssueCommentSerializer,
+    CommentReactionSerializer,
+)
+from plane.app.permissions import ProjectLitePermission
+from plane.db.models import (
+    IssueComment,
+    ProjectMember,
+    CommentReaction,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+
+
+class IssueCommentViewSet(WebhookMixin, BaseViewSet):
+    serializer_class = IssueCommentSerializer
+    model = IssueComment
+    webhook_event = "issue_comment"
+    permission_classes = [
+        ProjectLitePermission,
+    ]
+
+    filterset_fields = [
+        "issue__id",
+        "workspace__id",
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(issue_id=self.kwargs.get("issue_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .annotate(
+                is_member=Exists(
+                    ProjectMember.objects.filter(
+                        workspace__slug=self.kwargs.get("slug"),
+                        project_id=self.kwargs.get("project_id"),
+                        member_id=self.request.user.id,
+                        is_active=True,
+                    )
+                )
+            )
+            .distinct()
+        )
+
+    def create(self, request, slug, project_id, issue_id):
+        serializer = IssueCommentSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(
+                project_id=project_id,
+                issue_id=issue_id,
+                actor=request.user,
+            )
+            issue_activity.delay(
+                type="comment.activity.created",
+                requested_data=json.dumps(
+                    serializer.data, cls=DjangoJSONEncoder
+                ),
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id")),
+                project_id=str(self.kwargs.get("project_id")),
+                current_instance=None,
+                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 partial_update(self, request, slug, project_id, issue_id, pk):
+        issue_comment = IssueComment.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            issue_id=issue_id,
+            pk=pk,
+        )
+        requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
+        current_instance = json.dumps(
+            IssueCommentSerializer(issue_comment).data,
+            cls=DjangoJSONEncoder,
+        )
+        serializer = IssueCommentSerializer(
+            issue_comment, data=request.data, partial=True
+        )
+        if serializer.is_valid():
+            serializer.save()
+            issue_activity.delay(
+                type="comment.activity.updated",
+                requested_data=requested_data,
+                actor_id=str(request.user.id),
+                issue_id=str(issue_id),
+                project_id=str(project_id),
+                current_instance=current_instance,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                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)
+
+    def destroy(self, request, slug, project_id, issue_id, pk):
+        issue_comment = IssueComment.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            issue_id=issue_id,
+            pk=pk,
+        )
+        current_instance = json.dumps(
+            IssueCommentSerializer(issue_comment).data,
+            cls=DjangoJSONEncoder,
+        )
+        issue_comment.delete()
+        issue_activity.delay(
+            type="comment.activity.deleted",
+            requested_data=json.dumps({"comment_id": str(pk)}),
+            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=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class CommentReactionViewSet(BaseViewSet):
+    serializer_class = CommentReactionSerializer
+    model = CommentReaction
+    permission_classes = [
+        ProjectLitePermission,
+    ]
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(comment_id=self.kwargs.get("comment_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    def create(self, request, slug, project_id, comment_id):
+        serializer = CommentReactionSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(
+                project_id=project_id,
+                actor_id=request.user.id,
+                comment_id=comment_id,
+            )
+            issue_activity.delay(
+                type="comment_reaction.activity.created",
+                requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+                actor_id=str(request.user.id),
+                issue_id=None,
+                project_id=str(project_id),
+                current_instance=None,
+                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 destroy(self, request, slug, project_id, comment_id, reaction_code):
+        comment_reaction = CommentReaction.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            comment_id=comment_id,
+            reaction=reaction_code,
+            actor=request.user,
+        )
+        issue_activity.delay(
+            type="comment_reaction.activity.deleted",
+            requested_data=None,
+            actor_id=str(self.request.user.id),
+            issue_id=None,
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps(
+                {
+                    "reaction": str(reaction_code),
+                    "identifier": str(comment_reaction.id),
+                    "comment_id": str(comment_id),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        comment_reaction.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

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

@@ -0,0 +1,363 @@
+# Python imports
+import json
+
+# Django imports
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.core.serializers.json import DjangoJSONEncoder
+from django.db.models import (
+    Case,
+    CharField,
+    Exists,
+    F,
+    Func,
+    Max,
+    OuterRef,
+    Prefetch,
+    Q,
+    UUIDField,
+    Value,
+    When,
+)
+from django.db.models.functions import Coalesce
+from django.utils import timezone
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+
+# Third Party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+from plane.app.permissions import ProjectEntityPermission
+from plane.app.serializers import (
+    IssueCreateSerializer,
+    IssueDetailSerializer,
+    IssueFlatSerializer,
+    IssueSerializer,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from plane.db.models import (
+    Issue,
+    IssueAttachment,
+    IssueLink,
+    IssueReaction,
+    IssueSubscriber,
+    Project,
+)
+from plane.utils.issue_filters import issue_filters
+
+# Module imports
+from .. import BaseViewSet
+
+
+class IssueDraftViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+    serializer_class = IssueFlatSerializer
+    model = Issue
+
+    def get_queryset(self):
+        return (
+            Issue.objects.filter(project_id=self.kwargs.get("project_id"))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(is_draft=True)
+            .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())),
+                ),
+            )
+        ).distinct()
+
+    @method_decorator(gzip_page)
+    def list(self, request, slug, project_id):
+        filters = issue_filters(request.query_params, "GET")
+        # 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)
+
+        # Only use serializer when expand else return by values
+        if self.expand or self.fields:
+            issues = IssueSerializer(
+                issue_queryset,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+            ).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 create(self, request, slug, project_id):
+        project = Project.objects.get(pk=project_id)
+
+        serializer = IssueCreateSerializer(
+            data=request.data,
+            context={
+                "project_id": project_id,
+                "workspace_id": project.workspace_id,
+                "default_assignee_id": project.default_assignee_id,
+            },
+        )
+
+        if serializer.is_valid():
+            serializer.save(is_draft=True)
+
+            # Track the issue
+            issue_activity.delay(
+                type="issue_draft.activity.created",
+                requested_data=json.dumps(
+                    self.request.data, cls=DjangoJSONEncoder
+                ),
+                actor_id=str(request.user.id),
+                issue_id=str(serializer.data.get("id", None)),
+                project_id=str(project_id),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            issue = (
+                self.get_queryset().filter(pk=serializer.data["id"]).first()
+            )
+            return Response(
+                IssueSerializer(issue).data, status=status.HTTP_201_CREATED
+            )
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def partial_update(self, request, slug, project_id, pk):
+        issue = self.get_queryset().filter(pk=pk).first()
+
+        if not issue:
+            return Response(
+                {"error": "Issue does not exist"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        serializer = IssueCreateSerializer(
+            issue, data=request.data, partial=True
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+            issue_activity.delay(
+                type="issue_draft.activity.updated",
+                requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("pk", None)),
+                project_id=str(self.kwargs.get("project_id", None)),
+                current_instance=json.dumps(
+                    IssueSerializer(issue).data,
+                    cls=DjangoJSONEncoder,
+                ),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def retrieve(self, request, slug, project_id, pk=None):
+        issue = (
+            self.get_queryset()
+            .filter(pk=pk)
+            .prefetch_related(
+                Prefetch(
+                    "issue_reactions",
+                    queryset=IssueReaction.objects.select_related(
+                        "issue", "actor"
+                    ),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_attachment",
+                    queryset=IssueAttachment.objects.select_related("issue"),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_link",
+                    queryset=IssueLink.objects.select_related("created_by"),
+                )
+            )
+            .annotate(
+                is_subscribed=Exists(
+                    IssueSubscriber.objects.filter(
+                        workspace__slug=slug,
+                        project_id=project_id,
+                        issue_id=OuterRef("pk"),
+                        subscriber=request.user,
+                    )
+                )
+            )
+        ).first()
+
+        if not issue:
+            return Response(
+                {"error": "The required object does not exist."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        serializer = IssueDetailSerializer(issue, expand=self.expand)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def destroy(self, request, slug, project_id, pk=None):
+        issue = Issue.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
+        issue.delete()
+        issue_activity.delay(
+            type="issue_draft.activity.deleted",
+            requested_data=json.dumps({"issue_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(pk),
+            project_id=str(project_id),
+            current_instance={},
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)

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

@@ -0,0 +1,105 @@
+# Python imports
+import random
+
+# Django imports
+from django.db import IntegrityError
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet, BaseAPIView
+from plane.app.serializers import LabelSerializer
+from plane.app.permissions import (
+    ProjectMemberPermission,
+)
+from plane.db.models import (
+    Project,
+    Label,
+)
+from plane.utils.cache import invalidate_cache
+
+
+class LabelViewSet(BaseViewSet):
+    serializer_class = LabelSerializer
+    model = Label
+    permission_classes = [
+        ProjectMemberPermission,
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("parent")
+            .distinct()
+            .order_by("sort_order")
+        )
+
+    @invalidate_cache(
+        path="/api/workspaces/:slug/labels/", url_params=True, user=False
+    )
+    def create(self, request, slug, project_id):
+        try:
+            serializer = LabelSerializer(data=request.data)
+            if serializer.is_valid():
+                serializer.save(project_id=project_id)
+                return Response(
+                    serializer.data, status=status.HTTP_201_CREATED
+                )
+            return Response(
+                serializer.errors, status=status.HTTP_400_BAD_REQUEST
+            )
+        except IntegrityError:
+            return Response(
+                {
+                    "error": "Label with the same name already exists in the project"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+    @invalidate_cache(
+        path="/api/workspaces/:slug/labels/", url_params=True, user=False
+    )
+    def partial_update(self, request, *args, **kwargs):
+        return super().partial_update(request, *args, **kwargs)
+
+    @invalidate_cache(
+        path="/api/workspaces/:slug/labels/", url_params=True, user=False
+    )
+    def destroy(self, request, *args, **kwargs):
+        return super().destroy(request, *args, **kwargs)
+
+
+class BulkCreateIssueLabelsEndpoint(BaseAPIView):
+    def post(self, request, slug, project_id):
+        label_data = request.data.get("label_data", [])
+        project = Project.objects.get(pk=project_id)
+
+        labels = Label.objects.bulk_create(
+            [
+                Label(
+                    name=label.get("name", "Migrated"),
+                    description=label.get("description", "Migrated Issue"),
+                    color=f"#{random.randint(0, 0xFFFFFF+1):06X}",
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for label in label_data
+            ],
+            batch_size=50,
+            ignore_conflicts=True,
+        )
+
+        return Response(
+            {"labels": LabelSerializer(labels, many=True).data},
+            status=status.HTTP_201_CREATED,
+        )

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

@@ -0,0 +1,121 @@
+# 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
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import IssueLinkSerializer
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import IssueLink
+from plane.bgtasks.issue_activites_task import issue_activity
+
+
+class IssueLinkViewSet(BaseViewSet):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    model = IssueLink
+    serializer_class = IssueLinkSerializer
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .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,
+                project__archived_at__isnull=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    def create(self, request, slug, project_id, issue_id):
+        serializer = IssueLinkSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(
+                project_id=project_id,
+                issue_id=issue_id,
+            )
+            issue_activity.delay(
+                type="link.activity.created",
+                requested_data=json.dumps(
+                    serializer.data, cls=DjangoJSONEncoder
+                ),
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id")),
+                project_id=str(self.kwargs.get("project_id")),
+                current_instance=None,
+                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 partial_update(self, request, slug, project_id, issue_id, pk):
+        issue_link = IssueLink.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            issue_id=issue_id,
+            pk=pk,
+        )
+        requested_data = json.dumps(request.data, cls=DjangoJSONEncoder)
+        current_instance = json.dumps(
+            IssueLinkSerializer(issue_link).data,
+            cls=DjangoJSONEncoder,
+        )
+        serializer = IssueLinkSerializer(
+            issue_link, data=request.data, partial=True
+        )
+        if serializer.is_valid():
+            serializer.save()
+            issue_activity.delay(
+                type="link.activity.updated",
+                requested_data=requested_data,
+                actor_id=str(request.user.id),
+                issue_id=str(issue_id),
+                project_id=str(project_id),
+                current_instance=current_instance,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                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)
+
+    def destroy(self, request, slug, project_id, issue_id, pk):
+        issue_link = IssueLink.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            issue_id=issue_id,
+            pk=pk,
+        )
+        current_instance = json.dumps(
+            IssueLinkSerializer(issue_link).data,
+            cls=DjangoJSONEncoder,
+        )
+        issue_activity.delay(
+            type="link.activity.deleted",
+            requested_data=json.dumps({"link_id": str(pk)}),
+            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=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        issue_link.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

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

@@ -0,0 +1,90 @@
+# 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
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import IssueReactionSerializer
+from plane.app.permissions import ProjectLitePermission
+from plane.db.models import IssueReaction
+from plane.bgtasks.issue_activites_task import issue_activity
+
+
+class IssueReactionViewSet(BaseViewSet):
+    serializer_class = IssueReactionSerializer
+    model = IssueReaction
+    permission_classes = [
+        ProjectLitePermission,
+    ]
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .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,
+                project__archived_at__isnull=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    def create(self, request, slug, project_id, issue_id):
+        serializer = IssueReactionSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(
+                issue_id=issue_id,
+                project_id=project_id,
+                actor=request.user,
+            )
+            issue_activity.delay(
+                type="issue_reaction.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()),
+                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 destroy(self, request, slug, project_id, issue_id, reaction_code):
+        issue_reaction = IssueReaction.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            issue_id=issue_id,
+            reaction=reaction_code,
+            actor=request.user,
+        )
+        issue_activity.delay(
+            type="issue_reaction.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=json.dumps(
+                {
+                    "reaction": str(reaction_code),
+                    "identifier": str(issue_reaction.id),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        issue_reaction.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

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

@@ -0,0 +1,205 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.db.models import Q
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import (
+    IssueRelationSerializer,
+    RelatedIssueSerializer,
+)
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import (
+    Project,
+    IssueRelation,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+
+
+class IssueRelationViewSet(BaseViewSet):
+    serializer_class = IssueRelationSerializer
+    model = IssueRelation
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(issue_id=self.kwargs.get("issue_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .distinct()
+        )
+
+    def list(self, request, slug, project_id, issue_id):
+        issue_relations = (
+            IssueRelation.objects.filter(
+                Q(issue_id=issue_id) | Q(related_issue=issue_id)
+            )
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .order_by("-created_at")
+            .distinct()
+        )
+
+        blocking_issues = issue_relations.filter(
+            relation_type="blocked_by", related_issue_id=issue_id
+        )
+        blocked_by_issues = issue_relations.filter(
+            relation_type="blocked_by", issue_id=issue_id
+        )
+        duplicate_issues = issue_relations.filter(
+            issue_id=issue_id, relation_type="duplicate"
+        )
+        duplicate_issues_related = issue_relations.filter(
+            related_issue_id=issue_id, relation_type="duplicate"
+        )
+        relates_to_issues = issue_relations.filter(
+            issue_id=issue_id, relation_type="relates_to"
+        )
+        relates_to_issues_related = issue_relations.filter(
+            related_issue_id=issue_id, relation_type="relates_to"
+        )
+
+        blocked_by_issues_serialized = IssueRelationSerializer(
+            blocked_by_issues, many=True
+        ).data
+        duplicate_issues_serialized = IssueRelationSerializer(
+            duplicate_issues, many=True
+        ).data
+        relates_to_issues_serialized = IssueRelationSerializer(
+            relates_to_issues, many=True
+        ).data
+
+        # revere relation for blocked by issues
+        blocking_issues_serialized = RelatedIssueSerializer(
+            blocking_issues, many=True
+        ).data
+        # reverse relation for duplicate issues
+        duplicate_issues_related_serialized = RelatedIssueSerializer(
+            duplicate_issues_related, many=True
+        ).data
+        # reverse relation for related issues
+        relates_to_issues_related_serialized = RelatedIssueSerializer(
+            relates_to_issues_related, many=True
+        ).data
+
+        response_data = {
+            "blocking": blocking_issues_serialized,
+            "blocked_by": blocked_by_issues_serialized,
+            "duplicate": duplicate_issues_serialized
+            + duplicate_issues_related_serialized,
+            "relates_to": relates_to_issues_serialized
+            + relates_to_issues_related_serialized,
+        }
+
+        return Response(response_data, status=status.HTTP_200_OK)
+
+    def create(self, request, slug, project_id, issue_id):
+        relation_type = request.data.get("relation_type", None)
+        issues = request.data.get("issues", [])
+        project = Project.objects.get(pk=project_id)
+
+        issue_relation = IssueRelation.objects.bulk_create(
+            [
+                IssueRelation(
+                    issue_id=(
+                        issue if relation_type == "blocking" else issue_id
+                    ),
+                    related_issue_id=(
+                        issue_id if relation_type == "blocking" else issue
+                    ),
+                    relation_type=(
+                        "blocked_by"
+                        if relation_type == "blocking"
+                        else relation_type
+                    ),
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for issue in issues
+            ],
+            batch_size=10,
+            ignore_conflicts=True,
+        )
+
+        issue_activity.delay(
+            type="issue_relation.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()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+
+        if relation_type == "blocking":
+            return Response(
+                RelatedIssueSerializer(issue_relation, many=True).data,
+                status=status.HTTP_201_CREATED,
+            )
+        else:
+            return Response(
+                IssueRelationSerializer(issue_relation, many=True).data,
+                status=status.HTTP_201_CREATED,
+            )
+
+    def remove_relation(self, request, slug, project_id, issue_id):
+        relation_type = request.data.get("relation_type", None)
+        related_issue = request.data.get("related_issue", None)
+
+        if relation_type == "blocking":
+            issue_relation = IssueRelation.objects.get(
+                workspace__slug=slug,
+                project_id=project_id,
+                issue_id=related_issue,
+                related_issue_id=issue_id,
+            )
+        else:
+            issue_relation = IssueRelation.objects.get(
+                workspace__slug=slug,
+                project_id=project_id,
+                issue_id=issue_id,
+                related_issue_id=related_issue,
+            )
+        current_instance = json.dumps(
+            IssueRelationSerializer(issue_relation).data,
+            cls=DjangoJSONEncoder,
+        )
+        issue_relation.delete()
+        issue_activity.delay(
+            type="issue_relation.activity.deleted",
+            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=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)

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

@@ -0,0 +1,196 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.db.models import (
+    OuterRef,
+    Func,
+    F,
+    Q,
+    Value,
+    UUIDField,
+)
+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 BaseAPIView
+from plane.app.serializers import IssueSerializer
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import (
+    Issue,
+    IssueLink,
+    IssueAttachment,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from collections import defaultdict
+
+
+class SubIssuesEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    @method_decorator(gzip_page)
+    def get(self, request, slug, project_id, issue_id):
+        sub_issues = (
+            Issue.issue_objects.filter(
+                parent_id=issue_id, workspace__slug=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())),
+                ),
+            )
+            .annotate(state_group=F("state__group"))
+        )
+
+        # create's a dict with state group name with their respective issue id's
+        result = defaultdict(list)
+        for sub_issue in sub_issues:
+            result[sub_issue.state_group].append(str(sub_issue.id))
+
+        sub_issues = sub_issues.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(
+            {
+                "sub_issues": sub_issues,
+                "state_distribution": result,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    # Assign multiple sub issues
+    def post(self, request, slug, project_id, issue_id):
+        parent_issue = Issue.issue_objects.get(pk=issue_id)
+        sub_issue_ids = request.data.get("sub_issue_ids", [])
+
+        if not len(sub_issue_ids):
+            return Response(
+                {"error": "Sub Issue IDs are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        sub_issues = Issue.issue_objects.filter(id__in=sub_issue_ids)
+
+        for sub_issue in sub_issues:
+            sub_issue.parent = parent_issue
+
+        _ = Issue.objects.bulk_update(sub_issues, ["parent"], batch_size=10)
+
+        updated_sub_issues = Issue.issue_objects.filter(
+            id__in=sub_issue_ids
+        ).annotate(state_group=F("state__group"))
+
+        # Track the issue
+        _ = [
+            issue_activity.delay(
+                type="issue.activity.updated",
+                requested_data=json.dumps({"parent": str(issue_id)}),
+                actor_id=str(request.user.id),
+                issue_id=str(sub_issue_id),
+                project_id=str(project_id),
+                current_instance=json.dumps({"parent": str(sub_issue_id)}),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            for sub_issue_id in sub_issue_ids
+        ]
+
+        # create's a dict with state group name with their respective issue id's
+        result = defaultdict(list)
+        for sub_issue in updated_sub_issues:
+            result[sub_issue.state_group].append(str(sub_issue.id))
+
+        serializer = IssueSerializer(
+            updated_sub_issues,
+            many=True,
+        )
+        return Response(
+            {
+                "sub_issues": serializer.data,
+                "state_distribution": result,
+            },
+            status=status.HTTP_200_OK,
+        )

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

@@ -0,0 +1,125 @@
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import (
+    IssueSubscriberSerializer,
+    ProjectMemberLiteSerializer,
+)
+from plane.app.permissions import (
+    ProjectEntityPermission,
+    ProjectLitePermission,
+)
+from plane.db.models import (
+    IssueSubscriber,
+    ProjectMember,
+)
+
+
+class IssueSubscriberViewSet(BaseViewSet):
+    serializer_class = IssueSubscriberSerializer
+    model = IssueSubscriber
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get_permissions(self):
+        if self.action in ["subscribe", "unsubscribe", "subscription_status"]:
+            self.permission_classes = [
+                ProjectLitePermission,
+            ]
+        else:
+            self.permission_classes = [
+                ProjectEntityPermission,
+            ]
+
+        return super(IssueSubscriberViewSet, self).get_permissions()
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"),
+            issue_id=self.kwargs.get("issue_id"),
+        )
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .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,
+                project__archived_at__isnull=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    def list(self, request, slug, project_id, issue_id):
+        members = ProjectMember.objects.filter(
+            workspace__slug=slug,
+            project_id=project_id,
+            is_active=True,
+        ).select_related("member")
+        serializer = ProjectMemberLiteSerializer(members, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def destroy(self, request, slug, project_id, issue_id, subscriber_id):
+        issue_subscriber = IssueSubscriber.objects.get(
+            project=project_id,
+            subscriber=subscriber_id,
+            workspace__slug=slug,
+            issue=issue_id,
+        )
+        issue_subscriber.delete()
+        return Response(
+            status=status.HTTP_204_NO_CONTENT,
+        )
+
+    def subscribe(self, request, slug, project_id, issue_id):
+        if IssueSubscriber.objects.filter(
+            issue_id=issue_id,
+            subscriber=request.user,
+            workspace__slug=slug,
+            project=project_id,
+        ).exists():
+            return Response(
+                {"message": "User already subscribed to the issue."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        subscriber = IssueSubscriber.objects.create(
+            issue_id=issue_id,
+            subscriber_id=request.user.id,
+            project_id=project_id,
+        )
+        serializer = IssueSubscriberSerializer(subscriber)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    def unsubscribe(self, request, slug, project_id, issue_id):
+        issue_subscriber = IssueSubscriber.objects.get(
+            project=project_id,
+            subscriber=request.user,
+            workspace__slug=slug,
+            issue=issue_id,
+        )
+        issue_subscriber.delete()
+        return Response(
+            status=status.HTTP_204_NO_CONTENT,
+        )
+
+    def subscription_status(self, request, slug, project_id, issue_id):
+        issue_subscriber = IssueSubscriber.objects.filter(
+            issue=issue_id,
+            subscriber=request.user,
+            workspace__slug=slug,
+            project=project_id,
+        ).exists()
+        return Response(
+            {"subscribed": issue_subscriber}, status=status.HTTP_200_OK
+        )

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

@@ -0,0 +1,356 @@
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import (
+    Count,
+    Exists,
+    F,
+    Func,
+    IntegerField,
+    OuterRef,
+    Prefetch,
+    Q,
+    Subquery,
+    UUIDField,
+    Value,
+)
+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.app.serializers import (
+    ModuleDetailSerializer,
+)
+from plane.db.models import (
+    Issue,
+    Module,
+    ModuleFavorite,
+    ModuleLink,
+)
+from plane.utils.analytics_plot import burndown_plot
+
+# Module imports
+from .. import BaseAPIView
+
+
+class ModuleArchiveUnarchiveEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get_queryset(self):
+        favorite_subquery = ModuleFavorite.objects.filter(
+            user=self.request.user,
+            module_id=OuterRef("pk"),
+            project_id=self.kwargs.get("project_id"),
+            workspace__slug=self.kwargs.get("slug"),
+        )
+        cancelled_issues = (
+            Issue.issue_objects.filter(
+                state__group="cancelled",
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        completed_issues = (
+            Issue.issue_objects.filter(
+                state__group="completed",
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        started_issues = (
+            Issue.issue_objects.filter(
+                state__group="started",
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        unstarted_issues = (
+            Issue.issue_objects.filter(
+                state__group="unstarted",
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        backlog_issues = (
+            Issue.issue_objects.filter(
+                state__group="backlog",
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        total_issues = (
+            Issue.issue_objects.filter(
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        return (
+            Module.objects.filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(archived_at__isnull=False)
+            .annotate(is_favorite=Exists(favorite_subquery))
+            .select_related("workspace", "project", "lead")
+            .prefetch_related("members")
+            .prefetch_related(
+                Prefetch(
+                    "link_module",
+                    queryset=ModuleLink.objects.select_related(
+                        "module", "created_by"
+                    ),
+                )
+            )
+            .annotate(
+                completed_issues=Coalesce(
+                    Subquery(completed_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(
+                cancelled_issues=Coalesce(
+                    Subquery(cancelled_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(
+                started_issues=Coalesce(
+                    Subquery(started_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(
+                unstarted_issues=Coalesce(
+                    Subquery(unstarted_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(
+                backlog_issues=Coalesce(
+                    Subquery(backlog_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(
+                total_issues=Coalesce(
+                    Subquery(total_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(
+                member_ids=Coalesce(
+                    ArrayAgg(
+                        "members__id",
+                        distinct=True,
+                        filter=~Q(members__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                )
+            )
+            .order_by("-is_favorite", "-created_at")
+        )
+
+    def get(self, request, slug, project_id, pk=None):
+        if pk is None:
+            queryset = self.get_queryset()
+            modules = queryset.values(  # Required fields
+                "id",
+                "workspace_id",
+                "project_id",
+                # Model fields
+                "name",
+                "description",
+                "description_text",
+                "description_html",
+                "start_date",
+                "target_date",
+                "status",
+                "lead_id",
+                "member_ids",
+                "view_props",
+                "sort_order",
+                "external_source",
+                "external_id",
+                # computed fields
+                "total_issues",
+                "is_favorite",
+                "cancelled_issues",
+                "completed_issues",
+                "started_issues",
+                "unstarted_issues",
+                "backlog_issues",
+                "created_at",
+                "updated_at",
+                "archived_at",
+            )
+            return Response(modules, status=status.HTTP_200_OK)
+        else:
+            queryset = (
+                self.get_queryset()
+                .filter(pk=pk)
+                .annotate(
+                    sub_issues=Issue.issue_objects.filter(
+                        project_id=self.kwargs.get("project_id"),
+                        parent__isnull=False,
+                        issue_module__module_id=pk,
+                    )
+                    .order_by()
+                    .annotate(count=Func(F("id"), function="Count"))
+                    .values("count")
+                )
+            )
+            assignee_distribution = (
+                Issue.objects.filter(
+                    issue_module__module_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(display_name=F("assignees__display_name"))
+                .annotate(avatar=F("assignees__avatar"))
+                .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 = (
+                Issue.objects.filter(
+                    issue_module__module_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 = ModuleDetailSerializer(queryset.first()).data
+            data["distribution"] = {
+                "assignees": assignee_distribution,
+                "labels": label_distribution,
+                "completion_chart": {},
+            }
+
+            # Fetch the modules
+            modules = queryset.first()
+            if modules and modules.start_date and modules.target_date:
+                data["distribution"]["completion_chart"] = burndown_plot(
+                    queryset=modules,
+                    slug=slug,
+                    project_id=project_id,
+                    module_id=pk,
+                )
+
+            return Response(
+                data,
+                status=status.HTTP_200_OK,
+            )
+
+    def post(self, request, slug, project_id, module_id):
+        module = Module.objects.get(
+            pk=module_id, 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(
+            {"archived_at": str(module.archived_at)},
+            status=status.HTTP_200_OK,
+        )
+
+    def delete(self, request, slug, project_id, module_id):
+        module = Module.objects.get(
+            pk=module_id, project_id=project_id, workspace__slug=slug
+        )
+        module.archived_at = None
+        module.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)

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

@@ -1,51 +1,57 @@
 # Python imports
 import json
 
-# Django Imports
-from django.utils import timezone
-from django.db.models import Prefetch, F, OuterRef, Func, Exists, Count, Q
-from django.utils.decorators import method_decorator
-from django.views.decorators.gzip import gzip_page
 from django.contrib.postgres.aggregates import ArrayAgg
 from django.contrib.postgres.fields import ArrayField
-from django.db.models import Value, UUIDField
+from django.db.models import (
+    Count,
+    Exists,
+    F,
+    Func,
+    IntegerField,
+    OuterRef,
+    Prefetch,
+    Q,
+    Subquery,
+    UUIDField,
+    Value,
+)
 from django.db.models.functions import Coalesce
 
+# Django Imports
+from django.utils import timezone
+from rest_framework import status
+
 # Third party imports
 from rest_framework.response import Response
-from rest_framework import status
 
-# Module imports
-from . import BaseViewSet, BaseAPIView, WebhookMixin
-from plane.app.serializers import (
-    ModuleWriteSerializer,
-    ModuleSerializer,
-    ModuleIssueSerializer,
-    ModuleLinkSerializer,
-    ModuleFavoriteSerializer,
-    IssueSerializer,
-    ModuleUserPropertiesSerializer,
-    ModuleDetailSerializer,
-)
 from plane.app.permissions import (
     ProjectEntityPermission,
     ProjectLitePermission,
 )
-from plane.db.models import (
-    Module,
-    ModuleIssue,
-    Project,
-    Issue,
-    ModuleLink,
-    ModuleFavorite,
-    IssueLink,
-    IssueAttachment,
-    ModuleUserProperties,
+from plane.app.serializers import (
+    ModuleDetailSerializer,
+    ModuleFavoriteSerializer,
+    ModuleLinkSerializer,
+    ModuleSerializer,
+    ModuleUserPropertiesSerializer,
+    ModuleWriteSerializer,
 )
 from plane.bgtasks.issue_activites_task import issue_activity
-from plane.utils.issue_filters import issue_filters
+from plane.db.models import (
+    Issue,
+    Module,
+    ModuleFavorite,
+    ModuleIssue,
+    ModuleLink,
+    ModuleUserProperties,
+    Project,
+)
 from plane.utils.analytics_plot import burndown_plot
 
+# Module imports
+from .. import BaseAPIView, BaseViewSet, WebhookMixin
+
 
 class ModuleViewSet(WebhookMixin, BaseViewSet):
     model = Module
@@ -68,6 +74,59 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
             project_id=self.kwargs.get("project_id"),
             workspace__slug=self.kwargs.get("slug"),
         )
+        cancelled_issues = (
+            Issue.issue_objects.filter(
+                state__group="cancelled",
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        completed_issues = (
+            Issue.issue_objects.filter(
+                state__group="completed",
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        started_issues = (
+            Issue.issue_objects.filter(
+                state__group="started",
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        unstarted_issues = (
+            Issue.issue_objects.filter(
+                state__group="unstarted",
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        backlog_issues = (
+            Issue.issue_objects.filter(
+                state__group="backlog",
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        total_issues = (
+            Issue.issue_objects.filter(
+                issue_module__module_id=OuterRef("pk"),
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
         return (
             super()
             .get_queryset()
@@ -87,62 +146,39 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
                 )
             )
             .annotate(
-                total_issues=Count(
-                    "issue_module",
-                    filter=Q(
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                ),
-            )
-            .annotate(
-                completed_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="completed",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
+                completed_issues=Coalesce(
+                    Subquery(completed_issues[:1]),
+                    Value(0, output_field=IntegerField()),
                 )
             )
             .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,
-                    ),
+                cancelled_issues=Coalesce(
+                    Subquery(cancelled_issues[:1]),
+                    Value(0, output_field=IntegerField()),
                 )
             )
             .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,
-                    ),
+                started_issues=Coalesce(
+                    Subquery(started_issues[:1]),
+                    Value(0, output_field=IntegerField()),
                 )
             )
             .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,
-                    ),
+                unstarted_issues=Coalesce(
+                    Subquery(unstarted_issues[:1]),
+                    Value(0, output_field=IntegerField()),
                 )
             )
             .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,
-                    ),
+                backlog_issues=Coalesce(
+                    Subquery(backlog_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(
+                total_issues=Coalesce(
+                    Subquery(total_issues[:1]),
+                    Value(0, output_field=IntegerField()),
                 )
             )
             .annotate(
@@ -190,9 +226,9 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
                     "external_id",
                     # computed fields
                     "is_favorite",
-                    "total_issues",
                     "cancelled_issues",
                     "completed_issues",
+                    "total_issues",
                     "started_issues",
                     "unstarted_issues",
                     "backlog_issues",
@@ -204,7 +240,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def list(self, request, slug, project_id):
-        queryset = self.get_queryset()
+        queryset = self.get_queryset().filter(archived_at__isnull=True)
         if self.fields:
             modules = ModuleSerializer(
                 queryset,
@@ -231,8 +267,8 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
                 "external_source",
                 "external_id",
                 # computed fields
-                "is_favorite",
                 "total_issues",
+                "is_favorite",
                 "cancelled_issues",
                 "completed_issues",
                 "started_issues",
@@ -244,7 +280,21 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
         return Response(modules, status=status.HTTP_200_OK)
 
     def retrieve(self, request, slug, project_id, pk):
-        queryset = self.get_queryset().filter(pk=pk)
+        queryset = (
+            self.get_queryset()
+            .filter(archived_at__isnull=True)
+            .filter(pk=pk)
+            .annotate(
+                sub_issues=Issue.issue_objects.filter(
+                    project_id=self.kwargs.get("project_id"),
+                    parent__isnull=False,
+                    issue_module__module_id=pk,
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+        )
 
         assignee_distribution = (
             Issue.objects.filter(
@@ -345,9 +395,11 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
             "completion_chart": {},
         }
 
-        if queryset.first().start_date and queryset.first().target_date:
+        # Fetch the modules
+        modules = queryset.first()
+        if modules and modules.start_date and modules.target_date:
             data["distribution"]["completion_chart"] = burndown_plot(
-                queryset=queryset.first(),
+                queryset=modules,
                 slug=slug,
                 project_id=project_id,
                 module_id=pk,
@@ -359,14 +411,20 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
         )
 
     def partial_update(self, request, slug, project_id, pk):
-        queryset = self.get_queryset().filter(pk=pk)
+        module = self.get_queryset().filter(pk=pk)
+
+        if module.first().archived_at:
+            return Response(
+                {"error": "Archived module cannot be updated"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
         serializer = ModuleWriteSerializer(
-            queryset.first(), data=request.data, partial=True
+            module.first(), data=request.data, partial=True
         )
 
         if serializer.is_valid():
             serializer.save()
-            module = queryset.values(  
+            module = module.values(
                 # Required fields
                 "id",
                 "workspace_id",
@@ -387,10 +445,10 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
                 "external_id",
                 # computed fields
                 "is_favorite",
-                "total_issues",
                 "cancelled_issues",
                 "completed_issues",
                 "started_issues",
+                "total_issues",
                 "unstarted_issues",
                 "backlog_issues",
                 "created_at",
@@ -426,232 +484,6 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
-class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
-    serializer_class = ModuleIssueSerializer
-    model = ModuleIssue
-    webhook_event = "module_issue"
-    bulk = True
-
-    filterset_fields = [
-        "issue__labels__id",
-        "issue__assignees__id",
-    ]
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            Issue.issue_objects.filter(
-                project_id=self.kwargs.get("project_id"),
-                workspace__slug=self.kwargs.get("slug"),
-                issue_module__module_id=self.kwargs.get("module_id"),
-            )
-            .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),
-                    ),
-                    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()
-
-    @method_decorator(gzip_page)
-    def list(self, request, slug, project_id, module_id):
-        fields = [
-            field
-            for field in request.GET.get("fields", "").split(",")
-            if field
-        ]
-        filters = issue_filters(request.query_params, "GET")
-        issue_queryset = self.get_queryset().filter(**filters)
-        if self.fields or self.expand:
-            issues = IssueSerializer(
-                issue_queryset, many=True, fields=fields if fields else None
-            ).data
-        else:
-            issues = issue_queryset.values(
-                "id",
-                "name",
-                "state_id",
-                "sort_order",
-                "completed_at",
-                "estimate_point",
-                "priority",
-                "start_date",
-                "target_date",
-                "sequence_id",
-                "project_id",
-                "parent_id",
-                "cycle_id",
-                "module_ids",
-                "label_ids",
-                "assignee_ids",
-                "sub_issues_count",
-                "created_at",
-                "updated_at",
-                "created_by",
-                "updated_by",
-                "attachment_count",
-                "link_count",
-                "is_draft",
-                "archived_at",
-            )
-        return Response(issues, status=status.HTTP_200_OK)
-
-    # create multiple issues inside a module
-    def create_module_issues(self, request, slug, project_id, module_id):
-        issues = request.data.get("issues", [])
-        if not issues:
-            return Response(
-                {"error": "Issues are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        project = Project.objects.get(pk=project_id)
-        _ = ModuleIssue.objects.bulk_create(
-            [
-                ModuleIssue(
-                    issue_id=str(issue),
-                    module_id=module_id,
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    created_by=request.user,
-                    updated_by=request.user,
-                )
-                for issue in issues
-            ],
-            batch_size=10,
-            ignore_conflicts=True,
-        )
-        # Bulk Update the activity
-        _ = [
-            issue_activity.delay(
-                type="module.activity.created",
-                requested_data=json.dumps({"module_id": str(module_id)}),
-                actor_id=str(request.user.id),
-                issue_id=str(issue),
-                project_id=project_id,
-                current_instance=None,
-                epoch=int(timezone.now().timestamp()),
-                notification=True,
-                origin=request.META.get("HTTP_ORIGIN"),
-            )
-            for issue in issues
-        ]
-        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
-
-    # create multiple module inside an issue
-    def create_issue_modules(self, request, slug, project_id, issue_id):
-        modules = request.data.get("modules", [])
-        if not modules:
-            return Response(
-                {"error": "Modules are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        project = Project.objects.get(pk=project_id)
-        _ = ModuleIssue.objects.bulk_create(
-            [
-                ModuleIssue(
-                    issue_id=issue_id,
-                    module_id=module,
-                    project_id=project_id,
-                    workspace_id=project.workspace_id,
-                    created_by=request.user,
-                    updated_by=request.user,
-                )
-                for module in modules
-            ],
-            batch_size=10,
-            ignore_conflicts=True,
-        )
-        # Bulk Update the activity
-        _ = [
-            issue_activity.delay(
-                type="module.activity.created",
-                requested_data=json.dumps({"module_id": module}),
-                actor_id=str(request.user.id),
-                issue_id=issue_id,
-                project_id=project_id,
-                current_instance=None,
-                epoch=int(timezone.now().timestamp()),
-                notification=True,
-                origin=request.META.get("HTTP_ORIGIN"),
-            )
-            for module in modules
-        ]
-
-        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
-
-    def destroy(self, request, slug, project_id, module_id, issue_id):
-        module_issue = ModuleIssue.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            module_id=module_id,
-            issue_id=issue_id,
-        )
-        issue_activity.delay(
-            type="module.activity.deleted",
-            requested_data=json.dumps({"module_id": str(module_id)}),
-            actor_id=str(request.user.id),
-            issue_id=str(issue_id),
-            project_id=str(project_id),
-            current_instance=json.dumps(
-                {"module_name": module_issue.module.name}
-            ),
-            epoch=int(timezone.now().timestamp()),
-            notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
-        )
-        module_issue.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
 class ModuleLinkViewSet(BaseViewSet):
     permission_classes = [
         ProjectEntityPermission,
@@ -676,6 +508,7 @@ class ModuleLinkViewSet(BaseViewSet):
             .filter(
                 project__project_projectmember__member=self.request.user,
                 project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
             )
             .order_by("-created_at")
             .distinct()

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

@@ -0,0 +1,260 @@
+# Python imports
+import json
+
+# Django Imports
+from django.utils import timezone
+from django.db.models import F, OuterRef, Func, Q
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import Value, UUIDField
+from django.db.models.functions import Coalesce
+
+# Third party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet, WebhookMixin
+from plane.app.serializers import (
+    ModuleIssueSerializer,
+    IssueSerializer,
+)
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import (
+    ModuleIssue,
+    Project,
+    Issue,
+    IssueLink,
+    IssueAttachment,
+)
+from plane.bgtasks.issue_activites_task import issue_activity
+from plane.utils.issue_filters import issue_filters
+
+
+class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
+    serializer_class = ModuleIssueSerializer
+    model = ModuleIssue
+    webhook_event = "module_issue"
+    bulk = True
+
+    filterset_fields = [
+        "issue__labels__id",
+        "issue__assignees__id",
+    ]
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get_queryset(self):
+        return (
+            Issue.issue_objects.filter(
+                project_id=self.kwargs.get("project_id"),
+                workspace__slug=self.kwargs.get("slug"),
+                issue_module__module_id=self.kwargs.get("module_id"),
+            )
+            .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())),
+                ),
+            )
+        ).distinct()
+
+    @method_decorator(gzip_page)
+    def list(self, request, slug, project_id, module_id):
+        fields = [
+            field
+            for field in request.GET.get("fields", "").split(",")
+            if field
+        ]
+        filters = issue_filters(request.query_params, "GET")
+        issue_queryset = self.get_queryset().filter(**filters)
+        if self.fields or self.expand:
+            issues = IssueSerializer(
+                issue_queryset, many=True, fields=fields if fields else None
+            ).data
+        else:
+            issues = issue_queryset.values(
+                "id",
+                "name",
+                "state_id",
+                "sort_order",
+                "completed_at",
+                "estimate_point",
+                "priority",
+                "start_date",
+                "target_date",
+                "sequence_id",
+                "project_id",
+                "parent_id",
+                "cycle_id",
+                "module_ids",
+                "label_ids",
+                "assignee_ids",
+                "sub_issues_count",
+                "created_at",
+                "updated_at",
+                "created_by",
+                "updated_by",
+                "attachment_count",
+                "link_count",
+                "is_draft",
+                "archived_at",
+            )
+        return Response(issues, status=status.HTTP_200_OK)
+
+    # create multiple issues inside a module
+    def create_module_issues(self, request, slug, project_id, module_id):
+        issues = request.data.get("issues", [])
+        if not issues:
+            return Response(
+                {"error": "Issues are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        project = Project.objects.get(pk=project_id)
+        _ = ModuleIssue.objects.bulk_create(
+            [
+                ModuleIssue(
+                    issue_id=str(issue),
+                    module_id=module_id,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for issue in issues
+            ],
+            batch_size=10,
+            ignore_conflicts=True,
+        )
+        # Bulk Update the activity
+        _ = [
+            issue_activity.delay(
+                type="module.activity.created",
+                requested_data=json.dumps({"module_id": str(module_id)}),
+                actor_id=str(request.user.id),
+                issue_id=str(issue),
+                project_id=project_id,
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            for issue in issues
+        ]
+        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
+
+    # create multiple module inside an issue
+    def create_issue_modules(self, request, slug, project_id, issue_id):
+        modules = request.data.get("modules", [])
+        if not modules:
+            return Response(
+                {"error": "Modules are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        project = Project.objects.get(pk=project_id)
+        _ = ModuleIssue.objects.bulk_create(
+            [
+                ModuleIssue(
+                    issue_id=issue_id,
+                    module_id=module,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for module in modules
+            ],
+            batch_size=10,
+            ignore_conflicts=True,
+        )
+        # Bulk Update the activity
+        _ = [
+            issue_activity.delay(
+                type="module.activity.created",
+                requested_data=json.dumps({"module_id": module}),
+                actor_id=str(request.user.id),
+                issue_id=issue_id,
+                project_id=project_id,
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            for module in modules
+        ]
+
+        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
+
+    def destroy(self, request, slug, project_id, module_id, issue_id):
+        module_issue = ModuleIssue.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            module_id=module_id,
+            issue_id=issue_id,
+        )
+        issue_activity.delay(
+            type="module.activity.deleted",
+            requested_data=json.dumps({"module_id": str(module_id)}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=json.dumps(
+                {"module_name": module_issue.module.name}
+            ),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+        module_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

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

@@ -8,7 +8,7 @@ from rest_framework.response import Response
 from plane.utils.paginator import BasePaginator
 
 # Module imports
-from .base import BaseViewSet, BaseAPIView
+from ..base import BaseViewSet, BaseAPIView
 from plane.db.models import (
     Notification,
     IssueAssignee,
@@ -17,7 +17,10 @@ from plane.db.models import (
     WorkspaceMember,
     UserNotificationPreference,
 )
-from plane.app.serializers import NotificationSerializer, UserNotificationPreferenceSerializer
+from plane.app.serializers import (
+    NotificationSerializer,
+    UserNotificationPreferenceSerializer,
+)
 
 
 class NotificationViewSet(BaseViewSet, BasePaginator):

apiserver/plane/app/views/oauth.py

@@ -5,7 +5,6 @@ import os
 
 # Django imports
 from django.utils import timezone
-from django.conf import settings
 
 # Third Party modules
 from rest_framework.response import Response
@@ -250,9 +249,11 @@ class OauthEndpoint(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,
                     )
@@ -266,9 +267,11 @@ class OauthEndpoint(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,
                     )
@@ -391,9 +394,11 @@ class OauthEndpoint(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,
                     )
@@ -407,9 +412,11 @@ class OauthEndpoint(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,
                     )

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

@@ -1,25 +1,37 @@
 # Python imports
-from datetime import date, datetime, timedelta
+import json
+from datetime import datetime
+from django.core.serializers.json import DjangoJSONEncoder
 
 # Django imports
 from django.db import connection
 from django.db.models import Exists, OuterRef, Q
-from django.utils import timezone
 from django.utils.decorators import method_decorator
 from django.views.decorators.gzip import gzip_page
+
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
 
 from plane.app.permissions import ProjectEntityPermission
-from plane.app.serializers import (IssueLiteSerializer, PageFavoriteSerializer,
-                                   PageLogSerializer, PageSerializer,
-                                   SubPageSerializer)
-from plane.db.models import (Issue, IssueActivity, IssueAssignee, Page,
-                             PageFavorite, PageLog, ProjectMember)
+from plane.app.serializers import (
+    PageFavoriteSerializer,
+    PageLogSerializer,
+    PageSerializer,
+    SubPageSerializer,
+    PageDetailSerializer,
+)
+from plane.db.models import (
+    Page,
+    PageFavorite,
+    PageLog,
+    ProjectMember,
+)
 
 # Module imports
-from .base import BaseAPIView, BaseViewSet
+from ..base import BaseAPIView, BaseViewSet
+
+from plane.bgtasks.page_transaction_task import page_transaction
 
 
 def unarchive_archive_page_and_descendants(page_id, archived_at):
@@ -63,6 +75,7 @@ class PageViewSet(BaseViewSet):
             .filter(
                 project__project_projectmember__member=self.request.user,
                 project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
             )
             .filter(parent__isnull=True)
             .filter(Q(owned_by=self.request.user) | Q(access=0))
@@ -79,11 +92,21 @@ class PageViewSet(BaseViewSet):
     def create(self, request, slug, project_id):
         serializer = PageSerializer(
             data=request.data,
-            context={"project_id": project_id, "owned_by_id": request.user.id},
+            context={
+                "project_id": project_id,
+                "owned_by_id": request.user.id,
+                "description_html": request.data.get(
+                    "description_html", "<p></p>"
+                ),
+            },
         )
 
         if serializer.is_valid():
             serializer.save()
+            # capture the page transaction
+            page_transaction.delay(request.data, None, serializer.data["id"])
+            page = Page.objects.get(pk=serializer.data["id"])
+            serializer = PageDetailSerializer(page)
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
@@ -117,9 +140,25 @@ class PageViewSet(BaseViewSet):
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            serializer = PageSerializer(page, data=request.data, partial=True)
+            serializer = PageDetailSerializer(
+                page, data=request.data, partial=True
+            )
+            page_description = page.description_html
             if serializer.is_valid():
                 serializer.save()
+                # capture the page transaction
+                if request.data.get("description_html"):
+                    page_transaction.delay(
+                        new_value=request.data,
+                        old_value=json.dumps(
+                            {
+                                "description_html": page_description,
+                            },
+                            cls=DjangoJSONEncoder,
+                        ),
+                        page_id=pk,
+                    )
+
                 return Response(serializer.data, status=status.HTTP_200_OK)
             return Response(
                 serializer.errors, status=status.HTTP_400_BAD_REQUEST
@@ -132,18 +171,30 @@ class PageViewSet(BaseViewSet):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-    def lock(self, request, slug, project_id, page_id):
+    def retrieve(self, request, slug, project_id, pk=None):
+        page = self.get_queryset().filter(pk=pk).first()
+        if page is None:
+            return Response(
+                {"error": "Page not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        else:
+            return Response(
+                PageDetailSerializer(page).data, status=status.HTTP_200_OK
+            )
+
+    def lock(self, request, slug, project_id, pk):
         page = Page.objects.filter(
-            pk=page_id, workspace__slug=slug, project_id=project_id
+            pk=pk, workspace__slug=slug, project_id=project_id
         ).first()
 
         page.is_locked = True
         page.save()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
-    def unlock(self, request, slug, project_id, page_id):
+    def unlock(self, request, slug, project_id, pk):
         page = Page.objects.filter(
-            pk=page_id, workspace__slug=slug, project_id=project_id
+            pk=pk, workspace__slug=slug, project_id=project_id
         ).first()
 
         page.is_locked = False
@@ -152,13 +203,13 @@ class PageViewSet(BaseViewSet):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
     def list(self, request, slug, project_id):
-        queryset = self.get_queryset().filter(archived_at__isnull=True)
+        queryset = self.get_queryset()
         pages = PageSerializer(queryset, many=True).data
         return Response(pages, status=status.HTTP_200_OK)
 
-    def archive(self, request, slug, project_id, page_id):
+    def archive(self, request, slug, project_id, pk):
         page = Page.objects.get(
-            pk=page_id, workspace__slug=slug, project_id=project_id
+            pk=pk, workspace__slug=slug, project_id=project_id
         )
 
         # only the owner or admin can archive the page
@@ -176,13 +227,16 @@ class PageViewSet(BaseViewSet):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        unarchive_archive_page_and_descendants(page_id, datetime.now())
+        unarchive_archive_page_and_descendants(pk, datetime.now())
 
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(
+            {"archived_at": str(datetime.now())},
+            status=status.HTTP_200_OK,
+        )
 
-    def unarchive(self, request, slug, project_id, page_id):
+    def unarchive(self, request, slug, project_id, pk):
         page = Page.objects.get(
-            pk=page_id, workspace__slug=slug, project_id=project_id
+            pk=pk, workspace__slug=slug, project_id=project_id
         )
 
         # only the owner or admin can un archive the page
@@ -205,19 +259,10 @@ class PageViewSet(BaseViewSet):
             page.parent = None
             page.save(update_fields=["parent"])
 
-        unarchive_archive_page_and_descendants(page_id, None)
+        unarchive_archive_page_and_descendants(pk, None)
 
         return Response(status=status.HTTP_204_NO_CONTENT)
 
-    def archive_list(self, request, slug, project_id):
-        pages = Page.objects.filter(
-            project_id=project_id,
-            workspace__slug=slug,
-        ).filter(archived_at__isnull=False)
-
-        pages = PageSerializer(pages, many=True).data
-        return Response(pages, status=status.HTTP_200_OK)
-
     def destroy(self, request, slug, project_id, pk):
         page = Page.objects.get(
             pk=pk, workspace__slug=slug, project_id=project_id
@@ -261,29 +306,20 @@ class PageFavoriteViewSet(BaseViewSet):
     serializer_class = PageFavoriteSerializer
     model = PageFavorite
 
-    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(archived_at__isnull=True)
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(user=self.request.user)
-            .select_related("page", "page__owned_by")
+    def create(self, request, slug, project_id, pk):
+        _ = PageFavorite.objects.create(
+            project_id=project_id,
+            page_id=pk,
+            user=request.user,
         )
+        return Response(status=status.HTTP_204_NO_CONTENT)
 
-    def create(self, request, slug, project_id):
-        serializer = PageFavoriteSerializer(data=request.data)
-        if serializer.is_valid():
-            serializer.save(user=request.user, project_id=project_id)
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def destroy(self, request, slug, project_id, page_id):
+    def destroy(self, request, slug, project_id, pk):
         page_favorite = PageFavorite.objects.get(
             project=project_id,
             user=request.user,
             workspace__slug=slug,
-            page_id=page_id,
+            page_id=pk,
         )
         page_favorite.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)