fix: event tracking

* fix: file structure changes

* fix: pages update

* fix: license imports changed

.deepsource.toml

@@ -1,11 +1,5 @@
 version = 1
 
-exclude_patterns = [  
-  "bin/**",  
-  "**/node_modules/",  
-  "**/*.min.js"  
-]
-
 [[analyzers]]
 name = "shell"
 

.dockerignore

@@ -2,16 +2,5 @@
 *.pyc
 .env
 venv
-node_modules/
-**/node_modules/
-npm-debug.log
-.next/
-**/.next/
-.turbo/
-**/.turbo/
-build/
-**/build/
-out/
-**/out/
-dist/
-**/dist/
+node_modules
+npm-debug.log

.github/workflows/build-branch.yml

@@ -1,31 +1,62 @@
+
 name: Branch Build
 
 on:
   pull_request:
-    types:
+    types: 
       - closed
-    branches:
+    branches: 
       - master
-      - preview
+      - release
       - qa
       - develop
-      - release-*
-  release:
-    types: [released, prereleased]
 
 env:
-  TARGET_BRANCH: ${{ github.event.pull_request.base.ref || github.event.release.target_commitish }}
+  TARGET_BRANCH: ${{ github.event.pull_request.base.ref }}
 
 jobs:
-  branch_build_setup:
-    if: ${{ (github.event_name == 'pull_request' && github.event.action =='closed' && github.event.pull_request.merged == true) || github.event_name == 'release' }}
+  branch_build_and_push:
+    if: ${{ (github.event_name == 'pull_request' && github.event.action =='closed' && github.event.pull_request.merged == true) }}
     name: Build-Push Web/Space/API/Proxy Docker Image
     runs-on: ubuntu-20.04
 
     steps:
       - name: Check out the repo
         uses: actions/checkout@v3.3.0
+        
+      # - name: Set Target Branch Name on PR close
+      #   if: ${{ github.event_name == 'pull_request' && github.event.action =='closed' }}
+      #   run: echo "TARGET_BRANCH=${{ github.event.pull_request.base.ref }}" >> $GITHUB_ENV
 
+      # - name: Set Target Branch Name on other than PR close
+      #   if: ${{ github.event_name == 'push' }}
+      #   run: echo "TARGET_BRANCH=${{ github.ref_name }}" >> $GITHUB_ENV
+      
+      - uses: ASzc/change-string-case-action@v2
+        id: gh_branch_upper_lower
+        with:
+          string: ${{env.TARGET_BRANCH}}
+
+      - uses: mad9000/actions-find-and-replace-string@2
+        id: gh_branch_replace_slash
+        with:
+          source: ${{ steps.gh_branch_upper_lower.outputs.lowercase }}
+          find: '/'        
+          replace: '-'
+
+      - uses: mad9000/actions-find-and-replace-string@2
+        id: gh_branch_replace_dot
+        with:
+          source: ${{ steps.gh_branch_replace_slash.outputs.value }}
+          find: '.'        
+          replace: ''
+          
+      - uses: mad9000/actions-find-and-replace-string@2
+        id: gh_branch_clean
+        with:
+          source: ${{ steps.gh_branch_replace_dot.outputs.value }}
+          find: '_'
+          replace: ''
       - name: Uploading Proxy Source
         uses: actions/upload-artifact@v3
         with:
@@ -46,6 +77,7 @@ jobs:
             !./nginx
             !./deploy
             !./space
+      
       - name: Uploading Space Source
         uses: actions/upload-artifact@v3
         with:
@@ -57,24 +89,12 @@ jobs:
             !./deploy
             !./web
     outputs:
-      gh_branch_name: ${{ env.TARGET_BRANCH }}
+        gh_branch_name: ${{ steps.gh_branch_clean.outputs.value }}
 
   branch_build_push_frontend:
     runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
-    env:
-      FRONTEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+    needs: [ branch_build_and_push ]
     steps:
-      - name: Set Frontend Docker Tag 
-        run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
-          else
-            TAG=${{ env.FRONTEND_TAG }}
-          fi
-          echo "FRONTEND_TAG=${TAG}" >> $GITHUB_ENV
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2.5.0
 
@@ -94,7 +114,7 @@ jobs:
           context: .
           file: ./web/Dockerfile.web
           platforms: linux/amd64
-          tags: ${{ env.FRONTEND_TAG }}
+          tags: ${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
           push: true
         env:
           DOCKER_BUILDKIT: 1
@@ -103,20 +123,8 @@ jobs:
 
   branch_build_push_space:
     runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
-    env:
-      SPACE_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+    needs: [ branch_build_and_push ]
     steps:
-      - name: Set Space Docker Tag 
-        run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
-          else
-            TAG=${{ env.SPACE_TAG }}
-          fi
-          echo "SPACE_TAG=${TAG}" >> $GITHUB_ENV
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2.5.0
 
@@ -136,7 +144,7 @@ jobs:
           context: .
           file: ./space/Dockerfile.space
           platforms: linux/amd64
-          tags: ${{ env.SPACE_TAG }}
+          tags: ${{ secrets.DOCKERHUB_USERNAME }}/plane-space-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
           push: true
         env:
           DOCKER_BUILDKIT: 1
@@ -145,20 +153,8 @@ jobs:
 
   branch_build_push_backend:
     runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
-    env:
-      BACKEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+    needs: [ branch_build_and_push ]
     steps:
-      - name: Set Backend Docker Tag 
-        run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
-          else
-            TAG=${{ env.BACKEND_TAG }}
-          fi
-          echo "BACKEND_TAG=${TAG}" >> $GITHUB_ENV
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2.5.0
 
@@ -179,7 +175,7 @@ jobs:
           file: ./Dockerfile.api
           platforms: linux/amd64
           push: true
-          tags: ${{ env.BACKEND_TAG }}
+          tags: ${{ secrets.DOCKERHUB_USERNAME }}/plane-backend-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
         env:
           DOCKER_BUILDKIT: 1
           DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
@@ -187,20 +183,8 @@ jobs:
 
   branch_build_push_proxy:
     runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
-    env:
-      PROXY_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+    needs: [ branch_build_and_push ]
     steps:
-      - name: Set Proxy Docker Tag 
-        run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
-          else
-            TAG=${{ env.PROXY_TAG }}
-          fi
-          echo "PROXY_TAG=${TAG}" >> $GITHUB_ENV
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2.5.0
 
@@ -221,7 +205,7 @@ jobs:
           context: .
           file: ./Dockerfile
           platforms: linux/amd64
-          tags: ${{ env.PROXY_TAG }}
+          tags: ${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
           push: true
         env:
           DOCKER_BUILDKIT: 1

.github/workflows/codeql.yml

@@ -1,65 +0,0 @@
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ 'develop', 'hot-fix', 'stage-release' ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ 'develop' ]
-  schedule:
-    - cron: '53 19 * * 5'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        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
-
-    # 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
-
-
-    # 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
-
-    #   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
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
-      with:
-        category: "/language:${{matrix.language}}"

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

@@ -1,13 +1,11 @@
-name: Create Sync Action
+name: Create PR in Plane EE Repository to sync the changes
 
 on:
   pull_request:
     branches:
-      - preview 
+      - master
     types:
       - closed
-env: 
-  SOURCE_BRANCH_NAME: ${{github.event.pull_request.base.ref}}
 
 jobs:
   create_pr:
@@ -18,13 +16,27 @@ jobs:
       pull-requests: write
       contents: read
     steps:
+      - name: Check SOURCE_REPO
+        id: check_repo
+        env:
+          SOURCE_REPO: ${{ secrets.SOURCE_REPO_NAME }}
+        run: |
+          echo "::set-output name=is_correct_repo::$(if [[ "$SOURCE_REPO" == "makeplane/plane" ]]; then echo 'true'; else echo 'false'; fi)"
+
       - name: Checkout Code
+        if: steps.check_repo.outputs.is_correct_repo == 'true'
         uses: actions/checkout@v2
         with:
           persist-credentials: false
           fetch-depth: 0
 
+      - name: Set up Branch Name
+        if: steps.check_repo.outputs.is_correct_repo == 'true'
+        run: |
+          echo "SOURCE_BRANCH_NAME=${{ github.head_ref }}" >> $GITHUB_ENV
+
       - name: Setup GH CLI
+        if: steps.check_repo.outputs.is_correct_repo == 'true'
         run: |
           type -p curl >/dev/null || (sudo apt update && sudo apt install curl -y)
           curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
@@ -33,14 +45,35 @@ jobs:
           sudo apt update
           sudo apt install gh -y
 
-      - name: Push Changes to Target Repo
+      - name: Create Pull Request
+        if: steps.check_repo.outputs.is_correct_repo == 'true'
         env:
           GH_TOKEN: ${{ secrets.ACCESS_TOKEN }}
         run: |
-          TARGET_REPO="${{ secrets.SYNC_TARGET_REPO_NAME }}"
-          TARGET_BRANCH="${{ secrets.SYNC_TARGET_BRANCH_NAME }}"
+          TARGET_REPO="${{ secrets.TARGET_REPO_NAME }}"
+          TARGET_BRANCH="${{ secrets.TARGET_REPO_BRANCH }}"
           SOURCE_BRANCH="${{ env.SOURCE_BRANCH_NAME }}"
 
           git checkout $SOURCE_BRANCH
-          git remote add target-origin "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
-          git push target-origin $SOURCE_BRANCH:$TARGET_BRANCH
+          git remote add target "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
+          git push target $SOURCE_BRANCH:$SOURCE_BRANCH
+
+          PR_TITLE="${{ github.event.pull_request.title }}"
+          PR_BODY="${{ github.event.pull_request.body }}"
+
+          # Remove double quotes
+          PR_TITLE_CLEANED="${PR_TITLE//\"/}"
+          PR_BODY_CLEANED="${PR_BODY//\"/}"
+
+          # Construct PR_BODY_CONTENT using a here-document
+          PR_BODY_CONTENT=$(cat <<EOF
+          $PR_BODY_CLEANED
+          EOF
+          )
+
+          gh pr create \
+            --base $TARGET_BRANCH \
+            --head $SOURCE_BRANCH \
+            --title "[SYNC] $PR_TITLE_CLEANED" \
+            --body "$PR_BODY_CONTENT" \
+            --repo $TARGET_REPO

.github/workflows/update-docker-images.yml

@@ -0,0 +1,107 @@
+name: Update Docker Images for Plane on Release
+
+on:
+  release:
+    types: [released, prereleased]
+
+jobs:
+  build_push_backend:
+    name: Build and Push Api Server Docker Image
+    runs-on: ubuntu-20.04
+
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v3.3.0
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2.5.0
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2.1.0
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker (Docker Hub) from Github Release
+        id: metaFrontend
+        uses: docker/metadata-action@v4.3.0
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend
+          tags: |
+            type=ref,event=tag
+      
+      - name: Extract metadata (tags, labels) for Docker (Docker Hub) from Github Release
+        id: metaBackend
+        uses: docker/metadata-action@v4.3.0
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/plane-backend
+          tags: |
+            type=ref,event=tag
+
+      - name: Extract metadata (tags, labels) for Docker (Docker Hub) from Github Release
+        id: metaSpace
+        uses: docker/metadata-action@v4.3.0
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/plane-space
+          tags: |
+            type=ref,event=tag
+
+      - name: Extract metadata (tags, labels) for Docker (Docker Hub) from Github Release
+        id: metaProxy
+        uses: docker/metadata-action@v4.3.0
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy
+          tags: |
+            type=ref,event=tag
+
+      - name: Build and Push Frontend to Docker Container Registry
+        uses: docker/build-push-action@v4.0.0
+        with:
+          context: .
+          file: ./web/Dockerfile.web
+          platforms: linux/amd64
+          tags: ${{ steps.metaFrontend.outputs.tags }}
+          push: true
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKET_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and Push Backend to Docker Hub
+        uses: docker/build-push-action@v4.0.0
+        with:
+          context: ./apiserver
+          file: ./apiserver/Dockerfile.api
+          platforms: linux/amd64
+          push: true
+          tags: ${{ steps.metaBackend.outputs.tags }}
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKET_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and Push Plane-Deploy to Docker Hub
+        uses: docker/build-push-action@v4.0.0
+        with:
+          context: .
+          file: ./space/Dockerfile.space
+          platforms: linux/amd64
+          push: true
+          tags: ${{ steps.metaSpace.outputs.tags }}
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKET_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and Push Plane-Proxy to Docker Hub
+        uses: docker/build-push-action@v4.0.0
+        with:
+          context: ./nginx
+          file: ./nginx/Dockerfile
+          platforms: linux/amd64
+          push: true
+          tags: ${{ steps.metaProxy.outputs.tags }}
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKET_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}

.gitignore

@@ -80,6 +80,3 @@ tmp/
 ## packages
 dist
 .temp/
-
-# logs
-combined.log

CONTRIBUTING.md

@@ -33,8 +33,8 @@ The backend is a django project which is kept inside apiserver
 1. Clone the repo
 
 ```bash
-git clone https://github.com/makeplane/plane.git [folder-name]
-cd [folder-name]
+git clone https://github.com/makeplane/plane
+cd plane
 chmod +x setup.sh
 ```
 
@@ -44,12 +44,33 @@ chmod +x setup.sh
 ./setup.sh
 ```
 
-3. Start the containers
+3. Define `NEXT_PUBLIC_API_BASE_URL=http://localhost` in **web/.env** and **space/.env** file
 
 ```bash
-docker compose -f docker-compose-local.yml up
+echo "\nNEXT_PUBLIC_API_BASE_URL=http://localhost\n" >> ./web/.env
 ```
 
+```bash
+echo "\nNEXT_PUBLIC_API_BASE_URL=http://localhost\n" >> ./space/.env
+```
+
+4. Run Docker compose up
+
+```bash
+docker compose up -d
+```
+
+5. Install dependencies
+
+```bash
+yarn install
+```
+
+6. Run the web app in development mode
+
+```bash
+yarn dev
+```
 
 ## Missing a Feature?
 

Dockerfile

@@ -79,6 +79,7 @@ COPY apiserver/manage.py manage.py
 COPY apiserver/plane plane/
 COPY apiserver/templates templates/
 
+COPY apiserver/gunicorn.config.py ./
 RUN apk --no-cache add "bash~=5.2"
 COPY apiserver/bin ./bin/
 

ENV_SETUP.md

@@ -49,10 +49,24 @@ NGINX_PORT=80
 ​
 
 ```
+# Enable/Disable OAUTH - default 0 for selfhosted instance
+NEXT_PUBLIC_ENABLE_OAUTH=0
 # Public boards deploy URL
 NEXT_PUBLIC_DEPLOY_URL="http://localhost/spaces"
 ```
 
+​
+
+## {PROJECT_FOLDER}/spaces/.env.example
+
+​
+
+```
+# Flag to toggle OAuth
+NEXT_PUBLIC_ENABLE_OAUTH=0
+```
+
+​
 
 ## {PROJECT_FOLDER}/apiserver/.env
 
@@ -62,6 +76,7 @@ NEXT_PUBLIC_DEPLOY_URL="http://localhost/spaces"
 # Backend
 # Debug value for api server use it as 0 for production use
 DEBUG=0
+DJANGO_SETTINGS_MODULE="plane.settings.selfhosted" # deprecated
 ​
 # Error logs
 SENTRY_DSN=""

README.md

@@ -37,7 +37,7 @@ Meet [Plane](https://plane.so). An open-source software development tool to mana
 
 > 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.
 
-The easiest way to get started with Plane is by creating a [Plane Cloud](https://app.plane.so) account. Plane Cloud offers a hosted solution for Plane. If you prefer to self-host Plane, please refer to our [deployment documentation](https://docs.plane.so/self-hosting/docker-compose).
+The easiest way to get started with Plane is by creating a [Plane Cloud](https://app.plane.so) account. Plane Cloud offers a hosted solution for Plane. If you prefer to self-host Plane, please refer to our [deployment documentation](https://docs.plane.so/self-hosting).
 
 ## ⚡️ Contributors Quick Start
 
@@ -57,13 +57,17 @@ Setting up local environment is extremely easy and straight forward. Follow the
 1. Review the `.env` files available in various folders. Visit [Environment Setup](./ENV_SETUP.md) to know about various environment variables used in system
 1. Run the docker command to initiate various services `docker compose -f docker-compose-local.yml up -d`
 
+```bash
+./setup.sh
+```
+
 You are ready to make changes to the code. Do not forget to refresh the browser (in case id does not auto-reload)
 
 Thats it!
 
 ## 🍙 Self Hosting
 
-For self hosting environment setup, visit the [Self Hosting](https://docs.plane.so/self-hosting/docker-compose) documentation page
+For self hosting environment setup, visit the [Self Hosting](https://docs.plane.so/self-hosting) documentation page
 
 ## 🚀 Features
 

apiserver/.env.example

@@ -14,11 +14,6 @@ PGHOST="plane-db"
 PGDATABASE="plane"
 DATABASE_URL=postgresql://${PGUSER}:${PGPASSWORD}@${PGHOST}/${PGDATABASE}
 
-# Oauth variables
-GOOGLE_CLIENT_ID=""
-GITHUB_CLIENT_ID=""
-GITHUB_CLIENT_SECRET=""
-
 # Redis Settings
 REDIS_HOST="plane-redis"
 REDIS_PORT="6379"
@@ -43,8 +38,7 @@ GPT_ENGINE="gpt-3.5-turbo" # deprecated
 GITHUB_CLIENT_SECRET="" # For fetching release notes
 
 # Settings related to Docker
-DOCKERIZED=1 # deprecated
-
+DOCKERIZED=1
 # set to 1 If using the pre-configured minio setup
 USE_MINIO=1
 
@@ -55,6 +49,7 @@ NGINX_PORT=80
 # SignUps
 ENABLE_SIGNUP="1"
 
+
 # Enable Email/Password Signup
 ENABLE_EMAIL_PASSWORD="1"
 

apiserver/Dockerfile.api

@@ -44,6 +44,7 @@ COPY manage.py manage.py
 COPY plane plane/
 COPY templates templates/
 COPY package.json package.json
+COPY gunicorn.config.py ./
 USER root
 RUN apk --no-cache add "bash~=5.2"
 COPY ./bin ./bin/

apiserver/Dockerfile.dev

@@ -27,8 +27,7 @@ WORKDIR /code
 COPY requirements.txt ./requirements.txt
 ADD requirements ./requirements
 
-# Install the local development settings
-RUN pip install -r requirements/local.txt --compile --no-cache-dir
+RUN pip install -r requirements.txt --compile --no-cache-dir
 
 RUN addgroup -S plane && \
     adduser -S captain -G plane
@@ -49,5 +48,5 @@ USER captain
 # Expose container port and run entry point script
 EXPOSE 8000
 
-CMD [ "./bin/takeoff.local" ]
+# CMD [ "./bin/takeoff" ]
 

apiserver/Procfile

@@ -1,3 +1,3 @@
 web: gunicorn -w 4 -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:$PORT --max-requests 10000 --max-requests-jitter 1000 --access-logfile -
-worker: celery -A plane worker -l info -Q internal_tasks,external_tasks
+worker: celery -A plane worker -l info
 beat: celery -A plane beat -l INFO

apiserver/bin/takeoff

@@ -3,28 +3,18 @@ set -e
 python manage.py wait_for_db
 python manage.py migrate
 
-# Create the default bucket
-#!/bin/bash
+# Set default value for ENABLE_REGISTRATION
+ENABLE_REGISTRATION=${ENABLE_REGISTRATION:-1}
 
-# Collect system information
-HOSTNAME=$(hostname)
-MAC_ADDRESS=$(ip link show | awk '/ether/ {print $2}' | head -n 1)
-CPU_INFO=$(cat /proc/cpuinfo)
-MEMORY_INFO=$(free -h)
-DISK_INFO=$(df -h)
-
-# Concatenate information and compute SHA-256 hash
-SIGNATURE=$(echo "$HOSTNAME$MAC_ADDRESS$CPU_INFO$MEMORY_INFO$DISK_INFO" | sha256sum | awk '{print $1}')
-
-# Export the variables
-export MACHINE_SIGNATURE=$SIGNATURE
-
-# Register instance
-python manage.py register_instance $MACHINE_SIGNATURE
-# Load the configuration variable
-python manage.py configure_instance
+# Check if ENABLE_REGISTRATION is not set to '0'
+if [ "$ENABLE_REGISTRATION" != "0" ]; then
+    # Register instance
+    python manage.py register_instance
+    # Load the configuration variable
+    python manage.py configure_instance
+fi
 
 # Create the default bucket
-python manage.py create_bucket
+python bin/bucket_script.py
 
-exec gunicorn -w $GUNICORN_WORKERS -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:${PORT:-8000} --max-requests 1200 --max-requests-jitter 1000 --access-logfile -
+exec gunicorn -w $GUNICORN_WORKERS -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:8000 --max-requests 1200 --max-requests-jitter 1000 --access-logfile -

apiserver/bin/takeoff.local

@@ -1,31 +0,0 @@
-#!/bin/bash
-set -e
-python manage.py wait_for_db
-python manage.py migrate
-
-# Create the default bucket
-#!/bin/bash
-
-# Collect system information
-HOSTNAME=$(hostname)
-MAC_ADDRESS=$(ip link show | awk '/ether/ {print $2}' | head -n 1)
-CPU_INFO=$(cat /proc/cpuinfo)
-MEMORY_INFO=$(free -h)
-DISK_INFO=$(df -h)
-
-# Concatenate information and compute SHA-256 hash
-SIGNATURE=$(echo "$HOSTNAME$MAC_ADDRESS$CPU_INFO$MEMORY_INFO$DISK_INFO" | sha256sum | awk '{print $1}')
-
-# Export the variables
-export MACHINE_SIGNATURE=$SIGNATURE
-
-# Register instance
-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
-
-python manage.py runserver 0.0.0.0:8000 --settings=plane.settings.local
-

apiserver/gunicorn.config.py

@@ -0,0 +1,6 @@
+from psycogreen.gevent import patch_psycopg
+
+
+def post_fork(server, worker):
+    patch_psycopg()
+    worker.log.info("Made Psycopg2 Green")

apiserver/package.json

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

apiserver/plane/analytics/urls.py

@@ -0,0 +1,8 @@
+# from django.contrib import admin
+from django.urls import path
+
+from plane.analytics.views import EventTrackingEndpoint
+
+urlpatterns = [
+    path('track-event/', EventTrackingEndpoint.as_view(), name='event_tracking'),
+]

apiserver/plane/analytics/views/__init__.py

@@ -0,0 +1 @@
+from .event_tacking import EventTrackingEndpoint

apiserver/plane/analytics/views/event_tacking.py

@@ -0,0 +1,52 @@
+# Python imports
+import requests
+import json
+
+# Module imports
+from plane.app.views import BaseAPIView
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+
+# Django imports
+from django.conf import settings
+from django.core.serializers.json import DjangoJSONEncoder
+
+
+class EventTrackingEndpoint(BaseAPIView):
+    permission_class = [
+        IsAuthenticated,
+    ]
+
+    def post(self, request):
+        event_name = request.data.get("event_name", None)
+        extra = request.data.get("extra", None)
+
+        if not event_name or not extra:
+            return Response(
+                {"error": "event name and extra are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        _ = requests.post(
+            settings.ANALYTICS_BASE_API,
+            params={"token": settings.ANALYTICS_SECRET_KEY},
+            json=json.dumps(
+                {
+                    "eventName": event_name,
+                    "extra": extra,
+                    "user": {
+                        "id": str(request.user.id),
+                        "email": str(request.user.email),
+                        "first_name": str(request.user.first_name),
+                        "last_name": str(request.user.last_name),
+                        "last_login_ip": str(request.META.get("REMOTE_ADDR")),
+                        "last_login_uagent": str(request.META.get("HTTP_USER_AGENT"))
+                    },
+                },
+                cls=DjangoJSONEncoder,
+            ),
+        )
+        return Response({"message": "success"}, status=status.HTTP_200_OK)

apiserver/plane/api/middleware/api_authentication.py

@@ -1,47 +0,0 @@
-# Django imports
-from django.utils import timezone
-from django.db.models import Q
-
-# Third party imports
-from rest_framework import authentication
-from rest_framework.exceptions import AuthenticationFailed
-
-# Module imports
-from plane.db.models import APIToken
-
-
-class APIKeyAuthentication(authentication.BaseAuthentication):
-    """
-    Authentication with an API Key
-    """
-
-    www_authenticate_realm = "api"
-    media_type = "application/json"
-    auth_header_name = "X-Api-Key"
-
-    def get_api_token(self, request):
-        return request.headers.get(self.auth_header_name)
-
-    def validate_api_token(self, token):
-        try:
-            api_token = APIToken.objects.get(
-                Q(Q(expired_at__gt=timezone.now()) | Q(expired_at__isnull=True)),
-                token=token,
-                is_active=True,
-            )
-        except APIToken.DoesNotExist:
-            raise AuthenticationFailed("Given API token is not valid")
-
-        # save api token last used
-        api_token.last_used = timezone.now()
-        api_token.save(update_fields=["last_used"])
-        return (api_token.user, api_token.token)
-
-    def authenticate(self, request):
-        token = self.get_api_token(request=request)
-        if not token:
-            return None
-
-        # Validate the API token
-        user, token = self.validate_api_token(token)
-        return user, token

apiserver/plane/api/serializers/__init__.py

@@ -1,17 +0,0 @@
-from .user import UserLiteSerializer
-from .workspace import WorkspaceLiteSerializer
-from .project import ProjectSerializer, ProjectLiteSerializer
-from .issue import (
-    IssueSerializer,
-    LabelSerializer,
-    IssueLinkSerializer,
-    IssueAttachmentSerializer,
-    IssueCommentSerializer,
-    IssueAttachmentSerializer,
-    IssueActivitySerializer,
-    IssueExpandSerializer,
-)
-from .state import StateLiteSerializer, StateSerializer
-from .cycle import CycleSerializer, CycleIssueSerializer, CycleLiteSerializer
-from .module import ModuleSerializer, ModuleIssueSerializer, ModuleLiteSerializer
-from .inbox import InboxIssueSerializer

apiserver/plane/api/serializers/base.py

@@ -1,105 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-
-class BaseSerializer(serializers.ModelSerializer):
-    id = serializers.PrimaryKeyRelatedField(read_only=True)
-
-    def __init__(self, *args, **kwargs):
-        # If 'fields' is provided in the arguments, remove it and store it separately.
-        # This is done so as not to pass this custom argument up to the superclass.
-        fields = kwargs.pop("fields", [])
-        self.expand = kwargs.pop("expand", []) or []
-
-        # Call the initialization of the superclass.
-        super().__init__(*args, **kwargs)
-
-        # If 'fields' was provided, filter the fields of the serializer accordingly.
-        if fields:
-            self.fields = self._filter_fields(fields=fields)
-
-    def _filter_fields(self, fields):
-        """
-        Adjust the serializer's fields based on the provided 'fields' list.
-
-        :param fields: List or dictionary specifying which fields to include in the serializer.
-        :return: The updated fields for the serializer.
-        """
-        # Check each field_name in the provided fields.
-        for field_name in fields:
-            # If the field is a dictionary (indicating nested fields),
-            # loop through its keys and values.
-            if isinstance(field_name, dict):
-                for key, value in field_name.items():
-                    # If the value of this nested field is a list,
-                    # perform a recursive filter on it.
-                    if isinstance(value, list):
-                        self._filter_fields(self.fields[key], value)
-
-        # Create a list to store allowed fields.
-        allowed = []
-        for item in fields:
-            # If the item is a string, it directly represents a field's name.
-            if isinstance(item, str):
-                allowed.append(item)
-            # If the item is a dictionary, it represents a nested field.
-            # Add the key of this dictionary to the allowed list.
-            elif isinstance(item, dict):
-                allowed.append(list(item.keys())[0])
-
-        # Convert the current serializer's fields and the allowed fields to sets.
-        existing = set(self.fields)
-        allowed = set(allowed)
-
-        # Remove fields from the serializer that aren't in the 'allowed' list.
-        for field_name in existing - allowed:
-            self.fields.pop(field_name)
-
-        return self.fields
-
-    def to_representation(self, instance):
-        response = super().to_representation(instance)
-
-        # Ensure 'expand' is iterable before processing
-        if self.expand:
-            for expand in self.expand:
-                if expand in self.fields:
-                    # Import all the expandable serializers
-                    from . import (
-                        WorkspaceLiteSerializer,
-                        ProjectLiteSerializer,
-                        UserLiteSerializer,
-                        StateLiteSerializer,
-                        IssueSerializer,
-                    )
-
-                    # Expansion mapper
-                    expansion = {
-                        "user": UserLiteSerializer,
-                        "workspace": WorkspaceLiteSerializer,
-                        "project": ProjectLiteSerializer,
-                        "default_assignee": UserLiteSerializer,
-                        "project_lead": UserLiteSerializer,
-                        "state": StateLiteSerializer,
-                        "created_by": UserLiteSerializer,
-                        "issue": IssueSerializer,
-                        "actor": UserLiteSerializer,
-                        "owned_by": UserLiteSerializer,
-                        "members": UserLiteSerializer,
-                    }
-                    # Check if field in expansion  then expand the field
-                    if expand in expansion:
-                        if isinstance(response.get(expand), list):
-                            exp_serializer = expansion[expand](
-                                getattr(instance, expand), many=True
-                            )
-                        else:
-                            exp_serializer = expansion[expand](
-                                getattr(instance, expand)
-                            )
-                            response[expand] = exp_serializer.data
-                    else:
-                        # You might need to handle this case differently
-                        response[expand] = getattr(instance, f"{expand}_id", None)
-
-        return response

apiserver/plane/api/serializers/cycle.py

@@ -1,61 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from .base import BaseSerializer
-from plane.db.models import Cycle, CycleIssue
-
-
-class CycleSerializer(BaseSerializer):
-    total_issues = serializers.IntegerField(read_only=True)
-    cancelled_issues = serializers.IntegerField(read_only=True)
-    completed_issues = serializers.IntegerField(read_only=True)
-    started_issues = serializers.IntegerField(read_only=True)
-    unstarted_issues = serializers.IntegerField(read_only=True)
-    backlog_issues = serializers.IntegerField(read_only=True)
-    total_estimates = serializers.IntegerField(read_only=True)
-    completed_estimates = serializers.IntegerField(read_only=True)
-    started_estimates = serializers.IntegerField(read_only=True)
-
-    def validate(self, data):
-        if (
-            data.get("start_date", None) is not None
-            and data.get("end_date", None) is not None
-            and data.get("start_date", None) > data.get("end_date", None)
-        ):
-            raise serializers.ValidationError("Start date cannot exceed end date")
-        return data
-
-    class Meta:
-        model = Cycle
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-            "workspace",
-            "project",
-            "owned_by",
-        ]
-
-
-class CycleIssueSerializer(BaseSerializer):
-    sub_issues_count = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = CycleIssue
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "cycle",
-        ]
-
-
-class CycleLiteSerializer(BaseSerializer):
-
-    class Meta:
-        model = Cycle
-        fields = "__all__"

apiserver/plane/api/serializers/inbox.py

@@ -1,19 +0,0 @@
-# Module improts
-from .base import BaseSerializer
-from plane.db.models import InboxIssue
-
-class InboxIssueSerializer(BaseSerializer):
-
-    class Meta:
-        model = InboxIssue
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]

apiserver/plane/api/serializers/issue.py

@@ -1,393 +0,0 @@
-from lxml import html
-
-
-# Django imports
-from django.utils import timezone
-
-#  Third party imports
-from rest_framework import serializers
-
-# Module imports
-from plane.db.models import (
-    User,
-    Issue,
-    State,
-    IssueAssignee,
-    Label,
-    IssueLabel,
-    IssueLink,
-    IssueComment,
-    IssueAttachment,
-    IssueActivity,
-    ProjectMember,
-)
-from .base import BaseSerializer
-from .cycle import CycleSerializer, CycleLiteSerializer
-from .module import ModuleSerializer, ModuleLiteSerializer
-from .user import UserLiteSerializer
-from .state import StateLiteSerializer
-
-class IssueSerializer(BaseSerializer):
-    assignees = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(
-            queryset=User.objects.values_list("id", flat=True)
-        ),
-        write_only=True,
-        required=False,
-    )
-
-    labels = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(
-            queryset=Label.objects.values_list("id", flat=True)
-        ),
-        write_only=True,
-        required=False,
-    )
-
-    class Meta:
-        model = Issue
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-        exclude = [
-            "description",
-            "description_stripped",
-        ]
-
-    def validate(self, data):
-        if (
-            data.get("start_date", None) is not None
-            and data.get("target_date", None) is not None
-            and data.get("start_date", None) > data.get("target_date", None)
-        ):
-            raise serializers.ValidationError("Start date cannot exceed target date")
-        
-        try:
-            if(data.get("description_html", None) is not None):
-                parsed = html.fromstring(data["description_html"])
-                parsed_str = html.tostring(parsed, encoding='unicode')
-                data["description_html"] = parsed_str
-            
-        except Exception as e:
-            raise serializers.ValidationError(f"Invalid HTML: {str(e)}")
-
-        # Validate assignees are from project
-        if data.get("assignees", []):
-            data["assignees"] = ProjectMember.objects.filter(
-                project_id=self.context.get("project_id"),
-                is_active=True,
-                member_id__in=data["assignees"],
-            ).values_list("member_id", flat=True)
-
-        # Validate labels are from project
-        if data.get("labels", []):
-            data["labels"] = Label.objects.filter(
-                project_id=self.context.get("project_id"),
-                id__in=data["labels"],
-            ).values_list("id", flat=True)
-
-        # Check state is from the project only else raise validation error
-        if (
-            data.get("state")
-            and not State.objects.filter(
-                project_id=self.context.get("project_id"), pk=data.get("state")
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "State is not valid please pass a valid state_id"
-            )
-
-        # Check parent issue is from workspace as it can be cross workspace
-        if (
-            data.get("parent")
-            and not Issue.objects.filter(
-                workspace_id=self.context.get("workspace_id"), pk=data.get("parent")
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "Parent is not valid issue_id please pass a valid issue_id"
-            )
-
-        return data
-
-    def create(self, validated_data):
-        assignees = validated_data.pop("assignees", None)
-        labels = validated_data.pop("labels", None)
-
-        project_id = self.context["project_id"]
-        workspace_id = self.context["workspace_id"]
-        default_assignee_id = self.context["default_assignee_id"]
-
-        issue = Issue.objects.create(**validated_data, project_id=project_id)
-
-        # Issue Audit Users
-        created_by_id = issue.created_by_id
-        updated_by_id = issue.updated_by_id
-
-        if assignees is not None and len(assignees):
-            IssueAssignee.objects.bulk_create(
-                [
-                    IssueAssignee(
-                        assignee_id=assignee_id,
-                        issue=issue,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for assignee_id in assignees
-                ],
-                batch_size=10,
-            )
-        else:
-            # Then assign it to default assignee
-            if default_assignee_id is not None:
-                IssueAssignee.objects.create(
-                    assignee_id=default_assignee_id,
-                    issue=issue,
-                    project_id=project_id,
-                    workspace_id=workspace_id,
-                    created_by_id=created_by_id,
-                    updated_by_id=updated_by_id,
-                )
-
-        if labels is not None and len(labels):
-            IssueLabel.objects.bulk_create(
-                [
-                    IssueLabel(
-                        label_id=label_id,
-                        issue=issue,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for label_id in labels
-                ],
-                batch_size=10,
-            )
-
-        return issue
-
-    def update(self, instance, validated_data):
-        assignees = validated_data.pop("assignees", None)
-        labels = validated_data.pop("labels", None)
-
-        # Related models
-        project_id = instance.project_id
-        workspace_id = instance.workspace_id
-        created_by_id = instance.created_by_id
-        updated_by_id = instance.updated_by_id
-
-        if assignees is not None:
-            IssueAssignee.objects.filter(issue=instance).delete()
-            IssueAssignee.objects.bulk_create(
-                [
-                    IssueAssignee(
-                        assignee_id=assignee_id,
-                        issue=instance,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for assignee_id in assignees
-                ],
-                batch_size=10,
-            )
-
-        if labels is not None:
-            IssueLabel.objects.filter(issue=instance).delete()
-            IssueLabel.objects.bulk_create(
-                [
-                    IssueLabel(
-                        label_id=label_id,
-                        issue=instance,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for label_id in labels
-                ],
-                batch_size=10,
-            )
-
-        # Time updation occues even when other related models are updated
-        instance.updated_at = timezone.now()
-        return super().update(instance, validated_data)
-
-    def to_representation(self, instance):
-        data = super().to_representation(instance)
-        if "assignees" in self.fields:
-            if "assignees" in self.expand:
-                from .user import UserLiteSerializer
-
-                data["assignees"] = UserLiteSerializer(
-                    instance.assignees.all(), many=True
-                ).data
-            else:
-                data["assignees"] = [
-                    str(assignee.id) for assignee in instance.assignees.all()
-                ]
-        if "labels" in self.fields:
-            if "labels" in self.expand:
-                data["labels"] = LabelSerializer(instance.labels.all(), many=True).data
-            else:
-                data["labels"] = [str(label.id) for label in instance.labels.all()]
-
-        return data
-
-
-class LabelSerializer(BaseSerializer):
-    class Meta:
-        model = Label
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueLinkSerializer(BaseSerializer):
-    class Meta:
-        model = IssueLink
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-    # Validation if url already exists
-    def create(self, validated_data):
-        if IssueLink.objects.filter(
-            url=validated_data.get("url"), issue_id=validated_data.get("issue_id")
-        ).exists():
-            raise serializers.ValidationError(
-                {"error": "URL already exists for this Issue"}
-            )
-        return IssueLink.objects.create(**validated_data)
-
-
-class IssueAttachmentSerializer(BaseSerializer):
-    class Meta:
-        model = IssueAttachment
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueCommentSerializer(BaseSerializer):
-    is_member = serializers.BooleanField(read_only=True)
-
-    class Meta:
-        model = IssueComment
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-        exclude = [
-            "comment_stripped",
-            "comment_json",
-        ]
-
-    def validate(self, data):
-        try:
-            if(data.get("comment_html", None) is not None):
-                parsed = html.fromstring(data["comment_html"])
-                parsed_str = html.tostring(parsed, encoding='unicode')
-                data["comment_html"] = parsed_str
-            
-        except Exception as e:
-            raise serializers.ValidationError(f"Invalid HTML: {str(e)}")
-        return data
-
-
-class IssueActivitySerializer(BaseSerializer):
-    class Meta:
-        model = IssueActivity
-        exclude = [
-            "created_by",
-            "updated_by",
-        ]
-
-
-class CycleIssueSerializer(BaseSerializer):
-    cycle = CycleSerializer(read_only=True)
-
-    class Meta:
-        fields = [
-            "cycle",
-        ]
-
-
-class ModuleIssueSerializer(BaseSerializer):
-    module = ModuleSerializer(read_only=True)
-
-    class Meta:
-        fields = [
-            "module",
-        ]
-
-
-class LabelLiteSerializer(BaseSerializer):
-
-    class Meta:
-        model = Label
-        fields = [
-            "id",
-            "name",
-            "color",
-        ]
-
-
-class IssueExpandSerializer(BaseSerializer):
-    cycle = CycleLiteSerializer(source="issue_cycle.cycle", read_only=True)
-    module = ModuleLiteSerializer(source="issue_module.module", read_only=True)
-    labels = LabelLiteSerializer(read_only=True, many=True)
-    assignees = UserLiteSerializer(read_only=True, many=True)
-    state = StateLiteSerializer(read_only=True)
-
-    class Meta:
-        model = Issue
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]

apiserver/plane/api/serializers/module.py

@@ -1,161 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from .base import BaseSerializer
-from plane.db.models import (
-    User,
-    Module,
-    ModuleLink,
-    ModuleMember,
-    ModuleIssue,
-    ProjectMember,
-)
-
-
-class ModuleSerializer(BaseSerializer):
-    members = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(
-            queryset=User.objects.values_list("id", flat=True)
-        ),
-        write_only=True,
-        required=False,
-    )
-    total_issues = serializers.IntegerField(read_only=True)
-    cancelled_issues = serializers.IntegerField(read_only=True)
-    completed_issues = serializers.IntegerField(read_only=True)
-    started_issues = serializers.IntegerField(read_only=True)
-    unstarted_issues = serializers.IntegerField(read_only=True)
-    backlog_issues = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = Module
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-    def to_representation(self, instance):
-        data = super().to_representation(instance)
-        data["members"] = [str(member.id) for member in instance.members.all()]
-        return data
-
-    def validate(self, data):
-        if (
-            data.get("start_date", None) is not None
-            and data.get("target_date", None) is not None
-            and data.get("start_date", None) > data.get("target_date", None)
-        ):
-            raise serializers.ValidationError("Start date cannot exceed target date")
-
-        if data.get("members", []):
-            data["members"] = ProjectMember.objects.filter(
-                project_id=self.context.get("project_id"),
-                member_id__in=data["members"],
-            ).values_list("member_id", flat=True)
-
-        return data
-
-    def create(self, validated_data):
-        members = validated_data.pop("members", None)
-
-        project = self.context["project"]
-
-        module = Module.objects.create(**validated_data, project=project)
-
-        if members is not None:
-            ModuleMember.objects.bulk_create(
-                [
-                    ModuleMember(
-                        module=module,
-                        member=member,
-                        project=project,
-                        workspace=project.workspace,
-                        created_by=module.created_by,
-                        updated_by=module.updated_by,
-                    )
-                    for member in members
-                ],
-                batch_size=10,
-                ignore_conflicts=True,
-            )
-
-        return module
-
-    def update(self, instance, validated_data):
-        members = validated_data.pop("members", None)
-
-        if members is not None:
-            ModuleMember.objects.filter(module=instance).delete()
-            ModuleMember.objects.bulk_create(
-                [
-                    ModuleMember(
-                        module=instance,
-                        member=member,
-                        project=instance.project,
-                        workspace=instance.project.workspace,
-                        created_by=instance.created_by,
-                        updated_by=instance.updated_by,
-                    )
-                    for member in members
-                ],
-                batch_size=10,
-                ignore_conflicts=True,
-            )
-
-        return super().update(instance, validated_data)
-
-
-class ModuleIssueSerializer(BaseSerializer):
-    sub_issues_count = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = ModuleIssue
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-            "module",
-        ]
-
-
-class ModuleLinkSerializer(BaseSerializer):
-    class Meta:
-        model = ModuleLink
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-            "module",
-        ]
-
-    # Validation if url already exists
-    def create(self, validated_data):
-        if ModuleLink.objects.filter(
-            url=validated_data.get("url"), module_id=validated_data.get("module_id")
-        ).exists():
-            raise serializers.ValidationError(
-                {"error": "URL already exists for this Issue"}
-            )
-        return ModuleLink.objects.create(**validated_data)
-    
-
-class ModuleLiteSerializer(BaseSerializer):
-
-    class Meta:
-        model = Module
-        fields = "__all__"

apiserver/plane/api/serializers/project.py

@@ -1,92 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from plane.db.models import Project, ProjectIdentifier, WorkspaceMember, State, Estimate
-from .base import BaseSerializer
-
-
-class ProjectSerializer(BaseSerializer):
-
-    total_members = serializers.IntegerField(read_only=True)
-    total_cycles = serializers.IntegerField(read_only=True)
-    total_modules = serializers.IntegerField(read_only=True)
-    is_member = serializers.BooleanField(read_only=True)
-    sort_order = serializers.FloatField(read_only=True)
-    member_role = serializers.IntegerField(read_only=True)
-    is_deployed = serializers.BooleanField(read_only=True)
-
-    class Meta:
-        model = Project
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            'emoji',
-            "workspace",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-        ]
-
-    def validate(self, data):
-        # Check project lead should be a member of the workspace
-        if (
-            data.get("project_lead", None) is not None
-            and not WorkspaceMember.objects.filter(
-                workspace_id=self.context["workspace_id"],
-                member_id=data.get("project_lead"),
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "Project lead should be a user in the workspace"
-            )
-
-        # Check default assignee should be a member of the workspace
-        if (
-            data.get("default_assignee", None) is not None
-            and not WorkspaceMember.objects.filter(
-                workspace_id=self.context["workspace_id"],
-                member_id=data.get("default_assignee"),
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "Default assignee should be a user in the workspace"
-            )
-
-        return data
-
-    def create(self, validated_data):
-        identifier = validated_data.get("identifier", "").strip().upper()
-        if identifier == "":
-            raise serializers.ValidationError(detail="Project Identifier is required")
-
-        if ProjectIdentifier.objects.filter(
-            name=identifier, workspace_id=self.context["workspace_id"]
-        ).exists():
-            raise serializers.ValidationError(detail="Project Identifier is taken")
-
-        project = Project.objects.create(
-            **validated_data, workspace_id=self.context["workspace_id"]
-        )
-        _ = ProjectIdentifier.objects.create(
-            name=project.identifier,
-            project=project,
-            workspace_id=self.context["workspace_id"],
-        )
-        return project
-
-
-class ProjectLiteSerializer(BaseSerializer):
-    class Meta:
-        model = Project
-        fields = [
-            "id",
-            "identifier",
-            "name",
-            "cover_image",
-            "icon_prop",
-            "emoji",
-            "description",
-        ]
-        read_only_fields = fields

apiserver/plane/api/serializers/state.py

@@ -1,38 +0,0 @@
-# Module imports
-from .base import BaseSerializer
-from plane.db.models import State
-
-
-class StateSerializer(BaseSerializer):
-    def validate(self, data):
-        # If the default is being provided then make all other states default False
-        if data.get("default", False):
-            State.objects.filter(project_id=self.context.get("project_id")).update(
-                default=False
-            )
-        return data
-
-    class Meta:
-        model = State
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-            "workspace",
-            "project",
-        ]
-
-
-class StateLiteSerializer(BaseSerializer):
-    class Meta:
-        model = State
-        fields = [
-            "id",
-            "name",
-            "color",
-            "group",
-        ]
-        read_only_fields = fields

apiserver/plane/api/serializers/user.py

@@ -1,16 +0,0 @@
-# Module imports
-from plane.db.models import User
-from .base import BaseSerializer
-
-
-class UserLiteSerializer(BaseSerializer):
-    class Meta:
-        model = User
-        fields = [
-            "id",
-            "first_name",
-            "last_name",
-            "avatar",
-            "display_name",
-        ]
-        read_only_fields = fields

apiserver/plane/api/serializers/workspace.py

@@ -1,15 +0,0 @@
-# Module imports
-from plane.db.models import Workspace
-from .base import BaseSerializer
-
-
-class WorkspaceLiteSerializer(BaseSerializer):
-    """Lite serializer with only required fields"""
-    class Meta:
-        model = Workspace
-        fields = [
-            "name",
-            "slug",
-            "id",
-        ]
-        read_only_fields = fields

apiserver/plane/api/urls/inbox.py

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

apiserver/plane/api/urls/state.py

@@ -1,16 +0,0 @@
-from django.urls import path
-
-from plane.api.views import StateAPIEndpoint
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/states/",
-        StateAPIEndpoint.as_view(),
-        name="states",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/states/<uuid:state_id>/",
-        StateAPIEndpoint.as_view(),
-        name="states",
-    ),
-]

apiserver/plane/api/views/base.py

@@ -1,176 +0,0 @@
-# Python imports
-import zoneinfo
-import json
-
-# Django imports
-from django.conf import settings
-from django.db import IntegrityError
-from django.core.exceptions import ObjectDoesNotExist, ValidationError
-from django.utils import timezone
-
-# 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
-
-
-class TimezoneMixin:
-    """
-    This enables timezone conversion according
-    to the user set timezone
-    """
-
-    def initial(self, request, *args, **kwargs):
-        super().initial(request, *args, **kwargs)
-        if request.user.is_authenticated:
-            timezone.activate(zoneinfo.ZoneInfo(request.user.user_timezone))
-        else:
-            timezone.deactivate()
-
-
-class WebhookMixin:
-    webhook_event = None
-    bulk = False
-
-    def finalize_response(self, request, response, *args, **kwargs):
-        response = super().finalize_response(request, response, *args, **kwargs)
-
-        # Check for the case should webhook be sent
-        if (
-            self.webhook_event
-            and self.request.method in ["POST", "PATCH", "DELETE"]
-            and response.status_code in [200, 201, 204]
-        ):
-            # Push the object to delay
-            send_webhook.delay(
-                event=self.webhook_event,
-                payload=response.data,
-                kw=self.kwargs,
-                action=self.request.method,
-                slug=self.workspace_slug,
-                bulk=self.bulk,
-            )
-
-        return response
-
-
-class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
-    authentication_classes = [
-        APIKeyAuthentication,
-    ]
-
-    permission_classes = [
-        IsAuthenticated,
-    ]
-
-    throttle_classes = [
-        ApiKeyRateThrottle,
-    ]
-
-    def filter_queryset(self, queryset):
-        for backend in list(self.filter_backends):
-            queryset = backend().filter_queryset(self.request, queryset, self)
-        return queryset
-
-    def handle_exception(self, exc):
-        """
-        Handle any exception that occurs, by returning an appropriate response,
-        or re-raising the error.
-        """
-        try:
-            response = super().handle_exception(exc)
-            return response
-        except Exception as e:
-            if isinstance(e, IntegrityError):
-                return Response(
-                    {"error": "The payload is not valid"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if isinstance(e, ValidationError):
-                return Response(
-                    {
-                        "error": "The provided payload is not valid please try with a valid payload"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if isinstance(e, ObjectDoesNotExist):
-                model_name = str(exc).split(" matching query does not exist.")[0]
-                return Response(
-                    {"error": f"{model_name} does not exist."},
-                    status=status.HTTP_404_NOT_FOUND,
-                )
-
-            if isinstance(e, KeyError):
-                return Response(
-                    {"error": f"key {e} does not exist"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if settings.DEBUG:
-                print(e)
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            )
-
-    def dispatch(self, request, *args, **kwargs):
-        try:
-            response = super().dispatch(request, *args, **kwargs)
-            if settings.DEBUG:
-                from django.db import connection
-
-                print(
-                    f"{request.method} - {request.get_full_path()} of Queries: {len(connection.queries)}"
-                )
-            return response
-        except Exception as exc:
-            response = self.handle_exception(exc)
-            return exc
-
-    def finalize_response(self, request, response, *args, **kwargs):
-        # Call super to get the default response
-        response = super().finalize_response(request, response, *args, **kwargs)
-
-        # Add custom headers if they exist in the request META
-        ratelimit_remaining = request.META.get("X-RateLimit-Remaining")
-        if ratelimit_remaining is not None:
-            response["X-RateLimit-Remaining"] = ratelimit_remaining
-
-        ratelimit_reset = request.META.get("X-RateLimit-Reset")
-        if ratelimit_reset is not None:
-            response["X-RateLimit-Reset"] = ratelimit_reset
-
-        return response
-
-    @property
-    def workspace_slug(self):
-        return self.kwargs.get("slug", None)
-
-    @property
-    def project_id(self):
-        return self.kwargs.get("project_id", None)
-
-    @property
-    def fields(self):
-        fields = [
-            field for field in self.request.GET.get("fields", "").split(",") if field
-        ]
-        return fields if fields else None
-
-    @property
-    def expand(self):
-        expand = [
-            expand for expand in self.request.GET.get("expand", "").split(",") if expand
-        ]
-        return expand if expand else None

apiserver/plane/api/views/cycle.py

@@ -1,557 +0,0 @@
-# Python imports
-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
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-
-# Module imports
-from .base import BaseAPIView, WebhookMixin
-from plane.db.models import Cycle, Issue, CycleIssue, IssueLink, IssueAttachment
-from plane.app.permissions import ProjectEntityPermission
-from plane.api.serializers import (
-    CycleSerializer,
-    CycleIssueSerializer,
-)
-from plane.bgtasks.issue_activites_task import issue_activity
-
-
-class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to cycle.
-
-    """
-
-    serializer_class = CycleSerializer
-    model = Cycle
-    webhook_event = "cycle"
-    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)
-            .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, pk=None):
-        if pk:
-            queryset = self.get_queryset().get(pk=pk)
-            data = CycleSerializer(
-                queryset,
-                fields=self.fields,
-                expand=self.expand,
-            ).data
-            return Response(
-                data,
-                status=status.HTTP_200_OK,
-            )
-        queryset = self.get_queryset()
-        cycle_view = request.GET.get("cycle_view", "all")
-
-        # Current Cycle
-        if cycle_view == "current":
-            queryset = queryset.filter(
-                start_date__lte=timezone.now(),
-                end_date__gte=timezone.now(),
-            )
-            data = CycleSerializer(
-                queryset, many=True, fields=self.fields, expand=self.expand
-            ).data
-            return Response(data, status=status.HTTP_200_OK)
-
-        # Upcoming Cycles
-        if cycle_view == "upcoming":
-            queryset = queryset.filter(start_date__gt=timezone.now())
-            return self.paginate(
-                request=request,
-                queryset=(queryset),
-                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-
-        # Completed Cycles
-        if cycle_view == "completed":
-            queryset = queryset.filter(end_date__lt=timezone.now())
-            return self.paginate(
-                request=request,
-                queryset=(queryset),
-                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-
-        # Draft Cycles
-        if cycle_view == "draft":
-            queryset = queryset.filter(
-                end_date=None,
-                start_date=None,
-            )
-            return self.paginate(
-                request=request,
-                queryset=(queryset),
-                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-
-        # Incomplete Cycles
-        if cycle_view == "incomplete":
-            queryset = queryset.filter(
-                Q(end_date__gte=timezone.now().date()) | Q(end_date__isnull=True),
-            )
-            return self.paginate(
-                request=request,
-                queryset=(queryset),
-                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-        return self.paginate(
-            request=request,
-            queryset=(queryset),
-            on_results=lambda cycles: CycleSerializer(
-                cycles,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id):
-        if (
-            request.data.get("start_date", None) is None
-            and request.data.get("end_date", None) is None
-        ) or (
-            request.data.get("start_date", None) is not None
-            and request.data.get("end_date", None) is not None
-        ):
-            serializer = CycleSerializer(data=request.data)
-            if serializer.is_valid():
-                serializer.save(
-                    project_id=project_id,
-                    owned_by=request.user,
-                )
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        else:
-            return Response(
-                {
-                    "error": "Both start date and end date are either required or are to be null"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def patch(self, request, slug, project_id, pk):
-        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
-
-        request_data = request.data
-
-        if cycle.end_date is not None and cycle.end_date < timezone.now().date():
-            if "sort_order" in request_data:
-                # Can only change sort order
-                request_data = {
-                    "sort_order": request_data.get("sort_order", cycle.sort_order)
-                }
-            else:
-                return Response(
-                    {
-                        "error": "The Cycle has already been completed so it cannot be edited"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-        serializer = CycleSerializer(cycle, data=request.data, partial=True)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def delete(self, request, slug, project_id, pk):
-        cycle_issues = list(
-            CycleIssue.objects.filter(cycle_id=self.kwargs.get("pk")).values_list(
-                "issue", flat=True
-            )
-        )
-        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
-
-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                'type': "cycle.activity.deleted",
-                'requested_data': json.dumps({
-                    "cycle_id": str(pk),
-                    "cycle_name": str(cycle.name),
-                    "issues": [str(issue_id) for issue_id in cycle_issues],
-                }),
-                'actor_id': str(request.user.id),
-                'issue_id': None,
-                'project_id': str(project_id),
-                'current_instance': None,
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
-        )
-        # Delete the cycle
-        cycle.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`,
-    and `destroy` actions related to cycle issues.
-
-    """
-
-    serializer_class = CycleIssueSerializer
-    model = CycleIssue
-    webhook_event = "cycle_issue"
-    bulk = True
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            CycleIssue.objects.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)
-            .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")
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id, cycle_id):
-        order_by = request.GET.get("order_by", "created_at")
-        issues = (
-            Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(bridge_id=F("issue_cycle__id"))
-            .filter(project_id=project_id)
-            .filter(workspace__slug=slug)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("state")
-            .select_related("parent")
-            .prefetch_related("assignees")
-            .prefetch_related("labels")
-            .order_by(order_by)
-            .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")
-            )
-        )
-
-        return self.paginate(
-            request=request,
-            queryset=(issues),
-            on_results=lambda issues: CycleSerializer(
-                issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(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,
-            )
-
-        issues = Issue.objects.filter(
-            pk__in=issues, workspace__slug=slug, project_id=project_id
-        ).values_list("id", flat=True)
-
-        # Get all CycleIssues already created
-        cycle_issues = list(CycleIssue.objects.filter(issue_id__in=issues))
-        update_cycle_issue_activity = []
-        record_to_create = []
-        records_to_update = []
-
-        for issue in issues:
-            cycle_issue = [
-                cycle_issue
-                for cycle_issue in cycle_issues
-                if str(cycle_issue.issue_id) in issues
-            ]
-            # Update only when cycle changes
-            if len(cycle_issue):
-                if cycle_issue[0].cycle_id != cycle_id:
-                    update_cycle_issue_activity.append(
-                        {
-                            "old_cycle_id": str(cycle_issue[0].cycle_id),
-                            "new_cycle_id": str(cycle_id),
-                            "issue_id": str(cycle_issue[0].issue_id),
-                        }
-                    )
-                    cycle_issue[0].cycle_id = cycle_id
-                    records_to_update.append(cycle_issue[0])
-            else:
-                record_to_create.append(
-                    CycleIssue(
-                        project_id=project_id,
-                        workspace=cycle.workspace,
-                        created_by=request.user,
-                        updated_by=request.user,
-                        cycle=cycle,
-                        issue_id=issue,
-                    )
-                )
-
-        CycleIssue.objects.bulk_create(
-            record_to_create,
-            batch_size=10,
-            ignore_conflicts=True,
-        )
-        CycleIssue.objects.bulk_update(
-            records_to_update,
-            ["cycle"],
-            batch_size=10,
-        )
-
-        # Capture Issue Activity
-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                'type': "cycle.activity.created",
-                'requested_data': json.dumps({"cycles_list": str(issues)}),
-                'actor_id': str(self.request.user.id),
-                'issue_id': None,
-                'project_id': str(self.kwargs.get("project_id", None)),
-                'current_instance': json.dumps({
-                    "updated_cycle_issues": update_cycle_issue_activity,
-                    "created_cycle_issues": serializers.serialize("json", record_to_create),
-                }),
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
-        )
-
-        # Return all Cycle Issues
-        return Response(
-            CycleIssueSerializer(self.get_queryset(), many=True).data,
-            status=status.HTTP_200_OK,
-        )
-
-    def delete(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_id = cycle_issue.issue_id
-        cycle_issue.delete()
-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                '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()),
-            },
-            routing_key='external',
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class TransferCycleIssueAPIEndpoint(BaseAPIView):
-    """
-    This viewset provides `create` actions for transfering the issues into a particular cycle.
-
-    """
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def post(self, request, slug, project_id, cycle_id):
-        new_cycle_id = request.data.get("new_cycle_id", False)
-
-        if not new_cycle_id:
-            return Response(
-                {"error": "New Cycle Id is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        new_cycle = Cycle.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=new_cycle_id
-        )
-
-        if (
-            new_cycle.end_date is not None
-            and new_cycle.end_date < timezone.now().date()
-        ):
-            return Response(
-                {
-                    "error": "The cycle where the issues are transferred is already completed"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        cycle_issues = CycleIssue.objects.filter(
-            cycle_id=cycle_id,
-            project_id=project_id,
-            workspace__slug=slug,
-            issue__state__group__in=["backlog", "unstarted", "started"],
-        )
-
-        updated_cycles = []
-        for cycle_issue in cycle_issues:
-            cycle_issue.cycle_id = new_cycle_id
-            updated_cycles.append(cycle_issue)
-
-        cycle_issues = CycleIssue.objects.bulk_update(
-            updated_cycles, ["cycle_id"], batch_size=100
-        )
-
-        return Response({"message": "Success"}, status=status.HTTP_200_OK)

apiserver/plane/api/views/inbox.py

@@ -1,360 +0,0 @@
-# Python imports
-import json
-
-# Django improts
-from django.utils import timezone
-from django.db.models import Q
-from django.core.serializers.json import DjangoJSONEncoder
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from .base import BaseAPIView
-from plane.app.permissions import ProjectLitePermission
-from plane.api.serializers import InboxIssueSerializer, IssueSerializer
-from plane.db.models import InboxIssue, Issue, State, ProjectMember, Project, Inbox
-from plane.bgtasks.issue_activites_task import issue_activity
-
-
-class InboxIssueAPIEndpoint(BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to inbox issues.
-
-    """
-
-    permission_classes = [
-        ProjectLitePermission,
-    ]
-
-    serializer_class = InboxIssueSerializer
-    model = InboxIssue
-
-    filterset_fields = [
-        "status",
-    ]
-
-    def get_queryset(self):
-        inbox = Inbox.objects.filter(
-            workspace__slug=self.kwargs.get("slug"),
-            project_id=self.kwargs.get("project_id"),
-        ).first()
-
-        project = Project.objects.get(
-            workspace__slug=self.kwargs.get("slug"), pk=self.kwargs.get("project_id")
-        )
-
-        if inbox is None and not project.inbox_view:
-            return InboxIssue.objects.none()
-
-        return (
-            InboxIssue.objects.filter(
-                Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
-                workspace__slug=self.kwargs.get("slug"),
-                project_id=self.kwargs.get("project_id"),
-                inbox_id=inbox.id,
-            )
-            .select_related("issue", "workspace", "project")
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-        )
-
-    def get(self, request, slug, project_id, issue_id=None):
-        if issue_id:
-            inbox_issue_queryset = self.get_queryset().get(issue_id=issue_id)
-            inbox_issue_data = InboxIssueSerializer(
-                inbox_issue_queryset,
-                fields=self.fields,
-                expand=self.expand,
-            ).data
-            return Response(
-                inbox_issue_data,
-                status=status.HTTP_200_OK,
-            )
-        issue_queryset = self.get_queryset()
-        return self.paginate(
-            request=request,
-            queryset=(issue_queryset),
-            on_results=lambda inbox_issues: InboxIssueSerializer(
-                inbox_issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id):
-        if not request.data.get("issue", {}).get("name", False):
-            return Response(
-                {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        inbox = Inbox.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-
-        project = Project.objects.get(
-            workspace__slug=slug,
-            pk=project_id,
-        )
-
-        # Inbox view
-        if inbox is None and not project.inbox_view:
-            return Response(
-                {
-                    "error": "Inbox is not enabled for this project enable it through the project's api"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Check for valid priority
-        if not request.data.get("issue", {}).get("priority", "none") in [
-            "low",
-            "medium",
-            "high",
-            "urgent",
-            "none",
-        ]:
-            return Response(
-                {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        # Create or get state
-        state, _ = State.objects.get_or_create(
-            name="Triage",
-            group="backlog",
-            description="Default state for managing all Inbox Issues",
-            project_id=project_id,
-            color="#ff7700",
-        )
-
-        # create an issue
-        issue = Issue.objects.create(
-            name=request.data.get("issue", {}).get("name"),
-            description=request.data.get("issue", {}).get("description", {}),
-            description_html=request.data.get("issue", {}).get(
-                "description_html", "<p></p>"
-            ),
-            priority=request.data.get("issue", {}).get("priority", "low"),
-            project_id=project_id,
-            state=state,
-        )
-
-        # Create an Issue Activity
-        issue_activity.apply_async(
-            args=[],  # If no positional arguments are required
-            kwargs={
-                "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()),
-            },
-            routing_key="external",
-        )
-
-        # create an inbox issue
-        inbox_issue = InboxIssue.objects.create(
-            inbox_id=inbox.id,
-            project_id=project_id,
-            issue=issue,
-            source=request.data.get("source", "in-app"),
-        )
-
-        serializer = InboxIssueSerializer(inbox_issue)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def patch(self, request, slug, project_id, issue_id):
-        inbox = Inbox.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-
-        project = Project.objects.get(
-            workspace__slug=slug,
-            pk=project_id,
-        )
-
-        # Inbox view
-        if inbox is None and not project.inbox_view:
-            return Response(
-                {
-                    "error": "Inbox is not enabled for this project enable it through the project's api"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get the inbox issue
-        inbox_issue = InboxIssue.objects.get(
-            issue_id=issue_id,
-            workspace__slug=slug,
-            project_id=project_id,
-            inbox_id=inbox.id,
-        )
-
-        # Get the project member
-        project_member = ProjectMember.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            member=request.user,
-            is_active=True,
-        )
-
-        # Only project members admins and created_by users can access this endpoint
-        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
-            request.user.id
-        ):
-            return Response(
-                {"error": "You cannot edit inbox issues"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get issue data
-        issue_data = request.data.pop("issue", False)
-
-        if bool(issue_data):
-            issue = Issue.objects.get(
-                pk=issue_id, workspace__slug=slug, project_id=project_id
-            )
-            # Only allow guests and viewers to edit name and description
-            if project_member.role <= 10:
-                # viewers and guests since only viewers and guests
-                issue_data = {
-                    "name": issue_data.get("name", issue.name),
-                    "description_html": issue_data.get(
-                        "description_html", issue.description_html
-                    ),
-                    "description": issue_data.get("description", issue.description),
-                }
-
-            issue_serializer = IssueSerializer(issue, data=issue_data, partial=True)
-
-            if issue_serializer.is_valid():
-                current_instance = issue
-                # Log all the updates
-                requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
-                if issue is not None:
-                    issue_activity.apply_async(
-                        args=[],
-                        kwargs={
-                            "type": "issue.activity.updated",
-                            "requested_data": requested_data,
-                            "actor_id": str(request.user.id),
-                            "issue_id": str(issue_id),
-                            "project_id": str(project_id),
-                            "current_instance": json.dumps(
-                                IssueSerializer(current_instance).data,
-                                cls=DjangoJSONEncoder,
-                            ),
-                            "epoch": int(timezone.now().timestamp()),
-                        },
-                        routing_key="external",
-                    )
-                issue_serializer.save()
-            else:
-                return Response(
-                    issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
-                )
-
-        # Only project admins and members can edit inbox issue attributes
-        if project_member.role > 10:
-            serializer = InboxIssueSerializer(
-                inbox_issue, data=request.data, partial=True
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                # Update the issue state if the issue is rejected or marked as duplicate
-                if serializer.data["status"] in [-1, 2]:
-                    issue = Issue.objects.get(
-                        pk=issue_id,
-                        workspace__slug=slug,
-                        project_id=project_id,
-                    )
-                    state = State.objects.filter(
-                        group="cancelled", workspace__slug=slug, project_id=project_id
-                    ).first()
-                    if state is not None:
-                        issue.state = state
-                        issue.save()
-
-                # Update the issue state if it is accepted
-                if serializer.data["status"] in [1]:
-                    issue = Issue.objects.get(
-                        pk=issue_id,
-                        workspace__slug=slug,
-                        project_id=project_id,
-                    )
-
-                    # Update the issue state only if it is in triage state
-                    if issue.state.name == "Triage":
-                        # Move to default state
-                        state = State.objects.filter(
-                            workspace__slug=slug, project_id=project_id, default=True
-                        ).first()
-                        if state is not None:
-                            issue.state = state
-                            issue.save()
-
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        else:
-            return Response(
-                InboxIssueSerializer(inbox_issue).data, status=status.HTTP_200_OK
-            )
-
-    def delete(self, request, slug, project_id, issue_id):
-        inbox = Inbox.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-
-        project = Project.objects.get(
-            workspace__slug=slug,
-            pk=project_id,
-        )
-
-        # Inbox view
-        if inbox is None and not project.inbox_view:
-            return Response(
-                {
-                    "error": "Inbox is not enabled for this project enable it through the project's api"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get the inbox issue
-        inbox_issue = InboxIssue.objects.get(
-            issue_id=issue_id,
-            workspace__slug=slug,
-            project_id=project_id,
-            inbox_id=inbox.id,
-        )
-
-        # Get the project member
-        project_member = ProjectMember.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            member=request.user,
-            is_active=True,
-        )
-
-        # Check the inbox issue created
-        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
-            request.user.id
-        ):
-            return Response(
-                {"error": "You cannot delete inbox issue"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Check the issue status
-        if inbox_issue.status in [-2, -1, 0, 2]:
-            # Delete the issue also
-            Issue.objects.filter(
-                workspace__slug=slug, project_id=project_id, pk=issue_id
-            ).delete()
-
-        inbox_issue.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/issue.py

@@ -1,642 +0,0 @@
-# Python imports
-import json
-from itertools import chain
-
-# Django imports
-from django.db import IntegrityError
-from django.db.models import (
-    OuterRef,
-    Func,
-    Q,
-    F,
-    Case,
-    When,
-    Value,
-    CharField,
-    Max,
-    Exists,
-)
-from django.core.serializers.json import DjangoJSONEncoder
-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.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 (
-    IssueSerializer,
-    LabelSerializer,
-    IssueLinkSerializer,
-    IssueCommentSerializer,
-    IssueActivitySerializer,
-)
-
-
-class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to issue.
-
-    """
-
-    model = Issue
-    webhook_event = "issue"
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-    serializer_class = IssueSerializer
-
-    def get_queryset(self):
-        return (
-            Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("state")
-            .select_related("parent")
-            .prefetch_related("assignees")
-            .prefetch_related("labels")
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-        ).distinct()
-
-    def get(self, request, slug, project_id, pk=None):
-        if pk:
-            issue = Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            ).get(workspace__slug=slug, project_id=project_id, pk=pk)
-            return Response(
-                IssueSerializer(
-                    issue,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-                status=status.HTTP_200_OK,
-            )
-
-        # 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()
-            .annotate(cycle_id=F("issue_cycle__cycle_id"))
-            .annotate(module_id=F("issue_module__module_id"))
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-        )
-
-        # 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)
-
-        return self.paginate(
-            request=request,
-            queryset=(issue_queryset),
-            on_results=lambda issues: IssueSerializer(
-                issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id):
-        project = Project.objects.get(pk=project_id)
-
-        serializer = IssueSerializer(
-            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.apply_async(
-                args=[],  # If no positional arguments are required
-                kwargs={
-                    '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()),
-                },
-                routing_key='external',
-            )
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def patch(self, request, slug, project_id, pk=None):
-        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
-        current_instance = json.dumps(
-            IssueSerializer(issue).data, cls=DjangoJSONEncoder
-        )
-        requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
-        serializer = IssueSerializer(issue, data=request.data, partial=True)
-        if serializer.is_valid():
-            serializer.save()
-            issue_activity.apply_async(
-                args=[],
-                kwargs={
-                    '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()),
-                },
-                routing_key='external',
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def delete(self, request, slug, project_id, pk=None):
-        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
-        current_instance = json.dumps(
-            IssueSerializer(issue).data, cls=DjangoJSONEncoder
-        )
-        issue.delete()
-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                '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': current_instance,
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='your_routing_key',
-            queue='your_queue_name'
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class LabelAPIEndpoint(BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to the labels.
-
-    """
-
-    serializer_class = LabelSerializer
-    model = Label
-    permission_classes = [
-        ProjectMemberPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            Label.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("parent")
-            .distinct()
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-        )
-
-    def post(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,
-            )
-
-    def get(self, request, slug, project_id, pk=None):
-        if pk is None:
-            return self.paginate(
-                request=request,
-                queryset=(self.get_queryset()),
-                on_results=lambda labels: LabelSerializer(
-                    labels,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-        label = self.get_queryset().get(pk=pk)
-        serializer = LabelSerializer(
-            label,
-            fields=self.fields,
-            expand=self.expand,
-        )
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def patch(self, request, slug, project_id, pk=None):
-        label = self.get_queryset().get(pk=pk)
-        serializer = LabelSerializer(label, data=request.data, partial=True)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def delete(self, request, slug, project_id, pk=None):
-        label = self.get_queryset().get(pk=pk)
-        label.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class IssueLinkAPIEndpoint(BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to the links of the particular issue.
-
-    """
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    model = IssueLink
-    serializer_class = IssueLinkSerializer
-
-    def get_queryset(self):
-        return (
-            IssueLink.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(issue_id=self.kwargs.get("issue_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id, issue_id, pk=None):
-        if pk is None:
-            issue_links = self.get_queryset()
-            serializer = IssueLinkSerializer(
-                issue_links,
-                fields=self.fields,
-                expand=self.expand,
-            )
-            return self.paginate(
-                request=request,
-                queryset=(self.get_queryset()),
-                on_results=lambda issue_links: IssueLinkSerializer(
-                    issue_links,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-        issue_link = self.get_queryset().get(pk=pk)
-        serializer = IssueLinkSerializer(
-            issue_link,
-            fields=self.fields,
-            expand=self.expand,
-        )
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def post(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.apply_async(
-                args=[],  # If no positional arguments are required
-                kwargs={
-                    '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()),
-                },
-                routing_key='external',
-            )
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def patch(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.apply_async(
-                args=[],  # If no positional arguments are required
-                kwargs={
-                    '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()),
-                },
-                routing_key='external',
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def delete(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.apply_async(
-            args=[],  # If no positional arguments are required
-            kwargs={
-                '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()),
-            },
-            routing_key='external',
-        )
-        issue_link.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to comments of the particular issue.
-
-    """
-
-    serializer_class = IssueCommentSerializer
-    model = IssueComment
-    webhook_event = "issue_comment"
-    permission_classes = [
-        ProjectLitePermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            IssueComment.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(issue_id=self.kwargs.get("issue_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("issue")
-            .select_related("actor")
-            .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,
-                    )
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id, issue_id, pk=None):
-        if pk:
-            issue_comment = self.get_queryset().get(pk=pk)
-            serializer = IssueCommentSerializer(
-                issue_comment,
-                fields=self.fields,
-                expand=self.expand,
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return self.paginate(
-            request=request,
-            queryset=(self.get_queryset()),
-            on_results=lambda issue_comment: IssueCommentSerializer(
-                issue_comment,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(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.apply_async(
-                args=[],
-                kwargs={
-                    "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()),
-                },
-                routing_key="external",
-            )
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def patch(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.apply_async(
-                args=[],
-                kwargs={
-                    "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()),
-                },
-                routing_key="external",
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def delete(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.apply_async(
-            args=[],  # If no positional arguments are required
-            kwargs={
-                "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()),
-            },
-            routing_key="external",
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class IssueActivityAPIEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get(self, request, slug, project_id, issue_id, pk=None):
-        issue_activities = (
-            IssueActivity.objects.filter(
-                issue_id=issue_id, workspace__slug=slug, project_id=project_id
-            )
-            .filter(
-                ~Q(field__in=["comment", "vote", "reaction", "draft"]),
-                project__project_projectmember__member=self.request.user,
-            )
-            .select_related("actor", "workspace", "issue", "project")
-        ).order_by(request.GET.get("order_by", "created_at"))
-
-        if pk:
-            issue_activities = issue_activities.get(pk=pk)
-            serializer = IssueActivitySerializer(issue_activities)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-
-        return self.paginate(
-            request=request,
-            queryset=(issue_activities),
-            on_results=lambda issue_activity: IssueActivitySerializer(
-                issue_activity,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )

apiserver/plane/api/views/module.py

@@ -1,378 +0,0 @@
-# Python imports
-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
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from .base import BaseAPIView, WebhookMixin
-from plane.app.permissions import ProjectEntityPermission
-from plane.db.models import (
-    Project,
-    Module,
-    ModuleLink,
-    Issue,
-    ModuleIssue,
-    IssueAttachment,
-    IssueLink,
-)
-from plane.api.serializers import (
-    ModuleSerializer,
-    ModuleIssueSerializer,
-    IssueSerializer,
-)
-from plane.bgtasks.issue_activites_task import issue_activity
-
-
-class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to module.
-
-    """
-
-    model = Module
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-    serializer_class = ModuleSerializer
-    webhook_event = "module"
-
-    def get_queryset(self):
-        return (
-            Module.objects.filter(project_id=self.kwargs.get("project_id"))
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("lead")
-            .prefetch_related("members")
-            .prefetch_related(
-                Prefetch(
-                    "link_module",
-                    queryset=ModuleLink.objects.select_related("module", "created_by"),
-                )
-            )
-            .annotate(
-                total_issues=Count(
-                    "issue_module",
-                    filter=Q(
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                ),
-            )
-            .annotate(
-                completed_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="completed",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                cancelled_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="cancelled",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                started_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="started",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                unstarted_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="unstarted",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                backlog_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="backlog",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-        )
-
-    def post(self, request, slug, project_id):
-        project = Project.objects.get(workspace__slug=slug, pk=project_id)
-        serializer = ModuleSerializer(data=request.data, context={"project": project})
-        if serializer.is_valid():
-            serializer.save()
-            module = Module.objects.get(pk=serializer.data["id"])
-            serializer = ModuleSerializer(module)
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-    
-    def patch(self, request, slug, project_id, pk):
-        module = Module.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
-        serializer = ModuleSerializer(module, 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 get(self, request, slug, project_id, pk=None):
-        if pk:
-            queryset = self.get_queryset().get(pk=pk)
-            data = ModuleSerializer(
-                queryset,
-                fields=self.fields,
-                expand=self.expand,
-            ).data
-            return Response(
-                data,
-                status=status.HTTP_200_OK,
-            )
-        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 delete(self, request, slug, project_id, pk):
-        module = Module.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
-        module_issues = list(
-            ModuleIssue.objects.filter(module_id=pk).values_list("issue", flat=True)
-        )
-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                'type': "module.activity.deleted",
-                'requested_data': json.dumps({
-                    "module_id": str(pk),
-                    "module_name": str(module.name),
-                    "issues": [str(issue_id) for issue_id in module_issues],
-                }),
-                'actor_id': str(request.user.id),
-                'issue_id': None,
-                'project_id': str(project_id),
-                'current_instance': None,
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
-        )
-        module.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to module issues.
-
-    """
-
-    serializer_class = ModuleIssueSerializer
-    model = ModuleIssue
-    webhook_event = "module_issue"
-    bulk = True
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            ModuleIssue.objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("issue"))
-                .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(module_id=self.kwargs.get("module_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("module")
-            .select_related("issue", "issue__state", "issue__project")
-            .prefetch_related("issue__assignees", "issue__labels")
-            .prefetch_related("module__members")
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id, module_id):
-        order_by = request.GET.get("order_by", "created_at")
-        issues = (
-            Issue.issue_objects.filter(issue_module__module_id=module_id)
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(bridge_id=F("issue_module__id"))
-            .filter(project_id=project_id)
-            .filter(workspace__slug=slug)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("state")
-            .select_related("parent")
-            .prefetch_related("assignees")
-            .prefetch_related("labels")
-            .order_by(order_by)
-            .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")
-            )
-        )
-        return self.paginate(
-            request=request,
-            queryset=(issues),
-            on_results=lambda issues: IssueSerializer(
-                issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id, module_id):
-        issues = request.data.get("issues", [])
-        if not len(issues):
-            return Response(
-                {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        module = Module.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=module_id
-        )
-
-        issues = Issue.objects.filter(
-            workspace__slug=slug, project_id=project_id, pk__in=issues
-        ).values_list("id", flat=True)
-
-        module_issues = list(ModuleIssue.objects.filter(issue_id__in=issues))
-
-        update_module_issue_activity = []
-        records_to_update = []
-        record_to_create = []
-
-        for issue in issues:
-            module_issue = [
-                module_issue
-                for module_issue in module_issues
-                if str(module_issue.issue_id) in issues
-            ]
-
-            if len(module_issue):
-                if module_issue[0].module_id != module_id:
-                    update_module_issue_activity.append(
-                        {
-                            "old_module_id": str(module_issue[0].module_id),
-                            "new_module_id": str(module_id),
-                            "issue_id": str(module_issue[0].issue_id),
-                        }
-                    )
-                    module_issue[0].module_id = module_id
-                    records_to_update.append(module_issue[0])
-            else:
-                record_to_create.append(
-                    ModuleIssue(
-                        module=module,
-                        issue_id=issue,
-                        project_id=project_id,
-                        workspace=module.workspace,
-                        created_by=request.user,
-                        updated_by=request.user,
-                    )
-                )
-
-        ModuleIssue.objects.bulk_create(
-            record_to_create,
-            batch_size=10,
-            ignore_conflicts=True,
-        )
-
-        ModuleIssue.objects.bulk_update(
-            records_to_update,
-            ["module"],
-            batch_size=10,
-        )
-
-        # Capture Issue Activity
-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                'type': "module.activity.created",
-                'requested_data': json.dumps({"modules_list": str(issues)}),
-                'actor_id': str(self.request.user.id),
-                'issue_id': None,
-                'project_id': str(self.kwargs.get("project_id", None)),
-                'current_instance': json.dumps({
-                    "updated_module_issues": update_module_issue_activity,
-                    "created_module_issues": serializers.serialize("json", record_to_create),
-                }),
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
-        )
-
-        return Response(
-            ModuleIssueSerializer(self.get_queryset(), many=True).data,
-            status=status.HTTP_200_OK,
-        )
-
-    def delete(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
-        )
-        module_issue.delete()
-        issue_activity.apply_async(
-            args=[],  # If no positional arguments are required
-            kwargs={
-                'type': "module.activity.deleted",
-                'requested_data': json.dumps({
-                    "module_id": str(module_id),
-                    "issues": [str(module_issue.issue_id)],
-                }),
-                'actor_id': str(request.user.id),
-                'issue_id': str(issue_id),
-                'project_id': str(project_id),
-                'current_instance': None,
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/project.py

@@ -1,288 +0,0 @@
-# Django imports
-from django.db import IntegrityError
-from django.db.models import Exists, OuterRef, Q, F, Func, Subquery, Prefetch
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.serializers import ValidationError
-
-# Module imports
-from plane.db.models import (
-    Workspace,
-    Project,
-    ProjectFavorite,
-    ProjectMember,
-    ProjectDeployBoard,
-    State,
-    Cycle,
-    Module,
-    IssueProperty,
-    Inbox,
-)
-from plane.app.permissions import ProjectBasePermission
-from plane.api.serializers import ProjectSerializer
-from .base import BaseAPIView, WebhookMixin
-
-
-class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
-    """Project Endpoints to create, update, list, retrieve and delete endpoint"""
-
-    serializer_class = ProjectSerializer
-    model = Project
-    webhook_event = "project"
-
-    permission_classes = [
-        ProjectBasePermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            Project.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(Q(project_projectmember__member=self.request.user) | Q(network=2))
-            .select_related(
-                "workspace", "workspace__owner", "default_assignee", "project_lead"
-            )
-            .annotate(
-                is_member=Exists(
-                    ProjectMember.objects.filter(
-                        member=self.request.user,
-                        project_id=OuterRef("pk"),
-                        workspace__slug=self.kwargs.get("slug"),
-                        is_active=True,
-                    )
-                )
-            )
-            .annotate(
-                total_members=ProjectMember.objects.filter(
-                    project_id=OuterRef("id"),
-                    member__is_bot=False,
-                    is_active=True,
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                total_cycles=Cycle.objects.filter(project_id=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                total_modules=Module.objects.filter(project_id=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                member_role=ProjectMember.objects.filter(
-                    project_id=OuterRef("pk"),
-                    member_id=self.request.user.id,
-                    is_active=True,
-                ).values("role")
-            )
-            .annotate(
-                is_deployed=Exists(
-                    ProjectDeployBoard.objects.filter(
-                        project_id=OuterRef("pk"),
-                        workspace__slug=self.kwargs.get("slug"),
-                    )
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id=None):
-        if project_id is None:
-            sort_order_query = ProjectMember.objects.filter(
-                member=request.user,
-                project_id=OuterRef("pk"),
-                workspace__slug=self.kwargs.get("slug"),
-                is_active=True,
-            ).values("sort_order")
-            projects = (
-                self.get_queryset()
-                .annotate(sort_order=Subquery(sort_order_query))
-                .prefetch_related(
-                    Prefetch(
-                        "project_projectmember",
-                        queryset=ProjectMember.objects.filter(
-                            workspace__slug=slug,
-                            is_active=True,
-                        ).select_related("member"),
-                    )
-                )
-                .order_by(request.GET.get("order_by", "sort_order"))
-            )
-            return self.paginate(
-                request=request,
-                queryset=(projects),
-                on_results=lambda projects: ProjectSerializer(
-                    projects, many=True, fields=self.fields, expand=self.expand,
-                ).data,
-            )
-        project = self.get_queryset().get(workspace__slug=slug, pk=project_id)
-        serializer = ProjectSerializer(project, fields=self.fields, expand=self.expand,)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def post(self, request, slug):
-        try:
-            workspace = Workspace.objects.get(slug=slug)
-            serializer = ProjectSerializer(
-                data={**request.data}, context={"workspace_id": workspace.id}
-            )
-            if serializer.is_valid():
-                serializer.save()
-
-                # Add the user as Administrator to the project
-                project_member = ProjectMember.objects.create(
-                    project_id=serializer.data["id"], member=request.user, role=20
-                )
-                # Also create the issue property for the user
-                _ = IssueProperty.objects.create(
-                    project_id=serializer.data["id"],
-                    user=request.user,
-                )
-
-                if serializer.data["project_lead"] is not None and str(
-                    serializer.data["project_lead"]
-                ) != str(request.user.id):
-                    ProjectMember.objects.create(
-                        project_id=serializer.data["id"],
-                        member_id=serializer.data["project_lead"],
-                        role=20,
-                    )
-                    # Also create the issue property for the user
-                    IssueProperty.objects.create(
-                        project_id=serializer.data["id"],
-                        user_id=serializer.data["project_lead"],
-                    )
-
-                # Default states
-                states = [
-                    {
-                        "name": "Backlog",
-                        "color": "#A3A3A3",
-                        "sequence": 15000,
-                        "group": "backlog",
-                        "default": True,
-                    },
-                    {
-                        "name": "Todo",
-                        "color": "#3A3A3A",
-                        "sequence": 25000,
-                        "group": "unstarted",
-                    },
-                    {
-                        "name": "In Progress",
-                        "color": "#F59E0B",
-                        "sequence": 35000,
-                        "group": "started",
-                    },
-                    {
-                        "name": "Done",
-                        "color": "#16A34A",
-                        "sequence": 45000,
-                        "group": "completed",
-                    },
-                    {
-                        "name": "Cancelled",
-                        "color": "#EF4444",
-                        "sequence": 55000,
-                        "group": "cancelled",
-                    },
-                ]
-
-                State.objects.bulk_create(
-                    [
-                        State(
-                            name=state["name"],
-                            color=state["color"],
-                            project=serializer.instance,
-                            sequence=state["sequence"],
-                            workspace=serializer.instance.workspace,
-                            group=state["group"],
-                            default=state.get("default", False),
-                            created_by=request.user,
-                        )
-                        for state in states
-                    ]
-                )
-
-                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
-                serializer = ProjectSerializer(project)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(
-                serializer.errors,
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"name": "The project name is already taken"},
-                    status=status.HTTP_410_GONE,
-                )
-        except Workspace.DoesNotExist as e:
-            return Response(
-                {"error": "Workspace does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except ValidationError as e:
-            return Response(
-                {"identifier": "The project identifier is already taken"},
-                status=status.HTTP_410_GONE,
-            )
-
-    def patch(self, request, slug, project_id=None):
-        try:
-            workspace = Workspace.objects.get(slug=slug)
-            project = Project.objects.get(pk=project_id)
-
-            serializer = ProjectSerializer(
-                project,
-                data={**request.data},
-                context={"workspace_id": workspace.id},
-                partial=True,
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                if serializer.data["inbox_view"]:
-                    Inbox.objects.get_or_create(
-                        name=f"{project.name} Inbox", project=project, is_default=True
-                    )
-
-                    # Create the triage state in Backlog group
-                    State.objects.get_or_create(
-                        name="Triage",
-                        group="backlog",
-                        description="Default state for managing all Inbox Issues",
-                        project_id=project_id,
-                        color="#ff7700",
-                    )
-
-                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
-                serializer = ProjectSerializer(project)
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"name": "The project name is already taken"},
-                    status=status.HTTP_410_GONE,
-                )
-        except (Project.DoesNotExist, Workspace.DoesNotExist):
-            return Response(
-                {"error": "Project does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except ValidationError as e:
-            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)
-        project.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/state.py

@@ -1,87 +0,0 @@
-# Python imports
-from itertools import groupby
-
-# Django imports
-from django.db.models import Q
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-
-# Module imports
-from .base import BaseAPIView
-from plane.api.serializers import StateSerializer
-from plane.app.permissions import ProjectEntityPermission
-from plane.db.models import State, Issue
-
-
-class StateAPIEndpoint(BaseAPIView):
-    serializer_class = StateSerializer
-    model = State
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            State.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .filter(~Q(name="Triage"))
-            .select_related("project")
-            .select_related("workspace")
-            .distinct()
-        )
-
-    def post(self, request, slug, project_id):
-        serializer = StateSerializer(data=request.data, context={"project_id": project_id})
-        if serializer.is_valid():
-            serializer.save(project_id=project_id)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def get(self, request, slug, project_id, state_id=None):
-        if state_id:
-            serializer = StateSerializer(self.get_queryset().get(pk=state_id))
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return self.paginate(
-            request=request,
-            queryset=(self.get_queryset()),
-            on_results=lambda states: StateSerializer(
-                states,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def delete(self, request, slug, project_id, state_id):
-        state = State.objects.get(
-            ~Q(name="Triage"),
-            pk=state_id,
-            project_id=project_id,
-            workspace__slug=slug,
-        )
-
-        if state.default:
-            return Response({"error": "Default state cannot be deleted"}, status=status.HTTP_400_BAD_REQUEST)
-
-        # Check for any issues in the state
-        issue_exist = Issue.issue_objects.filter(state=state_id).exists()
-
-        if issue_exist:
-            return Response(
-                {"error": "The state is not empty, only empty states can be deleted"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        state.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    def patch(self, request, slug, project_id, state_id=None):
-        state = State.objects.get(workspace__slug=slug, project_id=project_id, pk=state_id)
-        serializer = StateSerializer(state, data=request.data, partial=True)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/app/apps.py

@@ -1,5 +1,5 @@
 from django.apps import AppConfig
 
 
-class AppApiConfig(AppConfig):
+class AppConfig(AppConfig):
     name = "plane.app"

apiserver/plane/app/permissions/workspace.py

@@ -99,6 +99,7 @@ class WorkspaceViewerPermission(BasePermission):
         return WorkspaceMember.objects.filter(
             member=request.user,
             workspace__slug=view.workspace_slug,
+            role__gte=10,
             is_active=True,
         ).exists()
 

apiserver/plane/app/serializers/issue.py

@@ -225,7 +225,6 @@ class IssueActivitySerializer(BaseSerializer):
     actor_detail = UserLiteSerializer(read_only=True, source="actor")
     issue_detail = IssueFlatSerializer(read_only=True, source="issue")
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
 
     class Meta:
         model = IssueActivity

apiserver/plane/app/serializers/project.py

@@ -103,19 +103,16 @@ class ProjectListSerializer(DynamicBaseSerializer):
     members = serializers.SerializerMethodField()
 
     def get_members(self, obj):
-        project_members = getattr(obj, "members_list", None)
-        if project_members is not None:
-            # Filter members by the project ID
-            return [
-                {
-                    "id": member.id,
-                    "member_id": member.member_id,
-                    "member__display_name": member.member.display_name,
-                    "member__avatar": member.member.avatar,
-                }
-                for member in project_members
-            ]
-        return []
+        project_members = ProjectMember.objects.filter(
+            project_id=obj.id,
+            is_active=True,
+        ).values(
+            "id",
+            "member_id",
+            "member__display_name",
+            "member__avatar",
+        )
+        return list(project_members)
 
     class Meta:
         model = Project
@@ -217,4 +214,4 @@ class ProjectPublicMemberSerializer(BaseSerializer):
             "workspace",
             "project",
             "member",
-        ]
+        ]

apiserver/plane/app/serializers/state.py

@@ -25,4 +25,4 @@ class StateLiteSerializer(BaseSerializer):
             "color",
             "group",
         ]
-        read_only_fields = fields
+        read_only_fields = fields

apiserver/plane/app/serializers/user.py

@@ -26,8 +26,6 @@ class UserSerializer(BaseSerializer):
             "token_updated_at",
             "is_onboarded",
             "is_bot",
-            "is_password_autoset",
-            "is_email_verified",
         ]
         extra_kwargs = {"password": {"write_only": True}}
 
@@ -61,9 +59,6 @@ class UserMeSerializer(BaseSerializer):
             "username",
             "theme",
             "last_workspace_id",
-            "use_case",
-            "is_password_autoset",
-            "is_email_verified",
         ]
         read_only_fields = fields
 
@@ -84,18 +79,9 @@ class UserMeSettingsSerializer(BaseSerializer):
         workspace_invites = WorkspaceMemberInvite.objects.filter(
             email=obj.email
         ).count()
-        if (
-            obj.last_workspace_id is not None
-            and Workspace.objects.filter(
-                pk=obj.last_workspace_id,
-                workspace_member__member=obj.id,
-                workspace_member__is_active=True,
-            ).exists()
-        ):
+        if obj.last_workspace_id is not None:
             workspace = Workspace.objects.filter(
-                pk=obj.last_workspace_id,
-                workspace_member__member=obj.id,
-                workspace_member__is_active=True,
+                pk=obj.last_workspace_id, workspace_member__member=obj.id
             ).first()
             return {
                 "last_workspace_id": obj.last_workspace_id,
@@ -108,9 +94,7 @@ class UserMeSettingsSerializer(BaseSerializer):
             }
         else:
             fallback_workspace = (
-                Workspace.objects.filter(
-                    workspace_member__member_id=obj.id, workspace_member__is_active=True
-                )
+                Workspace.objects.filter(workspace_member__member_id=obj.id)
                 .order_by("created_at")
                 .first()
             )
@@ -169,25 +153,14 @@ class ChangePasswordSerializer(serializers.Serializer):
     Serializer for password change endpoint.
     """
     old_password = serializers.CharField(required=True)
-    new_password = serializers.CharField(required=True, min_length=8)
-    confirm_password = serializers.CharField(required=True, min_length=8)
-
-    def validate(self, data):
-        if data.get("old_password") == data.get("new_password"):
-            raise serializers.ValidationError(
-                {"error": "New password cannot be same as old password."}
-            )
-
-        if data.get("new_password") != data.get("confirm_password"):
-            raise serializers.ValidationError(
-                {"error": "Confirm password should be same as the new password."}
-            )
-
-        return data
+    new_password = serializers.CharField(required=True)
 
 
 class ResetPasswordSerializer(serializers.Serializer):
+    model = User
+
     """
     Serializer for password change endpoint.
     """
-    new_password = serializers.CharField(required=True, min_length=8)
+    new_password = serializers.CharField(required=True)
+    confirm_password = serializers.CharField(required=True)

apiserver/plane/app/serializers/webhook.py

@@ -1,9 +1,3 @@
-# Python imports
-import urllib
-import socket
-import ipaddress
-from urllib.parse import urlparse
-
 # Third party imports
 from rest_framework import serializers
 
@@ -14,76 +8,6 @@ from plane.db.models.webhook import validate_domain, validate_schema
 
 class WebhookSerializer(DynamicBaseSerializer):
     url = serializers.URLField(validators=[validate_schema, validate_domain])
-    
-    def create(self, validated_data):
-        url = validated_data.get("url", None)
-
-        # Extract the hostname from the URL
-        hostname = urlparse(url).hostname
-        if not hostname:
-            raise serializers.ValidationError({"url": "Invalid URL: No hostname found."})
-
-        # Resolve the hostname to IP addresses
-        try:
-            ip_addresses = socket.getaddrinfo(hostname, None)
-        except socket.gaierror:
-            raise serializers.ValidationError({"url": "Hostname could not be resolved."})
-
-        if not ip_addresses:
-            raise serializers.ValidationError({"url": "No IP addresses found for the hostname."})
-
-        for addr in ip_addresses:
-            ip = ipaddress.ip_address(addr[4][0])
-            if ip.is_private or ip.is_loopback:
-                raise serializers.ValidationError({"url": "URL resolves to a blocked IP address."})
-
-        # Additional validation for multiple request domains and their subdomains
-        request = self.context.get('request')
-        disallowed_domains = ['plane.so',]  # Add your disallowed domains here
-        if request:
-            request_host = request.get_host().split(':')[0]  # Remove port if present
-            disallowed_domains.append(request_host)
-
-        # Check if hostname is a subdomain or exact match of any disallowed domain
-        if any(hostname == domain or hostname.endswith('.' + domain) for domain in disallowed_domains):
-            raise serializers.ValidationError({"url": "URL domain or its subdomain is not allowed."})
-
-        return Webhook.objects.create(**validated_data)
-    
-    def update(self, instance, validated_data):
-        url = validated_data.get("url", None)
-        if url:
-            # Extract the hostname from the URL
-            hostname = urlparse(url).hostname
-            if not hostname:
-                raise serializers.ValidationError({"url": "Invalid URL: No hostname found."})
-
-            # Resolve the hostname to IP addresses
-            try:
-                ip_addresses = socket.getaddrinfo(hostname, None)
-            except socket.gaierror:
-                raise serializers.ValidationError({"url": "Hostname could not be resolved."})
-
-            if not ip_addresses:
-                raise serializers.ValidationError({"url": "No IP addresses found for the hostname."})
-
-            for addr in ip_addresses:
-                ip = ipaddress.ip_address(addr[4][0])
-                if ip.is_private or ip.is_loopback:
-                    raise serializers.ValidationError({"url": "URL resolves to a blocked IP address."})
-
-            # Additional validation for multiple request domains and their subdomains
-            request = self.context.get('request')
-            disallowed_domains = ['plane.so',]  # Add your disallowed domains here
-            if request:
-                request_host = request.get_host().split(':')[0]  # Remove port if present
-                disallowed_domains.append(request_host)
-
-            # Check if hostname is a subdomain or exact match of any disallowed domain
-            if any(hostname == domain or hostname.endswith('.' + domain) for domain in disallowed_domains):
-                raise serializers.ValidationError({"url": "URL domain or its subdomain is not allowed."})
-
-        return super().update(instance, validated_data)
 
     class Meta:
         model = Webhook

apiserver/plane/app/serializers/workspace.py

@@ -21,23 +21,6 @@ class WorkSpaceSerializer(BaseSerializer):
     total_members = serializers.IntegerField(read_only=True)
     total_issues = serializers.IntegerField(read_only=True)
 
-    def validated(self, data):
-        if data.get("slug") in [
-            "404",
-            "accounts",
-            "api",
-            "create-workspace",
-            "god-mode",
-            "installations",
-            "invitations",
-            "onboarding",
-            "profile",
-            "spaces",
-            "workspace-invitations",
-            "password",
-        ]:
-            raise serializers.ValidationError({"slug": "Slug is not valid"})
-
     class Meta:
         model = Workspace
         fields = "__all__"
@@ -95,16 +78,6 @@ class WorkSpaceMemberInviteSerializer(BaseSerializer):
     class Meta:
         model = WorkspaceMemberInvite
         fields = "__all__"
-        read_only_fields = [
-            "id",
-            "email",
-            "token",
-            "workspace",
-            "message",
-            "responded_at",
-            "created_at",
-            "updated_at",
-        ]
 
 
 class TeamSerializer(BaseSerializer):

apiserver/plane/app/urls/__init__.py

@@ -45,4 +45,4 @@ urlpatterns = [
     *workspace_urls,
     *api_urls,
     *webhook_urls,
-]
+]

apiserver/plane/app/urls/asset.py

@@ -4,7 +4,6 @@ from django.urls import path
 from plane.app.views import (
     FileAssetEndpoint,
     UserAssetsEndpoint,
-    FileAssetViewSet,
 )
 
 
@@ -29,13 +28,4 @@ urlpatterns = [
         UserAssetsEndpoint.as_view(),
         name="user-file-assets",
     ),
-    path(
-        "workspaces/file-assets/<uuid:workspace_id>/<str:asset_key>/restore/",
-        FileAssetViewSet.as_view(
-            {
-                "post": "restore",
-            }
-        ),
-        name="file-assets-restore",
-    ),
 ]

apiserver/plane/app/urls/authentication.py

@@ -5,16 +5,18 @@ from rest_framework_simplejwt.views import TokenRefreshView
 
 from plane.app.views import (
     # Authentication
+    SignUpEndpoint,
     SignInEndpoint,
     SignOutEndpoint,
-    MagicGenerateEndpoint,
     MagicSignInEndpoint,
+    MagicSignInGenerateEndpoint,
     OauthEndpoint,
-    EmailCheckEndpoint,
     ## End Authentication
     # Auth Extended
     ForgotPasswordEndpoint,
+    VerifyEmailEndpoint,
     ResetPasswordEndpoint,
+    RequestEmailVerificationEndpoint,
     ChangePasswordEndpoint,
     ## End Auth Extender
     # API Tokens
@@ -25,15 +27,24 @@ from plane.app.views import (
 
 urlpatterns = [
     #  Social Auth
-    path("email-check/", EmailCheckEndpoint.as_view(), name="email"),
     path("social-auth/", OauthEndpoint.as_view(), name="oauth"),
     # Auth
+    path("sign-up/", SignUpEndpoint.as_view(), name="sign-up"),
     path("sign-in/", SignInEndpoint.as_view(), name="sign-in"),
     path("sign-out/", SignOutEndpoint.as_view(), name="sign-out"),
-    # magic sign in
-    path("magic-generate/", MagicGenerateEndpoint.as_view(), name="magic-generate"),
+    # Magic Sign In/Up
+    path(
+        "magic-generate/", MagicSignInGenerateEndpoint.as_view(), name="magic-generate"
+    ),
     path("magic-sign-in/", MagicSignInEndpoint.as_view(), name="magic-sign-in"),
     path("token/refresh/", TokenRefreshView.as_view(), name="token_refresh"),
+    # Email verification
+    path("email-verify/", VerifyEmailEndpoint.as_view(), name="email-verify"),
+    path(
+        "request-email-verify/",
+        RequestEmailVerificationEndpoint.as_view(),
+        name="request-reset-email",
+    ),
     # Password Manipulation
     path(
         "users/me/change-password/",

apiserver/plane/app/urls/cycle.py

@@ -7,6 +7,7 @@ from plane.app.views import (
     CycleDateCheckEndpoint,
     CycleFavoriteViewSet,
     TransferCycleIssueEndpoint,
+    CycleIssueGroupedEndpoint,
 )
 
 
@@ -43,6 +44,11 @@ urlpatterns = [
         ),
         name="project-issue-cycle",
     ),
+    path(
+        "v3/workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/",
+        CycleIssueGroupedEndpoint.as_view(),
+        name="project-issue-cycle",
+    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:pk>/",
         CycleIssueViewSet.as_view(

apiserver/plane/app/urls/issue.py

@@ -3,6 +3,8 @@ from django.urls import path
 
 from plane.app.views import (
     IssueViewSet,
+    IssueListEndpoint,
+    IssueListGroupedEndpoint,
     LabelViewSet,
     BulkCreateIssueLabelsEndpoint,
     BulkDeleteIssuesEndpoint,
@@ -35,6 +37,16 @@ urlpatterns = [
         ),
         name="project-issue",
     ),
+    path(
+        "v2/workspaces/<str:slug>/projects/<uuid:project_id>/issues/",
+        IssueListEndpoint.as_view(),
+        name="project-issue",
+    ),
+    path(
+        "v3/workspaces/<str:slug>/projects/<uuid:project_id>/issues/",
+        IssueListGroupedEndpoint.as_view(),
+        name="project-issue",
+    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/",
         IssueViewSet.as_view(

apiserver/plane/app/urls/module.py

@@ -7,6 +7,7 @@ from plane.app.views import (
     ModuleLinkViewSet,
     ModuleFavoriteViewSet,
     BulkImportModulesEndpoint,
+    ModuleIssueGroupedEndpoint,
 )
 
 
@@ -43,6 +44,11 @@ urlpatterns = [
         ),
         name="project-module-issues",
     ),
+    path(
+        "v3/workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/",
+        ModuleIssueGroupedEndpoint.as_view(),
+        name="project-issue-cycle",
+    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/<uuid:pk>/",
         ModuleIssueViewSet.as_view(

apiserver/plane/app/urls/project.py

@@ -13,7 +13,6 @@ from plane.app.views import (
     UserProjectInvitationsViewset,
     ProjectPublicCoverImagesEndpoint,
     ProjectDeployBoardViewSet,
-    UserProjectRolesEndpoint,
 )
 
 
@@ -66,7 +65,7 @@ urlpatterns = [
         name="project-member-invite",
     ),
     path(
-        "users/me/workspaces/<str:slug>/projects/invitations/",
+        "users/me/invitations/projects/",
         UserProjectInvitationsViewset.as_view(
             {
                 "get": "list",
@@ -76,12 +75,7 @@ urlpatterns = [
         name="user-project-invitations",
     ),
     path(
-        "users/me/workspaces/<str:slug>/project-roles/",
-        UserProjectRolesEndpoint.as_view(),
-        name="user-project-roles",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/join/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/join/",
         ProjectJoinEndpoint.as_view(),
         name="project-join",
     ),
@@ -175,4 +169,4 @@ urlpatterns = [
         ),
         name="project-deploy-board",
     ),
-]
+]

apiserver/plane/app/urls/user.py

@@ -7,7 +7,6 @@ from plane.app.views import (
     UpdateUserTourCompletedEndpoint,
     UserActivityEndpoint,
     ChangePasswordEndpoint,
-    SetUserPasswordEndpoint,
     ## End User
     ## Workspaces
     UserWorkSpacesEndpoint,
@@ -64,7 +63,7 @@ urlpatterns = [
         name="user-tour",
     ),
     path(
-        "users/me/activities/",
+        "users/workspaces/<str:slug>/activities/",
         UserActivityEndpoint.as_view(),
         name="user-activities",
     ),
@@ -90,10 +89,5 @@ urlpatterns = [
         UserWorkspaceDashboardEndpoint.as_view(),
         name="user-workspace-dashboard",
     ),
-    path(
-        "users/me/set-password/",
-        SetUserPasswordEndpoint.as_view(),
-        name="set-password",
-    ),
     ## End User Graph
 ]

apiserver/plane/app/urls/views.py

@@ -5,7 +5,7 @@ from plane.app.views import (
     IssueViewViewSet,
     GlobalViewViewSet,
     GlobalViewIssuesViewSet,
-    IssueViewFavoriteViewSet,   
+    IssueViewFavoriteViewSet,
 )
 
 

apiserver/plane/app/urls/workspace.py

@@ -65,7 +65,6 @@ urlpatterns = [
             {
                 "delete": "destroy",
                 "get": "retrieve",
-                "patch": "partial_update",
             }
         ),
         name="workspace-invitations",

apiserver/plane/app/views/__init__.py

@@ -11,7 +11,6 @@ from .project import (
     ProjectFavoritesViewSet,
     ProjectPublicCoverImagesEndpoint,
     ProjectDeployBoardViewSet,
-    UserProjectRolesEndpoint,
 )
 from .user import (
     UserEndpoint,
@@ -59,10 +58,13 @@ from .cycle import (
     CycleDateCheckEndpoint,
     CycleFavoriteViewSet,
     TransferCycleIssueEndpoint,
+    CycleIssueGroupedEndpoint,
 )
-from .asset import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
+from .asset import FileAssetEndpoint, UserAssetsEndpoint
 from .issue import (
     IssueViewSet,
+    IssueListEndpoint,
+    IssueListGroupedEndpoint,
     WorkSpaceIssuesEndpoint,
     IssueActivityEndpoint,
     IssueCommentViewSet,
@@ -83,19 +85,20 @@ from .issue import (
 )
 
 from .auth_extended import (
+    VerifyEmailEndpoint,
+    RequestEmailVerificationEndpoint,
     ForgotPasswordEndpoint,
     ResetPasswordEndpoint,
     ChangePasswordEndpoint,
-    SetUserPasswordEndpoint,
-    EmailCheckEndpoint,
-    MagicGenerateEndpoint,
 )
 
 
 from .authentication import (
+    SignUpEndpoint,
     SignInEndpoint,
     SignOutEndpoint,
     MagicSignInEndpoint,
+    MagicSignInGenerateEndpoint,
 )
 
 from .module import (
@@ -103,6 +106,7 @@ from .module import (
     ModuleIssueViewSet,
     ModuleLinkViewSet,
     ModuleFavoriteViewSet,
+    ModuleIssueGroupedEndpoint,
 )
 
 from .api import ApiTokenEndpoint
@@ -131,6 +135,7 @@ from .page import (
     PageFavoriteViewSet,
     PageLogEndpoint,
     SubPagesEndpoint,
+    CreateIssueFromBlockEndpoint,
 )
 
 from .search import GlobalSearchEndpoint, IssueSearchEndpoint
@@ -163,8 +168,4 @@ from .exporter import ExportIssuesEndpoint
 
 from .config import ConfigurationEndpoint
 
-from .webhook import (
-    WebhookEndpoint,
-    WebhookLogsEndpoint,
-    WebhookSecretRegenerateEndpoint,
-)
+from .webhook import WebhookEndpoint, WebhookLogsEndpoint, WebhookSecretRegenerateEndpoint

apiserver/plane/app/views/asset.py

@@ -1,16 +1,16 @@
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
-from rest_framework.parsers import MultiPartParser, FormParser, JSONParser
+from rest_framework.parsers import MultiPartParser, FormParser
 
 # Module imports
-from .base import BaseAPIView, BaseViewSet
+from .base import BaseAPIView
 from plane.db.models import FileAsset, Workspace
 from plane.app.serializers import FileAssetSerializer
 
 
 class FileAssetEndpoint(BaseAPIView):
-    parser_classes = (MultiPartParser, FormParser, JSONParser,)
+    parser_classes = (MultiPartParser, FormParser)
 
     """
     A viewset for viewing and editing task instances.
@@ -25,6 +25,7 @@ class FileAssetEndpoint(BaseAPIView):
         else:
             return Response({"error": "Asset key does not exist", "status": False}, status=status.HTTP_200_OK)
 
+
     def post(self, request, slug):
         serializer = FileAssetSerializer(data=request.data)
         if serializer.is_valid():
@@ -33,22 +34,15 @@ class FileAssetEndpoint(BaseAPIView):
             serializer.save(workspace_id=workspace.id)
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-    
+
+
     def delete(self, request, workspace_id, asset_key):
         asset_key = str(workspace_id) + "/" + asset_key
         file_asset = FileAsset.objects.get(asset=asset_key)
-        file_asset.is_deleted = True
-        file_asset.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class FileAssetViewSet(BaseViewSet):
-
-    def restore(self, request, workspace_id, asset_key):
-        asset_key = str(workspace_id) + "/" + asset_key
-        file_asset = FileAsset.objects.get(asset=asset_key)
-        file_asset.is_deleted = False
-        file_asset.save()
+        # Delete the file from storage
+        file_asset.asset.delete(save=False)
+        # Delete the file object
+        file_asset.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
@@ -56,23 +50,25 @@ class UserAssetsEndpoint(BaseAPIView):
     parser_classes = (MultiPartParser, FormParser)
 
     def get(self, request, asset_key):
-        files = FileAsset.objects.filter(asset=asset_key, created_by=request.user)
-        if files.exists():
-            serializer = FileAssetSerializer(files, context={"request": request})
-            return Response({"data": serializer.data, "status": True}, status=status.HTTP_200_OK)
-        else:
-            return Response({"error": "Asset key does not exist", "status": False}, status=status.HTTP_200_OK)
+            files = FileAsset.objects.filter(asset=asset_key, created_by=request.user)
+            if files.exists():
+                serializer = FileAssetSerializer(files, context={"request": request})
+                return Response({"data": serializer.data, "status": True}, status=status.HTTP_200_OK)
+            else:
+                return Response({"error": "Asset key does not exist", "status": False}, status=status.HTTP_200_OK)
 
     def post(self, request):
-        serializer = FileAssetSerializer(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)
+            serializer = FileAssetSerializer(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 delete(self, request, asset_key):
-        file_asset = FileAsset.objects.get(asset=asset_key, created_by=request.user)
-        file_asset.is_deleted = True
-        file_asset.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
+            file_asset = FileAsset.objects.get(asset=asset_key, created_by=request.user)
+            # Delete the file from storage
+            file_asset.asset.delete(save=False)
+            # Delete the file object
+            file_asset.delete()
+            return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/app/views/auth_extended.py

@@ -1,9 +1,5 @@
 ## Python imports
-import uuid
-import os
-import json
-import random
-import string
+import jwt
 
 ## Django imports
 from django.contrib.auth.tokens import PasswordResetTokenGenerator
@@ -12,117 +8,80 @@ from django.utils.encoding import (
     smart_bytes,
     DjangoUnicodeDecodeError,
 )
-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
 from rest_framework.response import Response
-from rest_framework.permissions import AllowAny
+from rest_framework import permissions
 from rest_framework_simplejwt.tokens import RefreshToken
 
+from sentry_sdk import capture_exception
+
 ## Module imports
 from . import BaseAPIView
 from plane.app.serializers import (
     ChangePasswordSerializer,
     ResetPasswordSerializer,
-    UserSerializer,
 )
-from plane.db.models import User, WorkspaceMemberInvite
-from plane.license.utils.instance_value import get_configuration_value
+from plane.db.models import User
+from plane.bgtasks.email_verification_task import email_verification
 from plane.bgtasks.forgot_password_task import forgot_password
-from plane.license.models import Instance
-from plane.settings.redis import redis_instance
-from plane.bgtasks.magic_link_code_task import magic_link
-from plane.bgtasks.event_tracking_task import auth_events
 
 
-def get_tokens_for_user(user):
-    refresh = RefreshToken.for_user(user)
-    return (
-        str(refresh.access_token),
-        str(refresh),
-    )
+class RequestEmailVerificationEndpoint(BaseAPIView):
+    def get(self, request):
+        token = RefreshToken.for_user(request.user).access_token
+        current_site = request.META.get('HTTP_ORIGIN')
+        email_verification.delay(
+            request.user.first_name, request.user.email, token, current_site
+        )
+        return Response(
+            {"message": "Email sent successfully"}, status=status.HTTP_200_OK
+        )
 
 
-def generate_magic_token(email):
-    key = "magic_" + str(email)
+class VerifyEmailEndpoint(BaseAPIView):
+    def get(self, request):
+        token = request.GET.get("token")
+        try:
+            payload = jwt.decode(token, settings.SECRET_KEY, algorithms="HS256")
+            user = User.objects.get(id=payload["user_id"])
 
-    ## Generate a random token
-    token = (
-        "".join(random.choices(string.ascii_lowercase, k=4))
-        + "-"
-        + "".join(random.choices(string.ascii_lowercase, k=4))
-        + "-"
-        + "".join(random.choices(string.ascii_lowercase, k=4))
-    )
-
-    # Initialize the redis instance
-    ri = redis_instance()
-
-    # Check if the key already exists in python
-    if ri.exists(key):
-        data = json.loads(ri.get(key))
-
-        current_attempt = data["current_attempt"] + 1
-
-        if data["current_attempt"] > 2:
-            return key, token, False
-
-        value = {
-            "current_attempt": current_attempt,
-            "email": email,
-            "token": token,
-        }
-        expiry = 600
-
-        ri.set(key, json.dumps(value), ex=expiry)
-
-    else:
-        value = {"current_attempt": 0, "email": email, "token": token}
-        expiry = 600
-
-        ri.set(key, json.dumps(value), ex=expiry)
-
-    return key, token, True
-
-
-def generate_password_token(user):
-    uidb64 = urlsafe_base64_encode(smart_bytes(user.id))
-    token = PasswordResetTokenGenerator().make_token(user)
-
-    return uidb64, token
+            if not user.is_email_verified:
+                user.is_email_verified = True
+                user.save()
+            return Response(
+                {"email": "Successfully activated"}, status=status.HTTP_200_OK
+            )
+        except jwt.ExpiredSignatureError as _indentifier:
+            return Response(
+                {"email": "Activation expired"}, status=status.HTTP_400_BAD_REQUEST
+            )
+        except jwt.exceptions.DecodeError as _indentifier:
+            return Response(
+                {"email": "Invalid token"}, status=status.HTTP_400_BAD_REQUEST
+            )
 
 
 class ForgotPasswordEndpoint(BaseAPIView):
-    permission_classes = [
-        AllowAny,
-    ]
+    permission_classes = [permissions.AllowAny]
 
     def post(self, request):
         email = request.data.get("email")
 
-        try:
-            validate_email(email)
-        except ValidationError:
-            return Response(
-                {"error": "Please enter a valid email"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        if User.objects.filter(email=email).exists():
+            user = User.objects.get(email=email)
+            uidb64 = urlsafe_base64_encode(smart_bytes(user.id))
+            token = PasswordResetTokenGenerator().make_token(user)
+
+            current_site = request.META.get('HTTP_ORIGIN')
 
-        # Get the user
-        user = User.objects.filter(email=email).first()
-        if user:
-            # Get the reset token for user
-            uidb64, token = generate_password_token(user=user)
-            current_site = request.META.get("HTTP_ORIGIN")
-            # send the forgot password email
             forgot_password.delay(
                 user.first_name, user.email, uidb64, token, current_site
             )
+
             return Response(
                 {"message": "Check your email to reset your password"},
                 status=status.HTTP_200_OK,
@@ -133,40 +92,30 @@ class ForgotPasswordEndpoint(BaseAPIView):
 
 
 class ResetPasswordEndpoint(BaseAPIView):
-    permission_classes = [
-        AllowAny,
-    ]
+    permission_classes = [permissions.AllowAny]
 
     def post(self, request, uidb64, token):
         try:
-            # Decode the id from the uidb64
             id = smart_str(urlsafe_base64_decode(uidb64))
             user = User.objects.get(id=id)
-
-            # check if the token is valid for the user
             if not PasswordResetTokenGenerator().check_token(user, token):
                 return Response(
-                    {"error": "Token is invalid"},
+                    {"error": "token is not valid, please check the new one"},
                     status=status.HTTP_401_UNAUTHORIZED,
                 )
-
-            # Reset the password
             serializer = ResetPasswordSerializer(data=request.data)
+
             if serializer.is_valid():
                 # set_password also hashes the password that the user will get
                 user.set_password(serializer.data.get("new_password"))
-                user.is_password_autoset = False
                 user.save()
-
-                # Log the user in
-                # Generate access token for the user
-                access_token, refresh_token = get_tokens_for_user(user)
-                data = {
-                    "access_token": access_token,
-                    "refresh_token": refresh_token,
+                response = {
+                    "status": "success",
+                    "code": status.HTTP_200_OK,
+                    "message": "Password updated successfully",
                 }
 
-                return Response(data, status=status.HTTP_200_OK)
+                return Response(response)
             return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
         except DjangoUnicodeDecodeError as indentifier:
@@ -179,289 +128,24 @@ class ResetPasswordEndpoint(BaseAPIView):
 class ChangePasswordEndpoint(BaseAPIView):
     def post(self, request):
         serializer = ChangePasswordSerializer(data=request.data)
+
         user = User.objects.get(pk=request.user.id)
         if serializer.is_valid():
-            if not user.check_password(serializer.data.get("old_password")):
+            # Check old password
+            if not user.object.check_password(serializer.data.get("old_password")):
                 return Response(
-                    {"error": "Old password is not correct"},
+                    {"old_password": ["Wrong password."]},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
             # set_password also hashes the password that the user will get
-            user.set_password(serializer.data.get("new_password"))
-            user.is_password_autoset = False
-            user.save()
-            return Response(
-                {"message": "Password updated successfully"}, status=status.HTTP_200_OK
-            )
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-
-class SetUserPasswordEndpoint(BaseAPIView):
-    def post(self, request):
-        user = User.objects.get(pk=request.user.id)
-        password = request.data.get("password", False)
-
-        # If the user password is not autoset then return error
-        if not user.is_password_autoset:
-            return Response(
-                {
-                    "error": "Your password is already set please change your password from profile"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Check password validation
-        if not password and len(str(password)) < 8:
-            return Response(
-                {"error": "Password is not valid"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        # Set the user password
-        user.set_password(password)
-        user.is_password_autoset = False
-        user.save()
-        serializer = UserSerializer(user)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-
-class MagicGenerateEndpoint(BaseAPIView):
-    permission_classes = [
-        AllowAny,
-    ]
-
-    def post(self, request):
-        email = request.data.get("email", False)
-
-        # Check the instance registration
-        instance = Instance.objects.first()
-        if instance is None or not instance.is_setup_done:
-            return Response(
-                {"error": "Instance is not configured"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if not email:
-            return Response(
-                {"error": "Please provide a valid email address"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Clean up the email
-        email = email.strip().lower()
-        validate_email(email)
-
-        # check if the email exists not
-        if not User.objects.filter(email=email).exists():
-            # Create a user
-            _ = User.objects.create(
-                email=email,
-                username=uuid.uuid4().hex,
-                password=make_password(uuid.uuid4().hex),
-                is_password_autoset=True,
-            )
-
-        ## Generate a random token
-        token = (
-            "".join(random.choices(string.ascii_lowercase, k=4))
-            + "-"
-            + "".join(random.choices(string.ascii_lowercase, k=4))
-            + "-"
-            + "".join(random.choices(string.ascii_lowercase, k=4))
-        )
-
-        ri = redis_instance()
-
-        key = "magic_" + str(email)
-
-        # Check if the key already exists in python
-        if ri.exists(key):
-            data = json.loads(ri.get(key))
-
-            current_attempt = data["current_attempt"] + 1
-
-            if data["current_attempt"] > 2:
-                return Response(
-                    {"error": "Max attempts exhausted. Please try again later."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            value = {
-                "current_attempt": current_attempt,
-                "email": email,
-                "token": token,
+            self.object.set_password(serializer.data.get("new_password"))
+            self.object.save()
+            response = {
+                "status": "success",
+                "code": status.HTTP_200_OK,
+                "message": "Password updated successfully",
             }
-            expiry = 600
 
-            ri.set(key, json.dumps(value), ex=expiry)
+            return Response(response)
 
-        else:
-            value = {"current_attempt": 0, "email": email, "token": token}
-            expiry = 600
-
-            ri.set(key, json.dumps(value), ex=expiry)
-
-        # If the smtp is configured send through here
-        current_site = request.META.get("HTTP_ORIGIN")
-        magic_link.delay(email, key, token, current_site)
-
-        return Response({"key": key}, status=status.HTTP_200_OK)
-
-
-class EmailCheckEndpoint(BaseAPIView):
-    permission_classes = [
-        AllowAny,
-    ]
-
-    def post(self, request):
-        # Check the instance registration
-        instance = Instance.objects.first()
-        if instance is None or not instance.is_setup_done:
-            return Response(
-                {"error": "Instance is not configured"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get configuration values
-        ENABLE_SIGNUP, ENABLE_MAGIC_LINK_LOGIN = get_configuration_value(
-            [
-                {
-                    "key": "ENABLE_SIGNUP",
-                    "default": os.environ.get("ENABLE_SIGNUP"),
-                },
-                {
-                    "key": "ENABLE_MAGIC_LINK_LOGIN",
-                    "default": os.environ.get("ENABLE_MAGIC_LINK_LOGIN"),
-                },
-            ]
-        )
-
-        email = request.data.get("email", False)
-
-        if not email:
-            return Response(
-                {"error": "Email is required"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        # validate the email
-        try:
-            validate_email(email)
-        except ValidationError:
-            return Response(
-                {"error": "Email is not valid"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        # Check if the user exists
-        user = User.objects.filter(email=email).first()
-        current_site = request.META.get("HTTP_ORIGIN")
-
-        # If new user
-        if user is None:
-            # Create the user
-            if (
-                ENABLE_SIGNUP == "0"
-                and not WorkspaceMemberInvite.objects.filter(
-                    email=email,
-                ).exists()
-            ):
-                return Response(
-                    {
-                        "error": "New account creation is disabled. Please contact your site administrator"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            # Create the user with default values
-            user = User.objects.create(
-                email=email,
-                username=uuid.uuid4().hex,
-                password=make_password(uuid.uuid4().hex),
-                is_password_autoset=True,
-            )
-
-            if not bool(
-                ENABLE_MAGIC_LINK_LOGIN,
-            ):
-                return Response(
-                    {"error": "Magic link sign in is disabled."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            # Send event
-            auth_events.delay(
-                user=user.id,
-                email=email,
-                user_agent=request.META.get("HTTP_USER_AGENT"),
-                ip=request.META.get("REMOTE_ADDR"),
-                event_name="SIGN_IN",
-                medium="MAGIC_LINK",
-                first_time=True,
-            )
-            key, token, current_attempt = generate_magic_token(email=email)
-            if not current_attempt:
-                return Response(
-                    {"error": "Max attempts exhausted. Please try again later."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            # Trigger the email
-            magic_link.delay(email, "magic_" + str(email), token, current_site)
-            return Response(
-                {"is_password_autoset": user.is_password_autoset, "is_existing": False},
-                status=status.HTTP_200_OK,
-            )
-
-        # Existing user
-        else:
-            if user.is_password_autoset:
-                ## Generate a random token
-                if not bool(ENABLE_MAGIC_LINK_LOGIN):
-                    return Response(
-                        {"error": "Magic link sign in is disabled."},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-
-                auth_events.delay(
-                    user=user.id,
-                    email=email,
-                    user_agent=request.META.get("HTTP_USER_AGENT"),
-                    ip=request.META.get("REMOTE_ADDR"),
-                    event_name="SIGN_IN",
-                    medium="MAGIC_LINK",
-                    first_time=False,
-                )
-
-                # Generate magic token
-                key, token, current_attempt = generate_magic_token(email=email)
-                if not current_attempt:
-                    return Response(
-                        {"error": "Max attempts exhausted. Please try again later."},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-
-                # Trigger the email
-                magic_link.delay(email, key, token, current_site)
-                return Response(
-                    {
-                        "is_password_autoset": user.is_password_autoset,
-                        "is_existing": True,
-                    },
-                    status=status.HTTP_200_OK,
-                )
-            else:
-                auth_events.delay(
-                    user=user.id,
-                    email=email,
-                    user_agent=request.META.get("HTTP_USER_AGENT"),
-                    ip=request.META.get("REMOTE_ADDR"),
-                    event_name="SIGN_IN",
-                    medium="EMAIL",
-                    first_time=False,
-                )
-
-                # User should enter password to login
-                return Response(
-                    {
-                        "is_password_autoset": user.is_password_autoset,
-                        "is_existing": True,
-                    },
-                    status=status.HTTP_200_OK,
-                )
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/app/views/authentication.py

@@ -1,7 +1,10 @@
 # Python imports
-import os
 import uuid
+import random
+import string
 import json
+import requests
+from requests.exceptions import RequestException
 
 # Django imports
 from django.utils import timezone
@@ -15,7 +18,8 @@ from rest_framework.response import Response
 from rest_framework.permissions import AllowAny
 from rest_framework import status
 from rest_framework_simplejwt.tokens import RefreshToken
-from sentry_sdk import capture_message
+
+from sentry_sdk import capture_exception, capture_message
 
 # Module imports
 from . import BaseAPIView
@@ -27,9 +31,7 @@ from plane.db.models import (
     ProjectMember,
 )
 from plane.settings.redis import redis_instance
-from plane.license.models import Instance
-from plane.license.utils.instance_value import get_configuration_value
-from plane.bgtasks.event_tracking_task import auth_events
+from plane.bgtasks.magic_link_code_task import magic_link
 
 
 def get_tokens_for_user(user):
@@ -44,16 +46,17 @@ class SignUpEndpoint(BaseAPIView):
     permission_classes = (AllowAny,)
 
     def post(self, request):
-        # Check if the instance configuration is done
-        instance = Instance.objects.first()
-        if instance is None or not instance.is_setup_done:
+        if not settings.ENABLE_SIGNUP:
             return Response(
-                {"error": "Instance is not configured"},
+                {
+                    "error": "New account creation is disabled. Please contact your site administrator"
+                },
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
         email = request.data.get("email", False)
         password = request.data.get("password", False)
+
         ## Raise exception if any of the above are missing
         if not email or not password:
             return Response(
@@ -61,8 +64,8 @@ class SignUpEndpoint(BaseAPIView):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        # Validate the email
         email = email.strip().lower()
+
         try:
             validate_email(email)
         except ValidationError as e:
@@ -71,31 +74,6 @@ class SignUpEndpoint(BaseAPIView):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        # get configuration values
-        # Get configuration values
-        ENABLE_SIGNUP, = get_configuration_value(
-            [
-                {
-                    "key": "ENABLE_SIGNUP",
-                    "default": os.environ.get("ENABLE_SIGNUP"),
-                },
-            ]
-        )
-
-        # If the sign up is not enabled and the user does not have invite disallow him from creating the account
-        if (
-            ENABLE_SIGNUP == "0"
-            and not WorkspaceMemberInvite.objects.filter(
-                email=email,
-            ).exists()
-        ):
-            return Response(
-                {
-                    "error": "New account creation is disabled. Please contact your site administrator"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
         # Check if the user already exists
         if User.objects.filter(email=email).exists():
             return Response(
@@ -107,103 +85,6 @@ class SignUpEndpoint(BaseAPIView):
         user.set_password(password)
 
         # settings last actives for the user
-        user.is_password_autoset = False
-        user.last_active = timezone.now()
-        user.last_login_time = timezone.now()
-        user.last_login_ip = request.META.get("REMOTE_ADDR")
-        user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
-        user.token_updated_at = timezone.now()
-        user.save()
-
-        access_token, refresh_token = get_tokens_for_user(user)
-
-        data = {
-            "access_token": access_token,
-            "refresh_token": refresh_token,
-        }
-
-        return Response(data, status=status.HTTP_200_OK)
-
-
-class SignInEndpoint(BaseAPIView):
-    permission_classes = (AllowAny,)
-
-    def post(self, request):
-        # Check if the instance configuration is done
-        instance = Instance.objects.first()
-        if instance is None or not instance.is_setup_done:
-            return Response(
-                {"error": "Instance is not configured"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        email = request.data.get("email", False)
-        password = request.data.get("password", False)
-
-        ## Raise exception if any of the above are missing
-        if not email or not password:
-            return Response(
-                {"error": "Both email and password are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Validate email
-        email = email.strip().lower()
-        try:
-            validate_email(email)
-        except ValidationError as e:
-            return Response(
-                {"error": "Please provide a valid email address."},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get the user
-        user = User.objects.filter(email=email).first()
-
-        # Existing user
-        if user:
-            # Check user password
-            if not user.check_password(password):
-                return Response(
-                    {
-                        "error": "Sorry, we could not find a user with the provided credentials. Please try again."
-                    },
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-
-        # Create the user
-        else:
-            ENABLE_SIGNUP, = get_configuration_value(
-                [
-                    {
-                        "key": "ENABLE_SIGNUP",
-                        "default": os.environ.get("ENABLE_SIGNUP"),
-                    },
-                ]
-            )
-            # Create the user
-            if (
-                ENABLE_SIGNUP == "0"
-                and not WorkspaceMemberInvite.objects.filter(
-                    email=email,
-                ).exists()
-            ):
-                return Response(
-                    {
-                        "error": "New account creation is disabled. Please contact your site administrator"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            user = User.objects.create(
-                email=email,
-                username=uuid.uuid4().hex,
-                password=make_password(password),
-                is_password_autoset=False,
-            )
-
-        # settings last active for the user
-        user.is_active = True
         user.last_active = timezone.now()
         user.last_login_time = timezone.now()
         user.last_login_ip = request.META.get("REMOTE_ADDR")
@@ -259,25 +140,186 @@ class SignInEndpoint(BaseAPIView):
                     else 15,
                     member=user,
                     created_by_id=project_member_invite.created_by_id,
+                ) for project_member_invite in project_member_invites
+            ],
+            ignore_conflicts=True,
+        )
+        # Delete all the invites
+        workspace_member_invites.delete()
+        project_member_invites.delete()
+
+        try:
+            # Send Analytics
+            if settings.ANALYTICS_BASE_API:
+                _ = requests.post(
+                    settings.ANALYTICS_BASE_API,
+                    headers={
+                        "Content-Type": "application/json",
+                        "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
+                    },
+                    json={
+                        "event_id": uuid.uuid4().hex,
+                        "event_data": {
+                            "medium": "email",
+                        },
+                        "user": {"email": email, "id": str(user.id)},
+                        "device_ctx": {
+                            "ip": request.META.get("REMOTE_ADDR"),
+                            "user_agent": request.META.get("HTTP_USER_AGENT"),
+                        },
+                        "event_type": "SIGN_UP",
+                    },
+                )
+        except RequestException as e:
+            capture_exception(e)
+
+        access_token, refresh_token = get_tokens_for_user(user)
+
+        data = {
+            "access_token": access_token,
+            "refresh_token": refresh_token,
+        }
+        return Response(data, status=status.HTTP_200_OK)
+
+
+class SignInEndpoint(BaseAPIView):
+    permission_classes = (AllowAny,)
+
+    def post(self, request):
+        email = request.data.get("email", False)
+        password = request.data.get("password", False)
+
+        ## Raise exception if any of the above are missing
+        if not email or not password:
+            return Response(
+                {"error": "Both email and password are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        email = email.strip().lower()
+
+        try:
+            validate_email(email)
+        except ValidationError as e:
+            return Response(
+                {"error": "Please provide a valid email address."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        user = User.objects.filter(email=email).first()
+
+        if user is None:
+            return Response(
+                {
+                    "error": "Sorry, we could not find a user with the provided credentials. Please try again."
+                },
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        # Sign up Process
+        if not user.check_password(password):
+            return Response(
+                {
+                    "error": "Sorry, we could not find a user with the provided credentials. Please try again."
+                },
+                status=status.HTTP_403_FORBIDDEN,
+            )
+        if not user.is_active:
+            return Response(
+                {
+                    "error": "Your account has been deactivated. Please contact your site administrator."
+                },
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        # settings last active for the user
+        user.last_active = timezone.now()
+        user.last_login_time = timezone.now()
+        user.last_login_ip = request.META.get("REMOTE_ADDR")
+        user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
+        user.token_updated_at = timezone.now()
+        user.save()
+
+        # Check if user has any accepted invites for workspace and add them to workspace
+        workspace_member_invites = WorkspaceMemberInvite.objects.filter(
+            email=user.email, accepted=True
+        )
+
+        WorkspaceMember.objects.bulk_create(
+            [
+                WorkspaceMember(
+                    workspace_id=workspace_member_invite.workspace_id,
+                    member=user,
+                    role=workspace_member_invite.role,
+                )
+                for workspace_member_invite in workspace_member_invites
+            ],
+            ignore_conflicts=True,
+        )
+
+        # Check if user has any project invites
+        project_member_invites = ProjectMemberInvite.objects.filter(
+            email=user.email, accepted=True
+        )
+
+        # Add user to workspace
+        WorkspaceMember.objects.bulk_create(
+            [
+                WorkspaceMember(
+                    workspace_id=project_member_invite.workspace_id,
+                    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,
                 )
                 for project_member_invite in project_member_invites
             ],
             ignore_conflicts=True,
         )
 
+        # Now add the users to project
+        ProjectMember.objects.bulk_create(
+            [
+                ProjectMember(
+                    workspace_id=project_member_invite.workspace_id,
+                    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,
+                ) for project_member_invite in project_member_invites
+            ],
+            ignore_conflicts=True,
+        )
+
         # Delete all the invites
         workspace_member_invites.delete()
         project_member_invites.delete()
-        # Send event
-        auth_events.delay(
-            user=user.id,
-            email=email,
-            user_agent=request.META.get("HTTP_USER_AGENT"),
-            ip=request.META.get("REMOTE_ADDR"),
-            event_name="SIGN_IN",
-            medium="EMAIL",
-            first_time=False,
-        )
+        try:
+            # Send Analytics
+            if settings.ANALYTICS_BASE_API:
+                _ = requests.post(
+                    settings.ANALYTICS_BASE_API,
+                    headers={
+                        "Content-Type": "application/json",
+                        "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
+                    },
+                    json={
+                        "event_id": uuid.uuid4().hex,
+                        "event_data": {
+                            "medium": "email",
+                        },
+                        "user": {"email": email, "id": str(user.id)},
+                        "device_ctx": {
+                            "ip": request.META.get("REMOTE_ADDR"),
+                            "user_agent": request.META.get("HTTP_USER_AGENT"),
+                        },
+                        "event_type": "SIGN_IN",
+                    },
+                )
+        except RequestException as e:
+            capture_exception(e)
 
         access_token, refresh_token = get_tokens_for_user(user)
         data = {
@@ -310,20 +352,77 @@ class SignOutEndpoint(BaseAPIView):
         return Response({"message": "success"}, status=status.HTTP_200_OK)
 
 
+class MagicSignInGenerateEndpoint(BaseAPIView):
+    permission_classes = [
+        AllowAny,
+    ]
+
+    def post(self, request):
+        email = request.data.get("email", False)
+
+        if not email:
+            return Response(
+                {"error": "Please provide a valid email address"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Clean up
+        email = email.strip().lower()
+        validate_email(email)
+
+        ## Generate a random token
+        token = (
+            "".join(random.choices(string.ascii_lowercase, k=4))
+            + "-"
+            + "".join(random.choices(string.ascii_lowercase, k=4))
+            + "-"
+            + "".join(random.choices(string.ascii_lowercase, k=4))
+        )
+
+        ri = redis_instance()
+
+        key = "magic_" + str(email)
+
+        # Check if the key already exists in python
+        if ri.exists(key):
+            data = json.loads(ri.get(key))
+
+            current_attempt = data["current_attempt"] + 1
+
+            if data["current_attempt"] > 2:
+                return Response(
+                    {"error": "Max attempts exhausted. Please try again later."},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            value = {
+                "current_attempt": current_attempt,
+                "email": email,
+                "token": token,
+            }
+            expiry = 600
+
+            ri.set(key, json.dumps(value), ex=expiry)
+
+        else:
+            value = {"current_attempt": 0, "email": email, "token": token}
+            expiry = 600
+
+            ri.set(key, json.dumps(value), ex=expiry)
+
+
+        current_site = request.META.get('HTTP_ORIGIN')
+        magic_link.delay(email, key, token, current_site)
+
+        return Response({"key": key}, status=status.HTTP_200_OK)
+
+
 class MagicSignInEndpoint(BaseAPIView):
     permission_classes = [
         AllowAny,
     ]
 
     def post(self, request):
-        # Check if the instance configuration is done
-        instance = Instance.objects.first()
-        if instance is None or not instance.is_setup_done:
-            return Response(
-                {"error": "Instance is not configured"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
         user_token = request.data.get("token", "").strip()
         key = request.data.get("key", False).strip().lower()
 
@@ -342,20 +441,71 @@ class MagicSignInEndpoint(BaseAPIView):
             email = data["email"]
 
             if str(token) == str(user_token):
-                user = User.objects.get(email=email)
-                # Send event
-                auth_events.delay(
-                    user=user.id,
-                    email=email,
-                    user_agent=request.META.get("HTTP_USER_AGENT"),
-                    ip=request.META.get("REMOTE_ADDR"),
-                    event_name="SIGN_IN",
-                    medium="MAGIC_LINK",
-                    first_time=False,
-                )
+                if User.objects.filter(email=email).exists():
+                    user = User.objects.get(email=email)
+                    if not user.is_active:
+                        return Response(
+                            {
+                                "error": "Your account has been deactivated. Please contact your site administrator."
+                            },
+                            status=status.HTTP_403_FORBIDDEN,
+                        )
+                    try:
+                        # Send event to Jitsu for tracking
+                        if settings.ANALYTICS_BASE_API:
+                            _ = requests.post(
+                                settings.ANALYTICS_BASE_API,
+                                headers={
+                                    "Content-Type": "application/json",
+                                    "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
+                                },
+                                json={
+                                    "event_id": uuid.uuid4().hex,
+                                    "event_data": {
+                                        "medium": "code",
+                                    },
+                                    "user": {"email": email, "id": str(user.id)},
+                                    "device_ctx": {
+                                        "ip": request.META.get("REMOTE_ADDR"),
+                                        "user_agent": request.META.get("HTTP_USER_AGENT"),
+                                    },
+                                    "event_type": "SIGN_IN",
+                                },
+                            )
+                    except RequestException as e:
+                        capture_exception(e)
+                else:
+                    user = User.objects.create(
+                        email=email,
+                        username=uuid.uuid4().hex,
+                        password=make_password(uuid.uuid4().hex),
+                        is_password_autoset=True,
+                    )
+                    try:
+                        # Send event to Jitsu for tracking
+                        if settings.ANALYTICS_BASE_API:
+                            _ = requests.post(
+                                settings.ANALYTICS_BASE_API,
+                                headers={
+                                    "Content-Type": "application/json",
+                                    "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
+                                },
+                                json={
+                                    "event_id": uuid.uuid4().hex,
+                                    "event_data": {
+                                        "medium": "code",
+                                    },
+                                    "user": {"email": email, "id": str(user.id)},
+                                    "device_ctx": {
+                                        "ip": request.META.get("REMOTE_ADDR"),
+                                        "user_agent": request.META.get("HTTP_USER_AGENT"),
+                                    },
+                                    "event_type": "SIGN_UP",
+                                },
+                            )
+                    except RequestException as e:
+                        capture_exception(e)
 
-                user.is_active = True
-                user.is_email_verified = True
                 user.last_active = timezone.now()
                 user.last_login_time = timezone.now()
                 user.last_login_ip = request.META.get("REMOTE_ADDR")
@@ -411,8 +561,7 @@ class MagicSignInEndpoint(BaseAPIView):
                             else 15,
                             member=user,
                             created_by_id=project_member_invite.created_by_id,
-                        )
-                        for project_member_invite in project_member_invites
+                        ) for project_member_invite in project_member_invites
                     ],
                     ignore_conflicts=True,
                 )

apiserver/plane/app/views/base.py

@@ -25,7 +25,7 @@ from django_filters.rest_framework import DjangoFilterBackend
 # Module imports
 from plane.utils.paginator import BasePaginator
 from plane.bgtasks.webhook_task import send_webhook
-
+from plane.bgtasks.track_events import track_event
 
 class TimezoneMixin:
     """
@@ -43,30 +43,49 @@ class TimezoneMixin:
 
 class WebhookMixin:
     webhook_event = None
-    bulk = False
 
-    def finalize_response(self, request, response, *args, **kwargs):
-        response = super().finalize_response(request, response, *args, **kwargs)
+    def initial_request(self, request, response, *args, **kwargs):
+        response = super().initial_request(request, response, *args, **kwargs)
 
-        # Check for the case should webhook be sent
         if (
             self.webhook_event
             and self.request.method in ["POST", "PATCH", "DELETE"]
             and response.status_code in [200, 201, 204]
         ):
-            # Push the object to delay
             send_webhook.delay(
                 event=self.webhook_event,
-                payload=response.data,
-                kw=self.kwargs,
+                event_data=json.dumps(response.data, cls=DjangoJSONEncoder),
                 action=self.request.method,
                 slug=self.workspace_slug,
-                bulk=self.bulk,
             )
 
         return response
 
 
+class AnalyticsMixin:
+    analytic_event = None
+    print("did it come here or not")
+
+    def initial(self, request, *args, **kwargs):
+        super().initial(request, *args, **kwargs)
+        print("hieieie")
+        print(self.workspace_slug,"workspace_slug")
+        # if (
+        #     self.analytic_event
+        #     and self.request.method in ["POST", "PATCH", "DELETE"]
+        #     and response.status_code in [200, 201, 204]
+        # ):
+        #     print(self.workspace_slug,"workspace_slug")
+        #     track_event.delay(
+        #         event_name=self.analytic_event,
+        #         slug=self.workspace_slug,
+        #         project_id=self.project_id,
+        #         user_id=self.request.user.id,
+        #     )
+
+        # return response
+    
+
 class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
     model = None
 

apiserver/plane/app/views/config.py

@@ -11,6 +11,7 @@ from rest_framework.response import Response
 
 # Module imports
 from .base import BaseAPIView
+from plane.license.models import Instance, InstanceConfiguration
 from plane.license.utils.instance_value import get_configuration_value
 
 
@@ -20,101 +21,75 @@ class ConfigurationEndpoint(BaseAPIView):
     ]
 
     def get(self, request):
-
-        # Get all the configuration
-        (
-            GOOGLE_CLIENT_ID,
-            GITHUB_CLIENT_ID,
-            GITHUB_APP_NAME,
-            EMAIL_HOST_USER,
-            EMAIL_HOST_PASSWORD,
-            ENABLE_MAGIC_LINK_LOGIN,
-            ENABLE_EMAIL_PASSWORD,
-            SLACK_CLIENT_ID,
-            POSTHOG_API_KEY,
-            POSTHOG_HOST,
-            UNSPLASH_ACCESS_KEY,
-            OPENAI_API_KEY,
-        ) = get_configuration_value(
-            [
-                {
-                    "key": "GOOGLE_CLIENT_ID",
-                    "default": os.environ.get("GOOGLE_CLIENT_ID", None),
-                },
-                {
-                    "key": "GITHUB_CLIENT_ID",
-                    "default": os.environ.get("GITHUB_CLIENT_ID", None),
-                },
-                {
-                    "key": "GITHUB_APP_NAME",
-                    "default": os.environ.get("GITHUB_APP_NAME", None),
-                },
-                {
-                    "key": "EMAIL_HOST_USER",
-                    "default": os.environ.get("EMAIL_HOST_USER", None),
-                },
-                {
-                    "key": "EMAIL_HOST_PASSWORD",
-                    "default": os.environ.get("EMAIL_HOST_PASSWORD", None),
-                },
-                {
-                    "key": "ENABLE_MAGIC_LINK_LOGIN",
-                    "default": os.environ.get("ENABLE_MAGIC_LINK_LOGIN", "1"),
-                },
-                {
-                    "key": "ENABLE_EMAIL_PASSWORD",
-                    "default": os.environ.get("ENABLE_EMAIL_PASSWORD", "1"),
-                },
-                {
-                    "key": "SLACK_CLIENT_ID",
-                    "default": os.environ.get("SLACK_CLIENT_ID", "1"),
-                },
-                {
-                    "key": "POSTHOG_API_KEY",
-                    "default": os.environ.get("POSTHOG_API_KEY", "1"),
-                },
-                {
-                    "key": "POSTHOG_HOST",
-                    "default": os.environ.get("POSTHOG_HOST", "1"),
-                },
-                {
-                    "key": "UNSPLASH_ACCESS_KEY",
-                    "default": os.environ.get("UNSPLASH_ACCESS_KEY", "1"),
-                },
-                {
-                    "key": "OPENAI_API_KEY",
-                    "default": os.environ.get("OPENAI_API_KEY", "1"),
-                },
-            ]
-        )
+        instance_configuration = InstanceConfiguration.objects.values("key", "value")
 
         data = {}
         # Authentication
-        data["google_client_id"] = GOOGLE_CLIENT_ID if GOOGLE_CLIENT_ID and GOOGLE_CLIENT_ID != "\"\"" else None
-        data["github_client_id"] = GITHUB_CLIENT_ID if GITHUB_CLIENT_ID and GITHUB_CLIENT_ID != "\"\"" else None
-        data["github_app_name"] = GITHUB_APP_NAME
+        data["google_client_id"] = get_configuration_value(
+            instance_configuration,
+            "GOOGLE_CLIENT_ID",
+            os.environ.get("GOOGLE_CLIENT_ID", None),
+        )
+        data["github_client_id"] = get_configuration_value(
+            instance_configuration,
+            "GITHUB_CLIENT_ID",
+            os.environ.get("GITHUB_CLIENT_ID", None),
+        )
+        data["github_app_name"] = get_configuration_value(
+            instance_configuration,
+            "GITHUB_APP_NAME",
+            os.environ.get("GITHUB_APP_NAME", None),
+        )
         data["magic_login"] = (
-            bool(EMAIL_HOST_USER) and bool(EMAIL_HOST_PASSWORD)
-        ) and ENABLE_MAGIC_LINK_LOGIN == "1"
-
-        data["email_password_login"] = ENABLE_EMAIL_PASSWORD == "1"
+            bool(
+                get_configuration_value(
+                    instance_configuration,
+                    "EMAIL_HOST_USER",
+                    os.environ.get("GITHUB_APP_NAME", None),
+                ),
+            )
+            and bool(
+                get_configuration_value(
+                    instance_configuration,
+                    "EMAIL_HOST_PASSWORD",
+                    os.environ.get("GITHUB_APP_NAME", None),
+                )
+            )
+        ) and get_configuration_value(
+            instance_configuration, "ENABLE_MAGIC_LINK_LOGIN", "0"
+        ) == "1"
+        data["email_password_login"] = (
+            get_configuration_value(
+                instance_configuration, "ENABLE_EMAIL_PASSWORD", "0"
+            )
+            == "1"
+        )
         # Slack client
-        data["slack_client_id"] = SLACK_CLIENT_ID
+        data["slack_client_id"] = get_configuration_value(
+            instance_configuration,
+            "SLACK_CLIENT_ID",
+            os.environ.get("SLACK_CLIENT_ID", None),
+        )
 
         # Posthog
-        data["posthog_api_key"] = POSTHOG_API_KEY
-        data["posthog_host"] = POSTHOG_HOST
+        data["posthog_api_key"] = get_configuration_value(
+            instance_configuration,
+            "POSTHOG_API_KEY",
+            os.environ.get("POSTHOG_API_KEY", None),
+        )
+        data["posthog_host"] = get_configuration_value(
+            instance_configuration,
+            "POSTHOG_HOST",
+            os.environ.get("POSTHOG_HOST", None),
+        )
 
         # Unsplash
-        data["has_unsplash_configured"] = bool(UNSPLASH_ACCESS_KEY)
-
-        # Open AI settings
-        data["has_openai_configured"] = bool(OPENAI_API_KEY)
-
-        # File size settings
-        data["file_size_limit"] = float(os.environ.get("FILE_SIZE_LIMIT", 5242880))
-
-        # is self managed
-        data["is_self_managed"] = bool(int(os.environ.get("IS_SELF_MANAGED", "1")))
+        data["has_unsplash_configured"] = bool(
+            get_configuration_value(
+                instance_configuration,
+                "UNSPLASH_ACCESS_KEY",
+                os.environ.get("UNSPLASH_ACCESS_KEY", None),
+            )
+        )
 
         return Response(data, status=status.HTTP_200_OK)

apiserver/plane/app/views/cycle.py

@@ -502,10 +502,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
 class CycleIssueViewSet(WebhookMixin, BaseViewSet):
     serializer_class = CycleIssueSerializer
     model = CycleIssue
-
-    webhook_event = "cycle_issue"
-    bulk = True
-
+    webhook_event = "cycle"
     permission_classes = [
         ProjectEntityPermission,
     ]
@@ -539,8 +536,9 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
 
     @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")
+        group_by = request.GET.get("group_by", False)
+        sub_group_by = request.GET.get("sub_group_by", False)
         filters = issue_filters(request.query_params, "GET")
         issues = (
             Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
@@ -575,9 +573,24 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
             )
         )
 
-        issues = IssueStateSerializer(issues, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(issue_dict, status=status.HTTP_200_OK)
+        issues_data = IssueStateSerializer(issues, many=True).data
+
+        if sub_group_by and sub_group_by == group_by:
+            return Response(
+                {"error": "Group by and sub group by cannot be same"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if group_by:
+            grouped_results = group_results(issues_data, group_by, sub_group_by)
+            return Response(
+                grouped_results,
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(
+            issues_data, status=status.HTTP_200_OK
+        )
 
     def create(self, request, slug, project_id, cycle_id):
         issues = request.data.get("issues", [])
@@ -675,6 +688,7 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
             pk=pk, workspace__slug=slug, project_id=project_id, cycle_id=cycle_id
         )
         issue_id = cycle_issue.issue_id
+        cycle_issue.delete()
         issue_activity.delay(
             type="cycle.activity.deleted",
             requested_data=json.dumps(
@@ -684,15 +698,64 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
                 }
             ),
             actor_id=str(self.request.user.id),
-            issue_id=str(cycle_issue.issue_id),
+            issue_id=str(self.kwargs.get("pk", None)),
             project_id=str(self.kwargs.get("project_id", None)),
             current_instance=None,
             epoch=int(timezone.now().timestamp()),
         )
-        cycle_issue.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
+class CycleIssueGroupedEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get(self, request, slug, project_id, cycle_id):
+        filters = issue_filters(request.query_params, "GET")
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
+
+        issues = (
+            Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(bridge_id=F("issue_cycle__id"))
+            .filter(project_id=project_id)
+            .filter(workspace__slug=slug)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("state")
+            .select_related("parent")
+            .prefetch_related("assignees")
+            .prefetch_related("labels")
+            .filter(**filters)
+            .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")
+            )
+        )
+
+        issues = IssueStateSerializer(issues, many=True, fields=fields if fields else None).data
+        issue_dict = {str(issue["id"]): issue for issue in issues}
+        return Response(
+            issue_dict,
+            status=status.HTTP_200_OK,
+        )
+
+
 class CycleDateCheckEndpoint(BaseAPIView):
     permission_classes = [
         ProjectEntityPermission,
@@ -805,4 +868,4 @@ class TransferCycleIssueEndpoint(BaseAPIView):
             updated_cycles, ["cycle_id"], batch_size=100
         )
 
-        return Response({"message": "Success"}, status=status.HTTP_200_OK)
+        return Response({"message": "Success"}, status=status.HTTP_200_OK)

apiserver/plane/app/views/external.py

@@ -1,6 +1,5 @@
 # Python imports
 import requests
-import os
 
 # Third party imports
 from openai import OpenAI
@@ -16,31 +15,23 @@ 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.models import InstanceConfiguration
 from plane.license.utils.instance_value import get_configuration_value
 
-
 class GPTIntegrationEndpoint(BaseAPIView):
     permission_classes = [
         ProjectEntityPermission,
     ]
 
     def post(self, request, slug, project_id):
-        OPENAI_API_KEY, GPT_ENGINE = get_configuration_value(
-            [
-                {
-                    "key": "OPENAI_API_KEY",
-                    "default": os.environ.get("OPENAI_API_KEY", None),
-                },
-                {
-                    "key": "GPT_ENGINE",
-                    "default": os.environ.get("GPT_ENGINE", "gpt-3.5-turbo"),
-                },
-            ]
-        )
 
         # Get the configuration value
+        instance_configuration = InstanceConfiguration.objects.values("key", "value")
+        api_key = get_configuration_value(instance_configuration, "OPENAI_API_KEY")
+        gpt_engine = get_configuration_value(instance_configuration, "GPT_ENGINE")
+
         # Check the keys
-        if not OPENAI_API_KEY or not GPT_ENGINE:
+        if not api_key or not gpt_engine:
             return Response(
                 {"error": "OpenAI API key and engine is required"},
                 status=status.HTTP_400_BAD_REQUEST,
@@ -56,12 +47,16 @@ class GPTIntegrationEndpoint(BaseAPIView):
 
         final_text = task + "\n" + prompt
 
+        instance_configuration = InstanceConfiguration.objects.values("key", "value")
+        
+        gpt_engine = get_configuration_value(instance_configuration, "GPT_ENGINE")
+
         client = OpenAI(
-            api_key=OPENAI_API_KEY,
+            api_key=api_key,
         )
 
         response = client.chat.completions.create(
-            model=GPT_ENGINE,
+            model=gpt_engine,
             messages=[{"role": "user", "content": final_text}],
         )
 
@@ -88,28 +83,16 @@ class ReleaseNotesEndpoint(BaseAPIView):
 
 
 class UnsplashEndpoint(BaseAPIView):
-    def get(self, request):
-        UNSPLASH_ACCESS_KEY, = get_configuration_value(
-            [
-                {
-                    "key": "UNSPLASH_ACCESS_KEY",
-                    "default": os.environ.get("UNSPLASH_ACCESS_KEY"),
-                }
-            ]
-        )
-        # Check unsplash access key
-        if not UNSPLASH_ACCESS_KEY:
-            return Response([], status=status.HTTP_200_OK)
 
-        # Query parameters
+    def get(self, request):
         query = request.GET.get("query", False)
         page = request.GET.get("page", 1)
         per_page = request.GET.get("per_page", 20)
 
         url = (
-            f"https://api.unsplash.com/search/photos/?client_id={UNSPLASH_ACCESS_KEY}&query={query}&page=${page}&per_page={per_page}"
+            f"https://api.unsplash.com/search/photos/?client_id={settings.UNSPLASH_ACCESS_KEY}&query={query}&page=${page}&per_page={per_page}"
             if query
-            else f"https://api.unsplash.com/photos/?client_id={UNSPLASH_ACCESS_KEY}&page={page}&per_page={per_page}"
+            else f"https://api.unsplash.com/photos/?client_id={settings.UNSPLASH_ACCESS_KEY}&page={page}&per_page={per_page}"
         )
 
         headers = {

apiserver/plane/app/views/importer.py

@@ -1,7 +1,5 @@
 # Python imports
 import uuid
-import json
-import requests
 
 # Third party imports
 from rest_framework import status
@@ -9,7 +7,7 @@ from rest_framework.response import Response
 
 # Django imports
 from django.db.models import Max, Q
-from django.conf import settings
+
 # Module imports
 from plane.app.views import BaseAPIView
 from plane.db.models import (
@@ -36,15 +34,20 @@ from plane.app.serializers import (
     IssueFlatSerializer,
     ModuleSerializer,
 )
+from plane.utils.integrations.github import get_github_repo_details
+from plane.utils.importers.jira import jira_project_issue_summary
+from plane.bgtasks.importer_task import service_importer
 from plane.utils.html_processor import strip_tags
 from plane.app.permissions import WorkSpaceAdminPermission
-from plane.bgtasks.importer_task import service_importer
+
 
 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"},
@@ -55,10 +58,11 @@ class ServiceIssueImportSummaryEndpoint(BaseAPIView):
                 integration__provider="github", workspace__slug=slug
             )
 
-            installtion_id = workspace_integration.config.get("installation_id", False)
+            access_tokens_url = workspace_integration.metadata.get(
+                "access_tokens_url", False
+            )
 
-            # Check for the installation id
-            if not installtion_id:
+            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."
@@ -66,33 +70,18 @@ class ServiceIssueImportSummaryEndpoint(BaseAPIView):
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            # Request segway for the required information
-            if settings.SEGWAY_BASE_URL:
-                headers = {
-                    "Content-Type": "application/json",
-                    "x-api-key": settings.SEGWAY_KEY,
-                }
-                data = {
-                    "owner": owner,
-                    "repo": repo,
-                    "installationId": installtion_id,
-                }
-                res = requests.post(
-                    f"{settings.SEGWAY_BASE_URL}/api/github",
-                    data=json.dumps(data),
-                    headers=headers,
-                )
-                if "error" in res.json():
-                    return Response(res.json(), status=status.HTTP_400_BAD_REQUEST)
-                else:
-                    return Response(
-                        res.json(),
-                        status=status.HTTP_200_OK,
-                    )
-            return Response(
-                {"error": "Inetgration service is not available please try later"},
-                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 = {
@@ -113,35 +102,16 @@ class ServiceIssueImportSummaryEndpoint(BaseAPIView):
             email = request.GET.get("email", "")
             cloud_hostname = request.GET.get("cloud_hostname", "")
 
-            if settings.SEGWAY_BASE_URL:
-                headers = {
-                    "Content-Type": "application/json",
-                    "x-api-key": settings.SEGWAY_KEY,
-                }
-                data = {
-                    "project_key": project_key,
-                    "api_token": api_token,
-                    "email": email,
-                    "cloud_hostname": cloud_hostname,
-                }
-                res = requests.post(
-                    f"{settings.SEGWAY_BASE_URL}/api/jira",
-                    data=json.dumps(data),
-                    headers=headers,
-                )
-
-                if "error" in res.json():
-                    return Response(res.json(), status=status.HTTP_400_BAD_REQUEST)
-                else:
-                    return Response(
-                        res.json(),
-                        status=status.HTTP_200_OK,
-                    )
-
-            return Response(
-                {"error": "Inetgration service is not available please try later"},
-                status=status.HTTP_400_BAD_REQUEST,
+            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,
@@ -152,21 +122,7 @@ class ImportServiceEndpoint(BaseAPIView):
     permission_classes = [
         WorkSpaceAdminPermission,
     ]
-
     def post(self, request, slug, service):
-        if service not in ["github", "jira"]:
-            return Response(
-                {"error": "Servivce not supported yet"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if service == "github":
-            workspace_integration = WorkspaceIntegration.objects.get(
-                integration__provider="github", workspace__slug=slug
-            )
-
-            installation_id = workspace_integration.config.get("installation_id", False)
-
         project_id = request.data.get("project_id", False)
 
         if not project_id:
@@ -174,84 +130,87 @@ class ImportServiceEndpoint(BaseAPIView):
                 {"error": "Project ID is required"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
+
         workspace = Workspace.objects.get(slug=slug)
 
-        # Validate the data
-        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,
+        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,
             )
 
-        # Update config
-        if config and service == "github":
-            config.update({"installation_id": installation_id})
+            service_importer.delay(service, importer.id)
+            serializer = ImporterSerializer(importer)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
 
-        # Get the api token -- # derecated
-        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,
+        if service == "jira":
+            data = request.data.get("data", False)
+            metadata = request.data.get("metadata", False)
+            config = request.data.get("config", False)
+            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,
             )
 
-        # Create an import
-        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,
         )
 
-        # Push it to segway
-        if settings.SEGWAY_BASE_URL:
-            headers = {
-                "Content-Type": "application/json",
-                "x-api-key": settings.SEGWAY_KEY,
-            }
-            data = {
-                "metadata": metadata,
-                "data": data,
-                "config": config,
-                "workspace_id": str(workspace.id),
-                "project_id": str(project_id),
-                "created_by": str(request.user.id),
-                "importer_id": str(importer.id),
-            }
-            res = requests.post(
-                f"{settings.SEGWAY_BASE_URL}/api/github/import",
-                data=json.dumps(data),
-                headers=headers,
-            )
-
-            if "error" in res.json():
-                importer.status = "failed"
-                importer.reason = str(res.json())
-                importer.save()
-            else:
-                importer.status = "processing"
-                importer.save(update_fields=["status"])
-        else:
-            importer.status = "failed"
-            importer.reason = "Segway base url is not present"
-            importer.save(update_fields=["status", "reason"])
-
-        # return the response
-        serializer = ImporterSerializer(importer)
-        return Response(serializer.data, status=status.HTTP_201_CREATED)
-
     def get(self, request, slug):
         imports = (
             Importer.objects.filter(workspace__slug=slug)
@@ -262,7 +221,9 @@ class ImportServiceEndpoint(BaseAPIView):
         return Response(serializer.data)
 
     def delete(self, request, slug, service, pk):
-        importer = Importer.objects.get(pk=pk, service=service, workspace__slug=slug)
+        importer = Importer.objects.get(
+            pk=pk, service=service, workspace__slug=slug
+        )
 
         if importer.imported_data is not None:
             # Delete all imported Issues
@@ -280,7 +241,9 @@ class ImportServiceEndpoint(BaseAPIView):
         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)
+        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()
@@ -516,7 +479,9 @@ class BulkImportModulesEndpoint(BaseAPIView):
                 [
                     ModuleLink(
                         module=module,
-                        url=module_data.get("link", {}).get("url", "https://plane.so"),
+                        url=module_data.get("link", {}).get(
+                            "url", "https://plane.so"
+                        ),
                         title=module_data.get("link", {}).get(
                             "title", "Original Issue"
                         ),

apiserver/plane/app/views/inbox.py

@@ -356,3 +356,4 @@ class InboxIssueViewSet(BaseViewSet):
         inbox_issue.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
+

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

@@ -1,11 +1,8 @@
 # Python improts
 import uuid
 import requests
-import json
-
 # Django imports
 from django.contrib.auth.hashers import make_password
-from django.conf import settings
 
 # Third party imports
 from rest_framework.response import Response
@@ -30,7 +27,6 @@ from plane.utils.integrations.github import (
 from plane.app.permissions import WorkSpaceAdminPermission
 from plane.utils.integrations.slack import slack_oauth
 
-
 class IntegrationViewSet(BaseViewSet):
     serializer_class = IntegrationSerializer
     model = Integration
@@ -50,7 +46,9 @@ class IntegrationViewSet(BaseViewSet):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        serializer = IntegrationSerializer(integration, data=request.data, partial=True)
+        serializer = IntegrationSerializer(
+            integration, data=request.data, partial=True
+        )
 
         if serializer.is_valid():
             serializer.save()
@@ -96,30 +94,14 @@ class WorkspaceIntegrationViewSet(BaseViewSet):
                     {"error": "Installation ID is required"},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
-            # Push it to segway
-            if settings.SEGWAY_BASE_URL:
-                headers = {
-                    "Content-Type": "application/json",
-                    "x-api-key": settings.SEGWAY_KEY,
-                }
-                data = {"installationId": installation_id}
-                res = requests.post(
-                    f"{settings.SEGWAY_BASE_URL}/api/github/metadata",
-                    data=json.dumps(data),
-                    headers=headers,
-                )
-                if "error" in res.json():
-                    return Response(res.json(), status=status.HTTP_400_BAD_REQUEST)
-                metadata = res.json()
+            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
-                )
+                return Response({"error": "Code is required"}, status=status.HTTP_400_BAD_REQUEST)
 
             slack_response = slack_oauth(code=code)
 
@@ -141,7 +123,9 @@ class WorkspaceIntegrationViewSet(BaseViewSet):
             is_password_autoset=True,
             is_bot=True,
             first_name=integration.title,
-            avatar=integration.avatar_url if integration.avatar_url is not None else "",
+            avatar=integration.avatar_url
+            if integration.avatar_url is not None
+            else "",
         )
 
         # Create an API Token for the bot user
@@ -177,7 +161,9 @@ class WorkspaceIntegrationViewSet(BaseViewSet):
         )
 
         if workspace_integration.integration.provider == "github":
-            installation_id = workspace_integration.config.get("installation_id", False)
+            installation_id = workspace_integration.config.get(
+                "installation_id", False
+            )
             if installation_id:
                 delete_github_installation(installation_id=installation_id)
 

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

@@ -1,15 +1,8 @@
-# Python imports
-import json
-import requests
-
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
 from sentry_sdk import capture_exception
 
-# Django imports
-from django.conf import settings
-
 # Module imports
 from plane.app.views import BaseViewSet, BaseAPIView
 from plane.db.models import (
@@ -42,32 +35,19 @@ class GithubRepositoriesEndpoint(BaseAPIView):
             workspace__slug=slug, pk=workspace_integration_id
         )
 
-        installation_id = workspace_integration.config.get("installation_id")
-
-        if not installation_id:
+        if workspace_integration.integration.provider != "github":
             return Response(
                 {"error": "Not a github integration"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-        # Push it to segway
-        if settings.SEGWAY_BASE_URL:
-            headers = {
-                "Content-Type": "application/json",
-                "x-api-key": settings.SEGWAY_KEY,
-            }
-            data = {
-                "installationId": installation_id,
-                "page": page,
-            }
-            res = requests.post(
-                f"{settings.SEGWAY_BASE_URL}/api/github/repos",
-                data=json.dumps(data),
-                headers=headers,
-            )
-            if "error" in res.json():
-                return Response(res.json(), status=status.HTTP_400_BAD_REQUEST)
-            else:
-                return Response(res.json(), status=status.HTTP_200_OK)
+
+        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):

apiserver/plane/app/views/issue.py

@@ -4,7 +4,6 @@ import random
 from itertools import chain
 
 # Django imports
-from django.db import models
 from django.utils import timezone
 from django.db.models import (
     Prefetch,
@@ -133,7 +132,6 @@ class IssueViewSet(WebhookMixin, BaseViewSet):
 
     @method_decorator(gzip_page)
     def list(self, request, slug, project_id):
-        fields = [field for field in request.GET.get("fields", "").split(",") if field]
         filters = issue_filters(request.query_params, "GET")
 
         # Custom ordering for priority and state
@@ -217,9 +215,25 @@ class IssueViewSet(WebhookMixin, BaseViewSet):
         else:
             issue_queryset = issue_queryset.order_by(order_by_param)
 
-        issues = IssueLiteSerializer(issue_queryset, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(issue_dict, status=status.HTTP_200_OK)
+        issues = IssueLiteSerializer(issue_queryset, many=True).data
+
+        ## Grouping the results
+        group_by = request.GET.get("group_by", False)
+        sub_group_by = request.GET.get("sub_group_by", False)
+        if sub_group_by and sub_group_by == group_by:
+            return Response(
+                {"error": "Group by and sub group by cannot be same"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if group_by:
+            grouped_results = group_results(issues, group_by, sub_group_by)
+            return Response(
+                grouped_results,
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(issues, status=status.HTTP_200_OK)
 
     def create(self, request, slug, project_id):
         project = Project.objects.get(pk=project_id)
@@ -297,6 +311,104 @@ class IssueViewSet(WebhookMixin, BaseViewSet):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
+class IssueListEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get(self, request, slug, project_id):
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
+        filters = issue_filters(request.query_params, "GET")
+
+        issue_queryset = (
+            Issue.objects.filter(workspace__slug=slug, project_id=project_id)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("state")
+            .select_related("parent")
+            .prefetch_related("assignees")
+            .prefetch_related("labels")
+            .prefetch_related(
+                Prefetch(
+                    "issue_reactions",
+                    queryset=IssueReaction.objects.select_related("actor"),
+                )
+            )
+            .filter(**filters)
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(module_id=F("issue_module__module_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .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")
+            )
+            .distinct()
+        )
+
+        serializer = IssueLiteSerializer(
+            issue_queryset, many=True, fields=fields if fields else None
+        )
+
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class IssueListGroupedEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get(self, request, slug, project_id):
+        filters = issue_filters(request.query_params, "GET")
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
+
+        issue_queryset = (
+            Issue.objects.filter(workspace__slug=slug, project_id=project_id)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("state")
+            .select_related("parent")
+            .prefetch_related("assignees")
+            .prefetch_related("labels")
+            .prefetch_related(
+                Prefetch(
+                    "issue_reactions",
+                    queryset=IssueReaction.objects.select_related("actor"),
+                )
+            )
+            .filter(**filters)
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(module_id=F("issue_module__module_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .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")
+            )
+            .distinct()
+        )
+
+        issues = IssueLiteSerializer(issue_queryset, many=True, fields=fields if fields else None).data
+        issue_dict = {str(issue["id"]): issue for issue in issues}
+        return Response(
+            issue_dict,
+            status=status.HTTP_200_OK,
+        )
+
+
 class UserWorkSpaceIssues(BaseAPIView):
     @method_decorator(gzip_page)
     def get(self, request, slug):
@@ -484,7 +596,7 @@ class IssueActivityEndpoint(BaseAPIView):
 class IssueCommentViewSet(WebhookMixin, BaseViewSet):
     serializer_class = IssueCommentSerializer
     model = IssueComment
-    webhook_event = "issue_comment"
+    webhook_event = "issue-comment"
     permission_classes = [
         ProjectLitePermission,
     ]
@@ -971,7 +1083,6 @@ class IssueArchiveViewSet(BaseViewSet):
 
     @method_decorator(gzip_page)
     def list(self, request, slug, project_id):
-        fields = [field for field in request.GET.get("fields", "").split(",") if field]
         filters = issue_filters(request.query_params, "GET")
         show_sub_issues = request.GET.get("show_sub_issues", "true")
 
@@ -1062,9 +1173,14 @@ class IssueArchiveViewSet(BaseViewSet):
             else issue_queryset.filter(parent__isnull=True)
         )
 
-        issues = IssueLiteSerializer(issue_queryset, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(issue_dict, status=status.HTTP_200_OK)
+        issues = IssueLiteSerializer(issue_queryset, many=True).data
+
+        ## Grouping the results
+        group_by = request.GET.get("group_by", False)
+        if group_by:
+            return Response(group_results(issues, group_by), status=status.HTTP_200_OK)
+
+        return Response(issues, status=status.HTTP_200_OK)
 
     def retrieve(self, request, slug, project_id, pk=None):
         issue = Issue.objects.get(
@@ -1464,7 +1580,6 @@ class IssueDraftViewSet(BaseViewSet):
     @method_decorator(gzip_page)
     def list(self, request, slug, project_id):
         filters = issue_filters(request.query_params, "GET")
-        fields = [field for field in request.GET.get("fields", "").split(",") if field]
 
         # Custom ordering for priority and state
         priority_order = ["urgent", "high", "medium", "low", "none"]
@@ -1547,9 +1662,18 @@ class IssueDraftViewSet(BaseViewSet):
         else:
             issue_queryset = issue_queryset.order_by(order_by_param)
 
-        issues = IssueLiteSerializer(issue_queryset, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(issue_dict, status=status.HTTP_200_OK)
+        issues = IssueLiteSerializer(issue_queryset, many=True).data
+
+        ## Grouping the results
+        group_by = request.GET.get("group_by", False)
+        if group_by:
+            grouped_results = group_results(issues, group_by)
+            return Response(
+                grouped_results,
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(issues, status=status.HTTP_200_OK)
 
     def create(self, request, slug, project_id):
         project = Project.objects.get(pk=project_id)
@@ -1626,4 +1750,4 @@ class IssueDraftViewSet(BaseViewSet):
             current_instance=current_instance,
             epoch=int(timezone.now().timestamp()),
         )
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/app/views/module.py

@@ -283,12 +283,9 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
-class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
+class ModuleIssueViewSet(BaseViewSet):
     serializer_class = ModuleIssueSerializer
     model = ModuleIssue
-    webhook_event = "module_issue"
-    bulk = True
-
 
     filterset_fields = [
         "issue__labels__id",
@@ -324,8 +321,9 @@ class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
 
     @method_decorator(gzip_page)
     def list(self, request, slug, project_id, module_id):
-        fields = [field for field in request.GET.get("fields", "").split(",") if field]
         order_by = request.GET.get("order_by", "created_at")
+        group_by = request.GET.get("group_by", False)
+        sub_group_by = request.GET.get("sub_group_by", False)
         filters = issue_filters(request.query_params, "GET")
         issues = (
             Issue.issue_objects.filter(issue_module__module_id=module_id)
@@ -359,9 +357,24 @@ class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
                 .values("count")
             )
         )
-        issues = IssueStateSerializer(issues, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(issue_dict, status=status.HTTP_200_OK)
+        issues_data = IssueStateSerializer(issues, many=True).data
+
+        if sub_group_by and sub_group_by == group_by:
+            return Response(
+                {"error": "Group by and sub group by cannot be same"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if group_by:
+            grouped_results = group_results(issues_data, group_by, sub_group_by)
+            return Response(
+                grouped_results,
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(
+            issues_data, status=status.HTTP_200_OK
+        )
 
     def create(self, request, slug, project_id, module_id):
         issues = request.data.get("issues", [])
@@ -448,6 +461,7 @@ class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
         module_issue = ModuleIssue.objects.get(
             workspace__slug=slug, project_id=project_id, module_id=module_id, pk=pk
         )
+        module_issue.delete()
         issue_activity.delay(
             type="module.activity.deleted",
             requested_data=json.dumps(
@@ -457,15 +471,63 @@ class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
                 }
             ),
             actor_id=str(request.user.id),
-            issue_id=str(module_issue.issue_id),
+            issue_id=str(pk),
             project_id=str(project_id),
             current_instance=None,
             epoch=int(timezone.now().timestamp()),
         )
-        module_issue.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
+class ModuleIssueGroupedEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def get(self, request, slug, project_id, module_id):
+        filters = issue_filters(request.query_params, "GET")
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
+
+        issues = (
+            Issue.issue_objects.filter(issue_module__module_id=module_id)
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(bridge_id=F("issue_module__id"))
+            .filter(project_id=project_id)
+            .filter(workspace__slug=slug)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("state")
+            .select_related("parent")
+            .prefetch_related("assignees")
+            .prefetch_related("labels")
+            .filter(**filters)
+            .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")
+            )
+        )
+
+        issues = IssueStateSerializer(issues, many=True, fields=fields if fields else None).data
+        issue_dict = {str(issue["id"]): issue for issue in issues}
+        return Response(
+            issue_dict,
+            status=status.HTTP_200_OK,
+        )
+
 class ModuleLinkViewSet(BaseViewSet):
     permission_classes = [
         ProjectEntityPermission,
@@ -521,4 +583,4 @@ class ModuleFavoriteViewSet(BaseViewSet):
             module_id=module_id,
         )
         module_favorite.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/app/views/oauth.py

@@ -2,6 +2,7 @@
 import uuid
 import requests
 import os
+from requests.exceptions import RequestException
 
 # Django imports
 from django.utils import timezone
@@ -28,10 +29,7 @@ from plane.db.models import (
     ProjectMemberInvite,
     ProjectMember,
 )
-from plane.bgtasks.event_tracking_task import auth_events
 from .base import BaseAPIView
-from plane.license.models import Instance
-from plane.license.utils.instance_value import get_configuration_value
 
 
 def get_tokens_for_user(user):
@@ -86,14 +84,7 @@ def get_access_token(request_token: str, client_id: str) -> str:
     if not request_token:
         raise ValueError("The request token has to be supplied!")
 
-    (CLIENT_SECRET,) = get_configuration_value(
-        [
-            {
-                "key": "GITHUB_CLIENT_SECRET",
-                "default": os.environ.get("GITHUB_CLIENT_SECRET", None),
-            },
-        ]
-    )
+    CLIENT_SECRET = os.environ.get("GITHUB_CLIENT_SECRET")
 
     url = f"https://github.com/login/oauth/access_token?client_id={client_id}&client_secret={CLIENT_SECRET}&code={request_token}"
     headers = {"accept": "application/json"}
@@ -142,31 +133,10 @@ class OauthEndpoint(BaseAPIView):
 
     def post(self, request):
         try:
-            # Check if instance is registered or not
-            instance = Instance.objects.first()
-            if instance is None and not instance.is_setup_done:
-                return Response(
-                    {"error": "Instance is not configured"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
             medium = request.data.get("medium", False)
             id_token = request.data.get("credential", False)
             client_id = request.data.get("clientId", False)
 
-            GOOGLE_CLIENT_ID, GITHUB_CLIENT_ID = get_configuration_value(
-                [
-                    {
-                        "key": "GOOGLE_CLIENT_ID",
-                        "default": os.environ.get("GOOGLE_CLIENT_ID"),
-                    },
-                    {
-                        "key": "GITHUB_CLIENT_ID",
-                        "default": os.environ.get("GITHUB_CLIENT_ID"),
-                    },
-                ]
-            )
-
             if not medium or not id_token:
                 return Response(
                     {
@@ -176,19 +146,9 @@ class OauthEndpoint(BaseAPIView):
                 )
 
             if medium == "google":
-                if not GOOGLE_CLIENT_ID:
-                    return Response(
-                        {"error": "Google login is not configured"},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
                 data = validate_google_token(id_token, client_id)
 
             if medium == "github":
-                if not GITHUB_CLIENT_ID:
-                    return Response(
-                        {"error": "Github login is not configured"},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
                 access_token = get_access_token(id_token, client_id)
                 data = get_user_data(access_token)
 
@@ -214,7 +174,15 @@ class OauthEndpoint(BaseAPIView):
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            user.is_active = True
+            ## Login Case
+            if not user.is_active:
+                return Response(
+                    {
+                        "error": "Your account has been deactivated. Please contact your site administrator."
+                    },
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+
             user.last_active = timezone.now()
             user.last_login_time = timezone.now()
             user.last_login_ip = request.META.get("REMOTE_ADDR")
@@ -271,8 +239,7 @@ class OauthEndpoint(BaseAPIView):
                         else 15,
                         member=user,
                         created_by_id=project_member_invite.created_by_id,
-                    )
-                    for project_member_invite in project_member_invites
+                    ) for project_member_invite in project_member_invites
                 ],
                 ignore_conflicts=True,
             )
@@ -289,17 +256,29 @@ class OauthEndpoint(BaseAPIView):
                     "last_login_at": timezone.now(),
                 },
             )
-
-            # Send event
-            auth_events.delay(
-                user=user.id,
-                email=email,
-                user_agent=request.META.get("HTTP_USER_AGENT"),
-                ip=request.META.get("REMOTE_ADDR"),
-                event_name="SIGN_IN",
-                medium=medium.upper(),
-                first_time=False,
-            )
+            try:
+                if settings.ANALYTICS_BASE_API:
+                    _ = requests.post(
+                        settings.ANALYTICS_BASE_API,
+                        headers={
+                            "Content-Type": "application/json",
+                            "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
+                        },
+                        json={
+                            "event_id": uuid.uuid4().hex,
+                            "event_data": {
+                                "medium": f"oauth-{medium}",
+                            },
+                            "user": {"email": email, "id": str(user.id)},
+                            "device_ctx": {
+                                "ip": request.META.get("REMOTE_ADDR"),
+                                "user_agent": request.META.get("HTTP_USER_AGENT"),
+                            },
+                            "event_type": "SIGN_IN",
+                        },
+                    )
+            except RequestException as e:
+                capture_exception(e)
 
             access_token, refresh_token = get_tokens_for_user(user)
 
@@ -310,26 +289,7 @@ class OauthEndpoint(BaseAPIView):
             return Response(data, status=status.HTTP_200_OK)
 
         except User.DoesNotExist:
-            (ENABLE_SIGNUP,) = get_configuration_value(
-                [
-                    {
-                        "key": "ENABLE_SIGNUP",
-                        "default": os.environ.get("ENABLE_SIGNUP", "0"),
-                    }
-                ]
-            )
-            if (
-                ENABLE_SIGNUP == "0"
-                and not WorkspaceMemberInvite.objects.filter(
-                    email=email,
-                ).exists()
-            ):
-                return Response(
-                    {
-                        "error": "New account creation is disabled. Please contact your site administrator"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
+            ## Signup Case
 
             username = uuid.uuid4().hex
 
@@ -345,7 +305,7 @@ class OauthEndpoint(BaseAPIView):
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            user = User.objects.create(
+            user = User(
                 username=username,
                 email=email,
                 mobile_number=mobile_number,
@@ -356,6 +316,7 @@ class OauthEndpoint(BaseAPIView):
             )
 
             user.set_password(uuid.uuid4().hex)
+            user.is_password_autoset = True
             user.last_active = timezone.now()
             user.last_login_time = timezone.now()
             user.last_login_ip = request.META.get("REMOTE_ADDR")
@@ -412,8 +373,7 @@ class OauthEndpoint(BaseAPIView):
                         else 15,
                         member=user,
                         created_by_id=project_member_invite.created_by_id,
-                    )
-                    for project_member_invite in project_member_invites
+                    ) for project_member_invite in project_member_invites
                 ],
                 ignore_conflicts=True,
             )
@@ -421,16 +381,29 @@ class OauthEndpoint(BaseAPIView):
             workspace_member_invites.delete()
             project_member_invites.delete()
 
-            # Send event
-            auth_events.delay(
-                user=user.id,
-                email=email,
-                user_agent=request.META.get("HTTP_USER_AGENT"),
-                ip=request.META.get("REMOTE_ADDR"),
-                event_name="SIGN_IN",
-                medium=medium.upper(),
-                first_time=True,
-            )
+            try:
+                if settings.ANALYTICS_BASE_API:
+                    _ = requests.post(
+                        settings.ANALYTICS_BASE_API,
+                        headers={
+                            "Content-Type": "application/json",
+                            "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
+                        },
+                        json={
+                            "event_id": uuid.uuid4().hex,
+                            "event_data": {
+                                "medium": f"oauth-{medium}",
+                            },
+                            "user": {"email": email, "id": str(user.id)},
+                            "device_ctx": {
+                                "ip": request.META.get("REMOTE_ADDR"),
+                                "user_agent": request.META.get("HTTP_USER_AGENT"),
+                            },
+                            "event_type": "SIGN_UP",
+                        },
+                    )
+            except RequestException as e:
+                capture_exception(e)
 
             SocialLoginConnection.objects.update_or_create(
                 medium=medium,
@@ -447,5 +420,4 @@ class OauthEndpoint(BaseAPIView):
                 "access_token": access_token,
                 "refresh_token": refresh_token,
             }
-
             return Response(data, status=status.HTTP_201_CREATED)

apiserver/plane/app/views/page.py

@@ -22,7 +22,6 @@ from plane.db.models import (
     IssueAssignee,
     IssueActivity,
     PageLog,
-    ProjectMember,
 )
 from plane.app.serializers import (
     PageSerializer,
@@ -137,19 +136,27 @@ class PageViewSet(BaseViewSet):
             )
 
     def lock(self, request, slug, project_id, page_id):
-        page = Page.objects.filter(
-            pk=page_id, workspace__slug=slug, project_id=project_id
-        ).first()
+        page = Page.objects.get(pk=page_id, workspace__slug=slug, project_id=project_id)
+
+        # only the owner can lock the page
+        if request.user.id != page.owned_by_id:
+            return Response(
+                {"error": "Only the page owner can lock the page"},
+            )
 
         page.is_locked = True
         page.save()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
     def unlock(self, request, slug, project_id, page_id):
-        page = Page.objects.filter(
-            pk=page_id, workspace__slug=slug, project_id=project_id
-        ).first()
+        page = Page.objects.get(pk=page_id, workspace__slug=slug, project_id=project_id)
 
+        # only the owner can unlock the page
+        if request.user.id != page.owned_by_id:
+            return Response(
+                {"error": "Only the page owner can unlock the page"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
         page.is_locked = False
         page.save()
 
@@ -157,23 +164,75 @@ class PageViewSet(BaseViewSet):
 
     def list(self, request, slug, project_id):
         queryset = self.get_queryset().filter(archived_at__isnull=True)
+        page_view = request.GET.get("page_view", False)
+
+        if not page_view:
+            return Response(
+                {"error": "Page View parameter is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # All Pages
+        if page_view == "all":
+            return Response(
+                PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK
+            )
+
+        # Recent pages
+        if page_view == "recent":
+            current_time = date.today()
+            day_before = current_time - timedelta(days=1)
+            todays_pages = queryset.filter(updated_at__date=date.today())
+            yesterdays_pages = queryset.filter(updated_at__date=day_before)
+            earlier_this_week = queryset.filter(
+                updated_at__date__range=(
+                    (timezone.now() - timedelta(days=7)),
+                    (timezone.now() - timedelta(days=2)),
+                )
+            )
+            return Response(
+                {
+                    "today": PageSerializer(todays_pages, many=True).data,
+                    "yesterday": PageSerializer(yesterdays_pages, many=True).data,
+                    "earlier_this_week": PageSerializer(
+                        earlier_this_week, many=True
+                    ).data,
+                },
+                status=status.HTTP_200_OK,
+            )
+
+        # Favorite Pages
+        if page_view == "favorite":
+            queryset = queryset.filter(is_favorite=True)
+            return Response(
+                PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK
+            )
+
+        # My pages
+        if page_view == "created_by_me":
+            queryset = queryset.filter(owned_by=request.user)
+            return Response(
+                PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK
+            )
+
+        # Created by other Pages
+        if page_view == "created_by_other":
+            queryset = queryset.filter(~Q(owned_by=request.user), access=0)
+            return Response(
+                PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK
+            )
+
         return Response(
-            PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK
+            {"error": "No matching view found"}, status=status.HTTP_400_BAD_REQUEST
         )
 
     def archive(self, request, slug, project_id, page_id):
         page = Page.objects.get(pk=page_id, workspace__slug=slug, project_id=project_id)
 
-        # only the owner and admin can archive the page
-        if (
-            ProjectMember.objects.filter(
-                project_id=project_id, member=request.user, is_active=True, role__gt=20
-            ).exists()
-            or request.user.id != page.owned_by_id
-        ):
+        if page.owned_by_id != request.user.id:
             return Response(
-                {"error": "Only the owner and admin can archive the page"},
-                status=status.HTTP_400_BAD_REQUEST,
+                {"error": "Only the owner of the page can archive a page"},
+                status=status.HTTP_204_NO_CONTENT,
             )
 
         unarchive_archive_page_and_descendants(page_id, datetime.now())
@@ -183,66 +242,34 @@ class PageViewSet(BaseViewSet):
     def unarchive(self, request, slug, project_id, page_id):
         page = Page.objects.get(pk=page_id, workspace__slug=slug, project_id=project_id)
 
-        # only the owner and admin can un archive the page
-        if (
-            ProjectMember.objects.filter(
-                project_id=project_id, member=request.user, is_active=True, role__gt=20
-            ).exists()
-            or request.user.id != page.owned_by_id
-        ):
+        if page.owned_by_id != request.user.id:
             return Response(
-                {"error": "Only the owner and admin can un archive the page"},
+                {"error": "Only the owner of the page can unarchive a page"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-
+        
         # if parent page is archived then the page will be un archived breaking the hierarchy
         if page.parent_id and page.parent.archived_at:
             page.parent = None
-            page.save(update_fields=["parent"])
+            page.save(update_fields=['parent'])
 
         unarchive_archive_page_and_descendants(page_id, 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 = (
+            Page.objects.filter(
+                project_id=project_id,
+                workspace__slug=slug,
+            )
+            .filter(archived_at__isnull=False)
+        )
 
         return Response(
             PageSerializer(pages, many=True).data, 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)
-
-        # only the owner and admin can delete the page
-        if (
-            ProjectMember.objects.filter(
-                project_id=project_id, member=request.user, is_active=True, role__gt=20
-            ).exists()
-            or request.user.id != page.owned_by_id
-        ):
-            return Response(
-                {"error": "Only the owner and admin can delete the page"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if page.archived_at is None:
-            return Response(
-                {"error": "The page should be archived before deleting"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # remove parent from all the children
-        _ = Page.objects.filter(
-            parent_id=pk, project_id=project_id, workspace__slug=slug
-        ).update(parent=None)
-
-        page.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
 
 class PageFavoriteViewSet(BaseViewSet):
     permission_classes = [
@@ -279,7 +306,6 @@ class PageFavoriteViewSet(BaseViewSet):
         page_favorite.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
-
 class PageLogEndpoint(BaseAPIView):
     permission_classes = [
         ProjectEntityPermission,
@@ -322,6 +348,36 @@ class PageLogEndpoint(BaseAPIView):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
+class CreateIssueFromBlockEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def post(self, request, slug, project_id, page_id):
+        page = Page.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            pk=page_id,
+        )
+        issue = Issue.objects.create(
+            name=request.data.get("name"),
+            project_id=project_id,
+        )
+        _ = IssueAssignee.objects.create(
+            issue=issue, assignee=request.user, project_id=project_id
+        )
+
+        _ = IssueActivity.objects.create(
+            issue=issue,
+            actor=request.user,
+            project_id=project_id,
+            comment=f"created the issue from {page.name} block",
+            verb="created",
+        )
+
+        return Response(IssueLiteSerializer(issue).data, status=status.HTTP_200_OK)
+
+
 class SubPagesEndpoint(BaseAPIView):
     permission_classes = [
         ProjectEntityPermission,
@@ -341,4 +397,4 @@ class SubPagesEndpoint(BaseAPIView):
         )
         return Response(
             SubPageSerializer(pages, many=True).data, status=status.HTTP_200_OK
-        )
+        )

apiserver/plane/app/views/project.py

@@ -26,7 +26,7 @@ from rest_framework import serializers
 from rest_framework.permissions import AllowAny
 
 # Module imports
-from .base import BaseViewSet, BaseAPIView, WebhookMixin
+from .base import BaseViewSet, BaseAPIView, WebhookMixin, AnalyticsMixin
 from plane.app.serializers import (
     ProjectSerializer,
     ProjectListSerializer,
@@ -39,10 +39,8 @@ from plane.app.serializers import (
 )
 
 from plane.app.permissions import (
-    WorkspaceUserPermission,
     ProjectBasePermission,
     ProjectMemberPermission,
-    ProjectLitePermission,
 )
 
 from plane.db.models import (
@@ -66,10 +64,11 @@ from plane.db.models import (
 from plane.bgtasks.project_invitation_task import project_invitation
 
 
-class ProjectViewSet(WebhookMixin, BaseViewSet):
+class ProjectViewSet(WebhookMixin, AnalyticsMixin, BaseViewSet):
     serializer_class = ProjectSerializer
     model = Project
     webhook_event = "project"
+    analytic_event = "project"
 
     permission_classes = [
         ProjectBasePermission,
@@ -145,16 +144,6 @@ class ProjectViewSet(WebhookMixin, BaseViewSet):
                     )
                 )
             )
-            .prefetch_related(
-                Prefetch(
-                    "project_projectmember",
-                    queryset=ProjectMember.objects.filter(
-                        workspace__slug=self.kwargs.get("slug"),
-                        is_active=True,
-                    ).select_related("member"),
-                    to_attr="members_list",
-                )
-            )
             .distinct()
         )
 
@@ -170,6 +159,15 @@ class ProjectViewSet(WebhookMixin, BaseViewSet):
         projects = (
             self.get_queryset()
             .annotate(sort_order=Subquery(sort_order_query))
+            .prefetch_related(
+                Prefetch(
+                    "project_projectmember",
+                    queryset=ProjectMember.objects.filter(
+                        workspace__slug=slug,
+                        is_active=True,
+                    ).select_related("member"),
+                )
+            )
             .order_by("sort_order", "name")
         )
         if request.GET.get("per_page", False) and request.GET.get("cursor", False):
@@ -391,7 +389,7 @@ class ProjectInvitationsViewset(BaseViewSet):
                 {"error": "You cannot invite a user with higher role"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-
+        
         workspace = Workspace.objects.get(slug=slug)
 
         project_invitations = []
@@ -427,7 +425,7 @@ class ProjectInvitationsViewset(BaseViewSet):
         project_invitations = ProjectMemberInvite.objects.bulk_create(
             project_invitations, batch_size=10, ignore_conflicts=True
         )
-        current_site = request.META.get("HTTP_ORIGIN")
+        current_site = request.META.get('HTTP_ORIGIN')
 
         # Send invitations
         for invitation in project_invitations:
@@ -472,13 +470,6 @@ class UserProjectInvitationsViewset(BaseViewSet):
         workspace_role = workspace_member.role
         workspace = workspace_member.workspace
 
-        # If the user was already part of workspace
-        _ = ProjectMember.objects.filter(
-            workspace__slug=slug,
-            project_id__in=project_ids,
-            member=request.user,
-        ).update(is_active=True)
-
         ProjectMember.objects.bulk_create(
             [
                 ProjectMember(
@@ -603,18 +594,6 @@ class ProjectMemberViewSet(BaseViewSet):
         ProjectMemberPermission,
     ]
 
-    def get_permissions(self):
-        if self.action == "leave":
-            self.permission_classes = [
-                ProjectLitePermission,
-            ]
-        else:
-            self.permission_classes = [
-                ProjectMemberPermission,
-            ]
-
-        return super(ProjectMemberViewSet, self).get_permissions()
-
     search_fields = [
         "member__display_name",
         "member__first_name",
@@ -679,25 +658,6 @@ class ProjectMemberViewSet(BaseViewSet):
                 )
             )
 
-            # Check if the user is already a member of the project and is inactive
-            if ProjectMember.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                member_id=member.get("member_id"),
-                is_active=False,
-            ).exists():
-                member_detail = ProjectMember.objects.get(
-                    workspace__slug=slug,
-                    project_id=project_id,
-                    member_id=member.get("member_id"),
-                    is_active=False,
-                )
-                # Check if the user has not deactivated the account
-                user = User.objects.filter(pk=member.get("member_id")).first()
-                if user.is_active:
-                    member_detail.is_active = True
-                    member_detail.save(update_fields=["is_active"])
-
         project_members = ProjectMember.objects.bulk_create(
             bulk_project_members,
             batch_size=10,
@@ -1010,20 +970,13 @@ class ProjectPublicCoverImagesEndpoint(BaseAPIView):
 
     def get(self, request):
         files = []
-        s3_client_params = {
-            "service_name": "s3",
-            "aws_access_key_id": settings.AWS_ACCESS_KEY_ID,
-            "aws_secret_access_key": settings.AWS_SECRET_ACCESS_KEY,
-        }
-
-        # Use AWS_S3_ENDPOINT_URL if it is present in the settings
-        if hasattr(settings, "AWS_S3_ENDPOINT_URL") and settings.AWS_S3_ENDPOINT_URL:
-            s3_client_params["endpoint_url"] = settings.AWS_S3_ENDPOINT_URL
-
-        s3 = boto3.client(**s3_client_params)
-
+        s3 = boto3.client(
+            "s3",
+            aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
+            aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
+        )
         params = {
-            "Bucket": settings.AWS_STORAGE_BUCKET_NAME,
+            "Bucket": settings.AWS_S3_BUCKET_NAME,
             "Prefix": "static/project-cover/",
         }
 
@@ -1034,19 +987,9 @@ class ProjectPublicCoverImagesEndpoint(BaseAPIView):
                 if not content["Key"].endswith(
                     "/"
                 ):  # This line ensures we're only getting files, not "sub-folders"
-                    if (
-                        hasattr(settings, "AWS_S3_CUSTOM_DOMAIN")
-                        and settings.AWS_S3_CUSTOM_DOMAIN
-                        and hasattr(settings, "AWS_S3_URL_PROTOCOL")
-                        and settings.AWS_S3_URL_PROTOCOL
-                    ):
-                        files.append(
-                            f"{settings.AWS_S3_URL_PROTOCOL}//{settings.AWS_S3_CUSTOM_DOMAIN}/{content['Key']}"
-                        )
-                    else:
-                        files.append(
-                            f"https://{settings.AWS_STORAGE_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
-                        )
+                    files.append(
+                        f"https://{settings.AWS_S3_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
+                    )
 
         return Response(files, status=status.HTTP_200_OK)
 
@@ -1098,21 +1041,4 @@ class ProjectDeployBoardViewSet(BaseViewSet):
         project_deploy_board.save()
 
         serializer = ProjectDeployBoardSerializer(project_deploy_board)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-
-class UserProjectRolesEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkspaceUserPermission,
-    ]
-
-    def get(self, request, slug):
-        project_members = ProjectMember.objects.filter(
-            workspace__slug=slug,
-            member_id=request.user.id,
-        ).values("project_id", "role")
-
-        project_members = {
-            str(member["project_id"]): member["role"] for member in project_members
-        }
-        return Response(project_members, status=status.HTTP_200_OK)
+        return Response(serializer.data, status=status.HTTP_200_OK)

apiserver/plane/app/views/state.py

@@ -77,7 +77,7 @@ class StateViewSet(BaseViewSet):
         )
 
         if state.default:
-            return Response({"error": "Default state cannot be deleted"}, status=status.HTTP_400_BAD_REQUEST)
+            return Response({"error": "Default state cannot be deleted"}, status=False)
 
         # Check for any issues in the state
         issue_exist = Issue.issue_objects.filter(state=pk).exists()
@@ -89,4 +89,4 @@ class StateViewSet(BaseViewSet):
             )
 
         state.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/app/views/user.py

@@ -12,14 +12,11 @@ from plane.app.serializers import (
 )
 
 from plane.app.views.base import BaseViewSet, BaseAPIView
-from plane.db.models import User, IssueActivity, WorkspaceMember, ProjectMember
+from plane.db.models import User, IssueActivity, WorkspaceMember
 from plane.license.models import Instance, InstanceAdmin
 from plane.utils.paginator import BasePaginator
 
 
-from django.db.models import Q, F, Count, Case, When, IntegerField
-
-
 class UserEndpoint(BaseViewSet):
     serializer_class = UserSerializer
     model = User
@@ -48,83 +45,16 @@ class UserEndpoint(BaseViewSet):
     def deactivate(self, request):
         # Check all workspace user is active
         user = self.get_object()
-
-        # Instance admin check
-        if InstanceAdmin.objects.filter(user=user).exists():
-            return Response({"error": "You cannot deactivate your account since you are an instance admin"}, status=status.HTTP_400_BAD_REQUEST)
-
-        projects_to_deactivate = []
-        workspaces_to_deactivate = []
-
-        projects = ProjectMember.objects.filter(
-            member=request.user, is_active=True
-        ).annotate(
-            other_admin_exists=Count(
-                Case(
-                    When(Q(role=20, is_active=True) & ~Q(member=request.user), then=1),
-                    default=0,
-                    output_field=IntegerField(),
-                )
-            ),
-            total_members=Count("id"),
-        )
-
-        for project in projects:
-            if project.other_admin_exists > 0 or (project.total_members == 1):
-                project.is_active = False
-                projects_to_deactivate.append(project)
-            else:
-                return Response(
-                    {
-                        "error": "You cannot deactivate account as you are the only admin in some projects."
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-        workspaces = WorkspaceMember.objects.filter(
-            member=request.user, is_active=True
-        ).annotate(
-            other_admin_exists=Count(
-                Case(
-                    When(Q(role=20, is_active=True) & ~Q(member=request.user), then=1),
-                    default=0,
-                    output_field=IntegerField(),
-                )
-            ),
-            total_members=Count("id"),
-        )
-
-        for workspace in workspaces:
-            if workspace.other_admin_exists > 0 or (workspace.total_members == 1):
-                workspace.is_active = False
-                workspaces_to_deactivate.append(workspace)
-            else:
-                return Response(
-                    {
-                        "error": "You cannot deactivate account as you are the only admin in some workspaces."
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-        ProjectMember.objects.bulk_update(
-            projects_to_deactivate, ["is_active"], batch_size=100
-        )
-
-        WorkspaceMember.objects.bulk_update(
-            workspaces_to_deactivate, ["is_active"], batch_size=100
-        )
+        if WorkspaceMember.objects.filter(member=request.user, is_active=True).exists():
+            return Response(
+                {
+                    "error": "User cannot deactivate account as user is active in some workspaces"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
 
         # Deactivate the user
         user.is_active = False
-        user.last_workspace_id = None
-        user.is_tour_completed = False
-        user.is_onboarded = False
-        user.onboarding_step = {
-            "workspace_join": False,
-            "profile_complete": False,
-            "workspace_create": False,
-            "workspace_invite": False,
-        }
         user.save()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
@@ -146,10 +76,10 @@ class UpdateUserTourCompletedEndpoint(BaseAPIView):
 
 
 class UserActivityEndpoint(BaseAPIView, BasePaginator):
-    def get(self, request):
-        queryset = IssueActivity.objects.filter(actor=request.user).select_related(
-            "actor", "workspace", "issue", "project"
-        )
+    def get(self, request, slug):
+        queryset = IssueActivity.objects.filter(
+            actor=request.user, workspace__slug=slug
+        ).select_related("actor", "workspace", "issue", "project")
 
         return self.paginate(
             request=request,
@@ -158,4 +88,3 @@ class UserActivityEndpoint(BaseAPIView, BasePaginator):
                 issue_activities, many=True
             ).data,
         )
-

apiserver/plane/app/views/view.py

@@ -20,7 +20,7 @@ from rest_framework.response import Response
 from rest_framework import status
 
 # Module imports
-from . import BaseViewSet, BaseAPIView
+from . import BaseViewSet
 from plane.app.serializers import (
     GlobalViewSerializer,
     IssueViewSerializer,
@@ -95,7 +95,6 @@ class GlobalViewIssuesViewSet(BaseViewSet):
     @method_decorator(gzip_page)
     def list(self, request, slug):
         filters = issue_filters(request.query_params, "GET")
-        fields = [field for field in request.GET.get("fields", "").split(",") if field]
 
         # Custom ordering for priority and state
         priority_order = ["urgent", "high", "medium", "low", "none"]
@@ -178,13 +177,25 @@ class GlobalViewIssuesViewSet(BaseViewSet):
             )
         else:
             issue_queryset = issue_queryset.order_by(order_by_param)
+        issues = IssueLiteSerializer(issue_queryset, many=True).data
 
-        issues = IssueLiteSerializer(issue_queryset, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(
-            issue_dict,
-            status=status.HTTP_200_OK,
-        )
+        ## Grouping the results
+        group_by = request.GET.get("group_by", False)
+        sub_group_by = request.GET.get("sub_group_by", False)
+        if sub_group_by and sub_group_by == group_by:
+            return Response(
+                {"error": "Group by and sub group by cannot be same"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if group_by:
+            grouped_results = group_results(issues, group_by, sub_group_by)
+            return Response(
+                grouped_results,
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(issues, status=status.HTTP_200_OK)
 
 
 class IssueViewViewSet(BaseViewSet):
@@ -246,4 +257,4 @@ class IssueViewFavoriteViewSet(BaseViewSet):
             view_id=view_id,
         )
         view_favourite.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/app/views/webhook.py

@@ -20,10 +20,9 @@ class WebhookEndpoint(BaseAPIView):
 
     def post(self, request, slug):
         workspace = Workspace.objects.get(slug=slug)
+
         try:
-            serializer = WebhookSerializer(
-                data=request.data, context={"request": request}
-            )
+            serializer = WebhookSerializer(data=request.data)
             if serializer.is_valid():
                 serializer.save(workspace_id=workspace.id)
                 return Response(serializer.data, status=status.HTTP_201_CREATED)
@@ -80,7 +79,6 @@ class WebhookEndpoint(BaseAPIView):
         serializer = WebhookSerializer(
             webhook,
             data=request.data,
-            context={request: request},
             partial=True,
             fields=(
                 "id",

apiserver/plane/app/views/workspace.py

@@ -70,11 +70,11 @@ from plane.app.permissions import (
     WorkSpaceAdminPermission,
     WorkspaceEntityPermission,
     WorkspaceViewerPermission,
-    WorkspaceUserPermission,
 )
 from plane.bgtasks.workspace_invitation_task import workspace_invitation
 from plane.utils.issue_filters import issue_filters
-from plane.bgtasks.event_tracking_task import workspace_invite_event
+from plane.utils.grouper import group_results
+
 
 class WorkSpaceViewSet(BaseViewSet):
     model = Workspace
@@ -113,10 +113,7 @@ class WorkSpaceViewSet(BaseViewSet):
         return (
             self.filter_queryset(super().get_queryset().select_related("owner"))
             .order_by("name")
-            .filter(
-                workspace_member__member=self.request.user,
-                workspace_member__is_active=True,
-            )
+            .filter(workspace_member__member=self.request.user)
             .annotate(total_members=member_count)
             .annotate(total_issues=issue_count)
             .select_related("owner")
@@ -192,21 +189,17 @@ class UserWorkSpacesEndpoint(BaseAPIView):
         )
 
         workspace = (
-            Workspace.objects.prefetch_related(
-                Prefetch(
-                    "workspace_member",
-                    queryset=WorkspaceMember.objects.filter(
-                        member=request.user, is_active=True
-                    ),
+            (
+                Workspace.objects.prefetch_related(
+                    Prefetch("workspace_member", queryset=WorkspaceMember.objects.all())
                 )
+                .filter(
+                    workspace_member__member=request.user,
+                )
+                .select_related("owner")
             )
-            .select_related("owner")
             .annotate(total_members=member_count)
             .annotate(total_issues=issue_count)
-            .filter(
-                workspace_member__member=request.user, workspace_member__is_active=True
-            )
-            .distinct()
         )
 
         serializer = WorkSpaceSerializer(self.filter_queryset(workspace), many=True)
@@ -326,7 +319,7 @@ class WorkspaceInvitationsViewset(BaseViewSet):
             workspace_invitations, batch_size=10, ignore_conflicts=True
         )
 
-        current_site = request.META.get("HTTP_ORIGIN")
+        current_site = request.META.get('HTTP_ORIGIN')
 
         # Send invitations
         for invitation in workspace_invitations:
@@ -407,16 +400,6 @@ class WorkspaceJoinEndpoint(BaseAPIView):
 
                     # Delete the invitation
                     workspace_invite.delete()
-                
-                # Send event
-                workspace_invite_event.delay(
-                    user=user.id if user is not None else None,
-                    email=email,
-                    user_agent=request.META.get("HTTP_USER_AGENT"),
-                    ip=request.META.get("REMOTE_ADDR"),
-                    event_name="MEMBER_ACCEPTED",
-                    accepted_from="EMAIL",
-                )
 
                 return Response(
                     {"message": "Workspace Invitation Accepted"},
@@ -435,9 +418,7 @@ class WorkspaceJoinEndpoint(BaseAPIView):
         )
 
     def get(self, request, slug, pk):
-        workspace_invitation = WorkspaceMemberInvite.objects.get(
-            workspace__slug=slug, pk=pk
-        )
+        workspace_invitation = WorkspaceMemberInvite.objects.get(workspace__slug=slug, pk=pk)
         serializer = WorkSpaceMemberInviteSerializer(workspace_invitation)
         return Response(serializer.data, status=status.HTTP_200_OK)
 
@@ -496,18 +477,6 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         WorkspaceEntityPermission,
     ]
 
-    def get_permissions(self):
-        if self.action == "leave":
-            self.permission_classes = [
-                WorkspaceUserPermission,
-            ]
-        else:
-            self.permission_classes = [
-                WorkspaceEntityPermission,
-            ]
-
-        return super(WorkSpaceMemberViewSet, self).get_permissions()
-
     search_fields = [
         "member__display_name",
         "member__first_name",
@@ -621,7 +590,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
                 member_with_role=Count(
                     "project_projectmember",
                     filter=Q(
-                        project_projectmember__member_id=workspace_member.id,
+                        project_projectmember__member_id=request.user.id,
                         project_projectmember__role=20,
                     ),
                 ),
@@ -631,7 +600,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         ):
             return Response(
                 {
-                    "error": "User is a part of some projects where they are the only admin, they should either leave that project or promote another user to admin."
+                    "error": "User is part of some projects where they are the only admin you should leave that project first"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )
@@ -666,7 +635,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         ):
             return Response(
                 {
-                    "error": "You cannot leave the workspace as you are the only admin of the workspace you will have to either delete the workspace or promote another user to admin."
+                    "error": "You cannot leave the workspace as your the only admin of the workspace you will have to either delete the workspace or create an another admin"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )
@@ -687,7 +656,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         ):
             return Response(
                 {
-                    "error": "You are a part of some projects where you are the only admin, you should either leave the project or promote another user to admin."
+                    "error": "User is part of some projects where they are the only admin you should leave that project first"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )
@@ -1229,7 +1198,6 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug, user_id):
-        fields = [field for field in request.GET.get("fields", "").split(",") if field]
         filters = issue_filters(request.query_params, "GET")
 
         # Custom ordering for priority and state
@@ -1331,11 +1299,18 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
         else:
             issue_queryset = issue_queryset.order_by(order_by_param)
 
-        issues = IssueLiteSerializer(
-            issue_queryset, many=True, fields=fields if fields else None
-        ).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(issue_dict, status=status.HTTP_200_OK)
+        issues = IssueLiteSerializer(issue_queryset, many=True).data
+
+        ## Grouping the results
+        group_by = request.GET.get("group_by", False)
+        if group_by:
+            grouped_results = group_results(issues, group_by)
+            return Response(
+                grouped_results,
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(issues, status=status.HTTP_200_OK)
 
 
 class WorkspaceLabelsEndpoint(BaseAPIView):

apiserver/plane/authentication/apps.py

@@ -2,4 +2,4 @@ from django.apps import AppConfig
 
 
 class ApiConfig(AppConfig):
-    name = "plane.api"
+    name = "plane.authentication"

apiserver/plane/bgtasks/__init__.py

@@ -1 +0,0 @@
-from .issue_sync_task import issue_sync

apiserver/plane/bgtasks/analytic_plot_export.py

@@ -1,8 +1,6 @@
 # Python imports
 import csv
 import io
-import requests
-import json
 
 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
@@ -18,7 +16,8 @@ from sentry_sdk import capture_exception
 from plane.db.models import Issue
 from plane.utils.analytics_plot import build_graph_plot
 from plane.utils.issue_filters import issue_filters
-from plane.license.utils.instance_value import get_email_configuration
+from plane.license.models import InstanceConfiguration
+from plane.license.utils.instance_value import get_configuration_value
 
 row_mapping = {
     "state__name": "State",
@@ -33,7 +32,7 @@ row_mapping = {
     "priority": "Priority",
     "estimate": "Estimate",
     "issue_cycle__cycle_id": "Cycle",
-    "issue_module__module_id": "Module",
+    "issue_module__module_id": "Module"
 }
 
 ASSIGNEE_ID = "assignees__id"
@@ -43,7 +42,7 @@ CYCLE_ID = "issue_cycle__cycle_id"
 MODULE_ID = "issue_module__module_id"
 
 
-def send_export_email(email, slug, csv_buffer, rows):
+def send_export_email(email, slug, csv_buffer):
     """Helper function to send export email."""
     subject = "Your Export is ready"
     html_content = render_to_string("emails/exports/analytics.html", {})
@@ -51,33 +50,20 @@ def send_export_email(email, slug, csv_buffer, rows):
 
     csv_buffer.seek(0)
 
-    (
-        EMAIL_HOST,
-        EMAIL_HOST_USER,
-        EMAIL_HOST_PASSWORD,
-        EMAIL_PORT,
-        EMAIL_USE_TLS,
-        EMAIL_FROM,
-    ) = get_email_configuration()
-
+    # Configure email connection from the database
+    instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
     connection = get_connection(
-        host=EMAIL_HOST,
-        port=int(EMAIL_PORT),
-        username=EMAIL_HOST_USER,
-        password=EMAIL_HOST_PASSWORD,
-        use_tls=EMAIL_USE_TLS == "1",
+        host=get_configuration_value(instance_configuration, "EMAIL_HOST"),
+        port=int(get_configuration_value(instance_configuration, "EMAIL_PORT", "587")),
+        username=get_configuration_value(instance_configuration, "EMAIL_HOST_USER"),
+        password=get_configuration_value(instance_configuration, "EMAIL_HOST_PASSWORD"),
+        use_tls=bool(get_configuration_value(instance_configuration, "EMAIL_USE_TLS", "1")),
+        use_ssl=bool(get_configuration_value(instance_configuration, "EMAIL_USE_SSL", "0")),
     )
 
-    msg = EmailMultiAlternatives(
-        subject=subject,
-        body=text_content,
-        from_email=EMAIL_FROM,
-        to=[email],
-        connection=connection,
-    )
+    msg = EmailMultiAlternatives(subject=subject, body=text_content, from_email=get_configuration_value(instance_configuration, "EMAIL_FROM"), to=[email], connection=connection)
     msg.attach(f"{slug}-analytics.csv", csv_buffer.getvalue())
     msg.send(fail_silently=False)
-    return
 
 
 def get_assignee_details(slug, filters):
@@ -373,7 +359,7 @@ def generate_non_segmented_rows(
     return [tuple(row_zero)] + rows
 
 
-@shared_task(queue='internal_tasks')
+@shared_task
 def analytic_export_task(email, data, slug):
     try:
         filters = issue_filters(data, "POST")
@@ -445,11 +431,8 @@ def analytic_export_task(email, data, slug):
             )
 
         csv_buffer = generate_csv_from_rows(rows)
-        send_export_email(email, slug, csv_buffer, rows)
-        return
+        send_export_email(email, slug, csv_buffer)
     except Exception as e:
-        print(e)
         if settings.DEBUG:
             print(e)
         capture_exception(e)
-        return

apiserver/plane/bgtasks/email_verification_task.py

@@ -0,0 +1,57 @@
+# Django imports
+from django.core.mail import EmailMultiAlternatives, get_connection
+from django.template.loader import render_to_string
+from django.utils.html import strip_tags
+from django.conf import settings
+
+# Third party imports
+from celery import shared_task
+
+
+from sentry_sdk import capture_exception
+
+# Module imports
+from plane.license.models import InstanceConfiguration
+from plane.license.utils.instance_value import get_configuration_value
+
+@shared_task
+def email_verification(first_name, email, token, current_site):
+
+    try:
+        realtivelink = "/request-email-verification/" + "?token=" + str(token)
+        abs_url = current_site + realtivelink
+
+        from_email_string = settings.EMAIL_FROM
+
+        subject = "Verify your Email!"
+
+        context = {
+            "first_name": first_name,
+            "verification_url": abs_url,
+        }
+
+        html_content = render_to_string("emails/auth/email_verification.html", context)
+
+        text_content = strip_tags(html_content)
+
+        # Configure email connection from the database
+        instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
+        connection = get_connection(
+            host=get_configuration_value(instance_configuration, "EMAIL_HOST"),
+            port=int(get_configuration_value(instance_configuration, "EMAIL_PORT", "587")),
+            username=get_configuration_value(instance_configuration, "EMAIL_HOST_USER"),
+            password=get_configuration_value(instance_configuration, "EMAIL_HOST_PASSWORD"),
+            use_tls=bool(get_configuration_value(instance_configuration, "EMAIL_USE_TLS", "1")),
+        )
+
+        # Initiate email alternatives
+        msg = EmailMultiAlternatives(subject=subject, body=text_content, from_email=get_configuration_value(instance_configuration, "EMAIL_FROM"), to=[email], connection=connection)
+        msg.attach_alternative(html_content, "text/html")
+        msg.send()
+        return
+    except Exception as e:
+        # Print logs if in DEBUG mode
+        if settings.DEBUG:
+            print(e)
+        capture_exception(e)
+        return

apiserver/plane/bgtasks/event_tracking_task.py

@@ -1,78 +0,0 @@
-import uuid
-import os
-
-# third party imports
-from celery import shared_task
-from sentry_sdk import capture_exception
-from posthog import Posthog
-
-# module imports
-from plane.license.utils.instance_value import get_configuration_value
-
-
-def posthogConfiguration():
-    POSTHOG_API_KEY, POSTHOG_HOST = get_configuration_value(
-        [
-            {
-                "key": "POSTHOG_API_KEY",
-                "default": os.environ.get("POSTHOG_API_KEY", None),
-            },
-            {
-                "key": "POSTHOG_HOST",
-                "default": os.environ.get("POSTHOG_HOST", None),
-            },
-        ]
-    )
-    if POSTHOG_API_KEY and POSTHOG_HOST:
-        return POSTHOG_API_KEY, POSTHOG_HOST
-    else:
-        return None, None
-
-
-@shared_task(queue='internal_tasks')
-def auth_events(user, email, user_agent, ip, event_name, medium, first_time):
-    try:
-        POSTHOG_API_KEY, POSTHOG_HOST = posthogConfiguration()
-
-        if POSTHOG_API_KEY and POSTHOG_HOST:
-            posthog = Posthog(POSTHOG_API_KEY, host=POSTHOG_HOST)
-            posthog.capture(
-                email,
-                event=event_name,
-                properties={
-                        "event_id": uuid.uuid4().hex,
-                        "user": {"email": email, "id": str(user)},
-                        "device_ctx": {
-                            "ip": ip,
-                            "user_agent": user_agent,
-                        },
-                        "medium": medium,
-                        "first_time": first_time
-                }
-            )
-    except Exception as e:
-        capture_exception(e)
- 
-
-@shared_task(queue='internal_tasks')
-def workspace_invite_event(user, email, user_agent, ip, event_name, accepted_from):
-    try:
-        POSTHOG_API_KEY, POSTHOG_HOST = posthogConfiguration()
-
-        if POSTHOG_API_KEY and POSTHOG_HOST:
-            posthog = Posthog(POSTHOG_API_KEY, host=POSTHOG_HOST)
-            posthog.capture(
-                email,
-                event=event_name,
-                properties={
-                        "event_id": uuid.uuid4().hex,
-                        "user": {"email": email, "id": str(user)},
-                        "device_ctx": {
-                            "ip": ip,
-                            "user_agent": user_agent,
-                        },
-                        "accepted_from": accepted_from
-                }
-            )
-    except Exception as e:
-        capture_exception(e)

apiserver/plane/bgtasks/export_task.py

@@ -71,7 +71,7 @@ def upload_to_s3(zip_file, workspace_id, token_id, slug):
     file_name = f"{workspace_id}/export-{slug}-{token_id[:6]}-{timezone.now()}.zip"
     expires_in = 7 * 24 * 60 * 60
 
-    if settings.USE_MINIO:
+    if settings.DOCKERIZED and settings.USE_MINIO:
         s3 = boto3.client(
             "s3",
             endpoint_url=settings.AWS_S3_ENDPOINT_URL,
@@ -105,14 +105,14 @@ def upload_to_s3(zip_file, workspace_id, token_id, slug):
         )
         s3.upload_fileobj(
             zip_file,
-            settings.AWS_STORAGE_BUCKET_NAME,
+            settings.AWS_S3_BUCKET_NAME,
             file_name,
             ExtraArgs={"ACL": "public-read", "ContentType": "application/zip"},
         )
 
         presigned_url = s3.generate_presigned_url(
             "get_object",
-            Params={"Bucket": settings.AWS_STORAGE_BUCKET_NAME, "Key": file_name},
+            Params={"Bucket": settings.AWS_S3_BUCKET_NAME, "Key": file_name},
             ExpiresIn=expires_in,
         )
 
@@ -259,7 +259,7 @@ def generate_xlsx(header, project_id, issues, files):
     files.append((f"{project_id}.xlsx", xlsx_file))
 
 
-@shared_task(queue='internal_tasks')
+@shared_task
 def issue_export_task(provider, workspace_id, project_ids, token_id, multiple, slug):
     try:
         exporter_instance = ExporterHistory.objects.get(token=token_id)

apiserver/plane/bgtasks/exporter_expired_task.py

@@ -15,13 +15,13 @@ from botocore.client import Config
 from plane.db.models import ExporterHistory
 
 
-@shared_task(queue='internal_tasks')
+@shared_task
 def delete_old_s3_link():
     # Get a list of keys and IDs to process
     expired_exporter_history = ExporterHistory.objects.filter(
         Q(url__isnull=False) & Q(created_at__lte=timezone.now() - timedelta(days=8))
     ).values_list("key", "id")
-    if settings.USE_MINIO:
+    if settings.DOCKERIZED and settings.USE_MINIO:
         s3 = boto3.client(
             "s3",
             endpoint_url=settings.AWS_S3_ENDPOINT_URL,
@@ -41,9 +41,9 @@ def delete_old_s3_link():
     for file_name, exporter_id in expired_exporter_history:
         # Delete object from S3
         if file_name:
-            if settings.USE_MINIO:
+            if settings.DOCKERIZED and settings.USE_MINIO:
                 s3.delete_object(Bucket=settings.AWS_STORAGE_BUCKET_NAME, Key=file_name)
             else:
-                s3.delete_object(Bucket=settings.AWS_STORAGE_BUCKET_NAME, Key=file_name)
+                s3.delete_object(Bucket=settings.AWS_S3_BUCKET_NAME, Key=file_name)
 
         ExporterHistory.objects.filter(id=exporter_id).update(url=None)

apiserver/plane/bgtasks/file_asset_task.py

@@ -1,29 +0,0 @@
-# Python imports
-from datetime import timedelta
-
-# Django imports
-from django.utils import timezone
-from django.db.models import Q
-
-# Third party imports
-from celery import shared_task
-
-# Module imports
-from plane.db.models import FileAsset
-
-
-@shared_task(queue='internal_tasks')
-def delete_file_asset():
-
-    # file assets to delete
-    file_assets_to_delete = FileAsset.objects.filter(
-        Q(is_deleted=True) & Q(updated_at__lte=timezone.now() - timedelta(days=7))
-    )
-
-    # Delete the file from storage and the file object from the database
-    for file_asset in file_assets_to_delete:
-        # Delete the file from storage
-        file_asset.asset.delete(save=False)
-        # Delete the file object
-        file_asset.delete()
-

apiserver/plane/bgtasks/forgot_password_task.py

@@ -1,8 +1,3 @@
-# Python import
-import os
-import requests
-import json
-
 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
 from django.template.loader import render_to_string
@@ -14,53 +9,39 @@ from celery import shared_task
 from sentry_sdk import capture_exception
 
 # Module imports
-from plane.license.utils.instance_value import get_email_configuration
+from plane.license.models import InstanceConfiguration
+from plane.license.utils.instance_value import get_configuration_value
 
-
-@shared_task(queue='internal_tasks')
+@shared_task
 def forgot_password(first_name, email, uidb64, token, current_site):
+
     try:
-        relative_link = (
-            f"/accounts/password/?uidb64={uidb64}&token={token}&email={email}"
-        )
-        abs_url = str(current_site) + relative_link
+        realtivelink = f"/accounts/reset-password/?uidb64={uidb64}&token={token}"
+        abs_url = current_site + realtivelink
 
-        (
-            EMAIL_HOST,
-            EMAIL_HOST_USER,
-            EMAIL_HOST_PASSWORD,
-            EMAIL_PORT,
-            EMAIL_USE_TLS,
-            EMAIL_FROM,
-        ) = get_email_configuration()
+        from_email_string = settings.EMAIL_FROM
 
-        subject = "A new password to your Plane account has been requested"
+        subject = "Reset Your Password - Plane"
 
         context = {
             "first_name": first_name,
             "forgot_password_url": abs_url,
-            "email": email,
         }
 
         html_content = render_to_string("emails/auth/forgot_password.html", context)
 
         text_content = strip_tags(html_content)
 
+        instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
         connection = get_connection(
-            host=EMAIL_HOST,
-            port=int(EMAIL_PORT),
-            username=EMAIL_HOST_USER,
-            password=EMAIL_HOST_PASSWORD,
-            use_tls=EMAIL_USE_TLS == "1",
-        )
-
-        msg = EmailMultiAlternatives(
-            subject=subject,
-            body=text_content,
-            from_email=EMAIL_FROM,
-            to=[email],
-            connection=connection,
+            host=get_configuration_value(instance_configuration, "EMAIL_HOST"),
+            port=int(get_configuration_value(instance_configuration, "EMAIL_PORT", "587")),
+            username=get_configuration_value(instance_configuration, "EMAIL_HOST_USER"),
+            password=get_configuration_value(instance_configuration, "EMAIL_HOST_PASSWORD"),
+            use_tls=bool(get_configuration_value(instance_configuration, "EMAIL_USE_TLS", "1")),
         )
+        # Initiate email alternatives
+        msg = EmailMultiAlternatives(subject=subject, body=text_content, from_email=get_configuration_value(instance_configuration, "EMAIL_FROM"), to=[email], connection=connection)
         msg.attach_alternative(html_content, "text/html")
         msg.send()
         return

apiserver/plane/bgtasks/importer_task.py

@@ -1,467 +1,200 @@
 # Python imports
+import json
+import requests
 import uuid
 
 # Django imports
-from django.db.models import Q, Max
+from django.conf import settings
+from django.core.serializers.json import DjangoJSONEncoder
 from django.contrib.auth.hashers import make_password
 
 # Third Party imports
 from celery import shared_task
-from celery.exceptions import MaxRetriesExceededError
+from sentry_sdk import capture_exception
 
 # Module imports
+from plane.app.serializers import ImporterSerializer
 from plane.db.models import (
     Importer,
     WorkspaceMember,
+    GithubRepositorySync,
+    GithubRepository,
     ProjectMember,
+    WorkspaceIntegration,
     Label,
     User,
     IssueProperty,
-    IssueAssignee,
-    IssueLabel,
-    IssueSequence,
-    IssueActivity,
-    IssueComment,
-    IssueLink,
-    ModuleIssue,
-    State,
-    Module,
-    Issue,
-    Cycle,
 )
 from plane.bgtasks.user_welcome_task import send_welcome_slack
 
 
-@shared_task(queue="internal_tasks")
+@shared_task
 def service_importer(service, importer_id):
-    pass
-
-
-## Utility functions
-def get_label_id(name, data):
     try:
-        existing_label = (
-            Label.objects.filter(
-                project_id=data.get("project_id"),
-                workspace_id=data.get("workspace_id"),
-                name__iexact=name,
-            )
-            .values("id")
-            .first()
-        )
-        return existing_label
-    except Label.DoesNotExist:
-        return None
+        importer = Importer.objects.get(pk=importer_id)
+        importer.status = "processing"
+        importer.save()
 
+        users = importer.data.get("users", [])
 
-def get_state_id(name, data):
-    try:
-        existing_state = (
-            State.objects.filter(
-                name__iexact=name,
-                project_id=data.get("project_id"),
-                workspace_id=data.get("workspace_id"),
-            )
-            .values("id")
-            .first()
-        )
-        return existing_state
-    except State.DoesNotExist:
-        return None
-
-
-def get_user_id(name):
-    try:
-        existing_user = User.objects.filter(email=name).values("id").first()
-        return existing_user
-    except User.DoesNotExist:
-        return None
-
-
-def update_imported_items(importer_id, entity, entity_id):
-    importer = Importer.objects.get(pk=importer_id)
-    if importer.imported_data:
-        importer.imported_data.setdefault(str(entity), []).append(str(entity_id))
-    else:
-        importer.imported_data = {
-            str(entity): [str(entity_id)]
-        }
-    importer.save()
-
-
-## Sync functions
-def members_sync(data):
-    try:
-        user = User.objects.get(email=data.get("email"))
-        _ = WorkspaceMember.objects.get_or_create(
-            member_id=user.id, workspace_id=data.get("workspace_id")
-        )
-        _ = ProjectMember.objects.get_or_create(
-            member_id=user.id,
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-        _ = IssueProperty.objects.get_or_create(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            user_id=user.id,
-            created_by_id=data.get("created_by"),
-        )
-
-    except User.DoesNotExist:
-        # For all invited users create the users
-        new_user = User.objects.create(
-            email=data.get("email").strip().lower(),
-            username=uuid.uuid4().hex,
-            password=make_password(uuid.uuid4().hex),
-            is_password_autoset=True,
-        )
-
-        service = data.get("external_source")
-
-        WorkspaceMember.objects.create(
-            member_id=new_user.id,
-            workspace_id=data.get("workspace_id"),
-            created_by_id=data.get("created_by"),
-        )
-
-        ProjectMember.objects.create(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            member_id=new_user.id,
-            created_by_id=data.get("created_by"),
-        )
-
-        IssueProperty.objects.create(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            user_id=new_user.id,
-            created_by_id=data.get("created_by"),
-        )
-        if data.get("source", False) == "slack":
-            send_welcome_slack.delay(
-                str(new_user.id),
-                True,
-                f"{new_user.email} was imported to Plane from {service}",
+        # Check if we need to import users as well
+        if len(users):
+            # For all invited users create the users
+            new_users = User.objects.bulk_create(
+                [
+                    User(
+                        email=user.get("email").strip().lower(),
+                        username=uuid.uuid4().hex,
+                        password=make_password(uuid.uuid4().hex),
+                        is_password_autoset=True,
+                    )
+                    for user in users
+                    if user.get("import", False) == "invite"
+                ],
+                batch_size=10,
+                ignore_conflicts=True,
             )
 
+            _ = [
+                send_welcome_slack.delay(
+                    str(user.id),
+                    True,
+                    f"{user.email} was imported to Plane from {service}",
+                )
+                for user in new_users
+            ]
 
-def label_sync(data):
-    existing_label = Label.objects.filter(
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-        name__iexact=data.get("name"),
-        external_id=data.get("external_id", None),
-        external_source=data.get("external_source"),
-    )
-
-    if not existing_label.exists() and data.get("name"):
-        label = Label.objects.create(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            name=data.get("name"),
-            color=data.get("color"),
-            created_by_id=data.get("created_by"),
-            external_id=data.get("external_id", None),
-            external_source=data.get("external_source"),
-        )
-        update_imported_items(data.get("importer_id"), "labels", label.id)
-
-
-def state_sync(data):
-    try:
-        state = State.objects.get(
-            external_id=data.get("external_id"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-
-    except State.DoesNotExist:
-        existing_states = State.objects.filter(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            group=data.get("state_group"),
-            name__iexact=data.get("state_name"),
-        )
-
-        if existing_states.exists():
-            existing_state = existing_states.first()
-            existing_state.external_id = data.get("external_id")
-            existing_state.external_source = data.get("external_source")
-            existing_state.save()
-        else:
-            state = State.objects.create(
-                project_id=data.get("project_id"),
-                workspace_id=data.get("workspace_id"),
-                name=data.get("state_name"),
-                group=data.get("state_group"),
-                created_by_id=data.get("created_by"),
-                external_id=data.get("external_id"),
-                external_source=data.get("external_source"),
+            workspace_users = User.objects.filter(
+                email__in=[
+                    user.get("email").strip().lower()
+                    for user in users
+                    if user.get("import", False) == "invite"
+                    or user.get("import", False) == "map"
+                ]
             )
-            update_imported_items(data.get("importer_id"), "states", state.id)
 
+            # Check if any of the users are already member of workspace
+            _ = WorkspaceMember.objects.filter(
+                member__in=[user for user in workspace_users],
+                workspace_id=importer.workspace_id,
+            ).update(is_active=True)
 
-def issue_sync(data):
-    try:
-        issue = Issue.objects.get(
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-    except Issue.DoesNotExist:
-        # Get the default state
-        default_state = State.objects.filter(
-            ~Q(name="Triage"), project_id=data.get("project_id"), default=True
-        ).first()
+            # Add new users to Workspace and project automatically
+            WorkspaceMember.objects.bulk_create(
+                [
+                    WorkspaceMember(
+                        member=user,
+                        workspace_id=importer.workspace_id,
+                        created_by=importer.created_by,
+                    )
+                    for user in workspace_users
+                ],
+                batch_size=100,
+                ignore_conflicts=True,
+            )
 
-        # 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=data.get("project_id")
+            ProjectMember.objects.bulk_create(
+                [
+                    ProjectMember(
+                        project_id=importer.project_id,
+                        workspace_id=importer.workspace_id,
+                        member=user,
+                        created_by=importer.created_by,
+                    )
+                    for user in workspace_users
+                ],
+                batch_size=100,
+                ignore_conflicts=True,
+            )
+
+            IssueProperty.objects.bulk_create(
+                [
+                    IssueProperty(
+                        project_id=importer.project_id,
+                        workspace_id=importer.workspace_id,
+                        user=user,
+                        created_by=importer.created_by,
+                    )
+                    for user in workspace_users
+                ],
+                batch_size=100,
+                ignore_conflicts=True,
+            )
+
+        # Check if sync config is on for github importers
+        if service == "github" and importer.config.get("sync", False):
+            name = importer.metadata.get("name", False)
+            url = importer.metadata.get("url", False)
+            config = importer.metadata.get("config", {})
+            owner = importer.metadata.get("owner", False)
+            repository_id = importer.metadata.get("repository_id", False)
+
+            workspace_integration = WorkspaceIntegration.objects.get(
+                workspace_id=importer.workspace_id, integration__provider="github"
+            )
+
+            # Delete the old repository object
+            GithubRepositorySync.objects.filter(project_id=importer.project_id).delete()
+            GithubRepository.objects.filter(project_id=importer.project_id).delete()
+
+            # Create a Label for github
+            label = Label.objects.filter(
+                name="GitHub", project_id=importer.project_id
             ).first()
 
-        # Get the maximum sequence_id
-        last_id = IssueSequence.objects.filter(
-            project_id=data.get("project_id")
-        ).aggregate(largest=Max("sequence"))["largest"]
+            if label is None:
+                label = Label.objects.create(
+                    name="GitHub",
+                    project_id=importer.project_id,
+                    description="Label to sync Plane issues with GitHub issues",
+                    color="#003773",
+                )
+            # Create repository
+            repo = GithubRepository.objects.create(
+                name=name,
+                url=url,
+                config=config,
+                repository_id=repository_id,
+                owner=owner,
+                project_id=importer.project_id,
+            )
 
-        last_id = 1 if last_id is None else last_id + 1
+            # Create repo sync
+            _ = GithubRepositorySync.objects.create(
+                repository=repo,
+                workspace_integration=workspace_integration,
+                actor=workspace_integration.actor,
+                credentials=importer.data.get("credentials", {}),
+                project_id=importer.project_id,
+                label=label,
+            )
 
-        # Get the maximum sort order
-        largest_sort_order = Issue.objects.filter(
-            project_id=data.get("project_id"), state=default_state
-        ).aggregate(largest=Max("sort_order"))["largest"]
+            # Add bot as a member in the project
+            _ = ProjectMember.objects.get_or_create(
+                member=workspace_integration.actor,
+                role=20,
+                project_id=importer.project_id,
+            )
 
-        largest_sort_order = (
-            65535 if largest_sort_order is None else largest_sort_order + 10000
-        )
-        parent_id = None
-        if data.get("parent_id", False):
-            parent_id = Issue.objects.filter(
-                external_id=data.get("parent_id"),
-                external_source=data.get("external_source"),
-                project_id=data.get("project_id"),
-                workspace_id=data.get("workspace_id"),
-            ).values("id")
+        if settings.PROXY_BASE_URL:
+            headers = {"Content-Type": "application/json"}
+            import_data_json = json.dumps(
+                ImporterSerializer(importer).data,
+                cls=DjangoJSONEncoder,
+            )
+            _ = requests.post(
+                f"{settings.PROXY_BASE_URL}/hooks/workspaces/{str(importer.workspace_id)}/projects/{str(importer.project_id)}/importers/{str(service)}/",
+                json=import_data_json,
+                headers=headers,
+            )
 
-        # Issues
-        issue = Issue.objects.create(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            state_id=get_state_id(data.get("state"), data).get("id")
-            if get_state_id(data.get("state"), data)
-            else default_state.id,
-            name=data.get("name", "Issue Created through Importer")[:255],
-            description_html=data.get("description_html", "<p></p>"),
-            sequence_id=last_id,
-            sort_order=largest_sort_order,
-            start_date=data.get("start_date", None),
-            target_date=data.get("target_date", None),
-            priority=data.get("priority", "none"),
-            created_by_id=data.get("created_by_id"),
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-            parent_id=parent_id,
-        )
-
-        # Sequences
-        _ = IssueSequence.objects.create(
-            issue=issue,
-            sequence=issue.sequence_id,
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-
-        # Attach Links
-        _ = IssueLink.objects.create(
-            issue=issue,
-            url=data.get("link", {}).get("url", "https://github.com"),
-            title=data.get("link", {}).get("title", "Original Issue"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            created_by_id=data.get("created_by_id"),
-        )
-
-        # Track the issue activities
-        _ = IssueActivity.objects.create(
-            issue=issue,
-            actor_id=data.get("created_by_id"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            comment=f"imported the issue from {data.get('external_source')}",
-            verb="created",
-            created_by_id=data.get("created_by_id"),
-        )
-
-        update_imported_items(data.get("importer_id"), "issues", issue.id)
-
-
-def issue_label_sync(data):
-    issue = Issue.objects.get(
-        external_source=data.get("external_issue_source"),
-        external_id=data.get("external_issue_id"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-    )
-    if get_label_id(data.get("name"), data):
-        IssueLabel.objects.create(
-            issue=issue,
-            label_id=get_label_id(data.get("name"), data).get("id"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            created_by_id=data.get("created_by_id"),
-        )
-
-
-def issue_assignee_sync(data):
-    issue = Issue.objects.get(
-        external_source=data.get("external_issue_source"),
-        external_id=data.get("external_issue_id"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-    )
-    user = User.objects.filter(email=data.get("email")).values("id")
-
-    IssueAssignee.objects.create(
-        issue=issue,
-        assignee_id=user,
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-        created_by_id=data.get("created_by_id"),
-    )
-
-
-def issue_comment_sync(data):
-    # Create Comments
-    issue = Issue.objects.get(
-        external_source=data.get("external_issue_source"),
-        external_id=data.get("external_issue_id"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-    )
-    IssueComment.objects.create(
-        issue=issue,
-        comment_html=data.get("comment_html", "<p></p>"),
-        actor_id=data.get("created_by_id"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-        created_by_id=get_user_id(data.get("created_by_id")).get("id")
-        if get_user_id(data.get("created_by_id"))
-        else data.get("created_by_id"),
-        external_id=data.get("external_id"),
-        external_source=data.get("external_source"),
-    )
-
-
-def cycles_sync(data):
-    try:
-        _ = Cycle.objects.get(
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-    except Cycle.DoesNotExist:
-        cycle = Cycle.objects.create(
-            name=data.get("name"),
-            description_html=data.get("description_html", "<p></p>"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            created_by_id=data.get("created_by"),
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-        )
-        update_imported_items(data.get("importer_id"), "cycles", cycle.id)
-
-
-def module_sync(data):
-    try:
-        _ = Module.objects.get(
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-    except Module.DoesNotExist:
-        module = Module.objects.create(
-            name=data.get("name"),
-            description_html=data.get("description_html", "<p></p>"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            created_by_id=data.get("created_by"),
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-        )
-        update_imported_items(data.get("importer_id"), "modules", module.id)
-
-
-def modules_issue_sync(data):
-    module = Module.objects.get(
-        external_id=data.get("module_id"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-        external_source=data.get("external_source"),
-    )
-    issue = Issue.objects.get(
-        external_id=data.get("issue_id"),
-        external_source=data.get("external_source"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-    )
-
-    _ = ModuleIssue.objects.create(
-        module=module,
-        issue=issue,
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-        created_by_id=data.get("created_by"),
-    )
-
-
-def import_sync(data):
-    importer = Importer.objects.get(pk=data.get("importer_id"))
-    importer.status = data.get("status")
-    importer.save(update_fields=["status"])
-
-
-@shared_task(bind=True, queue="segway_task", max_retries=5)
-def import_task(self, data):
-    type = data.get("type")
-
-    if type is None:
-        return
-
-    TYPE_MAPPER = {
-        "member.sync": members_sync,
-        "label.sync": label_sync,
-        "state.sync": state_sync,
-        "issue.sync": issue_sync,
-        "issue.label.sync": issue_label_sync,
-        "issue.assignee.sync": issue_assignee_sync,
-        "issue.comment.sync": issue_comment_sync,
-        "cycle.sync": cycles_sync,
-        "module.sync": module_sync,
-        "module.issue.sync": modules_issue_sync,
-        "import.sync": import_sync,
-    }
-    try:
-        func = TYPE_MAPPER.get(type)
-        if func is None:
-            return
-        # Call the function
-        func(data)
         return
     except Exception as e:
-        try:
-            # Retry with exponential backoff
-            self.retry(exc=e, countdown=50, backoff=2)
-        except MaxRetriesExceededError:
-            # For max retries reached items fail the import
-            importer = Importer.objects.get(pk=data.get("importer_id"))
-            importer.status = "failed"
-            importer.reason = e
-            importer.save()
-
+        importer = Importer.objects.get(pk=importer_id)
+        importer.status = "failed"
+        importer.save()
+        # Print logs if in DEBUG mode
+        if settings.DEBUG:
+            print(e)
+        capture_exception(e)
         return

apiserver/plane/bgtasks/issue_activites_task.py

@@ -1460,7 +1460,7 @@ def delete_draft_issue_activity(
 
 
 # Receive message from room group
-@shared_task(queue='internal_tasks')
+@shared_task
 def issue_activity(
     type,
     requested_data,

apiserver/plane/bgtasks/issue_automation_task.py

@@ -12,14 +12,15 @@ from celery import shared_task
 from sentry_sdk import capture_exception
 
 # Module imports
-from plane.db.models import Issue, Project, State
+from plane.db.models import Issue, Project, State, Page
 from plane.bgtasks.issue_activites_task import issue_activity
 
 
-@shared_task(queue='internal_tasks')
+@shared_task
 def archive_and_close_old_issues():
     archive_old_issues()
     close_old_issues()
+    delete_archived_pages()
 
 
 def archive_old_issues():
@@ -165,4 +166,21 @@ def close_old_issues():
         if settings.DEBUG:
             print(e)
         capture_exception(e)
-        return
+        return
+
+
+def delete_archived_pages():
+    try:
+        pages_to_delete = Page.objects.filter(
+            archived_at__isnull=False,
+            archived_at__lte=(timezone.now() - timedelta(days=30)),
+        )
+
+        pages_to_delete._raw_delete(pages_to_delete.db)
+        return 
+    except Exception as e:
+        if settings.DEBUG:
+            print(e)
+        capture_exception(e)
+        return
+

apiserver/plane/bgtasks/issue_sync_task.py

@@ -1,5 +0,0 @@
-from celery import shared_task
-
-@shared_task(queue="segway_tasks")
-def issue_sync(data):
-    print(f"Received data from Segway: {data}")

apiserver/plane/bgtasks/magic_link_code_task.py

@@ -1,8 +1,3 @@
-# Python imports
-import os
-import requests
-import json
-
 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
 from django.template.loader import render_to_string
@@ -14,48 +9,38 @@ from celery import shared_task
 from sentry_sdk import capture_exception
 
 # Module imports
-from plane.license.utils.instance_value import get_email_configuration
+from plane.license.models import InstanceConfiguration
+from plane.license.utils.instance_value import get_configuration_value
 
-
-@shared_task(queue='internal_tasks')
+@shared_task
 def magic_link(email, key, token, current_site):
     try:
-        (
-            EMAIL_HOST,
-            EMAIL_HOST_USER,
-            EMAIL_HOST_PASSWORD,
-            EMAIL_PORT,
-            EMAIL_USE_TLS,
-            EMAIL_FROM,
-        ) = get_email_configuration()
+        realtivelink = f"/magic-sign-in/?password={token}&key={key}"
+        abs_url = current_site + realtivelink
 
-        # Send the mail
-        subject = f"Your unique Plane login code is {token}"
-        context = {"code": token, "email": email}
+        subject = "Login for Plane"
+
+        context = {"magic_url": abs_url, "code": token}
 
         html_content = render_to_string("emails/auth/magic_signin.html", context)
+
         text_content = strip_tags(html_content)
 
+        instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
         connection = get_connection(
-            host=EMAIL_HOST,
-            port=int(EMAIL_PORT),
-            username=EMAIL_HOST_USER,
-            password=EMAIL_HOST_PASSWORD,
-            use_tls=EMAIL_USE_TLS == "1",
+            host=get_configuration_value(instance_configuration, "EMAIL_HOST"),
+            port=int(get_configuration_value(instance_configuration, "EMAIL_PORT", "587")),
+            username=get_configuration_value(instance_configuration, "EMAIL_HOST_USER"),
+            password=get_configuration_value(instance_configuration, "EMAIL_HOST_PASSWORD"),
+            use_tls=bool(get_configuration_value(instance_configuration, "EMAIL_USE_TLS", "1")),
         )
 
-        msg = EmailMultiAlternatives(
-            subject=subject,
-            body=text_content,
-            from_email=EMAIL_FROM,
-            to=[email],
-            connection=connection,
-        )
+        # Initiate email alternatives
+        msg = EmailMultiAlternatives(subject=subject, body=text_content, from_email=get_configuration_value(instance_configuration, "EMAIL_FROM"), to=[email], connection=connection)
         msg.attach_alternative(html_content, "text/html")
         msg.send()
         return
     except Exception as e:
-        print(e)
         capture_exception(e)
         # Print logs if in DEBUG mode
         if settings.DEBUG: