fix: draft issue title fixes

Merge branch 'develop' of github.com:makeplane/plane into fix/issue-state-change
fix: untitled draft issue
2024-01-03 12:29:53 +05:30 · 2024-01-03 11:59:50 +05:30 · 2024-01-02 19:11:25 +05:30 · 2024-01-02 18:52:46 +05:30 · 2024-01-02 18:12:55 +05:30 · 2024-01-02 14:45:51 +05:30
1622 changed files with 59250 additions and 51920 deletions
@@ -1,5 +1,11 @@
 version = 1

+exclude_patterns = [  
+  "bin/**",  
+  "**/node_modules/",  
+  "**/*.min.js"  
+]
+
 [[analyzers]]
 name = "shell"

@@ -2,5 +2,16 @@
 *.pyc
 .env
 venv
-node_modules
-npm-debug.log
+node_modules/
+**/node_modules/
+npm-debug.log
+.next/
+**/.next/
+.turbo/
+**/.turbo/
+build/
+**/build/
+out/
+**/out/
+dist/
+**/dist/
@@ -1,62 +1,31 @@
-
 name: Branch Build

 on:
  pull_request:
-    types: 
+    types:
      - closed
-    branches: 
+    branches:
      - master
-      - release
+      - preview
      - qa
      - develop
+      - release-*
+  release:
+    types: [released, prereleased]

 env:
-  TARGET_BRANCH: ${{ github.event.pull_request.base.ref }}
+  TARGET_BRANCH: ${{ github.event.pull_request.base.ref || github.event.release.target_commitish }}

 jobs:
-  branch_build_and_push:
-    if: ${{ (github.event_name == 'pull_request' && github.event.action =='closed' && github.event.pull_request.merged == true) }}
+  branch_build_setup:
+    if: ${{ (github.event_name == 'pull_request' && github.event.action =='closed' && github.event.pull_request.merged == true) || github.event_name == 'release' }}
    name: Build-Push Web/Space/API/Proxy Docker Image
    runs-on: ubuntu-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:
@@ -77,7 +46,6 @@ jobs:
            !./nginx
            !./deploy
            !./space
-      
      - name: Uploading Space Source
        uses: actions/upload-artifact@v3
        with:
@@ -89,12 +57,24 @@ jobs:
            !./deploy
            !./web
    outputs:
-        gh_branch_name: ${{ steps.gh_branch_clean.outputs.value }}
+      gh_branch_name: ${{ env.TARGET_BRANCH }}

  branch_build_push_frontend:
    runs-on: ubuntu-20.04
-    needs: [ branch_build_and_push ]
+    needs: [branch_build_setup]
+    env:
+      FRONTEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
    steps:
+      - name: Set Frontend Docker Tag 
+        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

@@ -114,7 +94,7 @@ jobs:
          context: .
          file: ./web/Dockerfile.web
          platforms: linux/amd64
-          tags: ${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
+          tags: ${{ env.FRONTEND_TAG }}
          push: true
        env:
          DOCKER_BUILDKIT: 1
@@ -123,8 +103,20 @@ jobs:

  branch_build_push_space:
    runs-on: ubuntu-20.04
-    needs: [ branch_build_and_push ]
+    needs: [branch_build_setup]
+    env:
+      SPACE_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
    steps:
+      - name: Set Space Docker Tag 
+        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

@@ -144,7 +136,7 @@ jobs:
          context: .
          file: ./space/Dockerfile.space
          platforms: linux/amd64
-          tags: ${{ secrets.DOCKERHUB_USERNAME }}/plane-space-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
+          tags: ${{ env.SPACE_TAG }}
          push: true
        env:
          DOCKER_BUILDKIT: 1
@@ -153,8 +145,20 @@ jobs:

  branch_build_push_backend:
    runs-on: ubuntu-20.04
-    needs: [ branch_build_and_push ]
+    needs: [branch_build_setup]
+    env:
+      BACKEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
    steps:
+      - name: Set Backend Docker Tag 
+        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

@@ -175,7 +179,7 @@ jobs:
          file: ./Dockerfile.api
          platforms: linux/amd64
          push: true
-          tags: ${{ secrets.DOCKERHUB_USERNAME }}/plane-backend-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
+          tags: ${{ env.BACKEND_TAG }}
        env:
          DOCKER_BUILDKIT: 1
          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
@@ -183,8 +187,20 @@ jobs:

  branch_build_push_proxy:
    runs-on: ubuntu-20.04
-    needs: [ branch_build_and_push ]
+    needs: [branch_build_setup]
+    env:
+      PROXY_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
    steps:
+      - name: Set Proxy Docker Tag 
+        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

@@ -205,7 +221,7 @@ jobs:
          context: .
          file: ./Dockerfile
          platforms: linux/amd64
-          tags: ${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
+          tags: ${{ env.PROXY_TAG }}
          push: true
        env:
          DOCKER_BUILDKIT: 1
@@ -1,6 +1,6 @@
 name: Build Pull Request Contents

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

@@ -14,13 +14,15 @@ jobs:
    steps:
      - name: Checkout Repository to Actions
        uses: actions/checkout@v3.3.0
+        with:
+          token: ${{ secrets.ACCESS_TOKEN }}

      - name: Setup Node.js 18.x
        uses: actions/setup-node@v2
        with:
          node-version: 18.x
-          cache: 'yarn'
-      
+          cache: "yarn"
+
      - name: Get changed files
        id: changed-files
        uses: tj-actions/changed-files@v38
@@ -44,5 +46,3 @@ jobs:
        run: |
          yarn 
          yarn build --filter=space
-
-
@@ -0,0 +1,65 @@
+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}}"
@@ -1,11 +1,13 @@
-name: Create PR in Plane EE Repository to sync the changes
+name: Create Sync Action

 on:
  pull_request:
    branches:
-      - master
+      - develop # Change this to preview
    types:
      - closed
+env: 
+  SOURCE_BRANCH_NAME: ${{github.event.pull_request.base.ref}}

 jobs:
  create_pr:
@@ -16,27 +18,13 @@ 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
@@ -46,34 +34,22 @@ jobs:
          sudo apt install gh -y

      - name: Create Pull Request
-        if: steps.check_repo.outputs.is_correct_repo == 'true'
        env:
          GH_TOKEN: ${{ secrets.ACCESS_TOKEN }}
        run: |
-          TARGET_REPO="${{ secrets.TARGET_REPO_NAME }}"
-          TARGET_BRANCH="${{ secrets.TARGET_REPO_BRANCH }}"
+          TARGET_REPO="${{ secrets.SYNC_TARGET_REPO_NAME }}"
+          TARGET_BRANCH="${{ secrets.SYNC_TARGET_BRANCH_NAME }}"
+          TARGET_BASE_BRANCH="${{ secrets.SYNC_TARGET_BASE_BRANCH_NAME }}"
          SOURCE_BRANCH="${{ env.SOURCE_BRANCH_NAME }}"

          git checkout $SOURCE_BRANCH
-          git remote add target "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
-          git push target $SOURCE_BRANCH:$SOURCE_BRANCH
+          git remote add target-origin "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
+          git push target-origin $SOURCE_BRANCH:$TARGET_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
-          )
+          PR_TITLE=${{secrets.SYNC_PR_TITLE}}

          gh pr create \
-            --base $TARGET_BRANCH \
-            --head $SOURCE_BRANCH \
-            --title "[SYNC] $PR_TITLE_CLEANED" \
-            --body "$PR_BODY_CONTENT" \
+            --base $TARGET_BASE_BRANCH \
+            --head $TARGET_BRANCH \
+            --title "$PR_TITLE" \
            --repo $TARGET_REPO
@@ -1,107 +0,0 @@
-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 }}
@@ -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
-cd plane
+git clone https://github.com/makeplane/plane.git [folder-name]
+cd [folder-name]
 chmod +x setup.sh
 ```

@@ -44,33 +44,12 @@ chmod +x setup.sh
 ./setup.sh
 ```

-3. Define `NEXT_PUBLIC_API_BASE_URL=http://localhost` in **web/.env** and **space/.env** file
+3. Start the containers

 ```bash
-echo "\nNEXT_PUBLIC_API_BASE_URL=http://localhost\n" >> ./web/.env
+docker compose -f docker-compose-local.yml up
 ```

-```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?

@@ -79,7 +79,6 @@ 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/

@@ -49,24 +49,10 @@ 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

@@ -76,7 +62,6 @@ NEXT_PUBLIC_ENABLE_OAUTH=0
 # 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=""
@@ -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).
+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).

 ## ⚡️ Contributors Quick Start

@@ -57,17 +57,13 @@ 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) documentation page
+For self hosting environment setup, visit the [Self Hosting](https://docs.plane.so/self-hosting/docker-compose) documentation page

 ## 🚀 Features

@@ -14,6 +14,11 @@ 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"
@@ -50,7 +55,6 @@ NGINX_PORT=80
 # SignUps
 ENABLE_SIGNUP="1"

-
 # Enable Email/Password Signup
 ENABLE_EMAIL_PASSWORD="1"

@@ -44,7 +44,6 @@ 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/
@@ -27,7 +27,8 @@ WORKDIR /code
 COPY requirements.txt ./requirements.txt
 ADD requirements ./requirements

-RUN pip install -r requirements.txt --compile --no-cache-dir
+# Install the local development settings
+RUN pip install -r requirements/local.txt --compile --no-cache-dir

 RUN addgroup -S plane && \
    adduser -S captain -G plane
@@ -48,5 +49,5 @@ USER captain
 # Expose container port and run entry point script
 EXPOSE 8000

-# CMD [ "./bin/takeoff" ]
+CMD [ "./bin/takeoff.local" ]

@@ -3,18 +3,28 @@ set -e
 python manage.py wait_for_db
 python manage.py migrate

-# Set default value for ENABLE_REGISTRATION
-ENABLE_REGISTRATION=${ENABLE_REGISTRATION:-1}
+# Create the default bucket
+#!/bin/bash

-# 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
+# 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

-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 -
+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 -
@@ -0,0 +1,31 @@
+#!/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
+
@@ -1,6 +0,0 @@
-from psycogreen.gevent import patch_psycopg
-
-
-def post_fork(server, worker):
-    patch_psycopg()
-    worker.log.info("Made Psycopg2 Green")
@@ -1,4 +1,4 @@
 {
-    "name": "plane-api",
-    "version": "0.13.2"
-}
+  "name": "plane-api",
+  "version": "0.14.0"
+}
@@ -1,9 +1,8 @@
-from django.utils import timezone
 from rest_framework.throttling import SimpleRateThrottle

-
 class ApiKeyRateThrottle(SimpleRateThrottle):
    scope = 'api_key'
+    rate = '60/minute'

    def get_cache_key(self, request, view):
        # Retrieve the API key from the request header
@@ -15,13 +14,10 @@ class ApiKeyRateThrottle(SimpleRateThrottle):
        return f'{self.scope}:{api_key}'

    def allow_request(self, request, view):
-        # Calculate the current time as a Unix timestamp
-        now = timezone.now().timestamp()
-
-        # Use the parent class's method to check if the request is allowed
        allowed = super().allow_request(request, view)

        if allowed:
+            now = self.timer()
            # Calculate the remaining limit and reset time
            history = self.cache.get(self.key, [])

@@ -9,8 +9,9 @@ from .issue import (
    IssueCommentSerializer,
    IssueAttachmentSerializer,
    IssueActivitySerializer,
+    IssueExpandSerializer,
 )
 from .state import StateLiteSerializer, StateSerializer
-from .cycle import CycleSerializer, CycleIssueSerializer
-from .module import ModuleSerializer, ModuleIssueSerializer
+from .cycle import CycleSerializer, CycleIssueSerializer, CycleLiteSerializer
+from .module import ModuleSerializer, ModuleIssueSerializer, ModuleLiteSerializer
 from .inbox import InboxIssueSerializer
@@ -97,7 +97,7 @@ class BaseSerializer(serializers.ModelSerializer):
                            exp_serializer = expansion[expand](
                                getattr(instance, expand)
                            )
-                            response[expand] = exp_serializer.data
+                        response[expand] = exp_serializer.data
                    else:
                        # You might need to handle this case differently
                        response[expand] = getattr(instance, f"{expand}_id", None)
@@ -30,6 +30,11 @@ class CycleSerializer(BaseSerializer):
        model = Cycle
        fields = "__all__"
        read_only_fields = [
+            "id",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
            "workspace",
            "project",
            "owned_by",
@@ -46,4 +51,11 @@ class CycleIssueSerializer(BaseSerializer):
            "workspace",
            "project",
            "cycle",
-        ]
+        ]
+
+
+class CycleLiteSerializer(BaseSerializer):
+
+    class Meta:
+        model = Cycle
+        fields = "__all__"
@@ -8,6 +8,12 @@ class InboxIssueSerializer(BaseSerializer):
        model = InboxIssue
        fields = "__all__"
        read_only_fields = [
-            "project",
+            "id",
            "workspace",
+            "project",
+            "issue",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
        ]
@@ -1,3 +1,6 @@
+from lxml import html
+
+
 # Django imports
 from django.utils import timezone

@@ -19,7 +22,10 @@ from plane.db.models import (
    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(
@@ -40,8 +46,8 @@ class IssueSerializer(BaseSerializer):

    class Meta:
        model = Issue
-        fields = "__all__"
        read_only_fields = [
+            "id",
            "workspace",
            "project",
            "created_by",
@@ -49,6 +55,10 @@ class IssueSerializer(BaseSerializer):
            "created_at",
            "updated_at",
        ]
+        exclude = [
+            "description",
+            "description_stripped",
+        ]

    def validate(self, data):
        if (
@@ -57,12 +67,21 @@ class IssueSerializer(BaseSerializer):
            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", []):
-            print(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)

@@ -77,7 +96,7 @@ class IssueSerializer(BaseSerializer):
        if (
            data.get("state")
            and not State.objects.filter(
-                project_id=self.context.get("project_id"), pk=data.get("state")
+                project_id=self.context.get("project_id"), pk=data.get("state").id
            ).exists()
        ):
            raise serializers.ValidationError(
@@ -88,7 +107,7 @@ class IssueSerializer(BaseSerializer):
        if (
            data.get("parent")
            and not Issue.objects.filter(
-                workspce_id=self.context.get("workspace_id"), pk=data.get("parent")
+                workspace_id=self.context.get("workspace_id"), pk=data.get("parent").id
            ).exists()
        ):
            raise serializers.ValidationError(
@@ -231,8 +250,13 @@ class LabelSerializer(BaseSerializer):
        model = Label
        fields = "__all__"
        read_only_fields = [
+            "id",
            "workspace",
            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
        ]


@@ -241,13 +265,14 @@ class IssueLinkSerializer(BaseSerializer):
        model = IssueLink
        fields = "__all__"
        read_only_fields = [
+            "id",
            "workspace",
            "project",
+            "issue",
            "created_by",
            "updated_by",
            "created_at",
            "updated_at",
-            "issue",
        ]

    # Validation if url already exists
@@ -266,13 +291,14 @@ class IssueAttachmentSerializer(BaseSerializer):
        model = IssueAttachment
        fields = "__all__"
        read_only_fields = [
+            "id",
+            "workspace",
+            "project",
+            "issue",
            "created_by",
            "updated_by",
            "created_at",
            "updated_at",
-            "workspace",
-            "project",
-            "issue",
        ]


@@ -281,39 +307,87 @@ class IssueCommentSerializer(BaseSerializer):

    class Meta:
        model = IssueComment
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueAttachmentSerializer(BaseSerializer):
-    class Meta:
-        model = IssueAttachment
-        fields = "__all__"
        read_only_fields = [
            "id",
+            "workspace",
+            "project",
+            "issue",
            "created_by",
            "updated_by",
            "created_at",
            "updated_at",
-            "workspace",
-            "project",
-            "issue",
        ]
+        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
-        fields = "__all__"
        exclude = [
            "created_by",
-            "udpated_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",
        ]
@@ -21,7 +21,6 @@ class ModuleSerializer(BaseSerializer):
        write_only=True,
        required=False,
    )
-    is_favorite = serializers.BooleanField(read_only=True)
    total_issues = serializers.IntegerField(read_only=True)
    cancelled_issues = serializers.IntegerField(read_only=True)
    completed_issues = serializers.IntegerField(read_only=True)
@@ -33,6 +32,7 @@ class ModuleSerializer(BaseSerializer):
        model = Module
        fields = "__all__"
        read_only_fields = [
+            "id",
            "workspace",
            "project",
            "created_by",
@@ -55,7 +55,6 @@ class ModuleSerializer(BaseSerializer):
            raise serializers.ValidationError("Start date cannot exceed target date")

        if data.get("members", []):
-            print(data.get("members"))
            data["members"] = ProjectMember.objects.filter(
                project_id=self.context.get("project_id"),
                member_id__in=data["members"],
@@ -66,18 +65,18 @@ class ModuleSerializer(BaseSerializer):
    def create(self, validated_data):
        members = validated_data.pop("members", None)

-        project = self.context["project"]
-
-        module = Module.objects.create(**validated_data, project=project)
+        project_id = self.context["project_id"]
+        workspace_id = self.context["workspace_id"]

+        module = Module.objects.create(**validated_data, project_id=project_id)
        if members is not None:
            ModuleMember.objects.bulk_create(
                [
                    ModuleMember(
                        module=module,
-                        member=member,
-                        project=project,
-                        workspace=project.workspace,
+                        member_id=str(member),
+                        project_id=project_id,
+                        workspace_id=workspace_id,
                        created_by=module.created_by,
                        updated_by=module.updated_by,
                    )
@@ -98,7 +97,7 @@ class ModuleSerializer(BaseSerializer):
                [
                    ModuleMember(
                        module=instance,
-                        member=member,
+                        member_id=str(member),
                        project=instance.project,
                        workspace=instance.project.workspace,
                        created_by=instance.created_by,
@@ -152,4 +151,11 @@ class ModuleLinkSerializer(BaseSerializer):
            raise serializers.ValidationError(
                {"error": "URL already exists for this Issue"}
            )
-        return ModuleLink.objects.create(**validated_data)
+        return ModuleLink.objects.create(**validated_data)
+    
+
+class ModuleLiteSerializer(BaseSerializer):
+
+    class Meta:
+        model = Module
+        fields = "__all__"
@@ -20,8 +20,13 @@ class ProjectSerializer(BaseSerializer):
        model = Project
        fields = "__all__"
        read_only_fields = [
-            "workspace",
            "id",
+            'emoji',
+            "workspace",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
        ]

    def validate(self, data):
@@ -16,6 +16,11 @@ class StateSerializer(BaseSerializer):
        model = State
        fields = "__all__"
        read_only_fields = [
+            "id",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
            "workspace",
            "project",
        ]
@@ -11,10 +11,6 @@ class UserLiteSerializer(BaseSerializer):
            "first_name",
            "last_name",
            "avatar",
-            "is_bot",
            "display_name",
        ]
-        read_only_fields = [
-            "id",
-            "is_bot",
-        ]
+        read_only_fields = fields
@@ -13,7 +13,7 @@ urlpatterns = [
        name="cycles",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:pk>/",
        CycleAPIEndpoint.as_view(),
        name="cycles",
    ),
@@ -23,7 +23,7 @@ urlpatterns = [
        name="cycle-issues",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:issue_id>/",
        CycleIssueAPIEndpoint.as_view(),
        name="cycle-issues",
    ),
@@ -5,12 +5,12 @@ from plane.api.views import InboxIssueAPIEndpoint

 urlpatterns = [
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
        InboxIssueAPIEndpoint.as_view(),
        name="inbox-issue",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:issue_id>/",
        InboxIssueAPIEndpoint.as_view(),
        name="inbox-issue",
    ),
@@ -15,27 +15,27 @@ urlpatterns = [
        name="issue",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/",
        IssueAPIEndpoint.as_view(),
        name="issue",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/labels/",
        LabelAPIEndpoint.as_view(),
        name="label",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/labels/<uuid:pk>/",
        LabelAPIEndpoint.as_view(),
        name="label",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-links/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/links/",
        IssueLinkAPIEndpoint.as_view(),
        name="link",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-links/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/links/<uuid:pk>/",
        IssueLinkAPIEndpoint.as_view(),
        name="link",
    ),
@@ -50,12 +50,12 @@ urlpatterns = [
        name="comment",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/activites/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/activities/",
        IssueActivityAPIEndpoint.as_view(),
        name="activity",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/activites/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/activities/<uuid:pk>/",
        IssueActivityAPIEndpoint.as_view(),
        name="activity",
    ),
@@ -19,7 +19,7 @@ urlpatterns = [
        name="module-issues",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/<uuid:issue_id>/",
        ModuleIssueAPIEndpoint.as_view(),
        name="module-issues",
    ),
@@ -9,7 +9,7 @@ urlpatterns = [
        name="project",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/",
        ProjectAPIEndpoint.as_view(),
        name="project",
    ),
@@ -8,4 +8,9 @@ urlpatterns = [
        StateAPIEndpoint.as_view(),
        name="states",
    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/states/<uuid:state_id>/",
+        StateAPIEndpoint.as_view(),
+        name="states",
+    ),
 ]
@@ -7,7 +7,6 @@ from django.conf import settings
 from django.db import IntegrityError
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.utils import timezone
-from django.core.serializers.json import DjangoJSONEncoder

 # Third party imports
 from rest_framework.views import APIView
@@ -36,28 +35,33 @@ class TimezoneMixin:
        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,
-                event_data=json.dumps(response.data, cls=DjangoJSONEncoder),
+                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,
@@ -139,13 +143,13 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
        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')
+        ratelimit_remaining = request.META.get("X-RateLimit-Remaining")
        if ratelimit_remaining is not None:
-            response['X-RateLimit-Remaining'] = ratelimit_remaining
+            response["X-RateLimit-Remaining"] = ratelimit_remaining

-        ratelimit_reset = request.META.get('X-RateLimit-Reset')
+        ratelimit_reset = request.META.get("X-RateLimit-Reset")
        if ratelimit_reset is not None:
-            response['X-RateLimit-Reset'] = ratelimit_reset
+            response["X-RateLimit-Reset"] = ratelimit_reset

        return response

@@ -169,4 +173,4 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
        expand = [
            expand for expand in self.request.GET.get("expand", "").split(",") if expand
        ]
-        return expand if expand else None
+        return expand if expand else None
@@ -17,7 +17,6 @@ from plane.app.permissions import ProjectEntityPermission
 from plane.api.serializers import (
    CycleSerializer,
    CycleIssueSerializer,
-    IssueSerializer,
 )
 from plane.bgtasks.issue_activites_task import issue_activity

@@ -142,7 +141,6 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
            )
        queryset = self.get_queryset()
        cycle_view = request.GET.get("cycle_view", "all")
-        queryset = queryset.order_by("-is_favorite", "-created_at")

        # Current Cycle
        if cycle_view == "current":
@@ -293,7 +291,7 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
                }
            ),
            actor_id=str(request.user.id),
-            issue_id=str(pk),
+            issue_id=None,
            project_id=str(project_id),
            current_instance=None,
            epoch=int(timezone.now().timestamp()),
@@ -305,14 +303,15 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):

 class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to cycle issues.
+    This viewset automatically provides `list`, `create`,
+    and `destroy` actions related to cycle issues.

    """

    serializer_class = CycleIssueSerializer
    model = CycleIssue
-    webhook_event = "cycle"
+    webhook_event = "cycle_issue"
+    bulk = True
    permission_classes = [
        ProjectEntityPermission,
    ]
@@ -457,7 +456,7 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
        # Capture Issue Activity
        issue_activity.delay(
            type="cycle.activity.created",
-            requested_data=json.dumps({"cycles_list": issues}),
+            requested_data=json.dumps({"cycles_list": str(issues)}),
            actor_id=str(self.request.user.id),
            issue_id=None,
            project_id=str(self.kwargs.get("project_id", None)),
@@ -478,9 +477,9 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
            status=status.HTTP_200_OK,
        )

-    def delete(self, request, slug, project_id, cycle_id, pk):
+    def delete(self, request, slug, project_id, cycle_id, issue_id):
        cycle_issue = CycleIssue.objects.get(
-            pk=pk, workspace__slug=slug, project_id=project_id, cycle_id=cycle_id
+            issue_id=issue_id, workspace__slug=slug, project_id=project_id, cycle_id=cycle_id
        )
        issue_id = cycle_issue.issue_id
        cycle_issue.delete()
@@ -493,7 +492,7 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
                }
            ),
            actor_id=str(self.request.user.id),
-            issue_id=str(self.kwargs.get("pk", None)),
+            issue_id=str(issue_id),
            project_id=str(self.kwargs.get("project_id", None)),
            current_instance=None,
            epoch=int(timezone.now().timestamp()),
@@ -14,7 +14,7 @@ from rest_framework.response import Response
 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
+from plane.db.models import InboxIssue, Issue, State, ProjectMember, Project, Inbox
 from plane.bgtasks.issue_activites_task import issue_activity


@@ -37,29 +37,39 @@ class InboxIssueAPIEndpoint(BaseAPIView):
    ]

    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(
+        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=self.kwargs.get("inbox_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, inbox_id, pk=None):
-        if pk:
-            issue_queryset = self.get_queryset().get(pk=pk)
-            issues_data = InboxIssueSerializer(
-                issue_queryset,
+    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(
-                issues_data,
+                inbox_issue_data,
                status=status.HTTP_200_OK,
            )
        issue_queryset = self.get_queryset()
@@ -74,12 +84,30 @@ class InboxIssueAPIEndpoint(BaseAPIView):
            ).data,
        )

-    def post(self, request, slug, project_id, inbox_id):
+    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",
@@ -123,21 +151,45 @@ class InboxIssueAPIEndpoint(BaseAPIView):
            current_instance=None,
            epoch=int(timezone.now().timestamp()),
        )
+
        # create an inbox issue
-        InboxIssue.objects.create(
-            inbox_id=inbox_id,
+        inbox_issue = InboxIssue.objects.create(
+            inbox_id=inbox.id,
            project_id=project_id,
            issue=issue,
            source=request.data.get("source", "in-app"),
        )

-        serializer = IssueSerializer(issue)
+        serializer = InboxIssueSerializer(inbox_issue)
        return Response(serializer.data, status=status.HTTP_200_OK)

-    def patch(self, request, slug, project_id, inbox_id, pk):
-        inbox_issue = InboxIssue.objects.get(
-            pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+    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,
@@ -145,6 +197,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
            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
@@ -159,7 +212,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):

        if bool(issue_data):
            issue = Issue.objects.get(
-                pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
+                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:
@@ -183,7 +236,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                        type="issue.activity.updated",
                        requested_data=requested_data,
                        actor_id=str(request.user.id),
-                        issue_id=str(issue.id),
+                        issue_id=str(issue_id),
                        project_id=str(project_id),
                        current_instance=json.dumps(
                            IssueSerializer(current_instance).data,
@@ -208,7 +261,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                # Update the issue state if the issue is rejected or marked as duplicate
                if serializer.data["status"] in [-1, 2]:
                    issue = Issue.objects.get(
-                        pk=inbox_issue.issue_id,
+                        pk=issue_id,
                        workspace__slug=slug,
                        project_id=project_id,
                    )
@@ -222,7 +275,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                # Update the issue state if it is accepted
                if serializer.data["status"] in [1]:
                    issue = Issue.objects.get(
-                        pk=inbox_issue.issue_id,
+                        pk=issue_id,
                        workspace__slug=slug,
                        project_id=project_id,
                    )
@@ -244,10 +297,33 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                InboxIssueSerializer(inbox_issue).data, status=status.HTTP_200_OK
            )

-    def delete(self, request, slug, project_id, inbox_id, pk):
-        inbox_issue = InboxIssue.objects.get(
-            pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+    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,
@@ -256,6 +332,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
            is_active=True,
        )

+        # Check the inbox issue created
        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
            request.user.id
        ):
@@ -268,8 +345,8 @@ class InboxIssueAPIEndpoint(BaseAPIView):
        if inbox_issue.status in [-2, -1, 0, 2]:
            # Delete the issue also
            Issue.objects.filter(
-                workspace__slug=slug, project_id=project_id, pk=inbox_issue.issue_id
+                workspace__slug=slug, project_id=project_id, pk=issue_id
            ).delete()

        inbox_issue.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -22,7 +22,6 @@ from django.utils import timezone
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
-from rest_framework.parsers import MultiPartParser, FormParser

 # Module imports
 from .base import BaseAPIView, WebhookMixin
@@ -41,14 +40,12 @@ from plane.db.models import (
    IssueComment,
    IssueActivity,
 )
-from plane.utils.issue_filters import issue_filters
 from plane.bgtasks.issue_activites_task import issue_activity
 from plane.api.serializers import (
    IssueSerializer,
    LabelSerializer,
    IssueLinkSerializer,
    IssueCommentSerializer,
-    IssueAttachmentSerializer,
    IssueActivitySerializer,
 )

@@ -103,7 +100,6 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
                status=status.HTTP_200_OK,
            )

-        filters = issue_filters(request.query_params, "GET")
        # Custom ordering for priority and state
        priority_order = ["urgent", "high", "medium", "low", "none"]
        state_order = ["backlog", "unstarted", "started", "completed", "cancelled"]
@@ -112,7 +108,6 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):

        issue_queryset = (
            self.get_queryset()
-            .filter(**filters)
            .annotate(cycle_id=F("issue_cycle__cycle_id"))
            .annotate(module_id=F("issue_module__module_id"))
            .annotate(
@@ -226,11 +221,20 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):

    def patch(self, request, slug, project_id, pk=None):
        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+        project = Project.objects.get(pk=project_id)
        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)
+        serializer = IssueSerializer(
+            issue,
+            data=request.data,
+            context={
+                "project_id": project_id,
+                "workspace_id": project.workspace_id,
+            },
+            partial=True,
+        )
        if serializer.is_valid():
            serializer.save()
            issue_activity.delay(
@@ -278,7 +282,7 @@ class LabelAPIEndpoint(BaseAPIView):

    def get_queryset(self):
        return (
-            Project.objects.filter(workspace__slug=self.kwargs.get("slug"))
+            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")
@@ -302,29 +306,29 @@ class LabelAPIEndpoint(BaseAPIView):
            )

    def get(self, request, slug, project_id, pk=None):
-        if pk:
-            label = self.get_queryset().get(pk=pk)
-            serializer = LabelSerializer(
-                label,
-                fields=self.fields,
-                expand=self.expand,
+        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,
            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        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)
-        return Response(serializer.data, status=status.HTTP_200_OK)
+        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)
@@ -356,25 +360,31 @@ class IssueLinkAPIEndpoint(BaseAPIView):
            .distinct()
        )

-    def get(self, request, slug, project_id, pk=None):
-        if pk:
-            label = self.get_queryset().get(pk=pk)
+    def get(self, request, slug, project_id, issue_id, pk=None):
+        if pk is None:
+            issue_links = self.get_queryset()
            serializer = IssueLinkSerializer(
-                label,
+                issue_links,
                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_links: IssueLinkSerializer(
-                issue_links,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
+            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)
@@ -449,7 +459,7 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):

    serializer_class = IssueCommentSerializer
    model = IssueComment
-    webhook_event = "issue-comment"
+    webhook_event = "issue_comment"
    permission_classes = [
        ProjectLitePermission,
    ]
@@ -587,7 +597,7 @@ class IssueActivityAPIEndpoint(BaseAPIView):
            serializer = IssueActivitySerializer(issue_activities)
            return Response(serializer.data, status=status.HTTP_200_OK)

-        self.paginate(
+        return self.paginate(
            request=request,
            queryset=(issue_activities),
            on_results=lambda issue_activity: IssueActivitySerializer(
@@ -121,14 +121,22 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
        )

    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})
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+        serializer = ModuleSerializer(data=request.data, context={"project_id": project_id, "workspace_id": project.workspace_id})
        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, context={"project_id": project_id}, partial=True)
+        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:
@@ -168,7 +176,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
                }
            ),
            actor_id=str(request.user.id),
-            issue_id=str(pk),
+            issue_id=None,
            project_id=str(project_id),
            current_instance=None,
            epoch=int(timezone.now().timestamp()),
@@ -186,7 +194,8 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):

    serializer_class = ModuleIssueSerializer
    model = ModuleIssue
-    webhook_event = "module"
+    webhook_event = "module_issue"
+    bulk = True

    permission_classes = [
        ProjectEntityPermission,
@@ -323,7 +332,7 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
        # Capture Issue Activity
        issue_activity.delay(
            type="module.activity.created",
-            requested_data=json.dumps({"modules_list": issues}),
+            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)),
@@ -343,9 +352,9 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
            status=status.HTTP_200_OK,
        )

-    def delete(self, request, slug, project_id, module_id, pk):
+    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, pk=pk
+            workspace__slug=slug, project_id=project_id, module_id=module_id, issue_id=issue_id
        )
        module_issue.delete()
        issue_activity.delay(
@@ -357,7 +366,7 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
                }
            ),
            actor_id=str(request.user.id),
-            issue_id=str(pk),
+            issue_id=str(issue_id),
            project_id=str(project_id),
            current_instance=None,
            epoch=int(timezone.now().timestamp()),
@@ -94,8 +94,8 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
            .distinct()
        )

-    def get(self, request, slug, pk=None):
-        if pk is None:
+    def get(self, request, slug, project_id=None):
+        if project_id is None:
            sort_order_query = ProjectMember.objects.filter(
                member=request.user,
                project_id=OuterRef("pk"),
@@ -114,7 +114,7 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                        ).select_related("member"),
                    )
                )
-                .order_by("sort_order", "name")
+                .order_by(request.GET.get("order_by", "sort_order"))
            )
            return self.paginate(
                request=request,
@@ -123,15 +123,13 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                    projects, many=True, fields=self.fields, expand=self.expand,
                ).data,
            )
-        else:
-            project = self.get_queryset().get(workspace__slug=slug, pk=pk)
-            serializer = ProjectSerializer(project, fields=self.fields, expand=self.expand,)
-            return Response(serializer.data, status=status.HTTP_200_OK)
+        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}
            )
@@ -236,10 +234,10 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                status=status.HTTP_410_GONE,
            )

-    def patch(self, request, slug, pk=None):
+    def patch(self, request, slug, project_id=None):
        try:
            workspace = Workspace.objects.get(slug=slug)
-            project = Project.objects.get(pk=pk)
+            project = Project.objects.get(pk=project_id)

            serializer = ProjectSerializer(
                project,
@@ -260,7 +258,7 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
                        name="Triage",
                        group="backlog",
                        description="Default state for managing all Inbox Issues",
-                        project_id=pk,
+                        project_id=project_id,
                        color="#ff7700",
                    )

@@ -282,4 +280,9 @@ class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
            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)
@@ -23,10 +23,8 @@ class StateAPIEndpoint(BaseAPIView):
    ]

    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
+        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"))
@@ -42,9 +40,9 @@ class StateAPIEndpoint(BaseAPIView):
            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, pk=None):
-        if pk:
-            serializer = StateSerializer(self.get_queryset().get(pk=pk))
+    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,
@@ -57,19 +55,19 @@ class StateAPIEndpoint(BaseAPIView):
            ).data,
        )

-    def delete(self, request, slug, project_id, pk):
+    def delete(self, request, slug, project_id, state_id):
        state = State.objects.get(
            ~Q(name="Triage"),
-            pk=pk,
+            pk=state_id,
            project_id=project_id,
            workspace__slug=slug,
        )

        if state.default:
-            return Response({"error": "Default state cannot be deleted"}, status=False)
+            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=pk).exists()
+        issue_exist = Issue.issue_objects.filter(state=state_id).exists()

        if issue_exist:
            return Response(
@@ -80,8 +78,8 @@ class StateAPIEndpoint(BaseAPIView):
        state.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

-    def patch(self, request, slug, project_id, pk=None):
-        state = State.objects.filter(workspace__slug=slug, project_id=project_id, pk=pk)
+    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()
@@ -99,7 +99,6 @@ class WorkspaceViewerPermission(BasePermission):
        return WorkspaceMember.objects.filter(
            member=request.user,
            workspace__slug=view.workspace_slug,
-            role__gte=10,
            is_active=True,
        ).exists()

@@ -1,45 +0,0 @@
-from django.utils import timezone
-from rest_framework.throttling import SimpleRateThrottle
-
-
-class ApiKeyRateThrottle(SimpleRateThrottle):
-    scope = 'api_key'
-
-    def get_cache_key(self, request, view):
-        # Retrieve the API key from the request header
-        api_key = request.headers.get('X-Api-Key')
-        if not api_key:
-            return None  # Allow the request if there's no API key
-
-        # Use the API key as part of the cache key
-        return f'{self.scope}:{api_key}'
-
-    def allow_request(self, request, view):
-        # Calculate the current time as a Unix timestamp
-        now = timezone.now().timestamp()
-
-        # Use the parent class's method to check if the request is allowed
-        allowed = super().allow_request(request, view)
-
-        if allowed:
-            # Calculate the remaining limit and reset time
-            history = self.cache.get(self.key, [])
-
-            # Remove old histories
-            while history and history[-1] <= now - self.duration:
-                history.pop()
-            
-            # Calculate the requests
-            num_requests = len(history)
-
-            # Check available requests
-            available = self.num_requests - num_requests
-
-            # Unix timestamp for when the rate limit will reset
-            reset_time = int(now + self.duration)
-
-            # Add headers
-            request.META['X-RateLimit-Remaining'] = max(0, available)
-            request.META['X-RateLimit-Reset'] = reset_time
-
-        return allowed
@@ -17,6 +17,7 @@ from .workspace import (
    WorkspaceThemeSerializer,
    WorkspaceMemberAdminSerializer,
    WorkspaceMemberMeSerializer,
+    WorkspaceUserPropertiesSerializer,
 )
 from .project import (
    ProjectSerializer,
@@ -31,6 +32,7 @@ from .project import (
    ProjectDeployBoardSerializer,
    ProjectMemberAdminSerializer,
    ProjectPublicMemberSerializer,
+    ProjectMemberRoleSerializer,
 )
 from .state import StateSerializer, StateLiteSerializer
 from .view import GlobalViewSerializer, IssueViewSerializer, IssueViewFavoriteSerializer
@@ -39,6 +41,7 @@ from .cycle import (
    CycleIssueSerializer,
    CycleFavoriteSerializer,
    CycleWriteSerializer,
+    CycleUserPropertiesSerializer,
 )
 from .asset import FileAssetSerializer
 from .issue import (
@@ -61,6 +64,8 @@ from .issue import (
    IssueRelationSerializer,
    RelatedIssueSerializer,
    IssuePublicSerializer,
+    IssueRelationLiteSerializer,
+
 )

 from .module import (
@@ -69,6 +74,7 @@ from .module import (
    ModuleIssueSerializer,
    ModuleLinkSerializer,
    ModuleFavoriteSerializer,
+    ModuleUserPropertiesSerializer,
 )

 from .api import APITokenSerializer, APITokenReadSerializer
@@ -9,11 +9,12 @@ class DynamicBaseSerializer(BaseSerializer):
    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", None)
+        fields = kwargs.pop("fields", [])
+        self.expand = kwargs.pop("expand", []) or []
+        fields = self.expand

        # Call the initialization of the superclass.
        super().__init__(*args, **kwargs)
-
        # If 'fields' was provided, filter the fields of the serializer accordingly.
        if fields is not None:
            self.fields = self._filter_fields(fields)
@@ -47,12 +48,91 @@ class DynamicBaseSerializer(BaseSerializer):
            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)
+        for field in allowed:
+            if field not in self.fields:
+                from . import (
+                    WorkspaceLiteSerializer,
+                    ProjectLiteSerializer,
+                    UserLiteSerializer,
+                    StateLiteSerializer,
+                    IssueSerializer,
+                    LabelSerializer,
+                    CycleIssueSerializer,
+                    IssueFlatSerializer,
+                )

-        # Remove fields from the serializer that aren't in the 'allowed' list.
-        for field_name in (existing - allowed):
-            self.fields.pop(field_name)
+                # 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,
+                    "assignees": UserLiteSerializer,
+                    "labels": LabelSerializer,
+                    "issue_cycle": CycleIssueSerializer,
+                    "parent": IssueFlatSerializer,
+                }
+                
+                self.fields[field] = expansion[field](many=True if field in ["members", "assignees", "labels", "issue_cycle"] else False)            

        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,
+                        LabelSerializer,
+                        CycleIssueSerializer,
+                    )
+
+                    # 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,
+                        "assignees": UserLiteSerializer,
+                        "labels": LabelSerializer,
+                        "issue_cycle": CycleIssueSerializer,
+                    }
+                    # 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
@@ -7,7 +7,7 @@ from .user import UserLiteSerializer
 from .issue import IssueStateSerializer
 from .workspace import WorkspaceLiteSerializer
 from .project import ProjectLiteSerializer
-from plane.db.models import Cycle, CycleIssue, CycleFavorite
+from plane.db.models import Cycle, CycleIssue, CycleFavorite, CycleUserProperties


 class CycleWriteSerializer(BaseSerializer):
@@ -40,6 +40,7 @@ class CycleSerializer(BaseSerializer):
    started_estimates = serializers.IntegerField(read_only=True)
    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    status = serializers.CharField(read_only=True)

    def validate(self, data):
        if (
@@ -105,3 +106,15 @@ class CycleFavoriteSerializer(BaseSerializer):
            "project",
            "user",
        ]
+
+
+class CycleUserPropertiesSerializer(BaseSerializer):
+    class Meta:
+        model = CycleUserProperties
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "cycle"
+            "user",
+        ]
@@ -4,6 +4,7 @@ from .base import BaseSerializer
 from plane.db.models import Estimate, EstimatePoint
 from plane.app.serializers import WorkspaceLiteSerializer, ProjectLiteSerializer

+from rest_framework import serializers

 class EstimateSerializer(BaseSerializer):
    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
@@ -19,6 +20,15 @@ class EstimateSerializer(BaseSerializer):


 class EstimatePointSerializer(BaseSerializer):
+
+    def validate(self, data):
+        if not data:
+            raise serializers.ValidationError("Estimate points are required")
+        value = data.get("value")
+        if value and len(value) > 20:
+            raise serializers.ValidationError("Value can't be more than 20 characters")
+        return data
+
    class Meta:
        model = EstimatePoint
        fields = "__all__"
@@ -49,7 +49,6 @@ class IssueStateInboxSerializer(BaseSerializer):
    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
    sub_issues_count = serializers.IntegerField(read_only=True)
-    bridge_id = serializers.UUIDField(read_only=True)
    issue_inbox = InboxIssueLiteSerializer(read_only=True, many=True)

    class Meta:
@@ -98,6 +98,12 @@ class IssueCreateSerializer(BaseSerializer):
            "updated_at",
        ]

+    def to_internal_value(self, data):
+        issue_type = self.context.get("issue_type") if self.context is not None else None
+        if data and issue_type == "draft-issue" and not data.get('name'):
+            data['name'] = 'UNTITLED ISSUE'
+        return super().to_internal_value(data)
+
    def to_representation(self, instance):
        data = super().to_representation(instance)
        data['assignees'] = [str(assignee.id) for assignee in instance.assignees.all()]
@@ -225,6 +231,7 @@ 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
@@ -277,17 +284,28 @@ class IssueLabelSerializer(BaseSerializer):
        ]


+class IssueRelationLiteSerializer(DynamicBaseSerializer):
+    project_id = serializers.PrimaryKeyRelatedField(read_only=True)
+    class Meta:
+        model = Issue
+        fields = [
+            "id",
+            "project_id",
+            "sequence_id",
+        ]
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]
+
+
 class IssueRelationSerializer(BaseSerializer):
-    issue_detail = IssueProjectLiteSerializer(read_only=True, source="related_issue")
+    issue_detail = IssueRelationLiteSerializer(read_only=True, source="related_issue")

    class Meta:
        model = IssueRelation
        fields = [
            "issue_detail",
-            "relation_type",
-            "related_issue",
-            "issue",
-            "id"
        ]
        read_only_fields = [
            "workspace",
@@ -295,16 +313,12 @@ class IssueRelationSerializer(BaseSerializer):
        ]

 class RelatedIssueSerializer(BaseSerializer):
-    issue_detail = IssueProjectLiteSerializer(read_only=True, source="issue")
+    issue_detail = IssueRelationLiteSerializer(read_only=True, source="issue")

    class Meta:
        model = IssueRelation
        fields = [
            "issue_detail",
-            "relation_type",
-            "related_issue",
-            "issue",
-            "id"
        ]
        read_only_fields = [
            "workspace",
@@ -511,7 +525,6 @@ class IssueStateSerializer(DynamicBaseSerializer):
    project_detail = ProjectLiteSerializer(read_only=True, source="project")
    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
    sub_issues_count = serializers.IntegerField(read_only=True)
-    bridge_id = serializers.UUIDField(read_only=True)
    attachment_count = serializers.IntegerField(read_only=True)
    link_count = serializers.IntegerField(read_only=True)

@@ -520,32 +533,58 @@ class IssueStateSerializer(DynamicBaseSerializer):
        fields = "__all__"


-class IssueSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    state_detail = StateSerializer(read_only=True, source="state")
-    parent_detail = IssueStateFlatSerializer(read_only=True, source="parent")
-    label_details = LabelSerializer(read_only=True, source="labels", many=True)
-    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
-    related_issues = IssueRelationSerializer(read_only=True, source="issue_relation", many=True)
-    issue_relations = RelatedIssueSerializer(read_only=True, source="issue_related", many=True)
-    issue_cycle = IssueCycleDetailSerializer(read_only=True)
-    issue_module = IssueModuleDetailSerializer(read_only=True)
-    issue_link = IssueLinkSerializer(read_only=True, many=True)
-    issue_attachment = IssueAttachmentSerializer(read_only=True, many=True)
+class IssueSerializer(DynamicBaseSerializer):
+    # ids
+    project_id = serializers.PrimaryKeyRelatedField(read_only=True)
+    state_id = serializers.PrimaryKeyRelatedField(read_only=True)
+    parent_id = serializers.PrimaryKeyRelatedField(read_only=True)
+    cycle_id = serializers.PrimaryKeyRelatedField(read_only=True)
+    module_id = serializers.PrimaryKeyRelatedField(read_only=True)
+
+    # Many to many
+    label_ids = serializers.PrimaryKeyRelatedField(read_only=True, many=True, source="labels")
+    assignee_ids = serializers.PrimaryKeyRelatedField(read_only=True, many=True, source="assignees")
+
+    # Count items
    sub_issues_count = serializers.IntegerField(read_only=True)
-    issue_reactions = IssueReactionSerializer(read_only=True, many=True)
+    attachment_count = serializers.IntegerField(read_only=True)
+    link_count = serializers.IntegerField(read_only=True)
+
+    # is
+    is_subscribed = serializers.BooleanField(read_only=True)

    class Meta:
        model = Issue
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
+        fields = [
+            "id",
+            "name",
+            "state_id",
+            "description_html",
+            "sort_order",
+            "completed_at",
+            "estimate_point",
+            "priority",
+            "start_date",
+            "target_date",
+            "sequence_id",
+            "project_id",
+            "parent_id",
+            "cycle_id",
+            "module_id",
+            "label_ids",
+            "assignee_ids",
+            "sub_issues_count",
            "created_at",
            "updated_at",
+            "created_by",
+            "updated_by",
+            "attachment_count",
+            "link_count",
+            "is_subscribed",
+            "is_draft",
+            "archived_at",
        ]
+        read_only_fields = fields


 class IssueLiteSerializer(DynamicBaseSerializer):
@@ -2,7 +2,7 @@
 from rest_framework import serializers

 # Module imports
-from .base import BaseSerializer
+from .base import BaseSerializer, DynamicBaseSerializer
 from .user import UserLiteSerializer
 from .project import ProjectLiteSerializer
 from .workspace import WorkspaceLiteSerializer
@@ -14,6 +14,7 @@ from plane.db.models import (
    ModuleIssue,
    ModuleLink,
    ModuleFavorite,
+    ModuleUserProperties,
 )


@@ -159,7 +160,7 @@ class ModuleLinkSerializer(BaseSerializer):
        return ModuleLink.objects.create(**validated_data)


-class ModuleSerializer(BaseSerializer):
+class ModuleSerializer(DynamicBaseSerializer):
    project_detail = ProjectLiteSerializer(read_only=True, source="project")
    lead_detail = UserLiteSerializer(read_only=True, source="lead")
    members_detail = UserLiteSerializer(read_only=True, many=True, source="members")
@@ -196,3 +197,14 @@ class ModuleFavoriteSerializer(BaseSerializer):
            "project",
            "user",
        ]
+
+class ModuleUserPropertiesSerializer(BaseSerializer):
+    class Meta:
+        model = ModuleUserProperties
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "module",
+            "user"
+        ]
@@ -103,16 +103,19 @@ class ProjectListSerializer(DynamicBaseSerializer):
    members = serializers.SerializerMethodField()

    def get_members(self, obj):
-        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)
+        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 []

    class Meta:
        model = Project
@@ -156,6 +159,11 @@ class ProjectMemberAdminSerializer(BaseSerializer):
        model = ProjectMember
        fields = "__all__"

+class ProjectMemberRoleSerializer(DynamicBaseSerializer):
+
+    class Meta:
+        model = ProjectMember
+        fields = ("id", "role", "member", "project")

 class ProjectMemberInviteSerializer(BaseSerializer):
    project = ProjectLiteSerializer(read_only=True)
@@ -26,6 +26,8 @@ class UserSerializer(BaseSerializer):
            "token_updated_at",
            "is_onboarded",
            "is_bot",
+            "is_password_autoset",
+            "is_email_verified",
        ]
        extra_kwargs = {"password": {"write_only": True}}

@@ -60,6 +62,8 @@ class UserMeSerializer(BaseSerializer):
            "theme",
            "last_workspace_id",
            "use_case",
+            "is_password_autoset",
+            "is_email_verified",
        ]
        read_only_fields = fields

@@ -80,9 +84,18 @@ class UserMeSettingsSerializer(BaseSerializer):
        workspace_invites = WorkspaceMemberInvite.objects.filter(
            email=obj.email
        ).count()
-        if obj.last_workspace_id is not None:
+        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()
+        ):
            workspace = Workspace.objects.filter(
-                pk=obj.last_workspace_id, workspace_member__member=obj.id
+                pk=obj.last_workspace_id,
+                workspace_member__member=obj.id,
+                workspace_member__is_active=True,
            ).first()
            return {
                "last_workspace_id": obj.last_workspace_id,
@@ -95,7 +108,9 @@ class UserMeSettingsSerializer(BaseSerializer):
            }
        else:
            fallback_workspace = (
-                Workspace.objects.filter(workspace_member__member_id=obj.id)
+                Workspace.objects.filter(
+                    workspace_member__member_id=obj.id, workspace_member__is_active=True
+                )
                .order_by("created_at")
                .first()
            )
@@ -154,14 +169,25 @@ class ChangePasswordSerializer(serializers.Serializer):
    Serializer for password change endpoint.
    """
    old_password = serializers.CharField(required=True)
-    new_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


 class ResetPasswordSerializer(serializers.Serializer):
-    model = User
-
    """
    Serializer for password change endpoint.
    """
-    new_password = serializers.CharField(required=True)
-    confirm_password = serializers.CharField(required=True)
+    new_password = serializers.CharField(required=True, min_length=8)
@@ -2,7 +2,7 @@
 from rest_framework import serializers

 # Module imports
-from .base import BaseSerializer
+from .base import BaseSerializer, DynamicBaseSerializer
 from .workspace import WorkspaceLiteSerializer
 from .project import ProjectLiteSerializer
 from plane.db.models import GlobalView, IssueView, IssueViewFavorite
@@ -38,7 +38,7 @@ class GlobalViewSerializer(BaseSerializer):
        return super().update(instance, validated_data)


-class IssueViewSerializer(BaseSerializer):
+class IssueViewSerializer(DynamicBaseSerializer):
    is_favorite = serializers.BooleanField(read_only=True)
    project_detail = ProjectLiteSerializer(source="project", read_only=True)
    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
@@ -80,4 +80,4 @@ class IssueViewFavoriteSerializer(BaseSerializer):
            "workspace",
            "project",
            "user",
-        ]
+        ]
@@ -1,3 +1,9 @@
+# Python imports
+import urllib
+import socket
+import ipaddress
+from urllib.parse import urlparse
+
 # Third party imports
 from rest_framework import serializers

@@ -8,6 +14,76 @@ 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
@@ -2,7 +2,7 @@
 from rest_framework import serializers

 # Module imports
-from .base import BaseSerializer
+from .base import BaseSerializer, DynamicBaseSerializer
 from .user import UserLiteSerializer, UserAdminLiteSerializer

 from plane.db.models import (
@@ -13,14 +13,32 @@ from plane.db.models import (
    TeamMember,
    WorkspaceMemberInvite,
    WorkspaceTheme,
+    WorkspaceUserProperties,
 )


-class WorkSpaceSerializer(BaseSerializer):
+class WorkSpaceSerializer(DynamicBaseSerializer):
    owner = UserLiteSerializer(read_only=True)
    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__"
@@ -45,7 +63,7 @@ class WorkspaceLiteSerializer(BaseSerializer):



-class WorkSpaceMemberSerializer(BaseSerializer):
+class WorkSpaceMemberSerializer(DynamicBaseSerializer):
    member = UserLiteSerializer(read_only=True)
    workspace = WorkspaceLiteSerializer(read_only=True)

@@ -61,7 +79,7 @@ class WorkspaceMemberMeSerializer(BaseSerializer):
        fields = "__all__"


-class WorkspaceMemberAdminSerializer(BaseSerializer):
+class WorkspaceMemberAdminSerializer(DynamicBaseSerializer):
    member = UserAdminLiteSerializer(read_only=True)
    workspace = WorkspaceLiteSerializer(read_only=True)

@@ -78,6 +96,16 @@ 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):
@@ -134,3 +162,13 @@ class WorkspaceThemeSerializer(BaseSerializer):
            "workspace",
            "actor",
        ]
+
+
+class WorkspaceUserPropertiesSerializer(BaseSerializer):
+    class Meta:
+        model = WorkspaceUserProperties
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "user",
+        ]
@@ -4,6 +4,7 @@ from django.urls import path
 from plane.app.views import (
    FileAssetEndpoint,
    UserAssetsEndpoint,
+    FileAssetViewSet,
 )


@@ -28,4 +29,13 @@ 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",
+    ),
 ]
@@ -5,18 +5,16 @@ 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
@@ -27,24 +25,15 @@ 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/Up
-    path(
-        "magic-generate/", MagicSignInGenerateEndpoint.as_view(), name="magic-generate"
-    ),
+    # magic sign in
+    path("magic-generate/", MagicGenerateEndpoint.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/",
@@ -7,7 +7,7 @@ from plane.app.views import (
    CycleDateCheckEndpoint,
    CycleFavoriteViewSet,
    TransferCycleIssueEndpoint,
-    CycleIssueGroupedEndpoint,
+    CycleUserPropertiesEndpoint,
 )


@@ -45,12 +45,7 @@ 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>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:issue_id>/",
        CycleIssueViewSet.as_view(
            {
                "get": "retrieve",
@@ -90,4 +85,9 @@ urlpatterns = [
        TransferCycleIssueEndpoint.as_view(),
        name="transfer-issues",
    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/user-properties/",
+        CycleUserPropertiesEndpoint.as_view(),
+        name="cycle-user-filters",
+    )
 ]
@@ -40,7 +40,7 @@ urlpatterns = [
        name="inbox-issue",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/<uuid:issue_id>/",
        InboxIssueViewSet.as_view(
            {
                "get": "retrieve",
@@ -3,8 +3,6 @@ from django.urls import path

 from plane.app.views import (
    IssueViewSet,
-    IssueListEndpoint,
-    IssueListGroupedEndpoint,
    LabelViewSet,
    BulkCreateIssueLabelsEndpoint,
    BulkDeleteIssuesEndpoint,
@@ -37,16 +35,6 @@ 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(
@@ -247,7 +235,7 @@ urlpatterns = [
    ## End Comment Reactions
    ## IssueProperty
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-display-properties/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-properties/",
        IssueUserDisplayPropertyEndpoint.as_view(),
        name="project-issue-display-properties",
    ),
@@ -287,16 +275,17 @@ urlpatterns = [
        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-relation/",
        IssueRelationViewSet.as_view(
            {
+                "get": "list",
                "post": "create",
            }
        ),
        name="issue-relation",
    ),
    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-relation/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/remove-relation/",
        IssueRelationViewSet.as_view(
            {
-                "delete": "destroy",
+                "post": "remove_relation",
            }
        ),
        name="issue-relation",
@@ -7,7 +7,7 @@ from plane.app.views import (
    ModuleLinkViewSet,
    ModuleFavoriteViewSet,
    BulkImportModulesEndpoint,
-    ModuleIssueGroupedEndpoint,
+    ModuleUserPropertiesEndpoint
 )


@@ -45,12 +45,7 @@ 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>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/<uuid:issue_id>/",
        ModuleIssueViewSet.as_view(
            {
                "get": "retrieve",
@@ -107,4 +102,9 @@ urlpatterns = [
        BulkImportModulesEndpoint.as_view(),
        name="bulk-modules-create",
    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/user-properties/",
+        ModuleUserPropertiesEndpoint.as_view(),
+        name="cycle-user-filters",
+    )
 ]
@@ -13,6 +13,7 @@ from plane.app.views import (
    UserProjectInvitationsViewset,
    ProjectPublicCoverImagesEndpoint,
    ProjectDeployBoardViewSet,
+    UserProjectRolesEndpoint,
 )


@@ -65,7 +66,7 @@ urlpatterns = [
        name="project-member-invite",
    ),
    path(
-        "users/me/invitations/projects/",
+        "users/me/workspaces/<str:slug>/projects/invitations/",
        UserProjectInvitationsViewset.as_view(
            {
                "get": "list",
@@ -75,7 +76,12 @@ urlpatterns = [
        name="user-project-invitations",
    ),
    path(
-        "workspaces/<str:slug>/projects/join/",
+        "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>/",
        ProjectJoinEndpoint.as_view(),
        name="project-join",
    ),
@@ -7,6 +7,7 @@ from plane.app.views import (
    UpdateUserTourCompletedEndpoint,
    UserActivityEndpoint,
    ChangePasswordEndpoint,
+    SetUserPasswordEndpoint,
    ## End User
    ## Workspaces
    UserWorkSpacesEndpoint,
@@ -63,7 +64,7 @@ urlpatterns = [
        name="user-tour",
    ),
    path(
-        "users/workspaces/<str:slug>/activities/",
+        "users/me/activities/",
        UserActivityEndpoint.as_view(),
        name="user-activities",
    ),
@@ -89,5 +90,10 @@ urlpatterns = [
        UserWorkspaceDashboardEndpoint.as_view(),
        name="user-workspace-dashboard",
    ),
+    path(
+        "users/me/set-password/",
+        SetUserPasswordEndpoint.as_view(),
+        name="set-password",
+    ),
    ## End User Graph
 ]
@@ -5,7 +5,7 @@ from plane.app.views import (
    IssueViewViewSet,
    GlobalViewViewSet,
    GlobalViewIssuesViewSet,
-    IssueViewFavoriteViewSet,
+    IssueViewFavoriteViewSet, 
 )


@@ -18,6 +18,8 @@ from plane.app.views import (
    WorkspaceUserProfileEndpoint,
    WorkspaceUserProfileIssuesEndpoint,
    WorkspaceLabelsEndpoint,
+    WorkspaceProjectMemberEndpoint,
+    WorkspaceUserPropertiesEndpoint,
 )


@@ -65,6 +67,7 @@ urlpatterns = [
            {
                "delete": "destroy",
                "get": "retrieve",
+                "patch": "partial_update",
            }
        ),
        name="workspace-invitations",
@@ -91,6 +94,11 @@ urlpatterns = [
        WorkSpaceMemberViewSet.as_view({"get": "list"}),
        name="workspace-member",
    ),
+    path(
+        "workspaces/<str:slug>/project-members/",
+        WorkspaceProjectMemberEndpoint.as_view(),
+        name="workspace-member-roles",
+    ),
    path(
        "workspaces/<str:slug>/members/<uuid:pk>/",
        WorkSpaceMemberViewSet.as_view(
@@ -194,4 +202,9 @@ urlpatterns = [
        WorkspaceLabelsEndpoint.as_view(),
        name="workspace-labels",
    ),
+    path(
+        "workspaces/<str:slug>/user-properties/",
+        WorkspaceUserPropertiesEndpoint.as_view(),
+        name="workspace-user-filters",
+    )
 ]
@@ -11,6 +11,7 @@ from .project import (
    ProjectFavoritesViewSet,
    ProjectPublicCoverImagesEndpoint,
    ProjectDeployBoardViewSet,
+    UserProjectRolesEndpoint,
 )
 from .user import (
    UserEndpoint,
@@ -44,6 +45,8 @@ from .workspace import (
    WorkspaceUserProfileEndpoint,
    WorkspaceUserProfileIssuesEndpoint,
    WorkspaceLabelsEndpoint,
+    WorkspaceProjectMemberEndpoint,
+    WorkspaceUserPropertiesEndpoint,
 )
 from .state import StateViewSet
 from .view import (
@@ -58,13 +61,11 @@ from .cycle import (
    CycleDateCheckEndpoint,
    CycleFavoriteViewSet,
    TransferCycleIssueEndpoint,
-    CycleIssueGroupedEndpoint,
+    CycleUserPropertiesEndpoint,
 )
-from .asset import FileAssetEndpoint, UserAssetsEndpoint
+from .asset import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
 from .issue import (
    IssueViewSet,
-    IssueListEndpoint,
-    IssueListGroupedEndpoint,
    WorkSpaceIssuesEndpoint,
    IssueActivityEndpoint,
    IssueCommentViewSet,
@@ -85,20 +86,19 @@ 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 (
@@ -106,7 +106,7 @@ from .module import (
    ModuleIssueViewSet,
    ModuleLinkViewSet,
    ModuleFavoriteViewSet,
-    ModuleIssueGroupedEndpoint,
+    ModuleUserPropertiesEndpoint,
 )

 from .api import ApiTokenEndpoint
@@ -135,7 +135,6 @@ from .page import (
    PageFavoriteViewSet,
    PageLogEndpoint,
    SubPagesEndpoint,
-    CreateIssueFromBlockEndpoint,
 )

 from .search import GlobalSearchEndpoint, IssueSearchEndpoint
@@ -168,4 +167,8 @@ from .exporter import ExportIssuesEndpoint

 from .config import ConfigurationEndpoint

-from .webhook import WebhookEndpoint, WebhookLogsEndpoint, WebhookSecretRegenerateEndpoint
+from .webhook import (
+    WebhookEndpoint,
+    WebhookLogsEndpoint,
+    WebhookSecretRegenerateEndpoint,
+)
@@ -4,7 +4,7 @@ from rest_framework.response import Response
 from rest_framework.parsers import MultiPartParser, FormParser, JSONParser

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

@@ -34,10 +34,20 @@ class FileAssetEndpoint(BaseAPIView):
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
    
-    def patch(self, request, workspace_id, asset_key):
+    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 = request.data.get("is_deleted", file_asset.is_deleted)
+        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()
        return Response(status=status.HTTP_204_NO_CONTENT)

@@ -63,8 +73,6 @@ class UserAssetsEndpoint(BaseAPIView):

    def delete(self, request, asset_key):
        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()
+        file_asset.is_deleted = True
+        file_asset.save()
        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -1,5 +1,9 @@
 ## Python imports
-import jwt
+import uuid
+import os
+import json
+import random
+import string

 ## Django imports
 from django.contrib.auth.tokens import PasswordResetTokenGenerator
@@ -8,80 +12,117 @@ 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 import permissions
+from rest_framework.permissions import AllowAny
 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
-from plane.bgtasks.email_verification_task import email_verification
+from plane.db.models import User, WorkspaceMemberInvite
+from plane.license.utils.instance_value import get_configuration_value
 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


-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 get_tokens_for_user(user):
+    refresh = RefreshToken.for_user(user)
+    return (
+        str(refresh.access_token),
+        str(refresh),
+    )


-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"])
+def generate_magic_token(email):
+    key = "magic_" + str(email)

-            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
-            )
+    ## 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


 class ForgotPasswordEndpoint(BaseAPIView):
-    permission_classes = [permissions.AllowAny]
+    permission_classes = [
+        AllowAny,
+    ]

    def post(self, request):
        email = request.data.get("email")

-        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')
+        try:
+            validate_email(email)
+        except ValidationError:
+            return Response(
+                {"error": "Please enter a valid email"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )

+        # 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,
@@ -92,30 +133,40 @@ class ForgotPasswordEndpoint(BaseAPIView):


 class ResetPasswordEndpoint(BaseAPIView):
-    permission_classes = [permissions.AllowAny]
+    permission_classes = [
+        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 not valid, please check the new one"},
+                    {"error": "Token is invalid"},
                    status=status.HTTP_401_UNAUTHORIZED,
                )
-            serializer = ResetPasswordSerializer(data=request.data)

+            # 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()
-                response = {
-                    "status": "success",
-                    "code": status.HTTP_200_OK,
-                    "message": "Password updated successfully",
+
+                # 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,
                }

-                return Response(response)
+                return Response(data, status=status.HTTP_200_OK)
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        except DjangoUnicodeDecodeError as indentifier:
@@ -128,24 +179,289 @@ 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():
-            # Check old password
-            if not user.object.check_password(serializer.data.get("old_password")):
+            if not user.check_password(serializer.data.get("old_password")):
                return Response(
-                    {"old_password": ["Wrong password."]},
+                    {"error": "Old password is not correct"},
                    status=status.HTTP_400_BAD_REQUEST,
                )
            # set_password also hashes the password that the user will get
-            self.object.set_password(serializer.data.get("new_password"))
-            self.object.save()
-            response = {
-                "status": "success",
-                "code": status.HTTP_200_OK,
-                "message": "Password updated successfully",
-            }
-
-            return Response(response)
-
+            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,
+            }
+            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)
+
+        # 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,
+                )
@@ -1,10 +1,7 @@
 # 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
@@ -18,8 +15,7 @@ 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_exception, capture_message
+from sentry_sdk import capture_message

 # Module imports
 from . import BaseAPIView
@@ -31,7 +27,9 @@ from plane.db.models import (
    ProjectMember,
 )
 from plane.settings.redis import redis_instance
-from plane.bgtasks.magic_link_code_task import magic_link
+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


 def get_tokens_for_user(user):
@@ -46,17 +44,16 @@ class SignUpEndpoint(BaseAPIView):
    permission_classes = (AllowAny,)

    def post(self, request):
-        if not settings.ENABLE_SIGNUP:
+        # Check if the instance configuration is done
+        instance = Instance.objects.first()
+        if instance is None or not instance.is_setup_done:
            return Response(
-                {
-                    "error": "New account creation is disabled. Please contact your site administrator"
-                },
+                {"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(
@@ -64,8 +61,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:
@@ -74,6 +71,31 @@ 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(
@@ -85,6 +107,7 @@ 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")
@@ -92,93 +115,13 @@ class SignUpEndpoint(BaseAPIView):
        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()
-
-        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)


@@ -186,6 +129,14 @@ 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)

@@ -196,8 +147,8 @@ class SignInEndpoint(BaseAPIView):
                status=status.HTTP_400_BAD_REQUEST,
            )

+        # Validate email
        email = email.strip().lower()
-
        try:
            validate_email(email)
        except ValidationError as e:
@@ -206,33 +157,53 @@ class SignInEndpoint(BaseAPIView):
                status=status.HTTP_400_BAD_REQUEST,
            )

+        # Get the user
        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,
-            )
+        # 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,
+                )

-        # 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,
+        # Create the user
+        else:
+            ENABLE_SIGNUP, = get_configuration_value(
+                [
+                    {
+                        "key": "ENABLE_SIGNUP",
+                        "default": os.environ.get("ENABLE_SIGNUP"),
+                    },
+                ]
            )
-        if not user.is_active:
-            return Response(
-                {
-                    "error": "Your account has been deactivated. Please contact your site administrator."
-                },
-                status=status.HTTP_403_FORBIDDEN,
+            # 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")
@@ -288,7 +259,8 @@ class SignInEndpoint(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,
        )
@@ -296,30 +268,16 @@ class SignInEndpoint(BaseAPIView):
        # 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_IN",
-                    },
-                )
-        except RequestException as e:
-            capture_exception(e)
+        # 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,
+        )

        access_token, refresh_token = get_tokens_for_user(user)
        data = {
@@ -352,77 +310,20 @@ 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()

@@ -441,71 +342,20 @@ class MagicSignInEndpoint(BaseAPIView):
            email = data["email"]

            if str(token) == str(user_token):
-                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 = 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,
+                )

+                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")
@@ -561,7 +411,8 @@ 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,
                )
@@ -43,20 +43,25 @@ 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)

+        # 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,
-                event_data=json.dumps(response.data, cls=DjangoJSONEncoder),
+                payload=response.data,
+                kw=self.kwargs,
                action=self.request.method,
                slug=self.workspace_slug,
+                bulk=self.bulk,
            )

        return response
@@ -154,6 +159,21 @@ class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
        if resolve(self.request.path_info).url_name == "project":
            return self.kwargs.get("pk", 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
+
+

 class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
    permission_classes = [
@@ -234,3 +254,17 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
    @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
@@ -11,7 +11,6 @@ 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


@@ -21,84 +20,101 @@ class ConfigurationEndpoint(BaseAPIView):
    ]

    def get(self, request):
-        instance_configuration = InstanceConfiguration.objects.values("key", "value")
+
+        # 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"),
+                },
+            ]
+        )

        data = {}
        # Authentication
-        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["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["magic_login"] = (
-            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"
-        )
+            bool(EMAIL_HOST_USER) and bool(EMAIL_HOST_PASSWORD)
+        ) and ENABLE_MAGIC_LINK_LOGIN == "1"
+
+        data["email_password_login"] = ENABLE_EMAIL_PASSWORD == "1"
        # Slack client
-        data["slack_client_id"] = get_configuration_value(
-            instance_configuration,
-            "SLACK_CLIENT_ID",
-            os.environ.get("SLACK_CLIENT_ID", None),
-        )
+        data["slack_client_id"] = SLACK_CLIENT_ID

        # Posthog
-        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),
-        )
+        data["posthog_api_key"] = POSTHOG_API_KEY
+        data["posthog_host"] = POSTHOG_HOST

        # Unsplash
-        data["has_unsplash_configured"] = bool(
-            get_configuration_value(
-                instance_configuration,
-                "UNSPLASH_ACCESS_KEY",
-                os.environ.get("UNSPLASH_ACCESS_KEY", None),
-            )
-        )
+        data["has_unsplash_configured"] = bool(UNSPLASH_ACCESS_KEY)

        # Open AI settings
-        data["has_openai_configured"] = bool(
-            get_configuration_value(
-                instance_configuration,
-                "OPENAI_API_KEY",
-                os.environ.get("OPENAI_API_KEY", None),
-            )
-        )
+        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")))

        return Response(data, status=status.HTTP_200_OK)
@@ -11,6 +11,10 @@ from django.db.models import (
    Count,
    Prefetch,
    Sum,
+    Case,
+    When,
+    Value,
+    CharField,
 )
 from django.core import serializers
 from django.utils import timezone
@@ -29,8 +33,9 @@ from plane.app.serializers import (
    CycleFavoriteSerializer,
    IssueStateSerializer,
    CycleWriteSerializer,
+    CycleUserPropertiesSerializer,
 )
-from plane.app.permissions import ProjectEntityPermission
+from plane.app.permissions import ProjectEntityPermission, ProjectLitePermission
 from plane.db.models import (
    User,
    Cycle,
@@ -40,6 +45,7 @@ from plane.db.models import (
    IssueLink,
    IssueAttachment,
    Label,
+    CycleUserProperties,
 )
 from plane.bgtasks.issue_activites_task import issue_activity
 from plane.utils.grouper import group_results
@@ -157,6 +163,23 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
                    ),
                )
            )
+            .annotate(
+                status=Case(
+                    When(
+                        Q(start_date__lte=timezone.now())
+                        & Q(end_date__gte=timezone.now()),
+                        then=Value("CURRENT"),
+                    ),
+                    When(start_date__gt=timezone.now(), then=Value("UPCOMING")),
+                    When(end_date__lt=timezone.now(), then=Value("COMPLETED")),
+                    When(
+                        Q(start_date__isnull=True) & Q(end_date__isnull=True),
+                        then=Value("DRAFT"),
+                    ),
+                    default=Value("DRAFT"),
+                    output_field=CharField(),
+                )
+            )
            .prefetch_related(
                Prefetch(
                    "issue_cycle__issue__assignees",
@@ -176,8 +199,9 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
    def list(self, request, slug, project_id):
        queryset = self.get_queryset()
        cycle_view = request.GET.get("cycle_view", "all")
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]

-        queryset = queryset.order_by("-is_favorite","-created_at")
+        queryset = queryset.order_by("-is_favorite", "-created_at")

        # Current Cycle
        if cycle_view == "current":
@@ -281,44 +305,8 @@ class CycleViewSet(WebhookMixin, BaseViewSet):

            return Response(data, status=status.HTTP_200_OK)

-        # Upcoming Cycles
-        if cycle_view == "upcoming":
-            queryset = queryset.filter(start_date__gt=timezone.now())
-            return Response(
-                CycleSerializer(queryset, many=True).data, status=status.HTTP_200_OK
-            )
-
-        # Completed Cycles
-        if cycle_view == "completed":
-            queryset = queryset.filter(end_date__lt=timezone.now())
-            return Response(
-                CycleSerializer(queryset, many=True).data, status=status.HTTP_200_OK
-            )
-
-        # Draft Cycles
-        if cycle_view == "draft":
-            queryset = queryset.filter(
-                end_date=None,
-                start_date=None,
-            )
-
-            return Response(
-                CycleSerializer(queryset, many=True).data, status=status.HTTP_200_OK
-            )
-
-        # Incomplete Cycles
-        if cycle_view == "incomplete":
-            queryset = queryset.filter(
-                Q(end_date__gte=timezone.now().date()) | Q(end_date__isnull=True),
-            )
-            return Response(
-                CycleSerializer(queryset, many=True).data, status=status.HTTP_200_OK
-            )
-
-        # If no matching view is found return all cycles
-        return Response(
-            CycleSerializer(queryset, many=True).data, status=status.HTTP_200_OK
-        )
+        cycles = CycleSerializer(queryset, many=True).data
+        return Response(cycles, status=status.HTTP_200_OK)

    def create(self, request, slug, project_id):
        if (
@@ -502,7 +490,10 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
 class CycleIssueViewSet(WebhookMixin, BaseViewSet):
    serializer_class = CycleIssueSerializer
    model = CycleIssue
-    webhook_event = "cycle"
+
+    webhook_event = "cycle_issue"
+    bulk = True
+
    permission_classes = [
        ProjectEntityPermission,
    ]
@@ -536,9 +527,8 @@ 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)
@@ -548,7 +538,6 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
                .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")
@@ -572,25 +561,10 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
                .values("count")
            )
        )
-
-        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
+        serializer = IssueStateSerializer(
+            issues, many=True, fields=fields if fields else None
        )
+        return Response(serializer.data, status=status.HTTP_200_OK)

    def create(self, request, slug, project_id, cycle_id):
        issues = request.data.get("issues", [])
@@ -683,12 +657,13 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
            status=status.HTTP_200_OK,
        )

-    def destroy(self, request, slug, project_id, cycle_id, pk):
+    def destroy(self, request, slug, project_id, cycle_id, issue_id):
        cycle_issue = CycleIssue.objects.get(
-            pk=pk, workspace__slug=slug, project_id=project_id, cycle_id=cycle_id
+            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.delay(
            type="cycle.activity.deleted",
            requested_data=json.dumps(
@@ -698,64 +673,15 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
                }
            ),
            actor_id=str(self.request.user.id),
-            issue_id=str(self.kwargs.get("pk", None)),
+            issue_id=str(issue_id),
            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,
@@ -868,4 +794,40 @@ 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)
+
+
+class CycleUserPropertiesEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectLitePermission,
+    ]
+
+    def patch(self, request, slug, project_id, cycle_id):
+        cycle_properties = CycleUserProperties.objects.get(
+            user=request.user,
+            cycle_id=cycle_id,
+            project_id=project_id,
+            workspace__slug=slug,
+        )
+
+        cycle_properties.filters = request.data.get("filters", cycle_properties.filters)
+        cycle_properties.display_filters = request.data.get(
+            "display_filters", cycle_properties.display_filters
+        )
+        cycle_properties.display_properties = request.data.get(
+            "display_properties", cycle_properties.display_properties
+        )
+        cycle_properties.save()
+
+        serializer = CycleUserPropertiesSerializer(cycle_properties)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    def get(self, request, slug, project_id, cycle_id):
+        cycle_properties, _ = CycleUserProperties.objects.get_or_create(
+            user=request.user,
+            project_id=project_id,
+            cycle_id=cycle_id,
+            workspace__slug=slug,
+        )
+        serializer = CycleUserPropertiesSerializer(cycle_properties)
+        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -53,11 +53,11 @@ class BulkEstimatePointEndpoint(BaseViewSet):
            )

        estimate_points = request.data.get("estimate_points", [])
-
-        if not len(estimate_points) or len(estimate_points) > 8:
+        
+        serializer = EstimatePointSerializer(data=request.data.get("estimate_points"), many=True)
+        if not serializer.is_valid():
            return Response(
-                {"error": "Estimate points are required"},
-                status=status.HTTP_400_BAD_REQUEST,
+                serializer.errors, status=status.HTTP_400_BAD_REQUEST
            )

        estimate_serializer = EstimateSerializer(data=request.data.get("estimate"))
@@ -1,5 +1,6 @@
 # Python imports
 import requests
+import os

 # Third party imports
 from openai import OpenAI
@@ -15,23 +16,31 @@ 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 api_key or not gpt_engine:
+        if not OPENAI_API_KEY or not GPT_ENGINE:
            return Response(
                {"error": "OpenAI API key and engine is required"},
                status=status.HTTP_400_BAD_REQUEST,
@@ -47,16 +56,12 @@ 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=api_key,
+            api_key=OPENAI_API_KEY,
        )

        response = client.chat.completions.create(
-            model=gpt_engine,
+            model=GPT_ENGINE,
            messages=[{"role": "user", "content": final_text}],
        )

@@ -83,16 +88,28 @@ 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
        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={settings.UNSPLASH_ACCESS_KEY}&query={query}&page=${page}&per_page={per_page}"
+            f"https://api.unsplash.com/search/photos/?client_id={UNSPLASH_ACCESS_KEY}&query={query}&page=${page}&per_page={per_page}"
            if query
-            else f"https://api.unsplash.com/photos/?client_id={settings.UNSPLASH_ACCESS_KEY}&page={page}&per_page={per_page}"
+            else f"https://api.unsplash.com/photos/?client_id={UNSPLASH_ACCESS_KEY}&page={page}&per_page={per_page}"
        )

        headers = {
@@ -107,7 +107,6 @@ class InboxIssueViewSet(BaseViewSet):
                project_id=project_id,
            )
            .filter(**filters)
-            .annotate(bridge_id=F("issue_inbox__id"))
            .select_related("workspace", "project", "state", "parent")
            .prefetch_related("assignees", "labels")
            .order_by("issue_inbox__snoozed_till", "issue_inbox__status")
@@ -204,9 +203,9 @@ class InboxIssueViewSet(BaseViewSet):
        serializer = IssueStateInboxSerializer(issue)
        return Response(serializer.data, status=status.HTTP_200_OK)

-    def partial_update(self, request, slug, project_id, inbox_id, pk):
+    def partial_update(self, request, slug, project_id, inbox_id, issue_id):
        inbox_issue = InboxIssue.objects.get(
-            pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+            issue_id=issue_id, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
        )
        # Get the project member
        project_member = ProjectMember.objects.get(
@@ -316,19 +315,16 @@ class InboxIssueViewSet(BaseViewSet):
                InboxIssueSerializer(inbox_issue).data, status=status.HTTP_200_OK
            )

-    def retrieve(self, request, slug, project_id, inbox_id, pk):
-        inbox_issue = InboxIssue.objects.get(
-            pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
-        )
+    def retrieve(self, request, slug, project_id, inbox_id, issue_id):
        issue = Issue.objects.get(
-            pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
+            pk=issue_id, workspace__slug=slug, project_id=project_id
        )
        serializer = IssueStateInboxSerializer(issue)
        return Response(serializer.data, status=status.HTTP_200_OK)

-    def destroy(self, request, slug, project_id, inbox_id, pk):
+    def destroy(self, request, slug, project_id, inbox_id, issue_id):
        inbox_issue = InboxIssue.objects.get(
-            pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+            issue_id=issue_id, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
        )
        # Get the project member
        project_member = ProjectMember.objects.get(
@@ -350,7 +346,7 @@ class InboxIssueViewSet(BaseViewSet):
        if inbox_issue.status in [-2, -1, 0, 2]:
            # Delete the issue also
            Issue.objects.filter(
-                workspace__slug=slug, project_id=project_id, pk=inbox_issue.issue_id
+                workspace__slug=slug, project_id=project_id, pk=issue_id
            ).delete()

        inbox_issue.delete()
@@ -4,6 +4,7 @@ import random
 from itertools import chain

 # Django imports
+from django.db import models
 from django.utils import timezone
 from django.db.models import (
    Prefetch,
@@ -51,6 +52,7 @@ from plane.app.serializers import (
    IssueRelationSerializer,
    RelatedIssueSerializer,
    IssuePublicSerializer,
+    IssueRelationLiteSerializer,
 )
 from plane.app.permissions import (
    ProjectEntityPermission,
@@ -128,21 +130,6 @@ class IssueViewSet(WebhookMixin, BaseViewSet):
                    queryset=IssueReaction.objects.select_related("actor"),
                )
            )
-        ).distinct()
-
-    @method_decorator(gzip_page)
-    def list(self, request, slug, project_id):
-        filters = issue_filters(request.query_params, "GET")
-
-        # Custom ordering for priority and state
-        priority_order = ["urgent", "high", "medium", "low", "none"]
-        state_order = ["backlog", "unstarted", "started", "completed", "cancelled"]
-
-        order_by_param = request.GET.get("order_by", "-created_at")
-
-        issue_queryset = (
-            self.get_queryset()
-            .filter(**filters)
            .annotate(cycle_id=F("issue_cycle__cycle_id"))
            .annotate(module_id=F("issue_module__module_id"))
            .annotate(
@@ -157,7 +144,26 @@ class IssueViewSet(WebhookMixin, BaseViewSet):
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
            )
-        )
+            .annotate(
+                is_subscribed=Exists(
+                    IssueSubscriber.objects.filter(
+                        subscriber=self.request.user, issue_id=OuterRef("id")
+                    )
+                )
+            )
+        ).distinct()
+
+    @method_decorator(gzip_page)
+    def list(self, request, slug, project_id):
+        filters = issue_filters(request.query_params, "GET")
+
+        # Custom ordering for priority and state
+        priority_order = ["urgent", "high", "medium", "low", "none"]
+        state_order = ["backlog", "unstarted", "started", "completed", "cancelled"]
+
+        order_by_param = request.GET.get("order_by", "-created_at")
+
+        issue_queryset = self.get_queryset().filter(**filters)

        # Priority Ordering
        if order_by_param == "priority" or order_by_param == "-priority":
@@ -215,24 +221,9 @@ class IssueViewSet(WebhookMixin, BaseViewSet):
        else:
            issue_queryset = issue_queryset.order_by(order_by_param)

-        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,
-            )
-
+        issues = IssueSerializer(
+            issue_queryset, many=True, fields=self.fields, expand=self.expand
+        ).data
        return Response(issues, status=status.HTTP_200_OK)

    def create(self, request, slug, project_id):
@@ -270,7 +261,10 @@ class IssueViewSet(WebhookMixin, BaseViewSet):
            .annotate(count=Func(F("id"), function="Count"))
            .values("count")
        ).get(workspace__slug=slug, project_id=project_id, pk=pk)
-        return Response(IssueSerializer(issue).data, status=status.HTTP_200_OK)
+        return Response(
+            IssueSerializer(issue, fields=self.fields, expand=self.expand).data,
+            status=status.HTTP_200_OK,
+        )

    def partial_update(self, request, slug, project_id, pk=None):
        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
@@ -311,104 +305,6 @@ 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):
@@ -596,7 +492,7 @@ class IssueActivityEndpoint(BaseAPIView):
 class IssueCommentViewSet(WebhookMixin, BaseViewSet):
    serializer_class = IssueCommentSerializer
    model = IssueComment
-    webhook_event = "issue-comment"
+    webhook_event = "issue_comment"
    permission_classes = [
        ProjectLitePermission,
    ]
@@ -702,16 +598,19 @@ class IssueUserDisplayPropertyEndpoint(BaseAPIView):
        ProjectLitePermission,
    ]

-    def post(self, request, slug, project_id):
-        issue_property, created = IssueProperty.objects.get_or_create(
+    def patch(self, request, slug, project_id):
+        issue_property = IssueProperty.objects.get(
            user=request.user,
            project_id=project_id,
        )

-        if not created:
-            issue_property.properties = request.data.get("properties", {})
-            issue_property.save()
-        issue_property.properties = request.data.get("properties", {})
+        issue_property.filters = request.data.get("filters", issue_property.filters)
+        issue_property.display_filters = request.data.get(
+            "display_filters", issue_property.display_filters
+        )
+        issue_property.display_properties = request.data.get(
+            "display_properties", issue_property.display_properties
+        )
        issue_property.save()
        serializer = IssuePropertySerializer(issue_property)
        return Response(serializer.data, status=status.HTTP_201_CREATED)
@@ -820,6 +719,13 @@ class SubIssuesEndpoint(BaseAPIView):
                .annotate(count=Func(F("id"), function="Count"))
                .values("count")
            )
+            .annotate(
+                is_subscribed=Exists(
+                    IssueSubscriber.objects.filter(
+                        subscriber=self.request.user, issue_id=OuterRef("id")
+                    )
+                )
+            )
            .prefetch_related(
                Prefetch(
                    "issue_reactions",
@@ -840,7 +746,7 @@ class SubIssuesEndpoint(BaseAPIView):
            item["state_group"]: item["state_count"] for item in state_distribution
        }

-        serializer = IssueLiteSerializer(
+        serializer = IssueSerializer(
            sub_issues,
            many=True,
        )
@@ -887,7 +793,7 @@ class SubIssuesEndpoint(BaseAPIView):
        ]

        return Response(
-            IssueFlatSerializer(updated_sub_issues, many=True).data,
+            IssueSerializer(updated_sub_issues, many=True).data,
            status=status.HTTP_200_OK,
        )

@@ -1083,6 +989,7 @@ 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")

@@ -1173,13 +1080,9 @@ class IssueArchiveViewSet(BaseViewSet):
            else issue_queryset.filter(parent__isnull=True)
        )

-        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)
-
+        issues = IssueLiteSerializer(
+            issue_queryset, many=True, fields=fields if fields else None
+        ).data
        return Response(issues, status=status.HTTP_200_OK)

    def retrieve(self, request, slug, project_id, pk=None):
@@ -1481,23 +1384,68 @@ class IssueRelationViewSet(BaseViewSet):
            .distinct()
        )

+    def list(self, request, slug, project_id, issue_id):
+        issue_relations = (
+            IssueRelation.objects.filter(Q(issue_id=issue_id) | Q(related_issue=issue_id))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .order_by("-created_at")
+            .distinct()
+        )
+
+        blocking_issues = issue_relations.filter(relation_type="blocked_by", related_issue_id=issue_id)
+        blocked_by_issues = issue_relations.filter(relation_type="blocked_by", issue_id=issue_id)
+        duplicate_issues = issue_relations.filter(issue_id=issue_id, relation_type="duplicate")
+        duplicate_issues_related = issue_relations.filter(related_issue_id=issue_id, relation_type="duplicate")
+        relates_to_issues = issue_relations.filter(issue_id=issue_id, relation_type="relates_to")
+        relates_to_issues_related = issue_relations.filter(related_issue_id=issue_id, relation_type="relates_to")
+
+        blocked_by_issues_serialized = IssueRelationSerializer(blocked_by_issues, many=True).data
+        duplicate_issues_serialized = IssueRelationSerializer(duplicate_issues, many=True).data
+        relates_to_issues_serialized = IssueRelationSerializer(relates_to_issues, many=True).data
+
+        # revere relation for blocked by issues
+        blocking_issues_serialized = RelatedIssueSerializer(blocking_issues, many=True).data
+        # reverse relation for duplicate issues
+        duplicate_issues_related_serialized = RelatedIssueSerializer(duplicate_issues_related, many=True).data
+        # reverse relation for related issues
+        relates_to_issues_related_serialized = RelatedIssueSerializer(relates_to_issues_related, many=True).data
+
+        response_data = {
+            'blocking': blocking_issues_serialized,
+            'blocked_by': blocked_by_issues_serialized,
+            'duplicate': duplicate_issues_serialized + duplicate_issues_related_serialized,
+            'relates_to': relates_to_issues_serialized + relates_to_issues_related_serialized,
+        }
+
+        return Response(response_data, status=status.HTTP_200_OK)
+
+
    def create(self, request, slug, project_id, issue_id):
-        related_list = request.data.get("related_list", [])
-        relation = request.data.get("relation", None)
+        relation_type = request.data.get("relation_type", None)
+        issues = request.data.get("issues", [])
        project = Project.objects.get(pk=project_id)

+        # If the current issue is duplicate of another issue then the current issue's state will be marked as duplicate
+        if relation_type == "duplicate":
+            issue = Issue.objects.get(pk=issue_id)
+            issue.state = State.objects.get(group="cancelled", workspace__slug=slug, project_id=project_id)
+            issue.save(update_fields=["state"])
+
        issue_relation = IssueRelation.objects.bulk_create(
            [
                IssueRelation(
-                    issue_id=related_issue["issue"],
-                    related_issue_id=related_issue["related_issue"],
-                    relation_type=related_issue["relation_type"],
+                    issue_id=issue if relation_type == "blocking" else issue_id,
+                    related_issue_id=issue_id if relation_type == "blocking" else issue,
+                    relation_type="blocked_by" if relation_type == "blocking" else relation_type,
                    project_id=project_id,
                    workspace_id=project.workspace_id,
                    created_by=request.user,
                    updated_by=request.user,
                )
-                for related_issue in related_list
+                for issue in issues
            ],
            batch_size=10,
            ignore_conflicts=True,
@@ -1513,7 +1461,7 @@ class IssueRelationViewSet(BaseViewSet):
            epoch=int(timezone.now().timestamp()),
        )

-        if relation == "blocking":
+        if relation_type == "blocking":
            return Response(
                RelatedIssueSerializer(issue_relation, many=True).data,
                status=status.HTTP_201_CREATED,
@@ -1524,10 +1472,18 @@ class IssueRelationViewSet(BaseViewSet):
                status=status.HTTP_201_CREATED,
            )

-    def destroy(self, request, slug, project_id, issue_id, pk):
-        issue_relation = IssueRelation.objects.get(
-            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
-        )
+    def remove_relation(self, request, slug, project_id, issue_id):
+        relation_type = request.data.get("relation_type", None)
+        related_issue = request.data.get("related_issue", None)
+
+        if relation_type == "blocking":
+            issue_relation = IssueRelation.objects.get(
+                workspace__slug=slug, project_id=project_id, issue_id=related_issue, related_issue_id=issue_id
+            )
+        else:
+            issue_relation = IssueRelation.objects.get(
+                workspace__slug=slug, project_id=project_id, issue_id=issue_id, related_issue_id=related_issue
+            )
        current_instance = json.dumps(
            IssueRelationSerializer(issue_relation).data,
            cls=DjangoJSONEncoder,
@@ -1535,7 +1491,7 @@ class IssueRelationViewSet(BaseViewSet):
        issue_relation.delete()
        issue_activity.delay(
            type="issue_relation.activity.deleted",
-            requested_data=json.dumps({"related_list": None}),
+            requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
            actor_id=str(request.user.id),
            issue_id=str(issue_id),
            project_id=str(project_id),
@@ -1580,6 +1536,7 @@ 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"]
@@ -1662,17 +1619,9 @@ class IssueDraftViewSet(BaseViewSet):
        else:
            issue_queryset = issue_queryset.order_by(order_by_param)

-        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,
-            )
-
+        issues = IssueLiteSerializer(
+            issue_queryset, many=True, fields=fields if fields else None
+        ).data
        return Response(issues, status=status.HTTP_200_OK)

    def create(self, request, slug, project_id):
@@ -1681,6 +1630,7 @@ class IssueDraftViewSet(BaseViewSet):
        serializer = IssueCreateSerializer(
            data=request.data,
            context={
+                "issue_type": "draft-issue",
                "project_id": project_id,
                "workspace_id": project.workspace_id,
                "default_assignee_id": project.default_assignee_id,
@@ -1750,4 +1700,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)
@@ -21,8 +21,9 @@ from plane.app.serializers import (
    ModuleLinkSerializer,
    ModuleFavoriteSerializer,
    IssueStateSerializer,
+    ModuleUserPropertiesSerializer,
 )
-from plane.app.permissions import ProjectEntityPermission
+from plane.app.permissions import ProjectEntityPermission, ProjectLitePermission
 from plane.db.models import (
    Module,
    ModuleIssue,
@@ -32,6 +33,7 @@ from plane.db.models import (
    ModuleFavorite,
    IssueLink,
    IssueAttachment,
+    ModuleUserProperties,
 )
 from plane.bgtasks.issue_activites_task import issue_activity
 from plane.utils.grouper import group_results
@@ -54,7 +56,6 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
        )

    def get_queryset(self):
-
        subquery = ModuleFavorite.objects.filter(
            user=self.request.user,
            module_id=OuterRef("pk"),
@@ -136,7 +137,7 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
                    ),
                )
            )
-            .order_by("-is_favorite","-created_at")
+            .order_by("-is_favorite", "-created_at")
        )

    def create(self, request, slug, project_id):
@@ -153,6 +154,14 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

+    def list(self, request, slug, project_id):
+        queryset = self.get_queryset()
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
+        modules = ModuleSerializer(
+            queryset, many=True, fields=fields if fields else None
+        ).data
+        return Response(modules, status=status.HTTP_200_OK)
+
    def retrieve(self, request, slug, project_id, pk):
        queryset = self.get_queryset().get(pk=pk)

@@ -283,9 +292,11 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
        return Response(status=status.HTTP_204_NO_CONTENT)


-class ModuleIssueViewSet(BaseViewSet):
+class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
    serializer_class = ModuleIssueSerializer
    model = ModuleIssue
+    webhook_event = "module_issue"
+    bulk = True

    filterset_fields = [
        "issue__labels__id",
@@ -321,9 +332,8 @@ class ModuleIssueViewSet(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)
@@ -333,7 +343,6 @@ class ModuleIssueViewSet(BaseViewSet):
                .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")
@@ -357,24 +366,10 @@ class ModuleIssueViewSet(BaseViewSet):
                .values("count")
            )
        )
-        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
+        serializer = IssueStateSerializer(
+            issues, many=True, fields=fields if fields else None
        )
+        return Response(serializer.data, status=status.HTTP_200_OK)

    def create(self, request, slug, project_id, module_id):
        issues = request.data.get("issues", [])
@@ -457,77 +452,31 @@ class ModuleIssueViewSet(BaseViewSet):
            status=status.HTTP_200_OK,
        )

-    def destroy(self, request, slug, project_id, module_id, pk):
+    def destroy(self, request, slug, project_id, module_id, issue_id):
        module_issue = ModuleIssue.objects.get(
-            workspace__slug=slug, project_id=project_id, module_id=module_id, pk=pk
+            workspace__slug=slug,
+            project_id=project_id,
+            module_id=module_id,
+            issue_id=issue_id,
        )
-        module_issue.delete()
        issue_activity.delay(
            type="module.activity.deleted",
            requested_data=json.dumps(
                {
                    "module_id": str(module_id),
-                    "issues": [str(module_issue.issue_id)],
+                    "issues": [str(issue_id)],
                }
            ),
            actor_id=str(request.user.id),
-            issue_id=str(pk),
+            issue_id=str(issue_id),
            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,
@@ -583,4 +532,42 @@ 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)
+
+
+class ModuleUserPropertiesEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectLitePermission,
+    ]
+
+    def patch(self, request, slug, project_id, module_id):
+        module_properties = ModuleUserProperties.objects.get(
+            user=request.user,
+            module_id=module_id,
+            project_id=project_id,
+            workspace__slug=slug,
+        )
+
+        module_properties.filters = request.data.get(
+            "filters", module_properties.filters
+        )
+        module_properties.display_filters = request.data.get(
+            "display_filters", module_properties.display_filters
+        )
+        module_properties.display_properties = request.data.get(
+            "display_properties", module_properties.display_properties
+        )
+        module_properties.save()
+
+        serializer = ModuleUserPropertiesSerializer(module_properties)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    def get(self, request, slug, project_id, module_id):
+        module_properties, _ = ModuleUserProperties.objects.get_or_create(
+            user=request.user,
+            project_id=project_id,
+            module_id=module_id,
+            workspace__slug=slug,
+        )
+        serializer = ModuleUserPropertiesSerializer(module_properties)
+        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -2,7 +2,6 @@
 import uuid
 import requests
 import os
-from requests.exceptions import RequestException

 # Django imports
 from django.utils import timezone
@@ -29,7 +28,10 @@ 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):
@@ -84,7 +86,14 @@ 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 = os.environ.get("GITHUB_CLIENT_SECRET")
+    (CLIENT_SECRET,) = get_configuration_value(
+        [
+            {
+                "key": "GITHUB_CLIENT_SECRET",
+                "default": os.environ.get("GITHUB_CLIENT_SECRET", None),
+            },
+        ]
+    )

    url = f"https://github.com/login/oauth/access_token?client_id={client_id}&client_secret={CLIENT_SECRET}&code={request_token}"
    headers = {"accept": "application/json"}
@@ -133,10 +142,31 @@ 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(
                    {
@@ -146,9 +176,19 @@ 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)

@@ -174,15 +214,7 @@ class OauthEndpoint(BaseAPIView):
                    status=status.HTTP_400_BAD_REQUEST,
                )

-            ## 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.is_active = True
            user.last_active = timezone.now()
            user.last_login_time = timezone.now()
            user.last_login_ip = request.META.get("REMOTE_ADDR")
@@ -239,7 +271,8 @@ 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,
            )
@@ -256,29 +289,17 @@ class OauthEndpoint(BaseAPIView):
                    "last_login_at": timezone.now(),
                },
            )
-            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)
+
+            # 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,
+            )

            access_token, refresh_token = get_tokens_for_user(user)

@@ -289,7 +310,26 @@ class OauthEndpoint(BaseAPIView):
            return Response(data, status=status.HTTP_200_OK)

        except User.DoesNotExist:
-            ## Signup Case
+            (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,
+                )

            username = uuid.uuid4().hex

@@ -305,7 +345,7 @@ class OauthEndpoint(BaseAPIView):
                    status=status.HTTP_400_BAD_REQUEST,
                )

-            user = User(
+            user = User.objects.create(
                username=username,
                email=email,
                mobile_number=mobile_number,
@@ -316,7 +356,6 @@ 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")
@@ -373,7 +412,8 @@ 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,
            )
@@ -381,29 +421,16 @@ class OauthEndpoint(BaseAPIView):
            workspace_member_invites.delete()
            project_member_invites.delete()

-            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)
+            # 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,
+            )

            SocialLoginConnection.objects.update_or_create(
                medium=medium,
@@ -420,4 +447,5 @@ class OauthEndpoint(BaseAPIView):
                "access_token": access_token,
                "refresh_token": refresh_token,
            }
-            return Response(data, status=status.HTTP_201_CREATED)
+
+            return Response(data, status=status.HTTP_201_CREATED)
@@ -22,6 +22,7 @@ from plane.db.models import (
    IssueAssignee,
    IssueActivity,
    PageLog,
+    ProjectMember,
 )
 from plane.app.serializers import (
    PageSerializer,
@@ -140,12 +141,6 @@ class PageViewSet(BaseViewSet):
            pk=page_id, workspace__slug=slug, project_id=project_id
        ).first()

-        # 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)
@@ -155,12 +150,6 @@ class PageViewSet(BaseViewSet):
            pk=page_id, workspace__slug=slug, project_id=project_id
        ).first()

-        # 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()

@@ -168,17 +157,22 @@ class PageViewSet(BaseViewSet):

    def list(self, request, slug, project_id):
        queryset = self.get_queryset().filter(archived_at__isnull=True)
-        return Response(
-            PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK
-        )
+        pages = PageSerializer(queryset, many=True).data
+        return Response(pages, status=status.HTTP_200_OK)

    def archive(self, request, slug, project_id, page_id):
        page = Page.objects.get(pk=page_id, workspace__slug=slug, project_id=project_id)

-        if page.owned_by_id != request.user.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
+        ):
            return Response(
-                {"error": "Only the owner of the page can archive a page"},
-                status=status.HTTP_204_NO_CONTENT,
+                {"error": "Only the owner and admin can archive the page"},
+                status=status.HTTP_400_BAD_REQUEST,
            )

        unarchive_archive_page_and_descendants(page_id, datetime.now())
@@ -188,9 +182,15 @@ 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)

-        if page.owned_by_id != request.user.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
+        ):
            return Response(
-                {"error": "Only the owner of the page can unarchive a page"},
+                {"error": "Only the owner and admin can un archive the page"},
                status=status.HTTP_400_BAD_REQUEST,
            )

@@ -209,13 +209,25 @@ class PageViewSet(BaseViewSet):
            workspace__slug=slug,
        ).filter(archived_at__isnull=False)

-        return Response(
-            PageSerializer(pages, many=True).data, status=status.HTTP_200_OK
-        )
+        pages = PageSerializer(pages, many=True).data
+        return Response(pages, status=status.HTTP_200_OK)
+

    def destroy(self, request, slug, project_id, pk):
        page = Page.objects.get(pk=pk, workspace__slug=slug, project_id=project_id)

+        # 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"},
@@ -227,7 +239,6 @@ class PageViewSet(BaseViewSet):
            parent_id=pk, project_id=project_id, workspace__slug=slug
        ).update(parent=None)

-
        page.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

@@ -310,36 +321,6 @@ 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,
@@ -36,11 +36,14 @@ from plane.app.serializers import (
    ProjectFavoriteSerializer,
    ProjectDeployBoardSerializer,
    ProjectMemberAdminSerializer,
+    ProjectMemberRoleSerializer,
 )

 from plane.app.permissions import (
+    WorkspaceUserPermission,
    ProjectBasePermission,
    ProjectMemberPermission,
+    ProjectLitePermission,
 )

 from plane.db.models import (
@@ -143,6 +146,16 @@ 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()
        )

@@ -158,15 +171,6 @@ 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):
@@ -177,12 +181,9 @@ class ProjectViewSet(WebhookMixin, BaseViewSet):
                    projects, many=True
                ).data,
            )
+        projects = ProjectListSerializer(projects, many=True, fields=fields if fields else None).data
+        return Response(projects, status=status.HTTP_200_OK)

-        return Response(
-            ProjectListSerializer(
-                projects, many=True, fields=fields if fields else None
-            ).data
-        )

    def create(self, request, slug):
        try:
@@ -388,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 = []
@@ -424,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:
@@ -469,6 +470,13 @@ 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(
@@ -593,6 +601,18 @@ 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",
@@ -657,6 +677,25 @@ class ProjectMemberViewSet(BaseViewSet):
                )
            )

+            # Check if the user is already a member of the project and is inactive
+            if ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member_id=member.get("member_id"),
+                is_active=False,
+            ).exists():
+                member_detail = ProjectMember.objects.get(
+                    workspace__slug=slug,
+                    project_id=project_id,
+                    member_id=member.get("member_id"),
+                    is_active=False,
+                )
+                # Check if the user has not deactivated the account
+                user = User.objects.filter(pk=member.get("member_id")).first()
+                if user.is_active:
+                    member_detail.is_active = True
+                    member_detail.save(update_fields=["is_active"])
+
        project_members = ProjectMember.objects.bulk_create(
            bulk_project_members,
            batch_size=10,
@@ -672,13 +711,7 @@ class ProjectMemberViewSet(BaseViewSet):
        return Response(serializer.data, status=status.HTTP_201_CREATED)

    def list(self, request, slug, project_id):
-        project_member = ProjectMember.objects.get(
-            member=request.user,
-            workspace__slug=slug,
-            project_id=project_id,
-            is_active=True,
-        )
-
+        # Get the list of project members for the project
        project_members = ProjectMember.objects.filter(
            project_id=project_id,
            workspace__slug=slug,
@@ -686,10 +719,7 @@ class ProjectMemberViewSet(BaseViewSet):
            is_active=True,
        ).select_related("project", "member", "workspace")

-        if project_member.role > 10:
-            serializer = ProjectMemberAdminSerializer(project_members, many=True)
-        else:
-            serializer = ProjectMemberSerializer(project_members, many=True)
+        serializer = ProjectMemberRoleSerializer(project_members, fields=("id", "member", "role"), many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def partial_update(self, request, slug, project_id, pk):
@@ -1040,4 +1070,21 @@ class ProjectDeployBoardViewSet(BaseViewSet):
        project_deploy_board.save()

        serializer = ProjectDeployBoardSerializer(project_deploy_board)
-        return Response(serializer.data, status=status.HTTP_200_OK)
+        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)
@@ -50,7 +50,8 @@ class GlobalSearchEndpoint(BaseAPIView):
        q = Q()
        for field in fields:
            if field == "sequence_id":
-                sequences = re.findall(r"\d+\.\d+|\d+", query)
+                # Match whole integers only (exclude decimal numbers)
+                sequences = re.findall(r"\b\d+\b", query)
                for sequence_id in sequences:
                    q |= Q(**{"sequence_id": sequence_id})
            else:
@@ -77,7 +77,7 @@ class StateViewSet(BaseViewSet):
        )

        if state.default:
-            return Response({"error": "Default state cannot be deleted"}, status=False)
+            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=pk).exists()
@@ -12,11 +12,14 @@ from plane.app.serializers import (
 )

 from plane.app.views.base import BaseViewSet, BaseAPIView
-from plane.db.models import User, IssueActivity, WorkspaceMember
+from plane.db.models import User, IssueActivity, WorkspaceMember, ProjectMember
 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
@@ -45,16 +48,83 @@ class UserEndpoint(BaseViewSet):
    def deactivate(self, request):
        # Check all workspace user is active
        user = self.get_object()
-        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,
-            )
+
+        # 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
+        )

        # 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)

@@ -76,10 +146,10 @@ class UpdateUserTourCompletedEndpoint(BaseAPIView):


 class UserActivityEndpoint(BaseAPIView, BasePaginator):
-    def get(self, request, slug):
-        queryset = IssueActivity.objects.filter(
-            actor=request.user, workspace__slug=slug
-        ).select_related("actor", "workspace", "issue", "project")
+    def get(self, request):
+        queryset = IssueActivity.objects.filter(actor=request.user).select_related(
+            "actor", "workspace", "issue", "project"
+        )

        return self.paginate(
            request=request,
@@ -88,3 +158,4 @@ class UserActivityEndpoint(BaseAPIView, BasePaginator):
                issue_activities, many=True
            ).data,
        )
+
@@ -20,14 +20,19 @@ from rest_framework.response import Response
 from rest_framework import status

 # Module imports
-from . import BaseViewSet
+from . import BaseViewSet, BaseAPIView
 from plane.app.serializers import (
    GlobalViewSerializer,
    IssueViewSerializer,
    IssueLiteSerializer,
    IssueViewFavoriteSerializer,
 )
-from plane.app.permissions import WorkspaceEntityPermission, ProjectEntityPermission
+from plane.app.permissions import (
+    WorkspaceEntityPermission,
+    ProjectEntityPermission,
+    WorkspaceViewerPermission,
+    ProjectLitePermission,
+)
 from plane.db.models import (
    Workspace,
    GlobalView,
@@ -43,8 +48,8 @@ from plane.utils.grouper import group_results


 class GlobalViewViewSet(BaseViewSet):
-    serializer_class = GlobalViewSerializer
-    model = GlobalView
+    serializer_class = IssueViewSerializer
+    model = IssueView
    permission_classes = [
        WorkspaceEntityPermission,
    ]
@@ -58,6 +63,7 @@ class GlobalViewViewSet(BaseViewSet):
            super()
            .get_queryset()
            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project__isnull=True)
            .select_related("workspace")
            .order_by(self.request.GET.get("order_by", "-created_at"))
            .distinct()
@@ -95,6 +101,7 @@ 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"]
@@ -177,25 +184,11 @@ class GlobalViewIssuesViewSet(BaseViewSet):
            )
        else:
            issue_queryset = issue_queryset.order_by(order_by_param)
-        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)
+        serializer = IssueLiteSerializer(
+            issue_queryset, many=True, fields=fields if fields else None
+        )
+        return Response(serializer.data, status=status.HTTP_200_OK)


 class IssueViewViewSet(BaseViewSet):
@@ -228,6 +221,14 @@ class IssueViewViewSet(BaseViewSet):
            .distinct()
        )

+    def list(self, request, slug, project_id):
+        queryset = self.get_queryset()
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
+        views = IssueViewSerializer(
+            queryset, many=True, fields=fields if fields else None
+        ).data
+        return Response(views, status=status.HTTP_200_OK)
+

 class IssueViewFavoriteViewSet(BaseViewSet):
    serializer_class = IssueViewFavoriteSerializer
@@ -257,4 +258,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)
@@ -20,9 +20,10 @@ class WebhookEndpoint(BaseAPIView):

    def post(self, request, slug):
        workspace = Workspace.objects.get(slug=slug)
-
        try:
-            serializer = WebhookSerializer(data=request.data)
+            serializer = WebhookSerializer(
+                data=request.data, context={"request": request}
+            )
            if serializer.is_valid():
                serializer.save(workspace_id=workspace.id)
                return Response(serializer.data, status=status.HTTP_201_CREATED)
@@ -79,6 +80,7 @@ class WebhookEndpoint(BaseAPIView):
        serializer = WebhookSerializer(
            webhook,
            data=request.data,
+            context={request: request},
            partial=True,
            fields=(
                "id",
@@ -44,6 +44,8 @@ from plane.app.serializers import (
    IssueLiteSerializer,
    WorkspaceMemberAdminSerializer,
    WorkspaceMemberMeSerializer,
+    ProjectMemberRoleSerializer,
+    WorkspaceUserPropertiesSerializer,
 )
 from plane.app.views.base import BaseAPIView
 from . import BaseViewSet
@@ -64,16 +66,19 @@ from plane.db.models import (
    WorkspaceMember,
    CycleIssue,
    IssueReaction,
+    WorkspaceUserProperties
 )
 from plane.app.permissions import (
    WorkSpaceBasePermission,
    WorkSpaceAdminPermission,
    WorkspaceEntityPermission,
    WorkspaceViewerPermission,
+    WorkspaceUserPermission,
+    ProjectLitePermission,
 )
 from plane.bgtasks.workspace_invitation_task import workspace_invitation
 from plane.utils.issue_filters import issue_filters
-from plane.utils.grouper import group_results
+from plane.bgtasks.event_tracking_task import workspace_invite_event


 class WorkSpaceViewSet(BaseViewSet):
@@ -113,7 +118,10 @@ class WorkSpaceViewSet(BaseViewSet):
        return (
            self.filter_queryset(super().get_queryset().select_related("owner"))
            .order_by("name")
-            .filter(workspace_member__member=self.request.user)
+            .filter(
+                workspace_member__member=self.request.user,
+                workspace_member__is_active=True,
+            )
            .annotate(total_members=member_count)
            .annotate(total_issues=issue_count)
            .select_related("owner")
@@ -170,6 +178,7 @@ class UserWorkSpacesEndpoint(BaseAPIView):
    ]

    def get(self, request):
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
        member_count = (
            WorkspaceMember.objects.filter(
                workspace=OuterRef("id"),
@@ -189,21 +198,28 @@ class UserWorkSpacesEndpoint(BaseAPIView):
        )

        workspace = (
-            (
-                Workspace.objects.prefetch_related(
-                    Prefetch("workspace_member", queryset=WorkspaceMember.objects.all())
+            Workspace.objects.prefetch_related(
+                Prefetch(
+                    "workspace_member",
+                    queryset=WorkspaceMember.objects.filter(
+                        member=request.user, is_active=True
+                    ),
                )
-                .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)
-        return Response(serializer.data, status=status.HTTP_200_OK)
+        workspaces = WorkSpaceSerializer(
+            self.filter_queryset(workspace),
+            fields=fields if fields else None,
+            many=True,
+        ).data
+        return Response(workspaces, status=status.HTTP_200_OK)


 class WorkSpaceAvailabilityCheckEndpoint(BaseAPIView):
@@ -319,7 +335,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:
@@ -401,6 +417,16 @@ 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"},
                    status=status.HTTP_200_OK,
@@ -418,7 +444,9 @@ 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)

@@ -477,6 +505,18 @@ 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",
@@ -506,10 +546,15 @@ class WorkSpaceMemberViewSet(BaseViewSet):
        workspace_members = self.get_queryset()

        if workspace_member.role > 10:
-            serializer = WorkspaceMemberAdminSerializer(workspace_members, many=True)
+            serializer = WorkspaceMemberAdminSerializer(
+                workspace_members,
+                fields=("id", "member", "role"),
+                many=True,
+            )
        else:
            serializer = WorkSpaceMemberSerializer(
                workspace_members,
+                fields=("id", "member", "role"),
                many=True,
            )
        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -590,7 +635,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
                member_with_role=Count(
                    "project_projectmember",
                    filter=Q(
-                        project_projectmember__member_id=request.user.id,
+                        project_projectmember__member_id=workspace_member.id,
                        project_projectmember__role=20,
                    ),
                ),
@@ -600,7 +645,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
        ):
            return Response(
                {
-                    "error": "User is part of some projects where they are the only admin you should leave that project first"
+                    "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."
                },
                status=status.HTTP_400_BAD_REQUEST,
            )
@@ -635,7 +680,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
        ):
            return Response(
                {
-                    "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"
+                    "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."
                },
                status=status.HTTP_400_BAD_REQUEST,
            )
@@ -656,7 +701,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
        ):
            return Response(
                {
-                    "error": "User is part of some projects where they are the only admin you should leave that project first"
+                    "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."
                },
                status=status.HTTP_400_BAD_REQUEST,
            )
@@ -674,6 +719,43 @@ class WorkSpaceMemberViewSet(BaseViewSet):
        return Response(status=status.HTTP_204_NO_CONTENT)


+class WorkspaceProjectMemberEndpoint(BaseAPIView):
+    serializer_class = ProjectMemberRoleSerializer
+    model = ProjectMember
+
+    permission_classes = [
+        WorkspaceEntityPermission,
+    ]
+
+    def get(self, request, slug):
+        # Fetch all project IDs where the user is involved
+        project_ids = ProjectMember.objects.filter(
+            member=request.user,
+            member__is_bot=False,
+            is_active=True,
+        ).values_list('project_id', flat=True).distinct()
+
+        # Get all the project members in which the user is involved
+        project_members = ProjectMember.objects.filter(
+            workspace__slug=slug,
+            member__is_bot=False,
+            project_id__in=project_ids,
+            is_active=True,
+        ).select_related("project", "member", "workspace")
+        project_members = ProjectMemberRoleSerializer(project_members, many=True).data
+
+        project_members_dict = dict()
+
+        # Construct a dictionary with project_id as key and project_members as value
+        for project_member in project_members:
+            project_id = project_member.pop("project")
+            if str(project_id) not in project_members_dict:
+                project_members_dict[str(project_id)] = []
+            project_members_dict[str(project_id)].append(project_member)
+
+        return Response(project_members_dict, status=status.HTTP_200_OK)
+
+
 class TeamMemberViewSet(BaseViewSet):
    serializer_class = TeamSerializer
    model = Team
@@ -1198,6 +1280,7 @@ 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
@@ -1299,17 +1382,9 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
        else:
            issue_queryset = issue_queryset.order_by(order_by_param)

-        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,
-            )
-
+        issues = IssueLiteSerializer(
+            issue_queryset, many=True, fields=fields if fields else None
+        ).data
        return Response(issues, status=status.HTTP_200_OK)


@@ -1324,3 +1399,30 @@ class WorkspaceLabelsEndpoint(BaseAPIView):
            project__project_projectmember__member=request.user,
        ).values("parent", "name", "color", "id", "project_id", "workspace__slug")
        return Response(labels, status=status.HTTP_200_OK)
+
+
+class WorkspaceUserPropertiesEndpoint(BaseAPIView):
+    permission_classes = [
+        WorkspaceViewerPermission,
+    ]
+
+    def patch(self, request, slug):
+        workspace_properties = WorkspaceUserProperties.objects.get(
+            user=request.user,
+            workspace__slug=slug,
+        )
+        
+        workspace_properties.filters = request.data.get("filters", workspace_properties.filters)
+        workspace_properties.display_filters = request.data.get("display_filters", workspace_properties.display_filters)
+        workspace_properties.display_properties = request.data.get("display_properties", workspace_properties.display_properties)
+        workspace_properties.save()
+
+        serializer = WorkspaceUserPropertiesSerializer(workspace_properties)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    def get(self, request, slug):
+        workspace_properties, _ = WorkspaceUserProperties.objects.get_or_create(
+            user=request.user, workspace__slug=slug
+        )
+        serializer = WorkspaceUserPropertiesSerializer(workspace_properties)
+        return Response(serializer.data, status=status.HTTP_200_OK)
@@ -1,6 +1,8 @@
 # Python imports
 import csv
 import io
+import requests
+import json

 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
@@ -16,8 +18,7 @@ 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.models import InstanceConfiguration
-from plane.license.utils.instance_value import get_configuration_value
+from plane.license.utils.instance_value import get_email_configuration

 row_mapping = {
    "state__name": "State",
@@ -32,7 +33,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"
@@ -42,7 +43,7 @@ CYCLE_ID = "issue_cycle__cycle_id"
 MODULE_ID = "issue_module__module_id"


-def send_export_email(email, slug, csv_buffer):
+def send_export_email(email, slug, csv_buffer, rows):
    """Helper function to send export email."""
    subject = "Your Export is ready"
    html_content = render_to_string("emails/exports/analytics.html", {})
@@ -50,20 +51,33 @@ def send_export_email(email, slug, csv_buffer):

    csv_buffer.seek(0)

-    # Configure email connection from the database
-    instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
+    (
+        EMAIL_HOST,
+        EMAIL_HOST_USER,
+        EMAIL_HOST_PASSWORD,
+        EMAIL_PORT,
+        EMAIL_USE_TLS,
+        EMAIL_FROM,
+    ) = get_email_configuration()
+
    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")),
-        use_ssl=bool(get_configuration_value(instance_configuration, "EMAIL_USE_SSL", "0")),
+        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=get_configuration_value(instance_configuration, "EMAIL_FROM"), to=[email], connection=connection)
+    msg = EmailMultiAlternatives(
+        subject=subject,
+        body=text_content,
+        from_email=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):
@@ -431,8 +445,11 @@ def analytic_export_task(email, data, slug):
            )

        csv_buffer = generate_csv_from_rows(rows)
-        send_export_email(email, slug, csv_buffer)
+        send_export_email(email, slug, csv_buffer, rows)
+        return
    except Exception as e:
+        print(e)
        if settings.DEBUG:
            print(e)
        capture_exception(e)
+        return
@@ -1,57 +0,0 @@
-# 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
@@ -0,0 +1,78 @@
+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
+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
+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)
@@ -1,3 +1,8 @@
+# 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
@@ -9,39 +14,53 @@ 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
+from plane.license.utils.instance_value import get_email_configuration
+

@shared_task
 def forgot_password(first_name, email, uidb64, token, current_site):
-
    try:
-        realtivelink = f"/accounts/reset-password/?uidb64={uidb64}&token={token}"
-        abs_url = current_site + realtivelink
+        relative_link = (
+            f"/accounts/password/?uidb64={uidb64}&token={token}&email={email}"
+        )
+        abs_url = str(current_site) + relative_link

-        from_email_string = settings.EMAIL_FROM
+        (
+            EMAIL_HOST,
+            EMAIL_HOST_USER,
+            EMAIL_HOST_PASSWORD,
+            EMAIL_PORT,
+            EMAIL_USE_TLS,
+            EMAIL_FROM,
+        ) = get_email_configuration()

-        subject = "Reset Your Password - Plane"
+        subject = "A new password to your Plane account has been requested"

        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=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")),
+            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,
        )
-        # 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
@@ -112,8 +112,16 @@ def track_parent(
    epoch,
 ):
    if current_instance.get("parent") != requested_data.get("parent"):
-        old_parent = Issue.objects.filter(pk=current_instance.get("parent")).first()
-        new_parent = Issue.objects.filter(pk=requested_data.get("parent")).first()
+        old_parent = (
+            Issue.objects.filter(pk=current_instance.get("parent")).first()
+            if current_instance.get("parent") is not None
+            else None
+        )
+        new_parent = (
+            Issue.objects.filter(pk=requested_data.get("parent")).first()
+            if requested_data.get("parent") is not None
+            else None
+        )

        issue_activities.append(
            IssueActivity(
@@ -714,7 +722,9 @@ def create_cycle_issue_activity(
        cycle = Cycle.objects.filter(
            pk=created_record.get("fields").get("cycle")
        ).first()
-        issue = Issue.objects.filter(pk=created_record.get("fields").get("issue")).first()
+        issue = Issue.objects.filter(
+            pk=created_record.get("fields").get("issue")
+        ).first()
        if issue:
            issue.updated_at = timezone.now()
            issue.save(update_fields=["updated_at"])
@@ -830,7 +840,9 @@ def create_module_issue_activity(
        module = Module.objects.filter(
            pk=created_record.get("fields").get("module")
        ).first()
-        issue = Issue.objects.filter(pk=created_record.get("fields").get("issue")).first()
+        issue = Issue.objects.filter(
+            pk=created_record.get("fields").get("issue")
+        ).first()
        if issue:
            issue.updated_at = timezone.now()
            issue.save(update_fields=["updated_at"])
@@ -1276,40 +1288,42 @@ def create_issue_relation_activity(
    current_instance = (
        json.loads(current_instance) if current_instance is not None else None
    )
-    if current_instance is None and requested_data.get("related_list") is not None:
-        for issue_relation in requested_data.get("related_list"):
-            if issue_relation.get("relation_type") == "blocked_by":
-                relation_type = "blocking"
-            else:
-                relation_type = issue_relation.get("relation_type")
-            issue = Issue.objects.get(pk=issue_relation.get("issue"))
+    if current_instance is None and requested_data.get("issues") is not None:
+        for related_issue in requested_data.get("issues"): 
+            issue = Issue.objects.get(pk=related_issue)
            issue_activities.append(
                IssueActivity(
-                    issue_id=issue_relation.get("related_issue"),
+                    issue_id=issue_id,
                    actor_id=actor_id,
                    verb="created",
                    old_value="",
                    new_value=f"{issue.project.identifier}-{issue.sequence_id}",
-                    field=relation_type,
+                    field=requested_data.get("relation_type"),
                    project_id=project_id,
                    workspace_id=workspace_id,
-                    comment=f"added {relation_type} relation",
-                    old_identifier=issue_relation.get("issue"),
+                    comment=f"added {requested_data.get('relation_type')} relation",
+                    old_identifier=related_issue,
                )
            )
-            issue = Issue.objects.get(pk=issue_relation.get("related_issue"))
+            issue = Issue.objects.get(pk=issue_id)
            issue_activities.append(
                IssueActivity(
-                    issue_id=issue_relation.get("issue"),
+                    issue_id=related_issue,
                    actor_id=actor_id,
                    verb="created",
                    old_value="",
                    new_value=f"{issue.project.identifier}-{issue.sequence_id}",
-                    field=f'{issue_relation.get("relation_type")}',
+                    field="blocking"
+                    if requested_data.get("relation_type") == "blocked_by"
+                    else (
+                        "blocked_by"
+                        if requested_data.get("relation_type") == "blocking"
+                        else requested_data.get("relation_type")
+                    ),
                    project_id=project_id,
                    workspace_id=workspace_id,
-                    comment=f'added {issue_relation.get("relation_type")} relation',
-                    old_identifier=issue_relation.get("related_issue"),
+                    comment=f'added {"blocking" if requested_data.get("relation_type") == "blocked_by" else ("blocked_by" if requested_data.get("relation_type") == "blocking" else requested_data.get("relation_type")),} relation',
+                    old_identifier=issue_id,
                    epoch=epoch,
                )
            )
@@ -1329,44 +1343,44 @@ def delete_issue_relation_activity(
    current_instance = (
        json.loads(current_instance) if current_instance is not None else None
    )
-    if current_instance is not None and requested_data.get("related_list") is None:
-        if current_instance.get("relation_type") == "blocked_by":
-            relation_type = "blocking"
-        else:
-            relation_type = current_instance.get("relation_type")
-        issue = Issue.objects.get(pk=current_instance.get("issue"))
-        issue_activities.append(
-            IssueActivity(
-                issue_id=current_instance.get("related_issue"),
-                actor_id=actor_id,
-                verb="deleted",
-                old_value=f"{issue.project.identifier}-{issue.sequence_id}",
-                new_value="",
-                field=relation_type,
-                project_id=project_id,
-                workspace_id=workspace_id,
-                comment=f"deleted {relation_type} relation",
-                old_identifier=current_instance.get("issue"),
-                epoch=epoch,
-            )
+    issue = Issue.objects.get(pk=requested_data.get("related_issue"))
+    issue_activities.append(
+        IssueActivity(
+            issue_id=issue_id,
+            actor_id=actor_id,
+            verb="deleted",
+            old_value=f"{issue.project.identifier}-{issue.sequence_id}",
+            new_value="",
+            field=requested_data.get("relation_type"),
+            project_id=project_id,
+            workspace_id=workspace_id,
+            comment=f"deleted {requested_data.get('relation_type')} relation",
+            old_identifier=requested_data.get("related_issue"),
+            epoch=epoch,
        )
-        issue = Issue.objects.get(pk=current_instance.get("related_issue"))
-        issue_activities.append(
-            IssueActivity(
-                issue_id=current_instance.get("issue"),
-                actor_id=actor_id,
-                verb="deleted",
-                old_value=f"{issue.project.identifier}-{issue.sequence_id}",
-                new_value="",
-                field=f'{current_instance.get("relation_type")}',
-                project_id=project_id,
-                workspace_id=workspace_id,
-                comment=f'deleted {current_instance.get("relation_type")} relation',
-                old_identifier=current_instance.get("related_issue"),
-                epoch=epoch,
-            )
+    )
+    issue = Issue.objects.get(pk=issue_id)
+    issue_activities.append(
+        IssueActivity(
+            issue_id=requested_data.get("related_issue"),
+            actor_id=actor_id,
+            verb="deleted",
+            old_value=f"{issue.project.identifier}-{issue.sequence_id}",
+            new_value="",
+            field="blocking"
+            if requested_data.get("relation_type") == "blocked_by"
+            else (
+                "blocked_by"
+                if requested_data.get("relation_type") == "blocking"
+                else requested_data.get("relation_type")
+            ),
+            project_id=project_id,
+            workspace_id=workspace_id,
+            comment=f'deleted {requested_data.get("relation_type")} relation',
+            old_identifier=requested_data.get("related_issue"),
+            epoch=epoch,
        )
-
+    )

 def create_draft_issue_activity(
    requested_data,
@@ -1,3 +1,8 @@
+# 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
@@ -9,38 +14,48 @@ 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
+from plane.license.utils.instance_value import get_email_configuration
+

@shared_task
 def magic_link(email, key, token, current_site):
    try:
-        realtivelink = f"/magic-sign-in/?password={token}&key={key}"
-        abs_url = current_site + realtivelink
+        (
+            EMAIL_HOST,
+            EMAIL_HOST_USER,
+            EMAIL_HOST_PASSWORD,
+            EMAIL_PORT,
+            EMAIL_USE_TLS,
+            EMAIL_FROM,
+        ) = get_email_configuration()

-        subject = "Login for Plane"
-
-        context = {"magic_url": abs_url, "code": token}
+        # Send the mail
+        subject = f"Your unique Plane login code is {token}"
+        context = {"code": token, "email": email}

        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=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")),
+            host=EMAIL_HOST,
+            port=int(EMAIL_PORT),
+            username=EMAIL_HOST_USER,
+            password=EMAIL_HOST_PASSWORD,
+            use_tls=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 = EmailMultiAlternatives(
+            subject=subject,
+            body=text_content,
+            from_email=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:
@@ -190,6 +190,7 @@ def notifications(type, issue_id, project_id, actor_id, subscriber, issue_activi
            issue_activities_created) if issue_activities_created is not None else None
    )
    if type not in [
+        "issue.activity.deleted",
        "cycle.activity.created",
        "cycle.activity.deleted",
        "module.activity.created",
@@ -290,6 +291,9 @@ def notifications(type, issue_id, project_id, actor_id, subscriber, issue_activi
                sender = "in_app:issue_activities:assigned"

            for issue_activity in issue_activities_created:
+                # Do not send notification for description update
+                if issue_activity.get("field") == "description":
+                    continue;
                issue_comment = issue_activity.get("issue_comment")
                if issue_comment is not None:
                    issue_comment = IssueComment.objects.get(
@@ -340,7 +344,7 @@ def notifications(type, issue_id, project_id, actor_id, subscriber, issue_activi
            .order_by("-created_at")
            .first()
        )
-        
+
        actor = User.objects.get(pk=actor_id)
        
        for mention_id in comment_mentions:
@@ -1,3 +1,6 @@
+# Python import
+import os
+
 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
 from django.template.loader import render_to_string
@@ -10,8 +13,7 @@ from sentry_sdk import capture_exception

 # Module imports
 from plane.db.models import Project, User, ProjectMemberInvite
-from plane.license.models import InstanceConfiguration
-from plane.license.utils.instance_value import get_configuration_value
+from plane.license.utils.instance_value import get_email_configuration

@shared_task
 def project_invitation(email, project_id, token, current_site, invitor):
@@ -25,8 +27,6 @@ def project_invitation(email, project_id, token, current_site, invitor):
        relativelink = f"/project-invitations/?invitation_id={project_member_invite.id}&email={email}&slug={project.workspace.slug}&project_id={str(project_id)}"
        abs_url = current_site + relativelink

-        from_email_string = settings.EMAIL_FROM
-
        subject = f"{user.first_name or user.display_name or user.email} invited you to join {project.name} on Plane"

        context = {
@@ -46,16 +46,31 @@ def project_invitation(email, project_id, token, current_site, invitor):
        project_member_invite.save()

        # Configure email connection from the database
-        instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
+        (
+            EMAIL_HOST,
+            EMAIL_HOST_USER,
+            EMAIL_HOST_PASSWORD,
+            EMAIL_PORT,
+            EMAIL_USE_TLS,
+            EMAIL_FROM,
+        ) = get_email_configuration()
+
        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")),
+            host=EMAIL_HOST,
+            port=int(EMAIL_PORT),
+            username=EMAIL_HOST_USER,
+            password=EMAIL_HOST_PASSWORD,
+            use_tls=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 = EmailMultiAlternatives(
+            subject=subject,
+            body=text_content,
+            from_email=EMAIL_FROM,
+            to=[email],
+            connection=connection,
+        )
+
        msg.attach_alternative(html_content, "text/html")
        msg.send()
        return
@@ -2,15 +2,67 @@ import requests
 import uuid
 import hashlib
 import json
+import hmac

 # Django imports
 from django.conf import settings
+from django.core.serializers.json import DjangoJSONEncoder

 # Third party imports
 from celery import shared_task
 from sentry_sdk import capture_exception

-from plane.db.models import Webhook, WebhookLog
+from plane.db.models import (
+    Webhook,
+    WebhookLog,
+    Project,
+    Issue,
+    Cycle,
+    Module,
+    ModuleIssue,
+    CycleIssue,
+    IssueComment,
+)
+from plane.api.serializers import (
+    ProjectSerializer,
+    IssueSerializer,
+    CycleSerializer,
+    ModuleSerializer,
+    CycleIssueSerializer,
+    ModuleIssueSerializer,
+    IssueCommentSerializer,
+    IssueExpandSerializer,
+)
+
+SERIALIZER_MAPPER = {
+    "project": ProjectSerializer,
+    "issue": IssueExpandSerializer,
+    "cycle": CycleSerializer,
+    "module": ModuleSerializer,
+    "cycle_issue": CycleIssueSerializer,
+    "module_issue": ModuleIssueSerializer,
+    "issue_comment": IssueCommentSerializer,
+}
+
+MODEL_MAPPER = {
+    "project": Project,
+    "issue": Issue,
+    "cycle": Cycle,
+    "module": Module,
+    "cycle_issue": CycleIssue,
+    "module_issue": ModuleIssue,
+    "issue_comment": IssueComment,
+}
+
+
+def get_model_data(event, event_id, many=False):
+    model = MODEL_MAPPER.get(event)
+    if many:
+        queryset = model.objects.filter(pk__in=event_id)
+    else:
+        queryset = model.objects.get(pk=event_id)
+    serializer = SERIALIZER_MAPPER.get(event)
+    return serializer(queryset, many=many).data


@shared_task(
@@ -31,18 +83,12 @@ def webhook_task(self, webhook, slug, event, event_data, action):
            "X-Plane-Event": event,
        }

-        # Your secret key
-        if webhook.secret_key:
-            # Concatenate the data and the secret key
-            message = event_data + webhook.secret_key
-
-            # Create a SHA-256 hash of the message
-            sha256 = hashlib.sha256()
-            sha256.update(message.encode("utf-8"))
-            signature = sha256.hexdigest()
-            headers["X-Plane-Signature"] = signature
-
-        event_data = json.loads(event_data) if event_data is not None else None
+        # # Your secret key
+        event_data = (
+            json.loads(json.dumps(event_data, cls=DjangoJSONEncoder))
+            if event_data is not None
+            else None
+        )

        action = {
            "POST": "create",
@@ -59,6 +105,16 @@ def webhook_task(self, webhook, slug, event, event_data, action):
            "data": event_data,
        }

+        # Use HMAC for generating signature
+        if webhook.secret_key:
+            hmac_signature = hmac.new(
+                webhook.secret_key.encode("utf-8"),
+                json.dumps(payload).encode("utf-8"),
+                hashlib.sha256,
+            )
+            signature = hmac_signature.hexdigest()
+            headers["X-Plane-Signature"] = signature
+
        # Send the webhook event
        response = requests.post(
            webhook.url,
@@ -96,10 +152,6 @@ def webhook_task(self, webhook, slug, event, event_data, action):
            retry_count=str(self.request.retries),
        )

-        # Retry logic
-        if self.request.retries >= self.max_retries:
-            Webhook.objects.filter(pk=webhook.id).update(is_active=False)
-            return
        raise requests.RequestException()

    except Exception as e:
@@ -110,7 +162,7 @@ def webhook_task(self, webhook, slug, event, event_data, action):


@shared_task()
-def send_webhook(event, event_data, action, slug):
+def send_webhook(event, payload, kw, action, slug, bulk):
    try:
        webhooks = Webhook.objects.filter(workspace__slug=slug, is_active=True)

@@ -120,17 +172,48 @@ def send_webhook(event, event_data, action, slug):
        if event == "issue":
            webhooks = webhooks.filter(issue=True)

-        if event == "module":
+        if event == "module" or event == "module_issue":
            webhooks = webhooks.filter(module=True)

-        if event == "cycle":
+        if event == "cycle" or event == "cycle_issue":
            webhooks = webhooks.filter(cycle=True)

-        if event == "issue-comment":
+        if event == "issue_comment":
            webhooks = webhooks.filter(issue_comment=True)

-        for webhook in webhooks:
-            webhook_task.delay(webhook.id, slug, event, event_data, action)
+        if webhooks:
+            if action in ["POST", "PATCH"]:
+                if bulk and event in ["cycle_issue", "module_issue"]:
+                    event_data = IssueExpandSerializer(
+                        Issue.objects.filter(
+                            pk__in=[
+                                str(event.get("issue")) for event in payload
+                            ]
+                        ).prefetch_related("issue_cycle", "issue_module"), many=True
+                    ).data
+                    event = "issue"
+                    action = "PATCH"
+                else:
+                    event_data = [
+                        get_model_data(
+                            event=event,
+                            event_id=payload.get("id") if isinstance(payload, dict) else None,
+                            many=False,
+                        )
+                    ]
+
+            if action == "DELETE":
+                event_data = [{"id": kw.get("pk")}]
+
+            for webhook in webhooks:
+                for data in event_data:
+                    webhook_task.delay(
+                        webhook=webhook.id,
+                        slug=slug,
+                        event=event,
+                        event_data=data,
+                        action=action,
+                    )

    except Exception as e:
        if settings.DEBUG:
@@ -1,3 +1,8 @@
+# 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
@@ -12,8 +17,7 @@ from slack_sdk.errors import SlackApiError

 # Module imports
 from plane.db.models import Workspace, WorkspaceMemberInvite, User
-from plane.license.models import InstanceConfiguration
-from plane.license.utils.instance_value import get_configuration_value
+from plane.license.utils.instance_value import get_email_configuration


@shared_task
@@ -30,19 +34,26 @@ def workspace_invitation(email, workspace_id, token, current_site, invitor):
        relative_link = f"/workspace-invitations/?invitation_id={workspace_member_invite.id}&email={email}&slug={workspace.slug}"

        # The complete url including the domain
-        abs_url = current_site + relative_link
+        abs_url = str(current_site) + relative_link

-        # The email from
-        from_email_string = settings.EMAIL_FROM
+
+        (
+            EMAIL_HOST,
+            EMAIL_HOST_USER,
+            EMAIL_HOST_PASSWORD,
+            EMAIL_PORT,
+            EMAIL_USE_TLS,
+            EMAIL_FROM,
+        ) = get_email_configuration()

        # Subject of the email
-        subject = f"{user.first_name or user.display_name or user.email} invited you to join {workspace.name} on Plane"
+        subject = f"{user.first_name or user.display_name or user.email} has invited you to join them in {workspace.name} on Plane"

        context = {
            "email": email,
-            "first_name": invitor,
+            "first_name": user.first_name or user.display_name or user.email,
            "workspace_name": workspace.name,
-            "invitation_url": abs_url,
+            "abs_url": abs_url,
        }

        html_content = render_to_string(
@@ -54,27 +65,18 @@ def workspace_invitation(email, workspace_id, token, current_site, invitor):
        workspace_member_invite.message = text_content
        workspace_member_invite.save()

-        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")
-            ),
+            host=EMAIL_HOST,
+            port=int(EMAIL_PORT),
+            username=EMAIL_HOST_USER,
+            password=EMAIL_HOST_PASSWORD,
+            use_tls=EMAIL_USE_TLS == "1",
        )
-        # Initiate email alternatives
+
        msg = EmailMultiAlternatives(
            subject=subject,
            body=text_content,
-            from_email=get_configuration_value(instance_configuration, "EMAIL_FROM"),
+            from_email=EMAIL_FROM,
            to=[email],
            connection=connection,
        )
@@ -94,6 +96,7 @@ def workspace_invitation(email, workspace_id, token, current_site, invitor):

        return
    except (Workspace.DoesNotExist, WorkspaceMemberInvite.DoesNotExist) as e:
+        print("Workspace or WorkspaceMember Invite Does not exists")
        return
    except Exception as e:
        # Print logs if in DEBUG mode
@@ -33,4 +33,4 @@ app.conf.beat_schedule = {
 # Load task modules from all registered Django app configs.
 app.autodiscover_tasks()

-app.conf.beat_scheduler = 'django_celery_beat.schedulers.DatabaseScheduler'
+app.conf.beat_scheduler = "django_celery_beat.schedulers.DatabaseScheduler"
@@ -0,0 +1,54 @@
+# Python imports
+import getpass
+
+# Django imports
+from django.core.management import BaseCommand
+
+# Module imports
+from plane.db.models import User
+
+
+class Command(BaseCommand):
+    help = "Reset password of the user with the given email"
+
+    def add_arguments(self, parser):
+        # Positional argument
+        parser.add_argument("email", type=str, help="user email")
+
+    def handle(self, *args, **options):
+        # get the user email from console
+        email = options.get("email", False)
+
+        # raise error if email is not present
+        if not email:
+            self.stderr.write("Error: Email is required")
+            return
+
+        # filter the user
+        user = User.objects.filter(email=email).first()
+
+        # Raise error if the user is not present
+        if not user:
+            self.stderr.write(f"Error: User with {email} does not exists")
+            return
+
+        # get password for the user
+        password = getpass.getpass("Password: ")
+        confirm_password = getpass.getpass("Password (again): ")
+        
+        # If the passwords doesn't match raise error
+        if password != confirm_password:
+            self.stderr.write("Error: Your passwords didn't match.")
+            return
+
+        # Blank passwords should not be allowed
+        if password.strip() == "":
+            self.stderr.write("Error: Blank passwords aren't allowed.")
+            return
+
+        # Set user password
+        user.set_password(password)
+        user.is_password_autoset = False
+        user.save()
+        
+        self.stdout.write(self.style.SUCCESS(f"User password updated succesfully"))
@@ -21,7 +21,7 @@ class Migration(migrations.Migration):
                ('id', models.UUIDField(db_index=True, default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True)),
                ('transaction', models.UUIDField(default=uuid.uuid4)),
                ('entity_identifier', models.UUIDField(null=True)),
-                ('entity_name', models.CharField(choices=[('to_do', 'To Do'), ('issue', 'issue'), ('image', 'Image'), ('video', 'Video'), ('file', 'File'), ('link', 'Link'), ('cycle', 'Cycle'), ('module', 'Module'), ('back_link', 'Back Link'), ('forward_link', 'Forward Link'), ('mention', 'Mention')], max_length=30, verbose_name='Transaction Type')),
+                ('entity_name', models.CharField(choices=[('to_do', 'To Do'), ('issue', 'issue'), ('image', 'Image'), ('video', 'Video'), ('file', 'File'), ('link', 'Link'), ('cycle', 'Cycle'), ('module', 'Module'), ('back_link', 'Back Link'), ('forward_link', 'Forward Link'), ('page_mention', 'Page Mention'), ('user_mention', 'User Mention')], max_length=30, verbose_name='Transaction Type')),
                ('created_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='%(class)s_created_by', to=settings.AUTH_USER_MODEL, verbose_name='Created By')),
                ('page', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='page_log', to='db.page')),
                ('project', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='project_%(class)s', to='db.project')),
--- a/Show More
+++ b/Show More