dev: create model fields

error of table not being defined while getting getBoundingClientRect()
and solve other TS issues

- Added ResolvedPos import from @tiptap/pm/model
- Updated setCellsBackgroundColor function parameter type to string
- Declared ToolboxItem type for toolbox items
- Modified columnsToolboxItems and rowsToolboxItems to use the ToolboxItem type
- Updated createToolbox function parameters to specify Element or null for triggerButton and ToolboxItem[] for items
- Added ts-expect-error comment above the toolbox variable declaration
- Updated update method parameter type to readonly Decoration[]
- Changed destructuring assignment of hoveredTable and hoveredCell in updateControls method to use Object.values and reduce method
- Added null check for this.table in updateControls method
- Wrapped the code that updates columnsControl and rowsControl with null checks for each control
- Replaced ts-ignore comments with proper dispatch calls in selectColumn and selectRow methods

Co-authored-by: sriram veeraghanta <veeraghanta.sriram@gmail.com>

.dockerignore

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

.github/workflows/build-branch.yml

@@ -6,17 +6,19 @@ on:
       - closed
     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
 
@@ -59,18 +61,18 @@ jobs:
 
   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-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
+      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_and_push.outputs.gh_branch_name }}" = "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend-private:latest"
-          elif [ "${{ needs.branch_build_and_push.outputs.gh_branch_name }}" = "release" ] || [ "${{ needs.branch_build_and_push.outputs.gh_branch_name }}" = "preview" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend-private:preview,${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend:preview"
+          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 }}"
+            TAG=${{ env.FRONTEND_TAG }}
           fi
           echo "FRONTEND_TAG=${TAG}" >> $GITHUB_ENV
       - name: Set up Docker Buildx
@@ -101,18 +103,18 @@ 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-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
+      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_and_push.outputs.gh_branch_name }}" = "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space:latest"
-          elif [ "${{ needs.branch_build_and_push.outputs.gh_branch_name }}" = "release" ] || [ "${{ needs.branch_build_and_push.outputs.gh_branch_name }}" = "preview" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space-private:preview,${{ secrets.DOCKERHUB_USERNAME }}/plane-space:preview"
+          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 }}"
+            TAG=${{ env.SPACE_TAG }}
           fi
           echo "SPACE_TAG=${TAG}" >> $GITHUB_ENV
       - name: Set up Docker Buildx
@@ -143,16 +145,16 @@ 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-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
+      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_and_push.outputs.gh_branch_name }}" = "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend-private:latest"
-          elif [ "${{ needs.branch_build_and_push.outputs.gh_branch_name }}" = "release" ] || [ "${{ needs.branch_build_and_push.outputs.gh_branch_name }}" = "preview" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend-private:preview",${{ secrets.DOCKERHUB_USERNAME }}/plane-backend:preview"
+          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
@@ -185,16 +187,16 @@ 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-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
+      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_and_push.outputs.gh_branch_name }}" = "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy-private:latest"
-          elif [ "${{ needs.branch_build_and_push.outputs.gh_branch_name }}" = "release" ] || [ "${{ needs.branch_build_and_push.outputs.gh_branch_name }}" = "preview" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy-private:preview,${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy:preview"
+          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

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

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

.github/workflows/codeql.yml

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

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

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

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

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

CONTRIBUTING.md

@@ -33,8 +33,8 @@ The backend is a django project which is kept inside apiserver
 1. Clone the repo
 
 ```bash
-git clone https://github.com/makeplane/plane
-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?
 

Dockerfile

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

ENV_SETUP.md

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

README.md

@@ -37,7 +37,7 @@ Meet [Plane](https://plane.so). An open-source software development tool to mana
 
 > Plane is still in its early days, not everything will be perfect yet, and hiccups may happen. Please let us know of any suggestions, ideas, or bugs that you encounter on our [Discord](https://discord.com/invite/A92xrEGCge) or GitHub issues, and we will use your feedback to improve on our upcoming releases.
 
-The easiest way to get started with Plane is by creating a [Plane Cloud](https://app.plane.so) account. Plane Cloud offers a hosted solution for Plane. If you prefer to self-host Plane, please refer to our [deployment documentation](https://docs.plane.so/self-hosting).
+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
 
@@ -63,7 +63,7 @@ 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
 

apiserver/.env.example

@@ -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"
@@ -34,9 +39,6 @@ OPENAI_API_BASE="https://api.openai.com/v1" # deprecated
 OPENAI_API_KEY="sk-" # deprecated
 GPT_ENGINE="gpt-3.5-turbo" # deprecated
 
-# Github
-GITHUB_CLIENT_SECRET="" # For fetching release notes
-
 # Settings related to Docker
 DOCKERIZED=1 # deprecated
 
@@ -50,7 +52,6 @@ NGINX_PORT=80
 # SignUps
 ENABLE_SIGNUP="1"
 
-
 # Enable Email/Password Signup
 ENABLE_EMAIL_PASSWORD="1"
 

apiserver/Dockerfile.api

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

apiserver/Dockerfile.dev

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

apiserver/bin/takeoff

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

apiserver/bin/takeoff.local

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

apiserver/gunicorn.config.py

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

apiserver/package.json

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

apiserver/plane/api/serializers/base.py

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

apiserver/plane/api/serializers/cycle.py

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

apiserver/plane/api/serializers/issue.py

@@ -1,3 +1,6 @@
+from lxml import html
+
+
 # Django imports
 from django.utils import timezone
 
@@ -21,7 +24,8 @@ from plane.db.models import (
 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(
@@ -42,7 +46,6 @@ class IssueSerializer(BaseSerializer):
 
     class Meta:
         model = Issue
-        fields = "__all__"
         read_only_fields = [
             "id",
             "workspace",
@@ -52,6 +55,10 @@ class IssueSerializer(BaseSerializer):
             "created_at",
             "updated_at",
         ]
+        exclude = [
+            "description",
+            "description_stripped",
+        ]
 
     def validate(self, data):
         if (
@@ -60,6 +67,15 @@ 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", []):
@@ -80,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(
@@ -91,7 +107,7 @@ class IssueSerializer(BaseSerializer):
         if (
             data.get("parent")
             and not Issue.objects.filter(
-                workspace_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(
@@ -291,7 +307,6 @@ class IssueCommentSerializer(BaseSerializer):
 
     class Meta:
         model = IssueComment
-        fields = "__all__"
         read_only_fields = [
             "id",
             "workspace",
@@ -302,6 +317,21 @@ class IssueCommentSerializer(BaseSerializer):
             "created_at",
             "updated_at",
         ]
+        exclude = [
+            "comment_stripped",
+            "comment_json",
+        ]
+
+    def validate(self, data):
+        try:
+            if(data.get("comment_html", None) is not None):
+                parsed = html.fromstring(data["comment_html"])
+                parsed_str = html.tostring(parsed, encoding='unicode')
+                data["comment_html"] = parsed_str
+            
+        except Exception as e:
+            raise serializers.ValidationError(f"Invalid HTML: {str(e)}")
+        return data
 
 
 class IssueActivitySerializer(BaseSerializer):
@@ -331,12 +361,23 @@ class ModuleIssueSerializer(BaseSerializer):
         ]
 
 
-class IssueExpandSerializer(BaseSerializer):
-    # Serialize the related cycle. It's a OneToOne relation.
-    cycle = CycleLiteSerializer(source="issue_cycle.cycle", read_only=True)
+class LabelLiteSerializer(BaseSerializer):
 
-    # Serialize the related module. It's a OneToOne relation.
+    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
@@ -349,4 +390,4 @@ class IssueExpandSerializer(BaseSerializer):
             "updated_by",
             "created_at",
             "updated_at",
-        ]
+        ]

apiserver/plane/api/serializers/module.py

@@ -65,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,
                     )
@@ -97,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,

apiserver/plane/api/serializers/project.py

@@ -21,6 +21,7 @@ class ProjectSerializer(BaseSerializer):
         fields = "__all__"
         read_only_fields = [
             "id",
+            'emoji',
             "workspace",
             "created_at",
             "updated_at",

apiserver/plane/api/serializers/state.py

@@ -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",
         ]

apiserver/plane/api/serializers/user.py

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

apiserver/plane/api/views/inbox.py

@@ -103,7 +103,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
         if inbox is None and not project.inbox_view:
             return Response(
                 {
-                    "error": "Inbox is not enabled for this project enable it through the project settings"
+                    "error": "Inbox is not enabled for this project enable it through the project's api"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )
@@ -177,7 +177,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
         if inbox is None and not project.inbox_view:
             return Response(
                 {
-                    "error": "Inbox is not enabled for this project enable it through the project settings"
+                    "error": "Inbox is not enabled for this project enable it through the project's api"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )
@@ -311,7 +311,7 @@ class InboxIssueAPIEndpoint(BaseAPIView):
         if inbox is None and not project.inbox_view:
             return Response(
                 {
-                    "error": "Inbox is not enabled for this project enable it through the project settings"
+                    "error": "Inbox is not enabled for this project enable it through the project's api"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )

apiserver/plane/api/views/issue.py

@@ -221,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(

apiserver/plane/api/views/module.py

@@ -121,8 +121,8 @@ 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"])
@@ -132,7 +132,7 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
     
     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)
+        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)

apiserver/plane/api/views/state.py

@@ -64,7 +64,7 @@ class StateAPIEndpoint(BaseAPIView):
         )
 
         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=state_id).exists()

apiserver/plane/app/serializers/__init__.py

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

apiserver/plane/app/serializers/base.py

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

apiserver/plane/app/serializers/cycle.py

@@ -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",
+        ]

apiserver/plane/app/serializers/estimate.py

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

apiserver/plane/app/serializers/inbox.py

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

apiserver/plane/app/serializers/issue.py

@@ -278,17 +278,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",
@@ -296,16 +307,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",
@@ -512,7 +519,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)
 
@@ -521,32 +527,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):

apiserver/plane/app/serializers/module.py

@@ -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"
+        ]

apiserver/plane/app/serializers/project.py

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

apiserver/plane/app/serializers/user.py

@@ -169,8 +169,8 @@ class ChangePasswordSerializer(serializers.Serializer):
     Serializer for password change endpoint.
     """
     old_password = serializers.CharField(required=True)
-    new_password = serializers.CharField(required=True)
-    confirm_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"):
@@ -187,9 +187,7 @@ class ChangePasswordSerializer(serializers.Serializer):
 
 
 class ResetPasswordSerializer(serializers.Serializer):
-    model = User
-
     """
     Serializer for password change endpoint.
     """
-    new_password = serializers.CharField(required=True)
+    new_password = serializers.CharField(required=True, min_length=8)

apiserver/plane/app/serializers/view.py

@@ -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",
-        ]
+        ]

apiserver/plane/app/serializers/workspace.py

@@ -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,10 +13,11 @@ 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)
@@ -62,7 +63,7 @@ class WorkspaceLiteSerializer(BaseSerializer):
 
 
 
-class WorkSpaceMemberSerializer(BaseSerializer):
+class WorkSpaceMemberSerializer(DynamicBaseSerializer):
     member = UserLiteSerializer(read_only=True)
     workspace = WorkspaceLiteSerializer(read_only=True)
 
@@ -78,7 +79,7 @@ class WorkspaceMemberMeSerializer(BaseSerializer):
         fields = "__all__"
 
 
-class WorkspaceMemberAdminSerializer(BaseSerializer):
+class WorkspaceMemberAdminSerializer(DynamicBaseSerializer):
     member = UserAdminLiteSerializer(read_only=True)
     workspace = WorkspaceLiteSerializer(read_only=True)
 
@@ -95,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):
@@ -151,3 +162,13 @@ class WorkspaceThemeSerializer(BaseSerializer):
             "workspace",
             "actor",
         ]
+
+
+class WorkspaceUserPropertiesSerializer(BaseSerializer):
+    class Meta:
+        model = WorkspaceUserProperties
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "user",
+        ]

apiserver/plane/app/urls/authentication.py

@@ -7,6 +7,7 @@ from plane.app.views import (
     # Authentication
     SignInEndpoint,
     SignOutEndpoint,
+    MagicGenerateEndpoint,
     MagicSignInEndpoint,
     OauthEndpoint,
     EmailCheckEndpoint,
@@ -30,6 +31,7 @@ urlpatterns = [
     path("sign-in/", SignInEndpoint.as_view(), name="sign-in"),
     path("sign-out/", SignOutEndpoint.as_view(), name="sign-out"),
     # magic sign in
+    path("magic-generate/", MagicGenerateEndpoint.as_view(), name="magic-generate"),
     path("magic-sign-in/", MagicSignInEndpoint.as_view(), name="magic-sign-in"),
     path("token/refresh/", TokenRefreshView.as_view(), name="token_refresh"),
     # Password Manipulation

apiserver/plane/app/urls/cycle.py

@@ -7,6 +7,7 @@ from plane.app.views import (
     CycleDateCheckEndpoint,
     CycleFavoriteViewSet,
     TransferCycleIssueEndpoint,
+    CycleUserPropertiesEndpoint,
 )
 
 
@@ -44,7 +45,7 @@ urlpatterns = [
         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",
@@ -84,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",
+    )
 ]

apiserver/plane/app/urls/inbox.py

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

apiserver/plane/app/urls/issue.py

@@ -235,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",
     ),
@@ -275,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",

apiserver/plane/app/urls/module.py

@@ -7,6 +7,7 @@ from plane.app.views import (
     ModuleLinkViewSet,
     ModuleFavoriteViewSet,
     BulkImportModulesEndpoint,
+    ModuleUserPropertiesEndpoint
 )
 
 
@@ -44,7 +45,7 @@ urlpatterns = [
         name="project-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>/",
         ModuleIssueViewSet.as_view(
             {
                 "get": "retrieve",
@@ -101,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",
+    )
 ]

apiserver/plane/app/urls/project.py

@@ -13,6 +13,7 @@ from plane.app.views import (
     UserProjectInvitationsViewset,
     ProjectPublicCoverImagesEndpoint,
     ProjectDeployBoardViewSet,
+    UserProjectRolesEndpoint,
 )
 
 
@@ -74,6 +75,11 @@ urlpatterns = [
         ),
         name="user-project-invitations",
     ),
+    path(
+        "users/me/workspaces/<str:slug>/project-roles/",
+        UserProjectRolesEndpoint.as_view(),
+        name="user-project-roles",
+    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/join/<uuid:pk>/",
         ProjectJoinEndpoint.as_view(),

apiserver/plane/app/urls/views.py

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

apiserver/plane/app/urls/workspace.py

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

apiserver/plane/app/views/__init__.py

@@ -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,6 +61,7 @@ from .cycle import (
     CycleDateCheckEndpoint,
     CycleFavoriteViewSet,
     TransferCycleIssueEndpoint,
+    CycleUserPropertiesEndpoint,
 )
 from .asset import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
 from .issue import (
@@ -87,6 +91,7 @@ from .auth_extended import (
     ChangePasswordEndpoint,
     SetUserPasswordEndpoint,
     EmailCheckEndpoint,
+    MagicGenerateEndpoint,
 )
 
 
@@ -101,6 +106,7 @@ from .module import (
     ModuleIssueViewSet,
     ModuleLinkViewSet,
     ModuleFavoriteViewSet,
+    ModuleUserPropertiesEndpoint,
 )
 
 from .api import ApiTokenEndpoint
@@ -129,7 +135,6 @@ from .page import (
     PageFavoriteViewSet,
     PageLogEndpoint,
     SubPagesEndpoint,
-    CreateIssueFromBlockEndpoint,
 )
 
 from .search import GlobalSearchEndpoint, IssueSearchEndpoint

apiserver/plane/app/views/auth_extended.py

@@ -34,12 +34,12 @@ from plane.app.serializers import (
 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, InstanceConfiguration
+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.user_count_task import update_user_instance_user_count
 from plane.bgtasks.event_tracking_task import auth_events
 
+
 def get_tokens_for_user(user):
     refresh = RefreshToken.for_user(user)
     return (
@@ -105,17 +105,24 @@ class ForgotPasswordEndpoint(BaseAPIView):
     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)
+        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,
@@ -126,18 +133,24 @@ class ForgotPasswordEndpoint(BaseAPIView):
 
 
 class ResetPasswordEndpoint(BaseAPIView):
-    permission_classes = [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 invalid"},
                     status=status.HTTP_401_UNAUTHORIZED,
                 )
 
+            # Reset the password
             serializer = ResetPasswordSerializer(data=request.data)
             if serializer.is_valid():
                 # set_password also hashes the password that the user will get
@@ -145,9 +158,9 @@ class ResetPasswordEndpoint(BaseAPIView):
                 user.is_password_autoset = False
                 user.save()
 
+                # Log the user in
                 # Generate access token for the user
                 access_token, refresh_token = get_tokens_for_user(user)
-
                 data = {
                     "access_token": access_token,
                     "refresh_token": refresh_token,
@@ -166,7 +179,6 @@ class ResetPasswordEndpoint(BaseAPIView):
 class ChangePasswordEndpoint(BaseAPIView):
     def post(self, request):
         serializer = ChangePasswordSerializer(data=request.data)
-
         user = User.objects.get(pk=request.user.id)
         if serializer.is_valid():
             if not user.check_password(serializer.data.get("old_password")):
@@ -212,35 +224,131 @@ class SetUserPasswordEndpoint(BaseAPIView):
         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):
-        # get the email
-
         # Check the instance registration
         instance = Instance.objects.first()
-        if instance is None:
+        if instance is None or not instance.is_setup_done:
             return Response(
                 {"error": "Instance is not configured"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        instance_configuration = InstanceConfiguration.objects.values("key", "value")
+        # 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)
-        type = request.data.get("type", "magic_code")
 
         if not email:
-            return Response({"error": "Email is required"}, status=status.HTTP_400_BAD_REQUEST)
+            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)
+            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()
@@ -250,12 +358,7 @@ class EmailCheckEndpoint(BaseAPIView):
         if user is None:
             # Create the user
             if (
-                get_configuration_value(
-                    instance_configuration,
-                    "ENABLE_SIGNUP",
-                    os.environ.get("ENABLE_SIGNUP", "0"),
-                )
-                == "0"
+                ENABLE_SIGNUP == "0"
                 and not WorkspaceMemberInvite.objects.filter(
                     email=email,
                 ).exists()
@@ -267,7 +370,7 @@ class EmailCheckEndpoint(BaseAPIView):
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-
+            # Create the user with default values
             user = User.objects.create(
                 email=email,
                 username=uuid.uuid4().hex,
@@ -275,109 +378,90 @@ class EmailCheckEndpoint(BaseAPIView):
                 is_password_autoset=True,
             )
 
-            # Update instance user count
-            update_user_instance_user_count.delay()
-
-            # Case when the user selects magic code
-            if type == "magic_code":
-                if not bool(get_configuration_value(
-                    instance_configuration,
-                    "ENABLE_MAGIC_LINK_LOGIN",
-                    os.environ.get("ENABLE_MAGIC_LINK_LOGIN")),
-                ):
-                    return Response(
-                        {"error": "Magic link sign in is disabled."},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                
-                # Send event
-                if settings.POSTHOG_API_KEY and settings.POSTHOG_HOST:
-                    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}, status=status.HTTP_200_OK)
-            else:
-                # Get the uidb64 and token for the user
-                uidb64, token = generate_password_token(user=user)
-                forgot_password.delay(
-                    user.first_name, user.email, uidb64, token, current_site
+            if not bool(
+                ENABLE_MAGIC_LINK_LOGIN,
+            ):
+                return Response(
+                    {"error": "Magic link sign in is disabled."},
+                    status=status.HTTP_400_BAD_REQUEST,
                 )
-                # Send event
-                if settings.POSTHOG_API_KEY and settings.POSTHOG_HOST:
-                    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=True,
-                    )
-                # Automatically send the email
-                return Response({"is_password_autoset": user.is_password_autoset}, 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 type == "magic_code":
+            if user.is_password_autoset:
                 ## Generate a random token
-                if not bool(get_configuration_value(
-                    instance_configuration,
-                    "ENABLE_MAGIC_LINK_LOGIN",
-                    os.environ.get("ENABLE_MAGIC_LINK_LOGIN")),
-                ):
+                if not bool(ENABLE_MAGIC_LINK_LOGIN):
                     return Response(
                         {"error": "Magic link sign in is disabled."},
                         status=status.HTTP_400_BAD_REQUEST,
                     )
-                
-                if settings.POSTHOG_API_KEY and settings.POSTHOG_HOST:
-                    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,
-                    )
-                
+
+                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)
+                    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}, status=status.HTTP_200_OK)
+                return Response(
+                    {
+                        "is_password_autoset": user.is_password_autoset,
+                        "is_existing": True,
+                    },
+                    status=status.HTTP_200_OK,
+                )
             else:
-                if settings.POSTHOG_API_KEY and settings.POSTHOG_HOST:
-                    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,
-                    )
-                
-                if user.is_password_autoset:
-                    # send email
-                    uidb64, token = generate_password_token(user=user)
-                    forgot_password.delay(
-                        user.first_name, user.email, uidb64, token, current_site
-                    )
-                    return Response({"is_password_autoset": user.is_password_autoset}, status=status.HTTP_200_OK)
-                else:
-                    # User should enter password to login
-                    return Response({"is_password_autoset": user.is_password_autoset}, status=status.HTTP_200_OK)
+                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,
+                )

apiserver/plane/app/views/authentication.py

@@ -1,8 +1,6 @@
 # Python imports
 import os
 import uuid
-import random
-import string
 import json
 
 # Django imports
@@ -17,7 +15,6 @@ from rest_framework.response import Response
 from rest_framework.permissions import AllowAny
 from rest_framework import status
 from rest_framework_simplejwt.tokens import RefreshToken
-
 from sentry_sdk import capture_message
 
 # Module imports
@@ -30,11 +27,9 @@ from plane.db.models import (
     ProjectMember,
 )
 from plane.settings.redis import redis_instance
-from plane.license.models import InstanceConfiguration, Instance
+from plane.license.models import Instance
 from plane.license.utils.instance_value import get_configuration_value
 from plane.bgtasks.event_tracking_task import auth_events
-from plane.bgtasks.magic_link_code_task import magic_link
-from plane.bgtasks.user_count_task import update_user_instance_user_count
 
 
 def get_tokens_for_user(user):
@@ -49,11 +44,16 @@ class SignUpEndpoint(BaseAPIView):
     permission_classes = (AllowAny,)
 
     def post(self, request):
-        instance_configuration = InstanceConfiguration.objects.values("key", "value")
+        # Check if the instance configuration is done
+        instance = Instance.objects.first()
+        if instance is None or not instance.is_setup_done:
+            return Response(
+                {"error": "Instance is not configured"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
 
         email = request.data.get("email", False)
         password = request.data.get("password", False)
-
         ## Raise exception if any of the above are missing
         if not email or not password:
             return Response(
@@ -61,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:
@@ -71,13 +71,20 @@ 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 (
-            get_configuration_value(
-                instance_configuration,
-                "ENABLE_SIGNUP",
-                os.environ.get("ENABLE_SIGNUP", "0"),
-            )
-            == "0"
+            ENABLE_SIGNUP == "0"
             and not WorkspaceMemberInvite.objects.filter(
                 email=email,
             ).exists()
@@ -100,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")
@@ -114,9 +122,6 @@ class SignUpEndpoint(BaseAPIView):
             "refresh_token": refresh_token,
         }
 
-        # Update instance user count
-        update_user_instance_user_count.delay()
-
         return Response(data, status=status.HTTP_200_OK)
 
 
@@ -124,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)
 
@@ -134,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:
@@ -144,33 +157,49 @@ class SignInEndpoint(BaseAPIView):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        # Check if the instance setup is done or not
-        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 the user
         user = User.objects.filter(email=email).first()
 
-        # User is not present in db
-        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,
+                )
 
-        # Check user password
-        if not user.check_password(password):
-            return Response(
-                {
-                    "error": "Sorry, we could not find a user with the provided credentials. Please try again."
-                },
-                status=status.HTTP_403_FORBIDDEN,
+        # Create the user
+        else:
+            ENABLE_SIGNUP, = get_configuration_value(
+                [
+                    {
+                        "key": "ENABLE_SIGNUP",
+                        "default": os.environ.get("ENABLE_SIGNUP"),
+                    },
+                ]
+            )
+            # Create the user
+            if (
+                ENABLE_SIGNUP == "0"
+                and not WorkspaceMemberInvite.objects.filter(
+                    email=email,
+                ).exists()
+            ):
+                return Response(
+                    {
+                        "error": "New account creation is disabled. Please contact your site administrator"
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            user = User.objects.create(
+                email=email,
+                username=uuid.uuid4().hex,
+                password=make_password(password),
+                is_password_autoset=False,
             )
 
         # settings last active for the user
@@ -240,16 +269,15 @@ class SignInEndpoint(BaseAPIView):
         workspace_member_invites.delete()
         project_member_invites.delete()
         # Send event
-        if settings.POSTHOG_API_KEY and settings.POSTHOG_HOST:
-            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,
-            )
+        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 = {
@@ -288,6 +316,7 @@ class MagicSignInEndpoint(BaseAPIView):
     ]
 
     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(
@@ -314,24 +343,16 @@ class MagicSignInEndpoint(BaseAPIView):
 
             if str(token) == str(user_token):
                 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,
-                    )
                 # Send event
-                if settings.POSTHOG_API_KEY and settings.POSTHOG_HOST:
-                    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,
-                    )
+                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

apiserver/plane/app/views/base.py

@@ -159,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 = [
@@ -239,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

apiserver/plane/app/views/config.py

@@ -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,87 +20,106 @@ 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["google_client_id"] = (
+            GOOGLE_CLIENT_ID if GOOGLE_CLIENT_ID and GOOGLE_CLIENT_ID != '""' else 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["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("EMAIL_HOST_USER", None),
-                ),
-            )
-            and bool(
-                get_configuration_value(
-                    instance_configuration,
-                    "EMAIL_HOST_PASSWORD",
-                    os.environ.get("EMAIL_HOST_PASSWORD", None),
-                )
-            )
-        ) and get_configuration_value(
-            instance_configuration, "ENABLE_MAGIC_LINK_LOGIN", "1"
-        ) == "1"
+            bool(EMAIL_HOST_USER) and bool(EMAIL_HOST_PASSWORD)
+        ) and ENABLE_MAGIC_LINK_LOGIN == "1"
 
-        data["email_password_login"] = (
-            get_configuration_value(
-                instance_configuration, "ENABLE_EMAIL_PASSWORD", "1"
-            )
-            == "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 smtp configured
+        data["is_smtp_configured"] = not (
+            bool(EMAIL_HOST_USER) and bool(EMAIL_HOST_PASSWORD)
+        )
+
         return Response(data, status=status.HTTP_200_OK)

apiserver/plane/app/views/cycle.py

@@ -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 (
@@ -550,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")
@@ -574,10 +561,10 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
                 .values("count")
             )
         )
-
-        issues = IssueStateSerializer(issues, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(issue_dict, status=status.HTTP_200_OK)
+        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", [])
@@ -670,11 +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
         issue_activity.delay(
             type="cycle.activity.deleted",
             requested_data=json.dumps(
@@ -684,7 +673,7 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
                 }
             ),
             actor_id=str(self.request.user.id),
-            issue_id=str(cycle_issue.issue_id),
+            issue_id=str(issue_id),
             project_id=str(self.kwargs.get("project_id", None)),
             current_instance=None,
             epoch=int(timezone.now().timestamp()),
@@ -805,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)

apiserver/plane/app/views/estimate.py

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

apiserver/plane/app/views/external.py

@@ -1,6 +1,7 @@
 # Python imports
 import requests
 import os
+
 # Third party imports
 from openai import OpenAI
 from rest_framework.response import Response
@@ -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", os.environ.get("OPENAI_API_KEY"))
-        gpt_engine = get_configuration_value(instance_configuration, "GPT_ENGINE", os.environ.get("GPT_ENGINE", "gpt-3.5-turbo"))
-
         # 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,
@@ -48,11 +57,11 @@ class GPTIntegrationEndpoint(BaseAPIView):
         final_text = task + "\n" + prompt
 
         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}],
         )
 
@@ -79,13 +88,17 @@ class ReleaseNotesEndpoint(BaseAPIView):
 
 
 class UnsplashEndpoint(BaseAPIView):
-
     def get(self, request):
-        instance_configuration = InstanceConfiguration.objects.values("key", "value")
-        unsplash_access_key = get_configuration_value(instance_configuration, "UNSPLASH_ACCESS_KEY", os.environ.get("UNSPLASH_ACCESS_KEY"))
-
+        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:
+        if not UNSPLASH_ACCESS_KEY:
             return Response([], status=status.HTTP_200_OK)
 
         # Query parameters
@@ -94,9 +107,9 @@ class UnsplashEndpoint(BaseAPIView):
         per_page = request.GET.get("per_page", 20)
 
         url = (
-            f"https://api.unsplash.com/search/photos/?client_id={unsplash_access_key}&query={query}&page=${page}&per_page={per_page}"
+            f"https://api.unsplash.com/search/photos/?client_id={UNSPLASH_ACCESS_KEY}&query={query}&page=${page}&per_page={per_page}"
             if query
-            else f"https://api.unsplash.com/photos/?client_id={unsplash_access_key}&page={page}&per_page={per_page}"
+            else f"https://api.unsplash.com/photos/?client_id={UNSPLASH_ACCESS_KEY}&page={page}&per_page={per_page}"
         )
 
         headers = {

apiserver/plane/app/views/inbox.py

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

apiserver/plane/app/views/issue.py

@@ -52,6 +52,7 @@ from plane.app.serializers import (
     IssueRelationSerializer,
     RelatedIssueSerializer,
     IssuePublicSerializer,
+    IssueRelationLiteSerializer,
 )
 from plane.app.permissions import (
     ProjectEntityPermission,
@@ -129,22 +130,6 @@ class IssueViewSet(WebhookMixin, BaseViewSet):
                     queryset=IssueReaction.objects.select_related("actor"),
                 )
             )
-        ).distinct()
-
-    @method_decorator(gzip_page)
-    def list(self, request, slug, project_id):
-        fields = [field for field in request.GET.get("fields", "").split(",") if field]
-        filters = issue_filters(request.query_params, "GET")
-
-        # Custom ordering for priority and state
-        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(
@@ -159,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":
@@ -217,9 +221,10 @@ class IssueViewSet(WebhookMixin, BaseViewSet):
         else:
             issue_queryset = issue_queryset.order_by(order_by_param)
 
-        issues = IssueLiteSerializer(issue_queryset, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(issue_dict, status=status.HTTP_200_OK)
+        issues = 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):
         project = Project.objects.get(pk=project_id)
@@ -256,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)
@@ -590,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)
@@ -708,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",
@@ -728,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,
         )
@@ -775,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,
         )
 
@@ -1062,9 +1080,10 @@ class IssueArchiveViewSet(BaseViewSet):
             else issue_queryset.filter(parent__isnull=True)
         )
 
-        issues = IssueLiteSerializer(issue_queryset, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(issue_dict, status=status.HTTP_200_OK)
+        issues = IssueLiteSerializer(
+            issue_queryset, many=True, fields=fields if fields else None
+        ).data
+        return Response(issues, status=status.HTTP_200_OK)
 
     def retrieve(self, request, slug, project_id, pk=None):
         issue = Issue.objects.get(
@@ -1365,23 +1384,62 @@ 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)
 
         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,
@@ -1397,7 +1455,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,
@@ -1408,10 +1466,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,
@@ -1419,7 +1485,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),
@@ -1547,9 +1613,10 @@ class IssueDraftViewSet(BaseViewSet):
         else:
             issue_queryset = issue_queryset.order_by(order_by_param)
 
-        issues = IssueLiteSerializer(issue_queryset, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(issue_dict, status=status.HTTP_200_OK)
+        issues = IssueLiteSerializer(
+            issue_queryset, many=True, fields=fields if fields else None
+        ).data
+        return Response(issues, status=status.HTTP_200_OK)
 
     def create(self, request, slug, project_id):
         project = Project.objects.get(pk=project_id)
@@ -1626,4 +1693,4 @@ class IssueDraftViewSet(BaseViewSet):
             current_instance=current_instance,
             epoch=int(timezone.now().timestamp()),
         )
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/app/views/module.py

@@ -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)
 
@@ -289,7 +298,6 @@ class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
     webhook_event = "module_issue"
     bulk = True
 
-
     filterset_fields = [
         "issue__labels__id",
         "issue__assignees__id",
@@ -335,7 +343,6 @@ class ModuleIssueViewSet(WebhookMixin, 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")
@@ -359,9 +366,10 @@ class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
                 .values("count")
             )
         )
-        issues = IssueStateSerializer(issues, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(issue_dict, status=status.HTTP_200_OK)
+        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", [])
@@ -444,20 +452,23 @@ class ModuleIssueViewSet(WebhookMixin, 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,
         )
         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(module_issue.issue_id),
+            issue_id=str(issue_id),
             project_id=str(project_id),
             current_instance=None,
             epoch=int(timezone.now().timestamp()),
@@ -521,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)

apiserver/plane/app/views/oauth.py

@@ -30,9 +30,8 @@ from plane.db.models import (
 )
 from plane.bgtasks.event_tracking_task import auth_events
 from .base import BaseAPIView
-from plane.license.models import InstanceConfiguration, Instance
+from plane.license.models import Instance
 from plane.license.utils.instance_value import get_configuration_value
-from plane.bgtasks.user_count_task import update_user_instance_user_count
 
 
 def get_tokens_for_user(user):
@@ -87,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"}
@@ -148,22 +154,18 @@ class OauthEndpoint(BaseAPIView):
             id_token = request.data.get("credential", False)
             client_id = request.data.get("clientId", False)
 
-            instance_configuration = InstanceConfiguration.objects.values(
-                "key", "value"
+            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 get_configuration_value(
-                instance_configuration,
-                "GOOGLE_CLIENT_ID",
-                os.environ.get("GOOGLE_CLIENT_ID"),
-            ) or not get_configuration_value(
-                instance_configuration,
-                "GITHUB_CLIENT_ID",
-                os.environ.get("GITHUB_CLIENT_ID"),
-            ):
-                return Response(
-                    {"error": "Github or Google login is not configured"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
 
             if not medium or not id_token:
                 return Response(
@@ -174,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)
 
@@ -279,16 +291,15 @@ class OauthEndpoint(BaseAPIView):
             )
 
             # Send event
-            if settings.POSTHOG_API_KEY and settings.POSTHOG_HOST:
-                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,
-                )
+            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)
 
@@ -299,25 +310,16 @@ class OauthEndpoint(BaseAPIView):
             return Response(data, status=status.HTTP_200_OK)
 
         except User.DoesNotExist:
-            ## Signup Case
-            instance_configuration = InstanceConfiguration.objects.values(
-                "key", "value"
+            (ENABLE_SIGNUP,) = get_configuration_value(
+                [
+                    {
+                        "key": "ENABLE_SIGNUP",
+                        "default": os.environ.get("ENABLE_SIGNUP", "0"),
+                    }
+                ]
             )
-            # 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,
-                )
-
             if (
-                get_configuration_value(
-                    instance_configuration,
-                    "ENABLE_SIGNUP",
-                    os.environ.get("ENABLE_SIGNUP", "0"),
-                )
-                == "0"
+                ENABLE_SIGNUP == "0"
                 and not WorkspaceMemberInvite.objects.filter(
                     email=email,
                 ).exists()
@@ -420,16 +422,15 @@ class OauthEndpoint(BaseAPIView):
             project_member_invites.delete()
 
             # Send event
-            if settings.POSTHOG_API_KEY and settings.POSTHOG_HOST:
-                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,
-                )
+            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,
@@ -447,6 +448,4 @@ class OauthEndpoint(BaseAPIView):
                 "refresh_token": refresh_token,
             }
 
-            # Update the user count
-            update_user_instance_user_count.delay()
             return Response(data, status=status.HTTP_201_CREATED)

apiserver/plane/app/views/page.py

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

apiserver/plane/app/views/project.py

@@ -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:
@@ -600,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",
@@ -664,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,
@@ -679,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,
@@ -693,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):
@@ -1048,3 +1071,20 @@ class ProjectDeployBoardViewSet(BaseViewSet):
 
         serializer = ProjectDeployBoardSerializer(project_deploy_board)
         return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class UserProjectRolesEndpoint(BaseAPIView):
+    permission_classes = [
+        WorkspaceUserPermission,
+    ]
+
+    def get(self, request, slug):
+        project_members = ProjectMember.objects.filter(
+            workspace__slug=slug,
+            member_id=request.user.id,
+        ).values("project_id", "role")
+
+        project_members = {
+            str(member["project_id"]): member["role"] for member in project_members
+        }
+        return Response(project_members, status=status.HTTP_200_OK)

apiserver/plane/app/views/search.py

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

apiserver/plane/app/views/state.py

@@ -77,7 +77,7 @@ class StateViewSet(BaseViewSet):
         )
 
         if state.default:
-            return Response({"error": "Default state cannot be deleted"}, status=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()

apiserver/plane/app/views/user.py

@@ -49,6 +49,10 @@ class UserEndpoint(BaseViewSet):
         # Check all workspace user is active
         user = self.get_object()
 
+        # Instance admin check
+        if InstanceAdmin.objects.filter(user=user).exists():
+            return Response({"error": "You cannot deactivate your account since you are an instance admin"}, status=status.HTTP_400_BAD_REQUEST)
+
         projects_to_deactivate = []
         workspaces_to_deactivate = []
 

apiserver/plane/app/views/view.py

@@ -27,7 +27,12 @@ from plane.app.serializers import (
     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()
@@ -179,12 +185,10 @@ class GlobalViewIssuesViewSet(BaseViewSet):
         else:
             issue_queryset = issue_queryset.order_by(order_by_param)
 
-        issues = IssueLiteSerializer(issue_queryset, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(
-            issue_dict,
-            status=status.HTTP_200_OK,
+        serializer = IssueLiteSerializer(
+            issue_queryset, many=True, fields=fields if fields else None
         )
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
 
 class IssueViewViewSet(BaseViewSet):
@@ -217,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
@@ -246,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)

apiserver/plane/app/views/workspace.py

@@ -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):
@@ -173,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"),
@@ -208,9 +214,12 @@ class UserWorkSpacesEndpoint(BaseAPIView):
             )
             .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):
@@ -408,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,
@@ -486,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",
@@ -515,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)
@@ -683,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
@@ -1312,8 +1385,7 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
         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)
+        return Response(issues, status=status.HTTP_200_OK)
 
 
 class WorkspaceLabelsEndpoint(BaseAPIView):
@@ -1327,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)

apiserver/plane/bgtasks/analytic_plot_export.py

@@ -1,7 +1,8 @@
 # Python imports
 import csv
 import io
-import os
+import requests
+import json
 
 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
@@ -17,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",
@@ -43,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", {})
@@ -51,51 +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", os.environ.get("EMAIL_HOST")
-        ),
-        port=int(
-            get_configuration_value(
-                instance_configuration, "EMAIL_PORT", os.environ.get("EMAIL_PORT")
-            )
-        ),
-        username=get_configuration_value(
-            instance_configuration,
-            "EMAIL_HOST_USER",
-            os.environ.get("EMAIL_HOST_USER"),
-        ),
-        password=get_configuration_value(
-            instance_configuration,
-            "EMAIL_HOST_PASSWORD",
-            os.environ.get("EMAIL_HOST_PASSWORD"),
-        ),
-        use_tls=bool(
-            get_configuration_value(
-                instance_configuration,
-                "EMAIL_USE_TLS",
-                os.environ.get("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=get_configuration_value(
-            instance_configuration,
-            "EMAIL_FROM",
-            os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
-        ),
+        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):
@@ -463,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

apiserver/plane/bgtasks/event_tracking_task.py

@@ -1,30 +1,78 @@
 import uuid
+import os
 
-from posthog import Posthog
-from django.conf import settings
-
-#third party imports
+# 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 = Posthog(settings.POSTHOG_API_KEY, host=settings.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
-            }
-        )
+        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)

apiserver/plane/bgtasks/forgot_password_task.py

@@ -14,7 +14,6 @@ from celery import shared_task
 from sentry_sdk import capture_exception
 
 # Module imports
-from plane.license.models import InstanceConfiguration, Instance
 from plane.license.utils.instance_value import get_email_configuration
 
 
@@ -26,10 +25,6 @@ def forgot_password(first_name, email, uidb64, token, current_site):
         )
         abs_url = str(current_site) + relative_link
 
-        instance_configuration = InstanceConfiguration.objects.filter(
-            key__startswith="EMAIL_"
-        ).values("key", "value")
-
         (
             EMAIL_HOST,
             EMAIL_HOST_USER,
@@ -37,36 +32,7 @@ def forgot_password(first_name, email, uidb64, token, current_site):
             EMAIL_PORT,
             EMAIL_USE_TLS,
             EMAIL_FROM,
-        ) = get_email_configuration(instance_configuration=instance_configuration)
-
-        # Send the email if the users don't have smtp configured
-        if not EMAIL_HOST or not EMAIL_HOST_USER or not EMAIL_HOST_PASSWORD:
-            # Check the instance registration
-            instance = Instance.objects.first()
-
-            # send the emails through control center
-            license_engine_base_url = os.environ.get("LICENSE_ENGINE_BASE_URL", False)
-
-            # headers
-            headers = {
-                "Content-Type": "application/json",
-                "x-instance-id": instance.instance_id,
-                "x-api-key": instance.api_key,
-            }
-
-            payload = {
-                "abs_url": abs_url,
-                "first_name": first_name,
-                "email": email,
-            }
-
-            _ = requests.post(
-                f"{license_engine_base_url}/api/instances/users/forgot-password/",
-                headers=headers,
-                data=json.dumps(payload),
-            )
-
-            return
+        ) = get_email_configuration()
 
         subject = "A new password to your Plane account has been requested"
 
@@ -80,15 +46,12 @@ def forgot_password(first_name, email, uidb64, token, current_site):
 
         text_content = strip_tags(html_content)
 
-        instance_configuration = InstanceConfiguration.objects.filter(
-            key__startswith="EMAIL_"
-        ).values("key", "value")
         connection = get_connection(
             host=EMAIL_HOST,
             port=int(EMAIL_PORT),
             username=EMAIL_HOST_USER,
             password=EMAIL_HOST_PASSWORD,
-            use_tls=bool(EMAIL_USE_TLS),
+            use_tls=EMAIL_USE_TLS == "1",
         )
 
         msg = EmailMultiAlternatives(

apiserver/plane/bgtasks/importer_task.py

@@ -26,7 +26,6 @@ from plane.db.models import (
     IssueProperty,
 )
 from plane.bgtasks.user_welcome_task import send_welcome_slack
-from plane.bgtasks.user_count_task import update_user_instance_user_count
 
 
 @shared_task
@@ -121,9 +120,6 @@ def service_importer(service, importer_id):
                 batch_size=100,
                 ignore_conflicts=True,
             )
-        
-        # Update instance user count
-        update_user_instance_user_count.delay()
 
         # Check if sync config is on for github importers
         if service == "github" and importer.config.get("sync", False):

apiserver/plane/bgtasks/issue_activites_task.py

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

apiserver/plane/bgtasks/magic_link_code_task.py

@@ -14,18 +14,12 @@ from celery import shared_task
 from sentry_sdk import capture_exception
 
 # Module imports
-from plane.license.models import InstanceConfiguration, Instance
 from plane.license.utils.instance_value import get_email_configuration
 
 
 @shared_task
 def magic_link(email, key, token, current_site):
     try:
-
-        instance_configuration = InstanceConfiguration.objects.filter(
-            key__startswith="EMAIL_"
-        ).values("key", "value")
-
         (
             EMAIL_HOST,
             EMAIL_HOST_USER,
@@ -33,34 +27,7 @@ def magic_link(email, key, token, current_site):
             EMAIL_PORT,
             EMAIL_USE_TLS,
             EMAIL_FROM,
-        ) = get_email_configuration(instance_configuration=instance_configuration)
-
-        # Send the email if the users don't have smtp configured
-        if not EMAIL_HOST or not EMAIL_HOST_USER or not EMAIL_HOST_PASSWORD:
-            # Check the instance registration
-            instance = Instance.objects.first()
-
-            # send the emails through control center
-            license_engine_base_url = os.environ.get("LICENSE_ENGINE_BASE_URL", False)
-
-            headers = {
-                "Content-Type": "application/json",
-                "x-instance-id": instance.instance_id,
-                "x-api-key": instance.api_key,
-            }
-
-            payload = {
-                "token": token,
-                "email": email,
-            }
-
-            _ = requests.post(
-                f"{license_engine_base_url}/api/instances/users/magic-code/",
-                headers=headers,
-                data=json.dumps(payload),
-            )
-
-            return
+        ) = get_email_configuration()
 
         # Send the mail
         subject = f"Your unique Plane login code is {token}"
@@ -74,7 +41,7 @@ def magic_link(email, key, token, current_site):
             port=int(EMAIL_PORT),
             username=EMAIL_HOST_USER,
             password=EMAIL_HOST_PASSWORD,
-            use_tls=bool(EMAIL_USE_TLS),
+            use_tls=EMAIL_USE_TLS == "1",
         )
 
         msg = EmailMultiAlternatives(

apiserver/plane/bgtasks/notification_task.py

@@ -291,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(
@@ -341,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:

apiserver/plane/bgtasks/project_invitation_task.py

@@ -13,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):
@@ -47,43 +46,27 @@ 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", os.environ.get("EMAIL_HOST")
-            ),
-            port=int(
-                get_configuration_value(
-                    instance_configuration, "EMAIL_PORT", os.environ.get("EMAIL_PORT")
-                )
-            ),
-            username=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_USER",
-                os.environ.get("EMAIL_HOST_USER"),
-            ),
-            password=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_PASSWORD",
-                os.environ.get("EMAIL_HOST_PASSWORD"),
-            ),
-            use_tls=bool(
-                get_configuration_value(
-                    instance_configuration,
-                    "EMAIL_USE_TLS",
-                    os.environ.get("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=get_configuration_value(
-                instance_configuration,
-                "EMAIL_FROM",
-                os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
-            ),
+            from_email=EMAIL_FROM,
             to=[email],
             connection=connection,
         )

apiserver/plane/bgtasks/user_count_task.py

@@ -1,49 +0,0 @@
-# Python imports
-import json
-import requests
-import os
-
-# django imports
-from django.conf import settings
-
-# Third party imports
-from celery import shared_task
-from sentry_sdk import capture_exception
-
-# Module imports
-from plane.db.models import User
-from plane.license.models import Instance
-
-@shared_task
-def update_user_instance_user_count():
-    try:
-        instance_users = User.objects.filter(is_bot=False).count()
-        instance = Instance.objects.update(user_count=instance_users)
-
-        # Update the count in the license engine
-        payload = {
-            "user_count": User.objects.count(),
-        }
-
-        # Save the user in control center
-        headers = {
-            "Content-Type": "application/json",
-            "x-instance-id": instance.instance_id,
-            "x-api-key": instance.api_key,
-        }
-
-        license_engine_base_url = os.environ.get("LICENSE_ENGINE_BASE_URL")
-        if not license_engine_base_url:
-            raise Exception("License Engine base url is required")
-        
-        # Update the license engine
-        _ = requests.post(
-            f"{license_engine_base_url}/api/instances/",
-            headers=headers,
-            data=json.dumps(payload),
-        )
-
-    except Exception as e:
-        if settings.DEBUG:
-            print(e)
-        capture_exception(e)

apiserver/plane/bgtasks/webhook_task.py

@@ -109,7 +109,7 @@ def webhook_task(self, webhook, slug, event, event_data, action):
         if webhook.secret_key:
             hmac_signature = hmac.new(
                 webhook.secret_key.encode("utf-8"),
-                json.dumps(payload, sort_keys=True).encode("utf-8"),
+                json.dumps(payload).encode("utf-8"),
                 hashlib.sha256,
             )
             signature = hmac_signature.hexdigest()

apiserver/plane/bgtasks/workspace_invitation_task.py

@@ -17,7 +17,6 @@ from slack_sdk.errors import SlackApiError
 
 # Module imports
 from plane.db.models import Workspace, WorkspaceMemberInvite, User
-from plane.license.models import InstanceConfiguration, Instance
 from plane.license.utils.instance_value import get_email_configuration
 
 
@@ -37,9 +36,6 @@ def workspace_invitation(email, workspace_id, token, current_site, invitor):
         # The complete url including the domain
         abs_url = str(current_site) + relative_link
 
-        instance_configuration = InstanceConfiguration.objects.filter(
-            key__startswith="EMAIL_"
-        ).values("key", "value")
 
         (
             EMAIL_HOST,
@@ -48,37 +44,7 @@ def workspace_invitation(email, workspace_id, token, current_site, invitor):
             EMAIL_PORT,
             EMAIL_USE_TLS,
             EMAIL_FROM,
-        ) = get_email_configuration(instance_configuration=instance_configuration)
-
-        # Send the email if the users don't have smtp configured
-        if not EMAIL_HOST or not EMAIL_HOST_USER or not EMAIL_HOST_PASSWORD:
-            # Check the instance registration
-            instance = Instance.objects.first()
-
-            # send the emails through control center
-            license_engine_base_url = os.environ.get("LICENSE_ENGINE_BASE_URL", False)
-            if not license_engine_base_url:
-                raise Exception("License engine base url is required")
-
-            headers = {
-                "Content-Type": "application/json",
-                "x-instance-id": instance.instance_id,
-                "x-api-key": instance.api_key,
-            }
-
-            payload = {
-                "user": user.first_name or user.display_name or user.email,
-                "workspace_name": workspace.name,
-                "invitation_url": abs_url,
-                "email": email,
-            }
-            _ = requests.post(
-                f"{license_engine_base_url}/api/instances/users/workspace-invitation/",
-                headers=headers,
-                data=json.dumps(payload),
-            )
-
-            return
+        ) = get_email_configuration()
 
         # Subject of the email
         subject = f"{user.first_name or user.display_name or user.email} has invited you to join them in {workspace.name} on Plane"
@@ -99,15 +65,12 @@ 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=EMAIL_HOST,
             port=int(EMAIL_PORT),
             username=EMAIL_HOST_USER,
             password=EMAIL_HOST_PASSWORD,
-            use_tls=bool(EMAIL_USE_TLS),
+            use_tls=EMAIL_USE_TLS == "1",
         )
 
         msg = EmailMultiAlternatives(

apiserver/plane/celery.py

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

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

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

apiserver/plane/db/migrations/0051_cycle_external_id_cycle_external_source_and_more.py

@@ -0,0 +1,83 @@
+# Generated by Django 4.2.7 on 2023-12-29 10:20
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('db', '0050_user_use_case_alter_workspace_organization_size'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='cycle',
+            name='external_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='cycle',
+            name='external_source',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='inboxissue',
+            name='external_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='inboxissue',
+            name='external_source',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='issue',
+            name='external_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='issue',
+            name='external_source',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='issuecomment',
+            name='external_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='issuecomment',
+            name='external_source',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='label',
+            name='external_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='label',
+            name='external_source',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='module',
+            name='external_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='module',
+            name='external_source',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='state',
+            name='external_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='state',
+            name='external_source',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]

apiserver/plane/db/migrations/0052_auto_20231220_1141.py

@@ -0,0 +1,136 @@
+# Generated by Django 4.2.7 on 2023-12-20 11:14
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import plane.db.models.cycle
+import plane.db.models.issue
+import plane.db.models.module
+import plane.db.models.view
+import plane.db.models.workspace
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('db', '0051_cycle_external_id_cycle_external_source_and_more'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='issueview',
+            old_name='query_data',
+            new_name='filters',
+        ),
+        migrations.RenameField(
+            model_name='issueproperty',
+            old_name='properties',
+            new_name='display_properties',
+        ),
+        migrations.AlterField(
+            model_name='issueproperty',
+            name='display_properties',
+            field=models.JSONField(default=plane.db.models.issue.get_default_display_properties),
+        ),
+        migrations.AddField(
+            model_name='issueproperty',
+            name='display_filters',
+            field=models.JSONField(default=plane.db.models.issue.get_default_display_filters),
+        ),
+        migrations.AddField(
+            model_name='issueproperty',
+            name='filters',
+            field=models.JSONField(default=plane.db.models.issue.get_default_filters),
+        ),
+        migrations.AddField(
+            model_name='issueview',
+            name='display_filters',
+            field=models.JSONField(default=plane.db.models.view.get_default_display_filters),
+        ),
+        migrations.AddField(
+            model_name='issueview',
+            name='display_properties',
+            field=models.JSONField(default=plane.db.models.view.get_default_display_properties),
+        ),
+        migrations.AddField(
+            model_name='issueview',
+            name='sort_order',
+            field=models.FloatField(default=65535),
+        ),
+        migrations.AlterField(
+            model_name='issueview',
+            name='project',
+            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='project_%(class)s', to='db.project'),
+        ),
+        migrations.CreateModel(
+            name='WorkspaceUserProperties',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, verbose_name='Created At')),
+                ('updated_at', models.DateTimeField(auto_now=True, verbose_name='Last Modified At')),
+                ('id', models.UUIDField(db_index=True, default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True)),
+                ('filters', models.JSONField(default=plane.db.models.workspace.get_default_filters)),
+                ('display_filters', models.JSONField(default=plane.db.models.workspace.get_default_display_filters)),
+                ('display_properties', models.JSONField(default=plane.db.models.workspace.get_default_display_properties)),
+                ('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')),
+                ('updated_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='%(class)s_updated_by', to=settings.AUTH_USER_MODEL, verbose_name='Last Modified By')),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='workspace_user_properties', to=settings.AUTH_USER_MODEL)),
+                ('workspace', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='workspace_user_properties', to='db.workspace')),
+            ],
+            options={
+                'verbose_name': 'Workspace User Property',
+                'verbose_name_plural': 'Workspace User Property',
+                'db_table': 'Workspace_user_properties',
+                'ordering': ('-created_at',),
+                'unique_together': {('workspace', 'user')},
+            },
+        ),
+        migrations.CreateModel(
+            name='ModuleUserProperties',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, verbose_name='Created At')),
+                ('updated_at', models.DateTimeField(auto_now=True, verbose_name='Last Modified At')),
+                ('id', models.UUIDField(db_index=True, default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True)),
+                ('filters', models.JSONField(default=plane.db.models.module.get_default_filters)),
+                ('display_filters', models.JSONField(default=plane.db.models.module.get_default_display_filters)),
+                ('display_properties', models.JSONField(default=plane.db.models.module.get_default_display_properties)),
+                ('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')),
+                ('module', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='module_user_properties', to='db.module')),
+                ('project', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='project_%(class)s', to='db.project')),
+                ('updated_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='%(class)s_updated_by', to=settings.AUTH_USER_MODEL, verbose_name='Last Modified By')),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='module_user_properties', to=settings.AUTH_USER_MODEL)),
+                ('workspace', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='workspace_%(class)s', to='db.workspace')),
+            ],
+            options={
+                'verbose_name': 'Module User Property',
+                'verbose_name_plural': 'Module User Property',
+                'db_table': 'module_user_properties',
+                'ordering': ('-created_at',),
+                'unique_together': {('module', 'user')},
+            },
+        ),
+        migrations.CreateModel(
+            name='CycleUserProperties',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, verbose_name='Created At')),
+                ('updated_at', models.DateTimeField(auto_now=True, verbose_name='Last Modified At')),
+                ('id', models.UUIDField(db_index=True, default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True)),
+                ('filters', models.JSONField(default=plane.db.models.cycle.get_default_filters)),
+                ('display_filters', models.JSONField(default=plane.db.models.cycle.get_default_display_filters)),
+                ('display_properties', models.JSONField(default=plane.db.models.cycle.get_default_display_properties)),
+                ('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')),
+                ('cycle', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='cycle_user_properties', to='db.cycle')),
+                ('project', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='project_%(class)s', to='db.project')),
+                ('updated_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='%(class)s_updated_by', to=settings.AUTH_USER_MODEL, verbose_name='Last Modified By')),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='cycle_user_properties', to=settings.AUTH_USER_MODEL)),
+                ('workspace', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='workspace_%(class)s', to='db.workspace')),
+            ],
+            options={
+                'verbose_name': 'Cycle User Property',
+                'verbose_name_plural': 'Cycle User Properties',
+                'db_table': 'cycle_user_properties',
+                'ordering': ('-created_at',),
+                'unique_together': {('cycle', 'user')},
+            },
+        ),
+    ]

apiserver/plane/db/migrations/0053_auto_20240102_1315.py

@@ -0,0 +1,65 @@
+# Generated by Django 4.2.7 on 2024-01-02 13:15
+
+from plane.db.models import WorkspaceUserProperties, ProjectMember, IssueView
+from django.db import migrations
+
+
+def workspace_user_properties(apps, schema_editor):
+    WorkspaceMember = apps.get_model("db", "WorkspaceMember")
+    updated_workspace_user_properties = []
+    for workspace_members in WorkspaceMember.objects.all():
+        updated_workspace_user_properties.append(
+            WorkspaceUserProperties(
+                user_id=workspace_members.member_id,
+                display_filters=workspace_members.view_props.get("display_filters"),
+                display_properties=workspace_members.view_props.get("display_properties"),
+                workspace_id=workspace_members.workspace_id,
+            )
+        )
+    WorkspaceUserProperties.objects.bulk_create(updated_workspace_user_properties, batch_size=2000)
+
+
+def project_user_properties(apps, schema_editor):
+    IssueProperty = apps.get_model("db", "IssueProperty")
+    updated_issue_user_properties = []
+    for issue_property in IssueProperty.objects.all():
+        project_member = ProjectMember.objects.filter(project_id=issue_property.project_id, member_id=issue_property.user_id).first()
+        if project_member:
+            issue_property.filters = project_member.view_props.get("filters")
+            issue_property.display_filters = project_member.view_props.get("display_filters")
+            updated_issue_user_properties.append(issue_property)
+
+    IssueProperty.objects.bulk_update(updated_issue_user_properties, ["filters", "display_filters"], batch_size=2000)
+
+
+def issue_view(apps, schema_editor):
+    GlobalView = apps.get_model("db", "GlobalView")
+    updated_issue_views = []
+    
+    for global_view in GlobalView.objects.all():
+        updated_issue_views.append(
+            IssueView(
+                workspace_id=global_view.workspace_id,
+                name=global_view.name,
+                description=global_view.description,
+                query=global_view.query,
+                access=global_view.access,
+                filters=global_view.query_data.get("filters", {}),
+                sort_order=global_view.sort_order,
+                created_by_id=global_view.created_by_id,
+                updated_by_id=global_view.updated_by_id,
+            )
+        )
+    IssueView.objects.bulk_create(updated_issue_views, batch_size=100)
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('db', '0052_auto_20231220_1141'),
+    ]
+
+    operations = [
+        migrations.RunPython(workspace_user_properties),
+        migrations.RunPython(project_user_properties),
+        migrations.RunPython(issue_view),
+    ]

apiserver/plane/db/models/__init__.py

@@ -9,6 +9,8 @@ from .workspace import (
     WorkspaceMemberInvite,
     TeamMember,
     WorkspaceTheme,
+    WorkspaceUserProperties,
+    WorkspaceBaseModel,
 )
 
 from .project import (
@@ -48,11 +50,11 @@ from .social_connection import SocialLoginConnection
 
 from .state import State
 
-from .cycle import Cycle, CycleIssue, CycleFavorite
+from .cycle import Cycle, CycleIssue, CycleFavorite, CycleUserProperties
 
 from .view import GlobalView, IssueView, IssueViewFavorite
 
-from .module import Module, ModuleMember, ModuleIssue, ModuleLink, ModuleFavorite
+from .module import Module, ModuleMember, ModuleIssue, ModuleLink, ModuleFavorite, ModuleUserProperties
 
 from .api import APIToken, APIActivityLog
 

apiserver/plane/db/models/cycle.py

@@ -6,6 +6,47 @@ from django.conf import settings
 from . import ProjectBaseModel
 
 
+def get_default_filters():
+    return {
+        "priority": None,
+        "state": None,
+        "state_group": None,
+        "assignees": None,
+        "created_by": None,
+        "labels": None,
+        "start_date": None,
+        "target_date": None,
+        "subscriber": None,
+    }
+
+def get_default_display_filters():
+    return {
+        "group_by": None,
+        "order_by": "-created_at",
+        "type": None,
+        "sub_issue": True,
+        "show_empty_groups": True,
+        "layout": "list",
+        "calendar_date_range": "",
+    }
+
+def get_default_display_properties():
+    return {
+        "assignee": True,
+        "attachment_count": True,
+        "created_on": True,
+        "due_date": True,
+        "estimate": True,
+        "key": True,
+        "labels": True,
+        "link": True,
+        "priority": True,
+        "start_date": True,
+        "state": True,
+        "sub_issue_count": True,
+        "updated_on": True,
+    }
+
 class Cycle(ProjectBaseModel):
     name = models.CharField(max_length=255, verbose_name="Cycle Name")
     description = models.TextField(verbose_name="Cycle Description", blank=True)
@@ -18,6 +59,8 @@ class Cycle(ProjectBaseModel):
     )
     view_props = models.JSONField(default=dict)
     sort_order = models.FloatField(default=65535)
+    external_source = models.CharField(max_length=255, null=True, blank=True)
+    external_id = models.CharField(max_length=255, blank=True, null=True)
 
     class Meta:
         verbose_name = "Cycle"
@@ -87,3 +130,28 @@ class CycleFavorite(ProjectBaseModel):
     def __str__(self):
         """Return user and the cycle"""
         return f"{self.user.email} <{self.cycle.name}>"
+
+
+class CycleUserProperties(ProjectBaseModel):
+    cycle = models.ForeignKey(
+        "db.Cycle", on_delete=models.CASCADE, related_name="cycle_user_properties"
+    )
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="cycle_user_properties",
+    )
+    filters = models.JSONField(default=get_default_filters)
+    display_filters = models.JSONField(default=get_default_display_filters)
+    display_properties = models.JSONField(default=get_default_display_properties)
+
+
+    class Meta:
+        unique_together = ["cycle", "user"]
+        verbose_name = "Cycle User Property"
+        verbose_name_plural = "Cycle User Properties"
+        db_table = "cycle_user_properties"
+        ordering = ("-created_at",)
+
+    def __str__(self):
+        return f"{self.cycle.name} {self.user.email}"

apiserver/plane/db/models/inbox.py

@@ -39,6 +39,8 @@ class InboxIssue(ProjectBaseModel):
         "db.Issue", related_name="inbox_duplicate", on_delete=models.SET_NULL, null=True
     )
     source = models.TextField(blank=True, null=True)
+    external_source = models.CharField(max_length=255, null=True, blank=True)
+    external_id = models.CharField(max_length=255, blank=True, null=True)
 
     class Meta:
         verbose_name = "InboxIssue"

apiserver/plane/db/models/issue.py

@@ -33,6 +33,48 @@ def get_default_properties():
     }
 
 
+def get_default_filters():
+    return {
+        "priority": None,
+        "state": None,
+        "state_group": None,
+        "assignees": None,
+        "created_by": None,
+        "labels": None,
+        "start_date": None,
+        "target_date": None,
+        "subscriber": None,
+    }
+
+def get_default_display_filters():
+    return {
+        "group_by": None,
+        "order_by": "-created_at",
+        "type": None,
+        "sub_issue": True,
+        "show_empty_groups": True,
+        "layout": "list",
+        "calendar_date_range": "",
+    }
+
+def get_default_display_properties():
+    return {
+        "assignee": True,
+        "attachment_count": True,
+        "created_on": True,
+        "due_date": True,
+        "estimate": True,
+        "key": True,
+        "labels": True,
+        "link": True,
+        "priority": True,
+        "start_date": True,
+        "state": True,
+        "sub_issue_count": True,
+        "updated_on": True,
+    }
+
+
 # TODO: Handle identifiers for Bulk Inserts - nk
 class IssueManager(models.Manager):
     def get_queryset(self):
@@ -102,6 +144,8 @@ class Issue(ProjectBaseModel):
     completed_at = models.DateTimeField(null=True)
     archived_at = models.DateField(null=True)
     is_draft = models.BooleanField(default=False)
+    external_source = models.CharField(max_length=255, null=True, blank=True)
+    external_id = models.CharField(max_length=255, blank=True, null=True)
 
     objects = models.Manager()
     issue_objects = IssueManager()
@@ -366,6 +410,8 @@ class IssueComment(ProjectBaseModel):
         default="INTERNAL",
         max_length=100,
     )
+    external_source = models.CharField(max_length=255, null=True, blank=True)
+    external_id = models.CharField(max_length=255, blank=True, null=True)
 
     def save(self, *args, **kwargs):
         self.comment_stripped = (
@@ -390,7 +436,9 @@ class IssueProperty(ProjectBaseModel):
         on_delete=models.CASCADE,
         related_name="issue_property_user",
     )
-    properties = models.JSONField(default=get_default_properties)
+    filters = models.JSONField(default=get_default_filters)
+    display_filters = models.JSONField(default=get_default_display_filters)
+    display_properties = models.JSONField(default=get_default_display_properties)
 
     class Meta:
         verbose_name = "Issue Property"
@@ -416,6 +464,8 @@ class Label(ProjectBaseModel):
     description = models.TextField(blank=True)
     color = models.CharField(max_length=255, blank=True)
     sort_order = models.FloatField(default=65535)
+    external_source = models.CharField(max_length=255, null=True, blank=True)
+    external_id = models.CharField(max_length=255, blank=True, null=True)
 
     class Meta:
         unique_together = ["name", "project"]

apiserver/plane/db/models/module.py

@@ -6,6 +6,47 @@ from django.conf import settings
 from . import ProjectBaseModel
 
 
+def get_default_filters():
+    return {
+        "priority": None,
+        "state": None,
+        "state_group": None,
+        "assignees": None,
+        "created_by": None,
+        "labels": None,
+        "start_date": None,
+        "target_date": None,
+        "subscriber": None,
+    },
+
+def get_default_display_filters():
+    return {
+        "group_by": None,
+        "order_by": "-created_at",
+        "type": None,
+        "sub_issue": True,
+        "show_empty_groups": True,
+        "layout": "list",
+        "calendar_date_range": "",
+    }
+
+def get_default_display_properties():
+    return {
+        "assignee": True,
+        "attachment_count": True,
+        "created_on": True,
+        "due_date": True,
+        "estimate": True,
+        "key": True,
+        "labels": True,
+        "link": True,
+        "priority": True,
+        "start_date": True,
+        "state": True,
+        "sub_issue_count": True,
+        "updated_on": True,
+    }
+
 class Module(ProjectBaseModel):
     name = models.CharField(max_length=255, verbose_name="Module Name")
     description = models.TextField(verbose_name="Module Description", blank=True)
@@ -41,6 +82,8 @@ class Module(ProjectBaseModel):
     )
     view_props = models.JSONField(default=dict)
     sort_order = models.FloatField(default=65535)
+    external_source = models.CharField(max_length=255, null=True, blank=True)
+    external_id = models.CharField(max_length=255, blank=True, null=True)
 
     class Meta:
         unique_together = ["name", "project"]
@@ -139,3 +182,28 @@ class ModuleFavorite(ProjectBaseModel):
     def __str__(self):
         """Return user and the module"""
         return f"{self.user.email} <{self.module.name}>"
+
+
+class ModuleUserProperties(ProjectBaseModel):
+    module = models.ForeignKey(
+        "db.Module", on_delete=models.CASCADE, related_name="module_user_properties"
+    )
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="module_user_properties",
+    )
+    filters = models.JSONField(default=get_default_filters)
+    display_filters = models.JSONField(default=get_default_display_filters)
+    display_properties = models.JSONField(default=get_default_display_properties)
+
+
+    class Meta:
+        unique_together = ["module", "user"]
+        verbose_name = "Module User Property"
+        verbose_name_plural = "Module User Property"
+        db_table = "module_user_properties"
+        ordering = ("-created_at",)
+
+    def __str__(self):
+        return f"{self.module.name} {self.user.email}"

apiserver/plane/db/models/state.py

@@ -24,6 +24,8 @@ class State(ProjectBaseModel):
         max_length=20,
     )
     default = models.BooleanField(default=False)
+    external_source = models.CharField(max_length=255, null=True, blank=True)
+    external_id = models.CharField(max_length=255, blank=True, null=True)
 
     def __str__(self):
         """Return name of the state"""

apiserver/plane/db/models/view.py

@@ -3,9 +3,50 @@ from django.db import models
 from django.conf import settings
 
 # Module import
-from . import ProjectBaseModel, BaseModel
+from . import ProjectBaseModel, BaseModel, WorkspaceBaseModel
 
 
+def get_default_filters():
+    return {
+        "priority": None,
+        "state": None,
+        "state_group": None,
+        "assignees": None,
+        "created_by": None,
+        "labels": None,
+        "start_date": None,
+        "target_date": None,
+        "subscriber": None,
+    }
+
+def get_default_display_filters():
+    return {
+        "group_by": None,
+        "order_by": "-created_at",
+        "type": None,
+        "sub_issue": True,
+        "show_empty_groups": True,
+        "layout": "list",
+        "calendar_date_range": "",
+    }
+
+def get_default_display_properties():
+    return {
+        "assignee": True,
+        "attachment_count": True,
+        "created_on": True,
+        "due_date": True,
+        "estimate": True,
+        "key": True,
+        "labels": True,
+        "link": True,
+        "priority": True,
+        "start_date": True,
+        "state": True,
+        "sub_issue_count": True,
+        "updated_on": True,
+    }
+
 class GlobalView(BaseModel):
     workspace = models.ForeignKey(
         "db.Workspace", on_delete=models.CASCADE, related_name="global_views"
@@ -40,14 +81,20 @@ class GlobalView(BaseModel):
         return f"{self.name} <{self.workspace.name}>"
 
 
-class IssueView(ProjectBaseModel):
+class IssueView(WorkspaceBaseModel):
     name = models.CharField(max_length=255, verbose_name="View Name")
     description = models.TextField(verbose_name="View Description", blank=True)
     query = models.JSONField(verbose_name="View Query")
+    filters = models.JSONField(default=dict)
+    display_filters = models.JSONField(default=get_default_display_filters)
+    display_properties = models.JSONField(default=get_default_display_properties)
     access = models.PositiveSmallIntegerField(
         default=1, choices=((0, "Private"), (1, "Public"))
     )
-    query_data = models.JSONField(default=dict)
+    sort_order = models.FloatField(default=65535)
+    cycle = models.ForeignKey("db.Cycle", on_delete=models.CASCADE, related_name="views")
+    module = models.ForeignKey("db.Module", on_delete=models.CASCADE, related_name="views")
+    layouts = models.JSONField(default=dict)
 
     class Meta:
         verbose_name = "Issue View"

apiserver/plane/db/models/workspace.py

@@ -54,6 +54,51 @@ def get_default_props():
         },
     }
 
+def get_default_filters():
+    return {
+        "priority": None,
+        "state": None,
+        "state_group": None,
+        "assignees": None,
+        "created_by": None,
+        "labels": None,
+        "start_date": None,
+        "target_date": None,
+        "subscriber": None,
+    }
+
+def get_default_display_filters():
+    return {
+        "display_filters": {
+            "group_by": None,
+            "order_by": "-created_at",
+            "type": None,
+            "sub_issue": True,
+            "show_empty_groups": True,
+            "layout": "list",
+            "calendar_date_range": "",
+        },
+    }
+
+def get_default_display_properties():
+    return {
+        "display_properties": {
+            "assignee": True,
+            "attachment_count": True,
+            "created_on": True,
+            "due_date": True,
+            "estimate": True,
+            "key": True,
+            "labels": True,
+            "link": True,
+            "priority": True,
+            "start_date": True,
+            "state": True,
+            "sub_issue_count": True,
+            "updated_on": True,
+        },
+    }
+
 
 def get_issue_props():
     return {
@@ -103,6 +148,22 @@ class Workspace(BaseModel):
         ordering = ("-created_at",)
 
 
+class WorkspaceBaseModel(BaseModel):
+    workspace = models.ForeignKey(
+        "db.Workspace", models.CASCADE, related_name="workspace_%(class)s"
+    )
+    project = models.ForeignKey(
+        "db.Project", models.CASCADE, related_name="project_%(class)s", null=True
+    )
+
+    class Meta:
+        abstract = True
+    
+    def save(self, *args, **kwargs):
+        if self.project:
+            self.workspace = self.project.workspace
+        super(WorkspaceBaseModel, self).save(*args, **kwargs)
+
 class WorkspaceMember(BaseModel):
     workspace = models.ForeignKey(
         "db.Workspace", on_delete=models.CASCADE, related_name="workspace_member"
@@ -218,3 +279,28 @@ class WorkspaceTheme(BaseModel):
         verbose_name_plural = "Workspace Themes"
         db_table = "workspace_themes"
         ordering = ("-created_at",)
+
+
+class WorkspaceUserProperties(BaseModel):
+    workspace = models.ForeignKey(
+        "db.Workspace", on_delete=models.CASCADE, related_name="workspace_user_properties"
+    )
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="workspace_user_properties",
+    )
+    filters = models.JSONField(default=get_default_filters)
+    display_filters = models.JSONField(default=get_default_display_filters)
+    display_properties = models.JSONField(default=get_default_display_properties)
+
+
+    class Meta:
+        unique_together = ["workspace", "user"]
+        verbose_name = "Workspace User Property"
+        verbose_name_plural = "Workspace User Property"
+        db_table = "Workspace_user_properties"
+        ordering = ("-created_at",)
+
+    def __str__(self):
+        return f"{self.workspace.name} {self.user.email}"

apiserver/plane/license/api/serializers/instance.py

@@ -43,7 +43,7 @@ class InstanceConfigurationSerializer(BaseSerializer):
     def to_representation(self, instance):
         data = super().to_representation(instance)
         # Decrypt secrets value
-        if instance.key in ["OPENAI_API_KEY", "GITHUB_CLIENT_SECRET", "EMAIL_HOST_PASSWORD", "UNSPLASH_ACESS_KEY"] and instance.value is not None:
+        if instance.is_encrypted and instance.value is not None:
             data["value"] = decrypt_data(instance.value)
 
-        return data
+        return data

apiserver/plane/license/api/views/__init__.py

@@ -2,8 +2,6 @@ from .instance import (
     InstanceEndpoint,
     InstanceAdminEndpoint,
     InstanceConfigurationEndpoint,
-    AdminSetupMagicSignInEndpoint,
+    InstanceAdminSignInEndpoint,
     SignUpScreenVisitedEndpoint,
-    AdminMagicSignInGenerateEndpoint,
-    AdminSetUserPasswordEndpoint,
 )

apiserver/plane/license/api/views/instance.py

@@ -11,6 +11,7 @@ from django.utils import timezone
 from django.contrib.auth.hashers import make_password
 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
@@ -26,15 +27,11 @@ from plane.license.api.serializers import (
     InstanceAdminSerializer,
     InstanceConfigurationSerializer,
 )
-from plane.app.serializers import UserSerializer
 from plane.license.api.permissions import (
     InstanceAdminPermission,
 )
-from plane.db.models import User
+from plane.db.models import User, WorkspaceMember, ProjectMember
 from plane.license.utils.encryption import encrypt_data
-from plane.settings.redis import redis_instance
-from plane.bgtasks.magic_link_code_task import magic_link
-from plane.license.utils.instance_value import get_configuration_value
 
 
 class InstanceEndpoint(BaseAPIView):
@@ -47,69 +44,6 @@ class InstanceEndpoint(BaseAPIView):
             AllowAny(),
         ]
 
-    def post(self, request):
-        # Check if the instance is registered
-        instance = Instance.objects.first()
-
-        # If instance is None then register this instance
-        if instance is None:
-            with open("package.json", "r") as file:
-                # Load JSON content from the file
-                data = json.load(file)
-
-            license_engine_base_url = os.environ.get("LICENSE_ENGINE_BASE_URL")
-
-            if not license_engine_base_url:
-                raise Response(
-                    {"error": "LICENSE_ENGINE_BASE_URL is required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            headers = {"Content-Type": "application/json"}
-
-            payload = {
-                "instance_key": os.environ.get("INSTANCE_KEY"),
-                "version": data.get("version", 0.1),
-                "machine_signature": os.environ.get("MACHINE_SIGNATURE"),
-                "user_count": User.objects.filter(is_bot=False).count(),
-            }
-
-            response = requests.post(
-                f"{license_engine_base_url}/api/instances/",
-                headers=headers,
-                data=json.dumps(payload),
-            )
-
-            if response.status_code == 201:
-                data = response.json()
-                # Create instance
-                instance = Instance.objects.create(
-                    instance_name="Plane Free",
-                    instance_id=data.get("id"),
-                    license_key=data.get("license_key"),
-                    api_key=data.get("api_key"),
-                    version=data.get("version"),
-                    last_checked_at=timezone.now(),
-                    user_count=data.get("user_count", 0),
-                )
-
-                serializer = InstanceSerializer(instance)
-                data = serializer.data
-                data["is_activated"] = True
-                return Response(
-                    data,
-                    status=status.HTTP_201_CREATED,
-                )
-            return Response(
-                {"error": "Instance could not be registered"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        else:
-            return Response(
-                {"message": "Instance already registered"},
-                status=status.HTTP_200_OK,
-            )
-
     def get(self, request):
         instance = Instance.objects.first()
         # get the instance
@@ -202,12 +136,7 @@ class InstanceConfigurationEndpoint(BaseAPIView):
         bulk_configurations = []
         for configuration in configurations:
             value = request.data.get(configuration.key, configuration.value)
-            if value is not None and configuration.key in [
-                "OPENAI_API_KEY",
-                "GITHUB_CLIENT_SECRET",
-                "EMAIL_HOST_PASSWORD",
-                "UNSPLASH_ACESS_KEY",
-            ]:
+            if configuration.is_encrypted:
                 configuration.value = encrypt_data(value)
             else:
                 configuration.value = value
@@ -229,15 +158,13 @@ def get_tokens_for_user(user):
     )
 
 
-class AdminMagicSignInGenerateEndpoint(BaseAPIView):
+class InstanceAdminSignInEndpoint(BaseAPIView):
     permission_classes = [
         AllowAny,
     ]
 
     def post(self, request):
-        email = request.data.get("email", False)
-
-        # Check the instance registration
+        # Check instance first
         instance = Instance.objects.first()
         if instance is None:
             return Response(
@@ -245,201 +172,63 @@ class AdminMagicSignInGenerateEndpoint(BaseAPIView):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        # check if the instance is already activated
         if InstanceAdmin.objects.first():
             return Response(
                 {"error": "Admin for this instance is already registered"},
                 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
-        email = email.strip().lower()
-        validate_email(email)
-
-        # check if the email exists
-        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 AdminSetupMagicSignInEndpoint(BaseAPIView):
-    permission_classes = [
-        AllowAny,
-    ]
-
-    def post(self, request):
-        user_token = request.data.get("token", "").strip()
-        key = request.data.get("key", "").strip().lower()
-
-        if not key or user_token == "":
-            return Response(
-                {"error": "User token and key are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if InstanceAdmin.objects.first():
-            return Response(
-                {"error": "Admin for this instance is already registered"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        ri = redis_instance()
-
-        if ri.exists(key):
-            data = json.loads(ri.get(key))
-
-            token = data["token"]
-            email = data["email"]
-
-            if str(token) == str(user_token):
-                # get the user
-                user = User.objects.get(email=email)
-                # get the email
-                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")
-                user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
-                user.token_updated_at = timezone.now()
-                user.save()
-
-                access_token, refresh_token = get_tokens_for_user(user)
-                data = {
-                    "access_token": access_token,
-                    "refresh_token": refresh_token,
-                }
-
-                return Response(data, status=status.HTTP_200_OK)
-
-            else:
-                return Response(
-                    {"error": "Your login code was incorrect. Please try again."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-        else:
-            return Response(
-                {"error": "The magic code/link has expired please try again"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class AdminSetUserPasswordEndpoint(BaseAPIView):
-    def post(self, request):
-        user = User.objects.get(pk=request.user.id)
+        # Get the email and password from all the user
+        email = request.data.get("email", False)
         password = request.data.get("password", False)
 
-        # If the user password is not autoset then return error
-        if not user.is_password_autoset:
+        # return error if the email and password is not present
+        if not email or not password:
             return Response(
-                {
-                    "error": "Your password is already set please change your password from profile"
-                },
+                {"error": "Email and password are required"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        # Check password validation
-        if not password and len(str(password)) < 8:
+        # Validate the email
+        email = email.strip().lower()
+        try:
+            validate_email(email)
+        except ValidationError as e:
             return Response(
-                {"error": "Password is not valid"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        instance = Instance.objects.first()
-        if instance is None:
-            return Response(
-                {"error": "Instance is not configured"},
+                {"error": "Please provide a valid email address."},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        license_engine_base_url = os.environ.get("LICENSE_ENGINE_BASE_URL", False)
-        if not license_engine_base_url:
-            return Response(
-                {"error": "License engine base url is required"},
-                status=status.HTTP_400_BAD_REQUEST,
+        # Check if already a user exists or not
+        user = User.objects.filter(email=email).first()
+
+        # Existing user
+        if user:
+            # Check user password
+            if not user.check_password(password):
+                return Response(
+                    {
+                        "error": "Sorry, we could not find a user with the provided credentials. Please try again."
+                    },
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+        else:
+            user = User.objects.create(
+                email=email,
+                username=uuid.uuid4().hex,
+                password=make_password(password),
+                is_password_autoset=False,
             )
 
-        # Save the user in control center
-        headers = {
-            "Content-Type": "application/json",
-            "x-instance-id": instance.instance_id,
-            "x-api-key": instance.api_key,
-        }
-        _ = requests.patch(
-            f"{license_engine_base_url}/api/instances/",
-            headers=headers,
-            data=json.dumps({"is_setup_done": True}),
-        )
-
-        # Also register the user as admin
-        _ = requests.post(
-            f"{license_engine_base_url}/api/instances/users/register/",
-            headers=headers,
-            data=json.dumps(
-                {
-                    "email": str(user.email),
-                    "signup_mode": "MAGIC_CODE",
-                    "is_admin": True,
-                }
-            ),
-        )
+        # 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")
+        user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
+        user.token_updated_at = timezone.now()
+        user.save()
 
         # Register the user as an instance admin
         _ = InstanceAdmin.objects.create(
@@ -450,12 +239,13 @@ class AdminSetUserPasswordEndpoint(BaseAPIView):
         instance.is_setup_done = True
         instance.save()
 
-        # 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)
+        # get tokens for user
+        access_token, refresh_token = get_tokens_for_user(user)
+        data = {
+            "access_token": access_token,
+            "refresh_token": refresh_token,
+        }
+        return Response(data, status=status.HTTP_200_OK)
 
 
 class SignUpScreenVisitedEndpoint(BaseAPIView):
@@ -465,31 +255,11 @@ class SignUpScreenVisitedEndpoint(BaseAPIView):
 
     def post(self, request):
         instance = Instance.objects.first()
-
         if instance is None:
             return Response(
                 {"error": "Instance is not configured"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-
-        license_engine_base_url = os.environ.get("LICENSE_ENGINE_BASE_URL", False)
-
-        if not license_engine_base_url:
-            return Response(
-                {"error": "License engine base url is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        headers = {
-            "Content-Type": "application/json",
-            "x-instance-id": instance.instance_id,
-            "x-api-key": instance.api_key,
-        }
-
-        payload = {"is_signup_screen_visited": True}
-        response = requests.patch(
-            f"{license_engine_base_url}/api/instances/",
-            headers=headers,
-            data=json.dumps(payload),
-        )
+        instance.is_signup_screen_visited = True
+        instance.save()
         return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/license/management/commands/configure_instance.py

@@ -21,84 +21,91 @@ class Command(BaseCommand):
                 "key": "ENABLE_SIGNUP",
                 "value": os.environ.get("ENABLE_SIGNUP", "1"),
                 "category": "AUTHENTICATION",
+                "is_encrypted": False, 
             },
             {
                 "key": "ENABLE_EMAIL_PASSWORD",
                 "value": os.environ.get("ENABLE_EMAIL_PASSWORD", "1"),
                 "category": "AUTHENTICATION",
+                "is_encrypted": False,
             },
             {
                 "key": "ENABLE_MAGIC_LINK_LOGIN",
                 "value": os.environ.get("ENABLE_MAGIC_LINK_LOGIN", "0"),
                 "category": "AUTHENTICATION",
+                "is_encrypted": False,
             },
             {
                 "key": "GOOGLE_CLIENT_ID",
                 "value": os.environ.get("GOOGLE_CLIENT_ID"),
                 "category": "GOOGLE",
+                "is_encrypted": False,
             },
             {
                 "key": "GITHUB_CLIENT_ID",
                 "value": os.environ.get("GITHUB_CLIENT_ID"),
                 "category": "GITHUB",
+                "is_encrypted": False,
             },
             {
                 "key": "GITHUB_CLIENT_SECRET",
-                "value": encrypt_data(os.environ.get("GITHUB_CLIENT_SECRET"))
-                if os.environ.get("GITHUB_CLIENT_SECRET")
-                else None,
+                "value": os.environ.get("GITHUB_CLIENT_SECRET"),
                 "category": "GITHUB",
+                "is_encrypted": True,
             },
             {
                 "key": "EMAIL_HOST",
                 "value": os.environ.get("EMAIL_HOST", ""),
                 "category": "SMTP",
+                "is_encrypted": False,
             },
             {
                 "key": "EMAIL_HOST_USER",
                 "value": os.environ.get("EMAIL_HOST_USER", ""),
                 "category": "SMTP",
+                "is_encrypted": False,
             },
             {
                 "key": "EMAIL_HOST_PASSWORD",
-                "value": encrypt_data(os.environ.get("EMAIL_HOST_PASSWORD"))
-                if os.environ.get("EMAIL_HOST_PASSWORD")
-                else None,
+                "value": os.environ.get("EMAIL_HOST_PASSWORD", ""),
                 "category": "SMTP",
+                "is_encrypted": True,
             },
             {
                 "key": "EMAIL_PORT",
                 "value": os.environ.get("EMAIL_PORT", "587"),
                 "category": "SMTP",
+                "is_encrypted": False,
             },
             {
                 "key": "EMAIL_FROM",
                 "value": os.environ.get("EMAIL_FROM", ""),
                 "category": "SMTP",
+                "is_encrypted": False,
             },
             {
                 "key": "EMAIL_USE_TLS",
                 "value": os.environ.get("EMAIL_USE_TLS", "1"),
                 "category": "SMTP",
+                "is_encrypted": False,
             },
             {
                 "key": "OPENAI_API_KEY",
-                "value": encrypt_data(os.environ.get("OPENAI_API_KEY"))
-                if os.environ.get("OPENAI_API_KEY")
-                else None,
+                "value": os.environ.get("OPENAI_API_KEY"),
                 "category": "OPENAI",
+                "is_encrypted": True,
             },
             {
                 "key": "GPT_ENGINE",
                 "value": os.environ.get("GPT_ENGINE", "gpt-3.5-turbo"),
                 "category": "SMTP",
+                "is_encrypted": False,
             },
             {
                 "key": "UNSPLASH_ACCESS_KEY",
-                "value": encrypt_data(os.environ.get("UNSPLASH_ACESS_KEY", ""))
-                if os.environ.get("UNSPLASH_ACESS_KEY")
-                else None,
+                "value": os.environ.get("UNSPLASH_ACESS_KEY", ""),
                 "category": "UNSPLASH",
+                "is_encrypted": True,
             },
         ]
 
@@ -107,8 +114,12 @@ class Command(BaseCommand):
                 key=item.get("key")
             )
             if created:
-                obj.value = item.get("value")
                 obj.category = item.get("category")
+                obj.is_encrypted = item.get("is_encrypted", False)
+                if item.get("is_encrypted", False):
+                    obj.value = encrypt_data(item.get("value"))
+                else:
+                    obj.value = item.get("value")
                 obj.save()
                 self.stdout.write(
                     self.style.SUCCESS(

apiserver/plane/license/management/commands/register_instance.py

@@ -1,11 +1,12 @@
 # Python imports
 import json
-import os
 import requests
+import secrets
 
 # Django imports
 from django.core.management.base import BaseCommand, CommandError
 from django.utils import timezone
+from django.conf import settings
 
 # Module imports
 from plane.license.models import Instance
@@ -29,56 +30,33 @@ class Command(BaseCommand):
                 # Load JSON content from the file
                 data = json.load(file)
 
-            machine_signature = options.get("machine_signature", False)
-            instance_key = os.environ.get("INSTANCE_KEY", False)
-
-            # Raise an exception if the admin email is not provided
-            if not instance_key:
-                raise CommandError("INSTANCE_KEY is required")
+            machine_signature = options.get("machine_signature", "machine-signature")
 
             if not machine_signature:
                 raise CommandError("Machine signature is required")
 
-            license_engine_base_url = os.environ.get("LICENSE_ENGINE_BASE_URL")
-
-            if not license_engine_base_url:
-                raise CommandError("LICENSE_ENGINE_BASE_URL is required")
-
-            headers = {"Content-Type": "application/json"}
-
             payload = {
-                "instance_key": instance_key,
+                "instance_key": settings.INSTANCE_KEY,
                 "version": data.get("version", 0.1),
                 "machine_signature": machine_signature,
                 "user_count": User.objects.filter(is_bot=False).count(),
             }
 
-            response = requests.post(
-                f"{license_engine_base_url}/api/instances/",
-                headers=headers,
-                data=json.dumps(payload),
+            instance = Instance.objects.create(
+                instance_name="Plane Free",
+                instance_id=secrets.token_hex(12),
+                license_key=None,
+                api_key=secrets.token_hex(8),
+                version=payload.get("version"),
+                last_checked_at=timezone.now(),
+                user_count=payload.get("user_count", 0),
             )
 
-            if response.status_code == 201:
-                data = response.json()
-                # Create instance
-                instance = Instance.objects.create(
-                    instance_name="Plane Free",
-                    instance_id=data.get("id"),
-                    license_key=data.get("license_key"),
-                    api_key=data.get("api_key"),
-                    version=data.get("version"),
-                    last_checked_at=timezone.now(),
-                    user_count=data.get("user_count", 0),
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"Instance registered"
                 )
-
-                self.stdout.write(
-                    self.style.SUCCESS(
-                        f"Instance successfully registered"
-                    )
-                )
-                return
-            raise CommandError("Instance could not be registered")
+            )        
         else:
             self.stdout.write(
                 self.style.SUCCESS(

apiserver/plane/license/migrations/0001_initial.py

@@ -1,4 +1,4 @@
-# Generated by Django 4.2.7 on 2023-11-29 14:39
+# Generated by Django 4.2.7 on 2023-12-06 06:49
 
 from django.conf import settings
 from django.db import migrations, models
@@ -34,6 +34,7 @@ class Migration(migrations.Migration):
                 ('is_setup_done', models.BooleanField(default=False)),
                 ('is_signup_screen_visited', models.BooleanField(default=False)),
                 ('user_count', models.PositiveBigIntegerField(default=0)),
+                ('is_verified', models.BooleanField(default=False)),
                 ('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')),
                 ('updated_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='%(class)s_updated_by', to=settings.AUTH_USER_MODEL, verbose_name='Last Modified By')),
             ],
@@ -53,6 +54,7 @@ class Migration(migrations.Migration):
                 ('key', models.CharField(max_length=100, unique=True)),
                 ('value', models.TextField(blank=True, default=None, null=True)),
                 ('category', models.TextField()),
+                ('is_encrypted', models.BooleanField(default=False)),
                 ('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')),
                 ('updated_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='%(class)s_updated_by', to=settings.AUTH_USER_MODEL, verbose_name='Last Modified By')),
             ],
@@ -70,6 +72,7 @@ class Migration(migrations.Migration):
                 ('updated_at', models.DateTimeField(auto_now=True, verbose_name='Last Modified At')),
                 ('id', models.UUIDField(db_index=True, default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True)),
                 ('role', models.PositiveIntegerField(choices=[(20, 'Admin')], default=20)),
+                ('is_verified', models.BooleanField(default=False)),
                 ('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')),
                 ('instance', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='admins', to='license.instance')),
                 ('updated_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='%(class)s_updated_by', to=settings.AUTH_USER_MODEL, verbose_name='Last Modified By')),

apiserver/plane/license/models/instance.py

@@ -30,6 +30,7 @@ class Instance(BaseModel):
     is_signup_screen_visited = models.BooleanField(default=False)
     # users
     user_count = models.PositiveBigIntegerField(default=0)
+    is_verified = models.BooleanField(default=False)
 
     class Meta:
         verbose_name = "Instance"
@@ -47,6 +48,7 @@ class InstanceAdmin(BaseModel):
     )
     instance = models.ForeignKey(Instance, on_delete=models.CASCADE, related_name="admins")
     role = models.PositiveIntegerField(choices=ROLE_CHOICES, default=20)
+    is_verified = models.BooleanField(default=False)
 
     class Meta:
         unique_together = ["instance", "user"]
@@ -61,6 +63,7 @@ class InstanceConfiguration(BaseModel):
     key = models.CharField(max_length=100, unique=True)
     value = models.TextField(null=True, blank=True, default=None)
     category = models.TextField()
+    is_encrypted = models.BooleanField(default=False)
 
     class Meta:
         verbose_name = "Instance Configuration"

apiserver/plane/license/urls.py

@@ -4,9 +4,7 @@ from plane.license.api.views import (
     InstanceEndpoint,
     InstanceAdminEndpoint,
     InstanceConfigurationEndpoint,
-    AdminMagicSignInGenerateEndpoint,
-    AdminSetupMagicSignInEndpoint,
-    AdminSetUserPasswordEndpoint,
+    InstanceAdminSignInEndpoint,
     SignUpScreenVisitedEndpoint,
 )
 
@@ -32,19 +30,9 @@ urlpatterns = [
         name="instance-configuration",
     ),
     path(
-        "instances/admins/magic-generate/",
-        AdminMagicSignInGenerateEndpoint.as_view(),
-        name="instance-admins",
-    ),
-    path(
-        "instances/admins/magic-sign-in/",
-        AdminSetupMagicSignInEndpoint.as_view(),
-        name="instance-admins",
-    ),
-    path(
-        "instances/admins/set-password/",
-        AdminSetUserPasswordEndpoint.as_view(),
-        name="instance-admins",
+        "instances/admins/sign-in/",
+        InstanceAdminSignInEndpoint.as_view(),
+        name="instance-admin-sign-in",
     ),
     path(
         "instances/admins/sign-up-screen-visited/",