Merge branch 'chore/settings_variable' of github.com:makeplane/plane into chore/settings_variable

Merge branch 'develop' of github.com:makeplane/plane into chore/settings_variable
chore: removed djnago settings module
2023-12-01 11:46:56 +05:30 · 2023-12-01 11:46:23 +05:30 · 2023-12-01 11:42:58 +05:30 · 2023-12-01 11:28:32 +05:30 · 2023-11-30 13:30:13 +05:30 · 2023-11-30 12:22:43 +05:30
1133 changed files with 17489 additions and 25965 deletions
@@ -2,16 +2,5 @@
 *.pyc
 .env
 venv
-node_modules/
-**/node_modules/
-npm-debug.log
-.next/
-**/.next/
-.turbo/
-**/.turbo/
-build/
-**/build/
-out/
-**/out/
-dist/
-**/dist/
+node_modules
+npm-debug.log
@@ -6,19 +6,17 @@ on:
      - closed
    branches:
      - master
+      - release
      - preview
      - qa
      - develop
-      - release-*
-  release:
-    types: [released, prereleased]

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

 jobs:
-  branch_build_setup:
-    if: ${{ (github.event_name == 'pull_request' && github.event.action =='closed' && github.event.pull_request.merged == true) || github.event_name == 'release' }}
+  branch_build_and_push:
+    if: ${{ (github.event_name == 'pull_request' && github.event.action =='closed' && github.event.pull_request.merged == true) }}
    name: Build-Push Web/Space/API/Proxy Docker Image
    runs-on: ubuntu-20.04

@@ -61,18 +59,18 @@ jobs:

  branch_build_push_frontend:
    runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
+    needs: [branch_build_and_push]
    env:
-      FRONTEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      FRONTEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
    steps:
      - name: Set Frontend Docker Tag 
        run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
+          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"
          else
-            TAG=${{ env.FRONTEND_TAG }}
+            TAG=${{ env.FRONTEND_TAG }}"
          fi
          echo "FRONTEND_TAG=${TAG}" >> $GITHUB_ENV
      - name: Set up Docker Buildx
@@ -103,18 +101,18 @@ jobs:

  branch_build_push_space:
    runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
+    needs: [branch_build_and_push]
    env:
-      SPACE_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      SPACE_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-space-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
    steps:
      - name: Set Space Docker Tag 
        run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
+          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"
          else
-            TAG=${{ env.SPACE_TAG }}
+            TAG=${{ env.SPACE_TAG }}"
          fi
          echo "SPACE_TAG=${TAG}" >> $GITHUB_ENV
      - name: Set up Docker Buildx
@@ -145,16 +143,16 @@ jobs:

  branch_build_push_backend:
    runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
+    needs: [branch_build_and_push]
    env:
-      BACKEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      BACKEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-backend-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
    steps:
      - name: Set Backend Docker Tag 
        run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
+          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"
          else
            TAG=${{ env.BACKEND_TAG }}
          fi
@@ -187,16 +185,16 @@ jobs:

  branch_build_push_proxy:
    runs-on: ubuntu-20.04
-    needs: [branch_build_setup]
+    needs: [branch_build_and_push]
    env:
-      PROXY_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      PROXY_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy-private:${{ needs.branch_build_and_push.outputs.gh_branch_name }}
    steps:
      - name: Set Proxy Docker Tag 
        run: |
-          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ] && [ "${{ github.event_name }}" == "release" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:latest,${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:${{ github.event.release.tag_name }}
-          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
-            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy${{ secrets.DOCKER_REPO_SUFFIX || '' }}:stable
+          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"
          else
            TAG=${{ env.PROXY_TAG }}
          fi
@@ -1,65 +0,0 @@
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ 'develop', 'hot-fix', 'stage-release' ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ 'develop' ]
-  schedule:
-    - cron: '53 19 * * 5'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'python', 'javascript' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Use only 'java' to analyze code written in Java, Kotlin or both
-        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-
-    # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines.
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #     echo "Run, Build Application using script"
-    #     ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
-      with:
-        category: "/language:${{matrix.language}}"
@@ -1,13 +1,11 @@
-name: Create Sync Action
+name: Create PR in Plane EE Repository to sync the changes

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

 jobs:
  create_pr:
@@ -18,13 +16,27 @@ jobs:
      pull-requests: write
      contents: read
    steps:
+      - name: Check SOURCE_REPO
+        id: check_repo
+        env:
+          SOURCE_REPO: ${{ secrets.SOURCE_REPO_NAME }}
+        run: |
+          echo "::set-output name=is_correct_repo::$(if [[ "$SOURCE_REPO" == "makeplane/plane" ]]; then echo 'true'; else echo 'false'; fi)"
+
      - name: Checkout Code
+        if: steps.check_repo.outputs.is_correct_repo == 'true'
        uses: actions/checkout@v2
        with:
          persist-credentials: false
          fetch-depth: 0

+      - name: Set up Branch Name
+        if: steps.check_repo.outputs.is_correct_repo == 'true'
+        run: |
+          echo "SOURCE_BRANCH_NAME=${{ github.head_ref }}" >> $GITHUB_ENV
+
      - name: Setup GH CLI
+        if: steps.check_repo.outputs.is_correct_repo == 'true'
        run: |
          type -p curl >/dev/null || (sudo apt update && sudo apt install curl -y)
          curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
@@ -33,14 +45,35 @@ jobs:
          sudo apt update
          sudo apt install gh -y

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

          git checkout $SOURCE_BRANCH
-          git remote add target-origin "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
-          git push target-origin $SOURCE_BRANCH:$TARGET_BRANCH
+          git remote add target "https://$GH_TOKEN@github.com/$TARGET_REPO.git"
+          git push target $SOURCE_BRANCH:$SOURCE_BRANCH
+
+          PR_TITLE="${{ github.event.pull_request.title }}"
+          PR_BODY="${{ github.event.pull_request.body }}"
+
+          # Remove double quotes
+          PR_TITLE_CLEANED="${PR_TITLE//\"/}"
+          PR_BODY_CLEANED="${PR_BODY//\"/}"
+
+          # Construct PR_BODY_CONTENT using a here-document
+          PR_BODY_CONTENT=$(cat <<EOF
+          $PR_BODY_CLEANED
+          EOF
+          )
+
+          gh pr create \
+            --base $TARGET_BRANCH \
+            --head $SOURCE_BRANCH \
+            --title "[SYNC] $PR_TITLE_CLEANED" \
+            --body "$PR_BODY_CONTENT" \
+            --repo $TARGET_REPO
@@ -0,0 +1,107 @@
+name: Update Docker Images for Plane on Release
+
+on:
+  release:
+    types: [released, prereleased]
+
+jobs:
+  build_push_backend:
+    name: Build and Push Api Server Docker Image
+    runs-on: ubuntu-20.04
+
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v3.3.0
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2.5.0
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2.1.0
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker (Docker Hub) from Github Release
+        id: metaFrontend
+        uses: docker/metadata-action@v4.3.0
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend
+          tags: |
+            type=ref,event=tag
+      
+      - name: Extract metadata (tags, labels) for Docker (Docker Hub) from Github Release
+        id: metaBackend
+        uses: docker/metadata-action@v4.3.0
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/plane-backend
+          tags: |
+            type=ref,event=tag
+
+      - name: Extract metadata (tags, labels) for Docker (Docker Hub) from Github Release
+        id: metaSpace
+        uses: docker/metadata-action@v4.3.0
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/plane-space
+          tags: |
+            type=ref,event=tag
+
+      - name: Extract metadata (tags, labels) for Docker (Docker Hub) from Github Release
+        id: metaProxy
+        uses: docker/metadata-action@v4.3.0
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy
+          tags: |
+            type=ref,event=tag
+
+      - name: Build and Push Frontend to Docker Container Registry
+        uses: docker/build-push-action@v4.0.0
+        with:
+          context: .
+          file: ./web/Dockerfile.web
+          platforms: linux/amd64
+          tags: ${{ steps.metaFrontend.outputs.tags }}
+          push: true
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKET_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and Push Backend to Docker Hub
+        uses: docker/build-push-action@v4.0.0
+        with:
+          context: ./apiserver
+          file: ./apiserver/Dockerfile.api
+          platforms: linux/amd64
+          push: true
+          tags: ${{ steps.metaBackend.outputs.tags }}
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKET_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and Push Plane-Deploy to Docker Hub
+        uses: docker/build-push-action@v4.0.0
+        with:
+          context: .
+          file: ./space/Dockerfile.space
+          platforms: linux/amd64
+          push: true
+          tags: ${{ steps.metaSpace.outputs.tags }}
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKET_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and Push Plane-Proxy to Docker Hub
+        uses: docker/build-push-action@v4.0.0
+        with:
+          context: ./nginx
+          file: ./nginx/Dockerfile
+          platforms: linux/amd64
+          push: true
+          tags: ${{ steps.metaProxy.outputs.tags }}
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKET_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
@@ -80,6 +80,3 @@ tmp/
 ## packages
 dist
 .temp/
-
-# logs
-combined.log
@@ -33,8 +33,8 @@ The backend is a django project which is kept inside apiserver
 1. Clone the repo

 ```bash
-git clone https://github.com/makeplane/plane.git [folder-name]
-cd [folder-name]
+git clone https://github.com/makeplane/plane
+cd plane
 chmod +x setup.sh
 ```

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

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

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

+```bash
+echo "\nNEXT_PUBLIC_API_BASE_URL=http://localhost\n" >> ./space/.env
+```
+
+4. Run Docker compose up
+
+```bash
+docker compose up -d
+```
+
+5. Install dependencies
+
+```bash
+yarn install
+```
+
+6. Run the web app in development mode
+
+```bash
+yarn dev
+```

 ## Missing a Feature?

@@ -79,6 +79,7 @@ COPY apiserver/manage.py manage.py
 COPY apiserver/plane plane/
 COPY apiserver/templates templates/

+COPY apiserver/gunicorn.config.py ./
 RUN apk --no-cache add "bash~=5.2"
 COPY apiserver/bin ./bin/

@@ -49,10 +49,24 @@ NGINX_PORT=80


 ```
+# Enable/Disable OAUTH - default 0 for selfhosted instance
+NEXT_PUBLIC_ENABLE_OAUTH=0
 # Public boards deploy URL
 NEXT_PUBLIC_DEPLOY_URL="http://localhost/spaces"
 ```

+
+
+## {PROJECT_FOLDER}/spaces/.env.example
+
+
+
+```
+# Flag to toggle OAuth
+NEXT_PUBLIC_ENABLE_OAUTH=0
+```
+
+

 ## {PROJECT_FOLDER}/apiserver/.env

@@ -37,7 +37,7 @@ Meet [Plane](https://plane.so). An open-source software development tool to mana

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

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

 ## ⚡️ Contributors Quick Start

@@ -63,7 +63,7 @@ Thats it!

 ## 🍙 Self Hosting

-For self hosting environment setup, visit the [Self Hosting](https://docs.plane.so/self-hosting/docker-compose) documentation page
+For self hosting environment setup, visit the [Self Hosting](https://docs.plane.so/self-hosting) documentation page

 ## 🚀 Features

@@ -14,11 +14,6 @@ PGHOST="plane-db"
 PGDATABASE="plane"
 DATABASE_URL=postgresql://${PGUSER}:${PGPASSWORD}@${PGHOST}/${PGDATABASE}

-# Oauth variables
-GOOGLE_CLIENT_ID=""
-GITHUB_CLIENT_ID=""
-GITHUB_CLIENT_SECRET=""
-
 # Redis Settings
 REDIS_HOST="plane-redis"
 REDIS_PORT="6379"
@@ -55,6 +50,7 @@ NGINX_PORT=80
 # SignUps
 ENABLE_SIGNUP="1"

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

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

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

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

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

@@ -1,3 +1,3 @@
 web: gunicorn -w 4 -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:$PORT --max-requests 10000 --max-requests-jitter 1000 --access-logfile -
-worker: celery -A plane worker -l info -Q internal_tasks,external_tasks
+worker: celery -A plane worker -l info
 beat: celery -A plane beat -l INFO
@@ -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:${PORT:-8000} --max-requests 1200 --max-requests-jitter 1000 --access-logfile -
+exec gunicorn -w $GUNICORN_WORKERS -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:8000 --max-requests 1200 --max-requests-jitter 1000 --access-logfile -
@@ -1,31 +0,0 @@
-#!/bin/bash
-set -e
-python manage.py wait_for_db
-python manage.py migrate
-
-# Create the default bucket
-#!/bin/bash
-
-# Collect system information
-HOSTNAME=$(hostname)
-MAC_ADDRESS=$(ip link show | awk '/ether/ {print $2}' | head -n 1)
-CPU_INFO=$(cat /proc/cpuinfo)
-MEMORY_INFO=$(free -h)
-DISK_INFO=$(df -h)
-
-# Concatenate information and compute SHA-256 hash
-SIGNATURE=$(echo "$HOSTNAME$MAC_ADDRESS$CPU_INFO$MEMORY_INFO$DISK_INFO" | sha256sum | awk '{print $1}')
-
-# Export the variables
-export MACHINE_SIGNATURE=$SIGNATURE
-
-# Register instance
-python manage.py register_instance $MACHINE_SIGNATURE
-# Load the configuration variable
-python manage.py configure_instance
-
-# Create the default bucket
-python manage.py create_bucket
-
-python manage.py runserver 0.0.0.0:8000 --settings=plane.settings.local
-
@@ -0,0 +1,6 @@
+from psycogreen.gevent import patch_psycopg
+
+
+def post_fork(server, worker):
+    patch_psycopg()
+    worker.log.info("Made Psycopg2 Green")
@@ -1,4 +1,4 @@
 {
-  "name": "plane-api",
-  "version": "0.14.0"
-}
+    "name": "plane-api",
+    "version": "0.13.2"
+}
@@ -30,11 +30,6 @@ class CycleSerializer(BaseSerializer):
        model = Cycle
        fields = "__all__"
        read_only_fields = [
-            "id",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
            "workspace",
            "project",
            "owned_by",
@@ -1,6 +1,3 @@
-from lxml import html
-
-
 # Django imports
 from django.utils import timezone

@@ -24,8 +21,7 @@ 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(
@@ -46,6 +42,7 @@ class IssueSerializer(BaseSerializer):

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

    def validate(self, data):
        if (
@@ -67,15 +60,6 @@ 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", []):
@@ -307,6 +291,7 @@ class IssueCommentSerializer(BaseSerializer):

    class Meta:
        model = IssueComment
+        fields = "__all__"
        read_only_fields = [
            "id",
            "workspace",
@@ -317,21 +302,6 @@ 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):
@@ -361,23 +331,12 @@ class ModuleIssueSerializer(BaseSerializer):
        ]


-class LabelLiteSerializer(BaseSerializer):
-
-    class Meta:
-        model = Label
-        fields = [
-            "id",
-            "name",
-            "color",
-        ]
-
-
 class IssueExpandSerializer(BaseSerializer):
+    # Serialize the related cycle. It's a OneToOne relation.
    cycle = CycleLiteSerializer(source="issue_cycle.cycle", read_only=True)
+
+    # Serialize the related module. It's a OneToOne relation.
    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
@@ -390,4 +349,4 @@ class IssueExpandSerializer(BaseSerializer):
            "updated_by",
            "created_at",
            "updated_at",
-        ]
+        ]
@@ -21,7 +21,6 @@ class ProjectSerializer(BaseSerializer):
        fields = "__all__"
        read_only_fields = [
            "id",
-            'emoji',
            "workspace",
            "created_at",
            "updated_at",
@@ -16,11 +16,6 @@ class StateSerializer(BaseSerializer):
        model = State
        fields = "__all__"
        read_only_fields = [
-            "id",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
            "workspace",
            "project",
        ]
@@ -11,6 +11,10 @@ class UserLiteSerializer(BaseSerializer):
            "first_name",
            "last_name",
            "avatar",
+            "is_bot",
            "display_name",
        ]
-        read_only_fields = fields
+        read_only_fields = [
+            "id",
+            "is_bot",
+        ]
@@ -281,22 +281,20 @@ class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
        )
        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)

-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                'type': "cycle.activity.deleted",
-                'requested_data': json.dumps({
+        issue_activity.delay(
+            type="cycle.activity.deleted",
+            requested_data=json.dumps(
+                {
                    "cycle_id": str(pk),
                    "cycle_name": str(cycle.name),
                    "issues": [str(issue_id) for issue_id in cycle_issues],
-                }),
-                'actor_id': str(request.user.id),
-                'issue_id': None,
-                'project_id': str(project_id),
-                'current_instance': None,
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
+                }
+            ),
+            actor_id=str(request.user.id),
+            issue_id=None,
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
        )
        # Delete the cycle
        cycle.delete()
@@ -456,21 +454,21 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
        )

        # Capture Issue Activity
-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                'type': "cycle.activity.created",
-                'requested_data': json.dumps({"cycles_list": str(issues)}),
-                'actor_id': str(self.request.user.id),
-                'issue_id': None,
-                'project_id': str(self.kwargs.get("project_id", None)),
-                'current_instance': json.dumps({
+        issue_activity.delay(
+            type="cycle.activity.created",
+            requested_data=json.dumps({"cycles_list": str(issues)}),
+            actor_id=str(self.request.user.id),
+            issue_id=None,
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps(
+                {
                    "updated_cycle_issues": update_cycle_issue_activity,
-                    "created_cycle_issues": serializers.serialize("json", record_to_create),
-                }),
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
+                    "created_cycle_issues": serializers.serialize(
+                        "json", record_to_create
+                    ),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
        )

        # Return all Cycle Issues
@@ -485,21 +483,19 @@ class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
        )
        issue_id = cycle_issue.issue_id
        cycle_issue.delete()
-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                'type': "cycle.activity.deleted",
-                'requested_data': json.dumps({
+        issue_activity.delay(
+            type="cycle.activity.deleted",
+            requested_data=json.dumps(
+                {
                    "cycle_id": str(self.kwargs.get("cycle_id")),
                    "issues": [str(issue_id)],
-                }),
-                'actor_id': str(self.request.user.id),
-                'issue_id': str(issue_id),
-                'project_id': str(self.kwargs.get("project_id", None)),
-                'current_instance': None,
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
+                }
+            ),
+            actor_id=str(self.request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
        )
        return Response(status=status.HTTP_204_NO_CONTENT)

@@ -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's api"
+                    "error": "Inbox is not enabled for this project enable it through the project settings"
                },
                status=status.HTTP_400_BAD_REQUEST,
            )
@@ -142,18 +142,14 @@ class InboxIssueAPIEndpoint(BaseAPIView):
        )

        # Create an Issue Activity
-        issue_activity.apply_async(
-            args=[],  # If no positional arguments are required
-            kwargs={
-                "type": "issue.activity.created",
-                "requested_data": json.dumps(request.data, cls=DjangoJSONEncoder),
-                "actor_id": str(request.user.id),
-                "issue_id": str(issue.id),
-                "project_id": str(project_id),
-                "current_instance": None,
-                "epoch": int(timezone.now().timestamp()),
-            },
-            routing_key="external",
+        issue_activity.delay(
+            type="issue.activity.created",
+            requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+            actor_id=str(request.user.id),
+            issue_id=str(issue.id),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
        )

        # create an inbox issue
@@ -181,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's api"
+                    "error": "Inbox is not enabled for this project enable it through the project settings"
                },
                status=status.HTTP_400_BAD_REQUEST,
            )
@@ -236,21 +232,17 @@ class InboxIssueAPIEndpoint(BaseAPIView):
                # Log all the updates
                requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
                if issue is not None:
-                    issue_activity.apply_async(
-                        args=[],
-                        kwargs={
-                            "type": "issue.activity.updated",
-                            "requested_data": requested_data,
-                            "actor_id": str(request.user.id),
-                            "issue_id": str(issue_id),
-                            "project_id": str(project_id),
-                            "current_instance": json.dumps(
-                                IssueSerializer(current_instance).data,
-                                cls=DjangoJSONEncoder,
-                            ),
-                            "epoch": int(timezone.now().timestamp()),
-                        },
-                        routing_key="external",
+                    issue_activity.delay(
+                        type="issue.activity.updated",
+                        requested_data=requested_data,
+                        actor_id=str(request.user.id),
+                        issue_id=str(issue_id),
+                        project_id=str(project_id),
+                        current_instance=json.dumps(
+                            IssueSerializer(current_instance).data,
+                            cls=DjangoJSONEncoder,
+                        ),
+                        epoch=int(timezone.now().timestamp()),
                    )
                issue_serializer.save()
            else:
@@ -319,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's api"
+                    "error": "Inbox is not enabled for this project enable it through the project settings"
                },
                status=status.HTTP_400_BAD_REQUEST,
            )
@@ -207,18 +207,14 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
            serializer.save()

            # Track the issue
-            issue_activity.apply_async(
-                args=[],  # If no positional arguments are required
-                kwargs={
-                    'type': "issue.activity.created",
-                    'requested_data': json.dumps(self.request.data, cls=DjangoJSONEncoder),
-                    'actor_id': str(request.user.id),
-                    'issue_id': str(serializer.data.get("id", None)),
-                    'project_id': str(project_id),
-                    'current_instance': None,
-                    'epoch': int(timezone.now().timestamp()),
-                },
-                routing_key='external',
+            issue_activity.delay(
+                type="issue.activity.created",
+                requested_data=json.dumps(self.request.data, cls=DjangoJSONEncoder),
+                actor_id=str(request.user.id),
+                issue_id=str(serializer.data.get("id", None)),
+                project_id=str(project_id),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
            )
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -232,18 +228,14 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
        serializer = IssueSerializer(issue, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
-            issue_activity.apply_async(
-                args=[],
-                kwargs={
-                    'type': "issue.activity.updated",
-                    'requested_data': requested_data,
-                    'actor_id': str(request.user.id),
-                    'issue_id': str(pk),
-                    'project_id': str(project_id),
-                    'current_instance': current_instance,
-                    'epoch': int(timezone.now().timestamp()),
-                },
-                routing_key='external',
+            issue_activity.delay(
+                type="issue.activity.updated",
+                requested_data=requested_data,
+                actor_id=str(request.user.id),
+                issue_id=str(pk),
+                project_id=str(project_id),
+                current_instance=current_instance,
+                epoch=int(timezone.now().timestamp()),
            )
            return Response(serializer.data, status=status.HTTP_200_OK)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -254,19 +246,14 @@ class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
            IssueSerializer(issue).data, cls=DjangoJSONEncoder
        )
        issue.delete()
-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                'type': "issue.activity.deleted",
-                'requested_data': json.dumps({"issue_id": str(pk)}),
-                'actor_id': str(request.user.id),
-                'issue_id': str(pk),
-                'project_id': str(project_id),
-                'current_instance': current_instance,
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='your_routing_key',
-            queue='your_queue_name'
+        issue_activity.delay(
+            type="issue.activity.deleted",
+            requested_data=json.dumps({"issue_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(pk),
+            project_id=str(project_id),
+            current_instance=current_instance,
+            epoch=int(timezone.now().timestamp()),
        )
        return Response(status=status.HTTP_204_NO_CONTENT)

@@ -322,11 +309,7 @@ class LabelAPIEndpoint(BaseAPIView):
                ).data,
            )
        label = self.get_queryset().get(pk=pk)
-        serializer = LabelSerializer(
-            label,
-            fields=self.fields,
-            expand=self.expand,
-        )
+        serializer = LabelSerializer(label, fields=self.fields, expand=self.expand,)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def patch(self, request, slug, project_id, pk=None):
@@ -336,6 +319,7 @@ class LabelAPIEndpoint(BaseAPIView):
            serializer.save()
            return Response(serializer.data, status=status.HTTP_200_OK)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+    

    def delete(self, request, slug, project_id, pk=None):
        label = self.get_queryset().get(pk=pk)
@@ -400,18 +384,14 @@ class IssueLinkAPIEndpoint(BaseAPIView):
                project_id=project_id,
                issue_id=issue_id,
            )
-            issue_activity.apply_async(
-                args=[],  # If no positional arguments are required
-                kwargs={
-                    'type': "link.activity.created",
-                    'requested_data': json.dumps(serializer.data, cls=DjangoJSONEncoder),
-                    'actor_id': str(self.request.user.id),
-                    'issue_id': str(self.kwargs.get("issue_id")),
-                    'project_id': str(self.kwargs.get("project_id")),
-                    'current_instance': None,
-                    'epoch': int(timezone.now().timestamp()),
-                },
-                routing_key='external',
+            issue_activity.delay(
+                type="link.activity.created",
+                requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id")),
+                project_id=str(self.kwargs.get("project_id")),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
            )
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -428,18 +408,14 @@ class IssueLinkAPIEndpoint(BaseAPIView):
        serializer = IssueLinkSerializer(issue_link, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
-            issue_activity.apply_async(
-                args=[],  # If no positional arguments are required
-                kwargs={
-                    'type': "link.activity.updated",
-                    'requested_data': requested_data,
-                    'actor_id': str(request.user.id),
-                    'issue_id': str(issue_id),
-                    'project_id': str(project_id),
-                    'current_instance': current_instance,
-                    'epoch': int(timezone.now().timestamp()),
-                },
-                routing_key='external',
+            issue_activity.delay(
+                type="link.activity.updated",
+                requested_data=requested_data,
+                actor_id=str(request.user.id),
+                issue_id=str(issue_id),
+                project_id=str(project_id),
+                current_instance=current_instance,
+                epoch=int(timezone.now().timestamp()),
            )
            return Response(serializer.data, status=status.HTTP_200_OK)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -452,18 +428,14 @@ class IssueLinkAPIEndpoint(BaseAPIView):
            IssueLinkSerializer(issue_link).data,
            cls=DjangoJSONEncoder,
        )
-        issue_activity.apply_async(
-            args=[],  # If no positional arguments are required
-            kwargs={
-                'type': "link.activity.deleted",
-                'requested_data': json.dumps({"link_id": str(pk)}),
-                'actor_id': str(request.user.id),
-                'issue_id': str(issue_id),
-                'project_id': str(project_id),
-                'current_instance': current_instance,
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
+        issue_activity.delay(
+            type="link.activity.deleted",
+            requested_data=json.dumps({"link_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=current_instance,
+            epoch=int(timezone.now().timestamp()),
        )
        issue_link.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -535,20 +507,14 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
                issue_id=issue_id,
                actor=request.user,
            )
-            issue_activity.apply_async(
-                args=[],
-                kwargs={
-                    "type": "comment.activity.created",
-                    "requested_data": json.dumps(
-                        serializer.data, cls=DjangoJSONEncoder
-                    ),
-                    "actor_id": str(self.request.user.id),
-                    "issue_id": str(self.kwargs.get("issue_id")),
-                    "project_id": str(self.kwargs.get("project_id")),
-                    "current_instance": None,
-                    "epoch": int(timezone.now().timestamp()),
-                },
-                routing_key="external",
+            issue_activity.delay(
+                type="comment.activity.created",
+                requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id")),
+                project_id=str(self.kwargs.get("project_id")),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
            )
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -567,18 +533,14 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
        )
        if serializer.is_valid():
            serializer.save()
-            issue_activity.apply_async(
-                args=[],
-                kwargs={
-                    "type": "comment.activity.updated",
-                    "requested_data": requested_data,
-                    "actor_id": str(request.user.id),
-                    "issue_id": str(issue_id),
-                    "project_id": str(project_id),
-                    "current_instance": current_instance,
-                    "epoch": int(timezone.now().timestamp()),
-                },
-                routing_key="external",
+            issue_activity.delay(
+                type="comment.activity.updated",
+                requested_data=requested_data,
+                actor_id=str(request.user.id),
+                issue_id=str(issue_id),
+                project_id=str(project_id),
+                current_instance=current_instance,
+                epoch=int(timezone.now().timestamp()),
            )
            return Response(serializer.data, status=status.HTTP_200_OK)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -592,18 +554,14 @@ class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
            cls=DjangoJSONEncoder,
        )
        issue_comment.delete()
-        issue_activity.apply_async(
-            args=[],  # If no positional arguments are required
-            kwargs={
-                "type": "comment.activity.deleted",
-                "requested_data": json.dumps({"comment_id": str(pk)}),
-                "actor_id": str(request.user.id),
-                "issue_id": str(issue_id),
-                "project_id": str(project_id),
-                "current_instance": current_instance,
-                "epoch": int(timezone.now().timestamp()),
-            },
-            routing_key="external",
+        issue_activity.delay(
+            type="comment.activity.deleted",
+            requested_data=json.dumps({"comment_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=current_instance,
+            epoch=int(timezone.now().timestamp()),
        )
        return Response(status=status.HTTP_204_NO_CONTENT)

@@ -624,7 +582,7 @@ class IssueActivityAPIEndpoint(BaseAPIView):
            )
            .select_related("actor", "workspace", "issue", "project")
        ).order_by(request.GET.get("order_by", "created_at"))
-
+ 
        if pk:
            issue_activities = issue_activities.get(pk=pk)
            serializer = IssueActivitySerializer(issue_activities)
@@ -166,22 +166,20 @@ class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
        module_issues = list(
            ModuleIssue.objects.filter(module_id=pk).values_list("issue", flat=True)
        )
-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                'type': "module.activity.deleted",
-                'requested_data': json.dumps({
+        issue_activity.delay(
+            type="module.activity.deleted",
+            requested_data=json.dumps(
+                {
                    "module_id": str(pk),
                    "module_name": str(module.name),
                    "issues": [str(issue_id) for issue_id in module_issues],
-                }),
-                'actor_id': str(request.user.id),
-                'issue_id': None,
-                'project_id': str(project_id),
-                'current_instance': None,
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
+                }
+            ),
+            actor_id=str(request.user.id),
+            issue_id=None,
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
        )
        module.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -332,21 +330,21 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
        )

        # Capture Issue Activity
-        issue_activity.apply_async(
-            args=[],
-            kwargs={
-                'type': "module.activity.created",
-                'requested_data': json.dumps({"modules_list": str(issues)}),
-                'actor_id': str(self.request.user.id),
-                'issue_id': None,
-                'project_id': str(self.kwargs.get("project_id", None)),
-                'current_instance': json.dumps({
+        issue_activity.delay(
+            type="module.activity.created",
+            requested_data=json.dumps({"modules_list": str(issues)}),
+            actor_id=str(self.request.user.id),
+            issue_id=None,
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps(
+                {
                    "updated_module_issues": update_module_issue_activity,
-                    "created_module_issues": serializers.serialize("json", record_to_create),
-                }),
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
+                    "created_module_issues": serializers.serialize(
+                        "json", record_to_create
+                    ),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
        )

        return Response(
@@ -359,20 +357,18 @@ class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
            workspace__slug=slug, project_id=project_id, module_id=module_id, issue_id=issue_id
        )
        module_issue.delete()
-        issue_activity.apply_async(
-            args=[],  # If no positional arguments are required
-            kwargs={
-                'type': "module.activity.deleted",
-                'requested_data': json.dumps({
+        issue_activity.delay(
+            type="module.activity.deleted",
+            requested_data=json.dumps(
+                {
                    "module_id": str(module_id),
                    "issues": [str(module_issue.issue_id)],
-                }),
-                'actor_id': str(request.user.id),
-                'issue_id': str(issue_id),
-                'project_id': str(project_id),
-                'current_instance': None,
-                'epoch': int(timezone.now().timestamp()),
-            },
-            routing_key='external',
+                }
+            ),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
        )
        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -64,7 +64,7 @@ class StateAPIEndpoint(BaseAPIView):
        )

        if state.default:
-            return Response({"error": "Default state cannot be deleted"}, status=status.HTTP_400_BAD_REQUEST)
+            return Response({"error": "Default state cannot be deleted"}, status=False)

        # Check for any issues in the state
        issue_exist = Issue.issue_objects.filter(state=state_id).exists()
@@ -103,19 +103,16 @@ class ProjectListSerializer(DynamicBaseSerializer):
    members = serializers.SerializerMethodField()

    def get_members(self, obj):
-        project_members = getattr(obj, "members_list", None)
-        if project_members is not None:
-            # Filter members by the project ID
-            return [
-                {
-                    "id": member.id,
-                    "member_id": member.member_id,
-                    "member__display_name": member.member.display_name,
-                    "member__avatar": member.member.avatar,
-                }
-                for member in project_members
-            ]
-        return []
+        project_members = ProjectMember.objects.filter(
+            project_id=obj.id,
+            is_active=True,
+        ).values(
+            "id",
+            "member_id",
+            "member__display_name",
+            "member__avatar",
+        )
+        return list(project_members)

    class Meta:
        model = Project
@@ -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, min_length=8)
-    confirm_password = serializers.CharField(required=True, min_length=8)
+    new_password = serializers.CharField(required=True)
+    confirm_password = serializers.CharField(required=True)

    def validate(self, data):
        if data.get("old_password") == data.get("new_password"):
@@ -187,7 +187,9 @@ class ChangePasswordSerializer(serializers.Serializer):


 class ResetPasswordSerializer(serializers.Serializer):
+    model = User
+
    """
    Serializer for password change endpoint.
    """
-    new_password = serializers.CharField(required=True, min_length=8)
+    new_password = serializers.CharField(required=True)
@@ -95,16 +95,6 @@ class WorkSpaceMemberInviteSerializer(BaseSerializer):
    class Meta:
        model = WorkspaceMemberInvite
        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "email",
-            "token",
-            "workspace",
-            "message",
-            "responded_at",
-            "created_at",
-            "updated_at",
-        ]


 class TeamSerializer(BaseSerializer):
@@ -7,7 +7,6 @@ from plane.app.views import (
    # Authentication
    SignInEndpoint,
    SignOutEndpoint,
-    MagicGenerateEndpoint,
    MagicSignInEndpoint,
    OauthEndpoint,
    EmailCheckEndpoint,
@@ -31,7 +30,6 @@ 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
@@ -1,34 +1,13 @@
 from django.urls import path

+
 from plane.app.views import (
    ProjectEstimatePointEndpoint,
    BulkEstimatePointEndpoint,
-    WorkspaceEstimateEndpoint,
 )


 urlpatterns = [
-    path(
-        "workspaces/<str:slug>/estimates/",
-        WorkspaceEstimateEndpoint.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
-        name="workspace-estimate-points",
-    ),
-    path(
-        "workspaces/<str:slug>/estimates/<uuid:estimate_id>/",
-        WorkspaceEstimateEndpoint.as_view(
-            {
-                "get": "retrieve",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="workspace-estimate-points",
-    ),
    path(
        "workspaces/<str:slug>/projects/<uuid:project_id>/project-estimates/",
        ProjectEstimatePointEndpoint.as_view(),
@@ -13,7 +13,6 @@ from plane.app.views import (
    UserProjectInvitationsViewset,
    ProjectPublicCoverImagesEndpoint,
    ProjectDeployBoardViewSet,
-    UserProjectRolesEndpoint,
 )


@@ -75,11 +74,6 @@ 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(),
@@ -65,7 +65,6 @@ urlpatterns = [
            {
                "delete": "destroy",
                "get": "retrieve",
-                "patch": "partial_update",
            }
        ),
        name="workspace-invitations",
@@ -11,7 +11,6 @@ from .project import (
    ProjectFavoritesViewSet,
    ProjectPublicCoverImagesEndpoint,
    ProjectDeployBoardViewSet,
-    UserProjectRolesEndpoint,
 )
 from .user import (
    UserEndpoint,
@@ -88,7 +87,6 @@ from .auth_extended import (
    ChangePasswordEndpoint,
    SetUserPasswordEndpoint,
    EmailCheckEndpoint,
-    MagicGenerateEndpoint,
 )


@@ -131,6 +129,7 @@ from .page import (
    PageFavoriteViewSet,
    PageLogEndpoint,
    SubPagesEndpoint,
+    CreateIssueFromBlockEndpoint,
 )

 from .search import GlobalSearchEndpoint, IssueSearchEndpoint
@@ -141,7 +140,6 @@ from .external import GPTIntegrationEndpoint, ReleaseNotesEndpoint, UnsplashEndp
 from .estimate import (
    ProjectEstimatePointEndpoint,
    BulkEstimatePointEndpoint,
-    WorkspaceEstimateEndpoint,
 )

 from .inbox import InboxViewSet, InboxIssueViewSet
@@ -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
+from plane.license.models import Instance, InstanceConfiguration
 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,24 +105,17 @@ class ForgotPasswordEndpoint(BaseAPIView):
    def post(self, request):
        email = request.data.get("email")

-        try:
-            validate_email(email)
-        except ValidationError:
-            return Response(
-                {"error": "Please enter a valid email"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        if User.objects.filter(email=email).exists():
+            user = User.objects.get(email=email)
+            uidb64 = urlsafe_base64_encode(smart_bytes(user.id))
+            token = PasswordResetTokenGenerator().make_token(user)

-        # Get the user
-        user = User.objects.filter(email=email).first()
-        if user:
-            # Get the reset token for user
-            uidb64, token = generate_password_token(user=user)
            current_site = request.META.get("HTTP_ORIGIN")
-            # send the forgot password email
+
            forgot_password.delay(
                user.first_name, user.email, uidb64, token, current_site
            )
+
            return Response(
                {"message": "Check your email to reset your password"},
                status=status.HTTP_200_OK,
@@ -133,24 +126,18 @@ 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
@@ -158,9 +145,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,
@@ -179,6 +166,7 @@ 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")):
@@ -224,131 +212,35 @@ 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 or not instance.is_setup_done:
+        if instance is None:
            return Response(
                {"error": "Instance is not configured"},
                status=status.HTTP_400_BAD_REQUEST,
            )

-        # Get configuration values
-        ENABLE_SIGNUP, ENABLE_MAGIC_LINK_LOGIN = get_configuration_value(
-            [
-                {
-                    "key": "ENABLE_SIGNUP",
-                    "default": os.environ.get("ENABLE_SIGNUP"),
-                },
-                {
-                    "key": "ENABLE_MAGIC_LINK_LOGIN",
-                    "default": os.environ.get("ENABLE_MAGIC_LINK_LOGIN"),
-                },
-            ]
-        )
+        instance_configuration = InstanceConfiguration.objects.values("key", "value")

        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()
@@ -358,7 +250,12 @@ class EmailCheckEndpoint(BaseAPIView):
        if user is None:
            # Create the user
            if (
-                ENABLE_SIGNUP == "0"
+                get_configuration_value(
+                    instance_configuration,
+                    "ENABLE_SIGNUP",
+                    os.environ.get("ENABLE_SIGNUP", "0"),
+                )
+                == "0"
                and not WorkspaceMemberInvite.objects.filter(
                    email=email,
                ).exists()
@@ -370,7 +267,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,
@@ -378,90 +275,109 @@ class EmailCheckEndpoint(BaseAPIView):
                is_password_autoset=True,
            )

-            if not bool(
-                ENABLE_MAGIC_LINK_LOGIN,
-            ):
-                return Response(
-                    {"error": "Magic link sign in is disabled."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
+            # Update instance user count
+            update_user_instance_user_count.delay()

-            # Send event
-            auth_events.delay(
-                user=user.id,
-                email=email,
-                user_agent=request.META.get("HTTP_USER_AGENT"),
-                ip=request.META.get("REMOTE_ADDR"),
-                event_name="SIGN_IN",
-                medium="MAGIC_LINK",
-                first_time=True,
-            )
-            key, token, current_attempt = generate_magic_token(email=email)
-            if not current_attempt:
-                return Response(
-                    {"error": "Max attempts exhausted. Please try again later."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            # Trigger the email
-            magic_link.delay(email, "magic_" + str(email), token, current_site)
-            return Response(
-                {"is_password_autoset": user.is_password_autoset, "is_existing": False},
-                status=status.HTTP_200_OK,
-            )
-
-        # Existing user
-        else:
-            if user.is_password_autoset:
-                ## Generate a random token
-                if not bool(ENABLE_MAGIC_LINK_LOGIN):
+            # 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,
                    )
-
-                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,
+                
+                # 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
                )
-
+                # 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)
+        # Existing user
+        else:
+            if type == "magic_code":
+                ## Generate a random token
+                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,
+                    )
+                
+                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,
+                    )
+                
                # 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,
-                        "is_existing": True,
-                    },
-                    status=status.HTTP_200_OK,
-                )
+                return Response({"is_password_autoset": user.is_password_autoset}, status=status.HTTP_200_OK)
            else:
-                auth_events.delay(
-                    user=user.id,
-                    email=email,
-                    user_agent=request.META.get("HTTP_USER_AGENT"),
-                    ip=request.META.get("REMOTE_ADDR"),
-                    event_name="SIGN_IN",
-                    medium="EMAIL",
-                    first_time=False,
-                )
-
-                # User should enter password to login
-                return Response(
-                    {
-                        "is_password_autoset": user.is_password_autoset,
-                        "is_existing": True,
-                    },
-                    status=status.HTTP_200_OK,
-                )
+                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)
@@ -1,6 +1,8 @@
 # Python imports
 import os
 import uuid
+import random
+import string
 import json

 # Django imports
@@ -15,6 +17,7 @@ from rest_framework.response import Response
 from rest_framework.permissions import AllowAny
 from rest_framework import status
 from rest_framework_simplejwt.tokens import RefreshToken
+
 from sentry_sdk import capture_message

 # Module imports
@@ -27,9 +30,11 @@ from plane.db.models import (
    ProjectMember,
 )
 from plane.settings.redis import redis_instance
-from plane.license.models import Instance
+from plane.license.models import InstanceConfiguration, 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):
@@ -44,16 +49,11 @@ class SignUpEndpoint(BaseAPIView):
    permission_classes = (AllowAny,)

    def post(self, request):
-        # Check if the instance configuration is done
-        instance = Instance.objects.first()
-        if instance is None or not instance.is_setup_done:
-            return Response(
-                {"error": "Instance is not configured"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        instance_configuration = InstanceConfiguration.objects.values("key", "value")

        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,20 +71,13 @@ class SignUpEndpoint(BaseAPIView):
                status=status.HTTP_400_BAD_REQUEST,
            )

-        # get configuration values
-        # Get configuration values
-        ENABLE_SIGNUP, = get_configuration_value(
-            [
-                {
-                    "key": "ENABLE_SIGNUP",
-                    "default": os.environ.get("ENABLE_SIGNUP"),
-                },
-            ]
-        )
-
-        # If the sign up is not enabled and the user does not have invite disallow him from creating the account
        if (
-            ENABLE_SIGNUP == "0"
+            get_configuration_value(
+                instance_configuration,
+                "ENABLE_SIGNUP",
+                os.environ.get("ENABLE_SIGNUP", "0"),
+            )
+            == "0"
            and not WorkspaceMemberInvite.objects.filter(
                email=email,
            ).exists()
@@ -107,7 +100,6 @@ class SignUpEndpoint(BaseAPIView):
        user.set_password(password)

        # settings last actives for the user
-        user.is_password_autoset = False
        user.last_active = timezone.now()
        user.last_login_time = timezone.now()
        user.last_login_ip = request.META.get("REMOTE_ADDR")
@@ -122,6 +114,9 @@ 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)


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

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

-        # Validate email
        email = email.strip().lower()
+
        try:
            validate_email(email)
        except ValidationError as e:
@@ -157,49 +144,33 @@ 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()

-        # Existing user
-        if user:
-            # Check user password
-            if not user.check_password(password):
-                return Response(
-                    {
-                        "error": "Sorry, we could not find a user with the provided credentials. Please try again."
-                    },
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-
-        # Create the user
-        else:
-            ENABLE_SIGNUP, = get_configuration_value(
-                [
-                    {
-                        "key": "ENABLE_SIGNUP",
-                        "default": os.environ.get("ENABLE_SIGNUP"),
-                    },
-                ]
+        # 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,
            )
-            # 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,
+        # 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,
            )

        # settings last active for the user
@@ -269,15 +240,16 @@ class SignInEndpoint(BaseAPIView):
        workspace_member_invites.delete()
        project_member_invites.delete()
        # Send event
-        auth_events.delay(
-            user=user.id,
-            email=email,
-            user_agent=request.META.get("HTTP_USER_AGENT"),
-            ip=request.META.get("REMOTE_ADDR"),
-            event_name="SIGN_IN",
-            medium="EMAIL",
-            first_time=False,
-        )
+        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,
+            )

        access_token, refresh_token = get_tokens_for_user(user)
        data = {
@@ -316,7 +288,6 @@ 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(
@@ -343,16 +314,24 @@ 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
-                auth_events.delay(
-                    user=user.id,
-                    email=email,
-                    user_agent=request.META.get("HTTP_USER_AGENT"),
-                    ip=request.META.get("REMOTE_ADDR"),
-                    event_name="SIGN_IN",
-                    medium="MAGIC_LINK",
-                    first_time=False,
-                )
+                if 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,
+                    )

                user.is_active = True
                user.is_email_verified = True
@@ -11,6 +11,7 @@ from rest_framework.response import Response

 # Module imports
 from .base import BaseAPIView
+from plane.license.models import Instance, InstanceConfiguration
 from plane.license.utils.instance_value import get_configuration_value


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

    def get(self, request):
-
-        # Get all the configuration
-        (
-            GOOGLE_CLIENT_ID,
-            GITHUB_CLIENT_ID,
-            GITHUB_APP_NAME,
-            EMAIL_HOST_USER,
-            EMAIL_HOST_PASSWORD,
-            ENABLE_MAGIC_LINK_LOGIN,
-            ENABLE_EMAIL_PASSWORD,
-            SLACK_CLIENT_ID,
-            POSTHOG_API_KEY,
-            POSTHOG_HOST,
-            UNSPLASH_ACCESS_KEY,
-            OPENAI_API_KEY,
-        ) = get_configuration_value(
-            [
-                {
-                    "key": "GOOGLE_CLIENT_ID",
-                    "default": os.environ.get("GOOGLE_CLIENT_ID", None),
-                },
-                {
-                    "key": "GITHUB_CLIENT_ID",
-                    "default": os.environ.get("GITHUB_CLIENT_ID", None),
-                },
-                {
-                    "key": "GITHUB_APP_NAME",
-                    "default": os.environ.get("GITHUB_APP_NAME", None),
-                },
-                {
-                    "key": "EMAIL_HOST_USER",
-                    "default": os.environ.get("EMAIL_HOST_USER", None),
-                },
-                {
-                    "key": "EMAIL_HOST_PASSWORD",
-                    "default": os.environ.get("EMAIL_HOST_PASSWORD", None),
-                },
-                {
-                    "key": "ENABLE_MAGIC_LINK_LOGIN",
-                    "default": os.environ.get("ENABLE_MAGIC_LINK_LOGIN", "1"),
-                },
-                {
-                    "key": "ENABLE_EMAIL_PASSWORD",
-                    "default": os.environ.get("ENABLE_EMAIL_PASSWORD", "1"),
-                },
-                {
-                    "key": "SLACK_CLIENT_ID",
-                    "default": os.environ.get("SLACK_CLIENT_ID", "1"),
-                },
-                {
-                    "key": "POSTHOG_API_KEY",
-                    "default": os.environ.get("POSTHOG_API_KEY", "1"),
-                },
-                {
-                    "key": "POSTHOG_HOST",
-                    "default": os.environ.get("POSTHOG_HOST", "1"),
-                },
-                {
-                    "key": "UNSPLASH_ACCESS_KEY",
-                    "default": os.environ.get("UNSPLASH_ACCESS_KEY", "1"),
-                },
-                {
-                    "key": "OPENAI_API_KEY",
-                    "default": os.environ.get("OPENAI_API_KEY", "1"),
-                },
-            ]
-        )
+        instance_configuration = InstanceConfiguration.objects.values("key", "value")

        data = {}
        # Authentication
-        data["google_client_id"] = GOOGLE_CLIENT_ID if GOOGLE_CLIENT_ID and GOOGLE_CLIENT_ID != "\"\"" else None
-        data["github_client_id"] = GITHUB_CLIENT_ID if GITHUB_CLIENT_ID and GITHUB_CLIENT_ID != "\"\"" else None
-        data["github_app_name"] = GITHUB_APP_NAME
+        data["google_client_id"] = get_configuration_value(
+            instance_configuration,
+            "GOOGLE_CLIENT_ID",
+            os.environ.get("GOOGLE_CLIENT_ID", None),
+        )
+        data["github_client_id"] = get_configuration_value(
+            instance_configuration,
+            "GITHUB_CLIENT_ID",
+            os.environ.get("GITHUB_CLIENT_ID", None),
+        )
+        data["github_app_name"] = get_configuration_value(
+            instance_configuration,
+            "GITHUB_APP_NAME",
+            os.environ.get("GITHUB_APP_NAME", None),
+        )
        data["magic_login"] = (
-            bool(EMAIL_HOST_USER) and bool(EMAIL_HOST_PASSWORD)
-        ) and ENABLE_MAGIC_LINK_LOGIN == "1"
+            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"

-        data["email_password_login"] = ENABLE_EMAIL_PASSWORD == "1"
+        data["email_password_login"] = (
+            get_configuration_value(
+                instance_configuration, "ENABLE_EMAIL_PASSWORD", "1"
+            )
+            == "1"
+        )
        # Slack client
-        data["slack_client_id"] = SLACK_CLIENT_ID
+        data["slack_client_id"] = get_configuration_value(
+            instance_configuration,
+            "SLACK_CLIENT_ID",
+            os.environ.get("SLACK_CLIENT_ID", None),
+        )

        # Posthog
-        data["posthog_api_key"] = POSTHOG_API_KEY
-        data["posthog_host"] = POSTHOG_HOST
+        data["posthog_api_key"] = get_configuration_value(
+            instance_configuration,
+            "POSTHOG_API_KEY",
+            os.environ.get("POSTHOG_API_KEY", None),
+        )
+        data["posthog_host"] = get_configuration_value(
+            instance_configuration,
+            "POSTHOG_HOST",
+            os.environ.get("POSTHOG_HOST", None),
+        )

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

        # Open AI settings
-        data["has_openai_configured"] = bool(OPENAI_API_KEY)
+        data["has_openai_configured"] = bool(
+            get_configuration_value(
+                instance_configuration,
+                "OPENAI_API_KEY",
+                os.environ.get("OPENAI_API_KEY", None),
+            )
+        )

-        # File size settings
        data["file_size_limit"] = float(os.environ.get("FILE_SIZE_LIMIT", 5242880))

-        # is self managed
-        data["is_self_managed"] = bool(int(os.environ.get("IS_SELF_MANAGED", "1")))
-
        return Response(data, status=status.HTTP_200_OK)
@@ -4,158 +4,13 @@ from rest_framework import status

 # Module imports
 from .base import BaseViewSet, BaseAPIView
-from plane.app.permissions import ProjectEntityPermission, WorkspaceEntityPermission
-from plane.db.models import Project, Estimate, EstimatePoint, Workspace
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import Project, Estimate, EstimatePoint
 from plane.app.serializers import (
    EstimateSerializer,
    EstimatePointSerializer,
    EstimateReadSerializer,
 )
-from django.db.models import Q
-
-class WorkspaceEstimateEndpoint(BaseViewSet):
-    permission_classes = [
-        WorkspaceEntityPermission,
-    ]
-    model = Estimate
-    serializer_class = EstimateSerializer
-
-    def list(self, request, slug):
-        estimates = Estimate.objects.filter(
-            workspace__slug=slug, project_id__isnull=True
-        ).prefetch_related("points").select_related("workspace")
-        serializer = EstimateReadSerializer(estimates, many=True)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def create(self, request, slug):
-        if not request.data.get("estimate", False):
-            return Response(
-                {"error": "Estimate is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        estimate_points = request.data.get("estimate_points", [])
-
-        if not len(estimate_points) or len(estimate_points) > 8:
-            return Response(
-                {"error": "Estimate points are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        estimate_serializer = EstimateSerializer(data=request.data.get("estimate"))
-        if not estimate_serializer.is_valid():
-            return Response(
-                estimate_serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            )
-        workspace = Workspace.objects.get(slug=slug)
-        estimate = estimate_serializer.save(workspace_id=workspace.id)
-        estimate_points = EstimatePoint.objects.bulk_create(
-            [
-                EstimatePoint(
-                    estimate=estimate,
-                    key=estimate_point.get("key", 0),
-                    value=estimate_point.get("value", ""),
-                    description=estimate_point.get("description", ""),
-                    workspace_id=estimate.workspace_id,
-                    created_by=request.user,
-                    updated_by=request.user,
-                )
-                for estimate_point in estimate_points
-            ],
-            batch_size=10,
-            ignore_conflicts=True,
-        )
-
-        estimate_point_serializer = EstimatePointSerializer(
-            estimate_points, many=True
-        )
-
-        return Response(
-            {
-                "estimate": estimate_serializer.data,
-                "estimate_points": estimate_point_serializer.data,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    def retrieve(self, request, slug, estimate_id):
-        estimate = Estimate.objects.get(
-            pk=estimate_id, workspace__slug=slug
-        )
-        serializer = EstimateReadSerializer(estimate)
-        return Response(
-            serializer.data,
-            status=status.HTTP_200_OK,
-        )
-
-    def partial_update(self, request, slug, estimate_id):
-        if not request.data.get("estimate", False):
-            return Response(
-                {"error": "Estimate is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if not len(request.data.get("estimate_points", [])):
-            return Response(
-                {"error": "Estimate points are required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        estimate = Estimate.objects.get(pk=estimate_id)
-
-        estimate_serializer = EstimateSerializer(
-            estimate, data=request.data.get("estimate"), partial=True
-        )
-        if not estimate_serializer.is_valid():
-            return Response(
-                estimate_serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        estimate = estimate_serializer.save()
-
-        estimate_points_data = request.data.get("estimate_points", [])
-
-        estimate_points = EstimatePoint.objects.filter(
-            pk__in=[
-                estimate_point.get("id") for estimate_point in estimate_points_data
-            ],
-            workspace__slug=slug,
-            estimate_id=estimate_id,
-        )
-
-        updated_estimate_points = []
-        for estimate_point in estimate_points:
-            # Find the data for that estimate point
-            estimate_point_data = [
-                point
-                for point in estimate_points_data
-                if point.get("id") == str(estimate_point.id)
-            ]
-            if len(estimate_point_data):
-                estimate_point.value = estimate_point_data[0].get(
-                    "value", estimate_point.value
-                )
-                updated_estimate_points.append(estimate_point)
-
-        EstimatePoint.objects.bulk_update(
-            updated_estimate_points, ["value"], batch_size=10,
-        )
-
-        estimate_point_serializer = EstimatePointSerializer(estimate_points, many=True)
-        return Response(
-            {
-                "estimate": estimate_serializer.data,
-                "estimate_points": estimate_point_serializer.data,
-            },
-            status=status.HTTP_200_OK,
-        )
-
-    def destroy(self, request, slug, estimate_id):
-        estimate = Estimate.objects.get(
-            pk=estimate_id, workspace__slug=slug
-        )
-        estimate.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)


 class ProjectEstimatePointEndpoint(BaseAPIView):
@@ -184,14 +39,6 @@ class BulkEstimatePointEndpoint(BaseViewSet):
    serializer_class = EstimateSerializer

    def list(self, request, slug, project_id):
-        workspace = request.GET.get("workspace", False)
-        if workspace:
-            estimates = Estimate.objects.filter(
-               Q(project_id=project_id) | Q(project_id__isnull=True), workspace__slug=slug,
-            ).prefetch_related("points").select_related("workspace")
-            serializer = EstimateReadSerializer(estimates, many=True)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-
        estimates = Estimate.objects.filter(
            workspace__slug=slug, project_id=project_id
        ).prefetch_related("points").select_related("workspace", "project")
@@ -1,7 +1,6 @@
 # Python imports
 import requests
 import os
-
 # Third party imports
 from openai import OpenAI
 from rest_framework.response import Response
@@ -16,31 +15,23 @@ from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import Workspace, Project
 from plane.app.serializers import ProjectLiteSerializer, WorkspaceLiteSerializer
 from plane.utils.integrations.github import get_release_notes
+from plane.license.models import InstanceConfiguration
 from plane.license.utils.instance_value import get_configuration_value

-
 class GPTIntegrationEndpoint(BaseAPIView):
    permission_classes = [
        ProjectEntityPermission,
    ]

    def post(self, request, slug, project_id):
-        OPENAI_API_KEY, GPT_ENGINE = get_configuration_value(
-            [
-                {
-                    "key": "OPENAI_API_KEY",
-                    "default": os.environ.get("OPENAI_API_KEY", None),
-                },
-                {
-                    "key": "GPT_ENGINE",
-                    "default": os.environ.get("GPT_ENGINE", "gpt-3.5-turbo"),
-                },
-            ]
-        )

        # Get the configuration value
+        instance_configuration = InstanceConfiguration.objects.values("key", "value")
+        api_key = get_configuration_value(instance_configuration, "OPENAI_API_KEY", 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 OPENAI_API_KEY or not GPT_ENGINE:
+        if not api_key or not gpt_engine:
            return Response(
                {"error": "OpenAI API key and engine is required"},
                status=status.HTTP_400_BAD_REQUEST,
@@ -57,11 +48,11 @@ class GPTIntegrationEndpoint(BaseAPIView):
        final_text = task + "\n" + prompt

        client = OpenAI(
-            api_key=OPENAI_API_KEY,
+            api_key=api_key,
        )

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

@@ -88,17 +79,13 @@ class ReleaseNotesEndpoint(BaseAPIView):


 class UnsplashEndpoint(BaseAPIView):
+
    def get(self, request):
-        UNSPLASH_ACCESS_KEY, = get_configuration_value(
-            [
-                {
-                    "key": "UNSPLASH_ACCESS_KEY",
-                    "default": os.environ.get("UNSPLASH_ACCESS_KEY"),
-                }
-            ]
-        )
+        instance_configuration = InstanceConfiguration.objects.values("key", "value")
+        unsplash_access_key = get_configuration_value(instance_configuration, "UNSPLASH_ACCESS_KEY", 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
@@ -107,9 +94,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 = {
@@ -1,7 +1,5 @@
 # Python imports
 import uuid
-import json
-import requests

 # Third party imports
 from rest_framework import status
@@ -9,7 +7,7 @@ from rest_framework.response import Response

 # Django imports
 from django.db.models import Max, Q
-from django.conf import settings
+
 # Module imports
 from plane.app.views import BaseAPIView
 from plane.db.models import (
@@ -36,15 +34,20 @@ from plane.app.serializers import (
    IssueFlatSerializer,
    ModuleSerializer,
 )
+from plane.utils.integrations.github import get_github_repo_details
+from plane.utils.importers.jira import jira_project_issue_summary
+from plane.bgtasks.importer_task import service_importer
 from plane.utils.html_processor import strip_tags
 from plane.app.permissions import WorkSpaceAdminPermission
-from plane.bgtasks.importer_task import service_importer
+

 class ServiceIssueImportSummaryEndpoint(BaseAPIView):
+
    def get(self, request, slug, service):
        if service == "github":
            owner = request.GET.get("owner", False)
            repo = request.GET.get("repo", False)
+
            if not owner or not repo:
                return Response(
                    {"error": "Owner and repo are required"},
@@ -55,10 +58,11 @@ class ServiceIssueImportSummaryEndpoint(BaseAPIView):
                integration__provider="github", workspace__slug=slug
            )

-            installtion_id = workspace_integration.config.get("installation_id", False)
+            access_tokens_url = workspace_integration.metadata.get(
+                "access_tokens_url", False
+            )

-            # Check for the installation id
-            if not installtion_id:
+            if not access_tokens_url:
                return Response(
                    {
                        "error": "There was an error during the installation of the GitHub app. To resolve this issue, we recommend reinstalling the GitHub app."
@@ -66,33 +70,18 @@ class ServiceIssueImportSummaryEndpoint(BaseAPIView):
                    status=status.HTTP_400_BAD_REQUEST,
                )

-            # Request segway for the required information
-            if settings.SEGWAY_BASE_URL:
-                headers = {
-                    "Content-Type": "application/json",
-                    "x-api-key": settings.SEGWAY_KEY,
-                }
-                data = {
-                    "owner": owner,
-                    "repo": repo,
-                    "installationId": installtion_id,
-                }
-                res = requests.post(
-                    f"{settings.SEGWAY_BASE_URL}/api/github",
-                    data=json.dumps(data),
-                    headers=headers,
-                )
-                if "error" in res.json():
-                    return Response(res.json(), status=status.HTTP_400_BAD_REQUEST)
-                else:
-                    return Response(
-                        res.json(),
-                        status=status.HTTP_200_OK,
-                    )
-            return Response(
-                {"error": "Inetgration service is not available please try later"},
-                status=status.HTTP_400_BAD_REQUEST,
+            issue_count, labels, collaborators = get_github_repo_details(
+                access_tokens_url, owner, repo
            )
+            return Response(
+                {
+                    "issue_count": issue_count,
+                    "labels": labels,
+                    "collaborators": collaborators,
+                },
+                status=status.HTTP_200_OK,
+            )
+
        if service == "jira":
            # Check for all the keys
            params = {
@@ -113,35 +102,16 @@ class ServiceIssueImportSummaryEndpoint(BaseAPIView):
            email = request.GET.get("email", "")
            cloud_hostname = request.GET.get("cloud_hostname", "")

-            if settings.SEGWAY_BASE_URL:
-                headers = {
-                    "Content-Type": "application/json",
-                    "x-api-key": settings.SEGWAY_KEY,
-                }
-                data = {
-                    "project_key": project_key,
-                    "api_token": api_token,
-                    "email": email,
-                    "cloud_hostname": cloud_hostname,
-                }
-                res = requests.post(
-                    f"{settings.SEGWAY_BASE_URL}/api/jira",
-                    data=json.dumps(data),
-                    headers=headers,
-                )
-
-                if "error" in res.json():
-                    return Response(res.json(), status=status.HTTP_400_BAD_REQUEST)
-                else:
-                    return Response(
-                        res.json(),
-                        status=status.HTTP_200_OK,
-                    )
-
-            return Response(
-                {"error": "Inetgration service is not available please try later"},
-                status=status.HTTP_400_BAD_REQUEST,
+            response = jira_project_issue_summary(
+                email, api_token, project_key, cloud_hostname
            )
+            if "error" in response:
+                return Response(response, status=status.HTTP_400_BAD_REQUEST)
+            else:
+                return Response(
+                    response,
+                    status=status.HTTP_200_OK,
+                )
        return Response(
            {"error": "Service not supported yet"},
            status=status.HTTP_400_BAD_REQUEST,
@@ -152,21 +122,7 @@ class ImportServiceEndpoint(BaseAPIView):
    permission_classes = [
        WorkSpaceAdminPermission,
    ]
-
    def post(self, request, slug, service):
-        if service not in ["github", "jira"]:
-            return Response(
-                {"error": "Servivce not supported yet"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if service == "github":
-            workspace_integration = WorkspaceIntegration.objects.get(
-                integration__provider="github", workspace__slug=slug
-            )
-
-            installation_id = workspace_integration.config.get("installation_id", False)
-
        project_id = request.data.get("project_id", False)

        if not project_id:
@@ -174,84 +130,87 @@ class ImportServiceEndpoint(BaseAPIView):
                {"error": "Project ID is required"},
                status=status.HTTP_400_BAD_REQUEST,
            )
+
        workspace = Workspace.objects.get(slug=slug)

-        # Validate the data
-        data = request.data.get("data", False)
-        metadata = request.data.get("metadata", False)
-        config = request.data.get("config", False)
-        if not data or not metadata or not config:
-            return Response(
-                {"error": "Data, config and metadata are required"},
-                status=status.HTTP_400_BAD_REQUEST,
+        if service == "github":
+            data = request.data.get("data", False)
+            metadata = request.data.get("metadata", False)
+            config = request.data.get("config", False)
+            if not data or not metadata or not config:
+                return Response(
+                    {"error": "Data, config and metadata are required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            api_token = APIToken.objects.filter(
+                user=request.user, workspace=workspace
+            ).first()
+            if api_token is None:
+                api_token = APIToken.objects.create(
+                    user=request.user,
+                    label="Importer",
+                    workspace=workspace,
+                )
+
+            importer = Importer.objects.create(
+                service=service,
+                project_id=project_id,
+                status="queued",
+                initiated_by=request.user,
+                data=data,
+                metadata=metadata,
+                token=api_token,
+                config=config,
+                created_by=request.user,
+                updated_by=request.user,
            )

-        # Update config
-        if config and service == "github":
-            config.update({"installation_id": installation_id})
+            service_importer.delay(service, importer.id)
+            serializer = ImporterSerializer(importer)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)

-        # Get the api token -- # derecated
-        api_token = APIToken.objects.filter(
-            user=request.user, workspace=workspace
-        ).first()
-        if api_token is None:
-            api_token = APIToken.objects.create(
-                user=request.user,
-                label="Importer",
-                workspace=workspace,
+        if service == "jira":
+            data = request.data.get("data", False)
+            metadata = request.data.get("metadata", False)
+            config = request.data.get("config", False)
+            if not data or not metadata:
+                return Response(
+                    {"error": "Data, config and metadata are required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+            api_token = APIToken.objects.filter(
+                user=request.user, workspace=workspace
+            ).first()
+            if api_token is None:
+                api_token = APIToken.objects.create(
+                    user=request.user,
+                    label="Importer",
+                    workspace=workspace,
+                )
+
+            importer = Importer.objects.create(
+                service=service,
+                project_id=project_id,
+                status="queued",
+                initiated_by=request.user,
+                data=data,
+                metadata=metadata,
+                token=api_token,
+                config=config,
+                created_by=request.user,
+                updated_by=request.user,
            )

-        # Create an import
-        importer = Importer.objects.create(
-            service=service,
-            project_id=project_id,
-            status="queued",
-            initiated_by=request.user,
-            data=data,
-            metadata=metadata,
-            token=api_token,
-            config=config,
-            created_by=request.user,
-            updated_by=request.user,
+            service_importer.delay(service, importer.id)
+            serializer = ImporterSerializer(importer)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+        return Response(
+            {"error": "Servivce not supported yet"},
+            status=status.HTTP_400_BAD_REQUEST,
        )

-        # Push it to segway
-        if settings.SEGWAY_BASE_URL:
-            headers = {
-                "Content-Type": "application/json",
-                "x-api-key": settings.SEGWAY_KEY,
-            }
-            data = {
-                "metadata": metadata,
-                "data": data,
-                "config": config,
-                "workspace_id": str(workspace.id),
-                "project_id": str(project_id),
-                "created_by": str(request.user.id),
-                "importer_id": str(importer.id),
-            }
-            res = requests.post(
-                f"{settings.SEGWAY_BASE_URL}/api/github/import",
-                data=json.dumps(data),
-                headers=headers,
-            )
-
-            if "error" in res.json():
-                importer.status = "failed"
-                importer.reason = str(res.json())
-                importer.save()
-            else:
-                importer.status = "processing"
-                importer.save(update_fields=["status"])
-        else:
-            importer.status = "failed"
-            importer.reason = "Segway base url is not present"
-            importer.save(update_fields=["status", "reason"])
-
-        # return the response
-        serializer = ImporterSerializer(importer)
-        return Response(serializer.data, status=status.HTTP_201_CREATED)
-
    def get(self, request, slug):
        imports = (
            Importer.objects.filter(workspace__slug=slug)
@@ -262,7 +221,9 @@ class ImportServiceEndpoint(BaseAPIView):
        return Response(serializer.data)

    def delete(self, request, slug, service, pk):
-        importer = Importer.objects.get(pk=pk, service=service, workspace__slug=slug)
+        importer = Importer.objects.get(
+            pk=pk, service=service, workspace__slug=slug
+        )

        if importer.imported_data is not None:
            # Delete all imported Issues
@@ -280,7 +241,9 @@ class ImportServiceEndpoint(BaseAPIView):
        return Response(status=status.HTTP_204_NO_CONTENT)

    def patch(self, request, slug, service, pk):
-        importer = Importer.objects.get(pk=pk, service=service, workspace__slug=slug)
+        importer = Importer.objects.get(
+            pk=pk, service=service, workspace__slug=slug
+        )
        serializer = ImporterSerializer(importer, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
@@ -516,7 +479,9 @@ class BulkImportModulesEndpoint(BaseAPIView):
                [
                    ModuleLink(
                        module=module,
-                        url=module_data.get("link", {}).get("url", "https://plane.so"),
+                        url=module_data.get("link", {}).get(
+                            "url", "https://plane.so"
+                        ),
                        title=module_data.get("link", {}).get(
                            "title", "Original Issue"
                        ),
@@ -1,11 +1,8 @@
 # Python improts
 import uuid
 import requests
-import json
-
 # Django imports
 from django.contrib.auth.hashers import make_password
-from django.conf import settings

 # Third party imports
 from rest_framework.response import Response
@@ -30,7 +27,6 @@ from plane.utils.integrations.github import (
 from plane.app.permissions import WorkSpaceAdminPermission
 from plane.utils.integrations.slack import slack_oauth

-
 class IntegrationViewSet(BaseViewSet):
    serializer_class = IntegrationSerializer
    model = Integration
@@ -50,7 +46,9 @@ class IntegrationViewSet(BaseViewSet):
                status=status.HTTP_400_BAD_REQUEST,
            )

-        serializer = IntegrationSerializer(integration, data=request.data, partial=True)
+        serializer = IntegrationSerializer(
+            integration, data=request.data, partial=True
+        )

        if serializer.is_valid():
            serializer.save()
@@ -96,30 +94,14 @@ class WorkspaceIntegrationViewSet(BaseViewSet):
                    {"error": "Installation ID is required"},
                    status=status.HTTP_400_BAD_REQUEST,
                )
-            # Push it to segway
-            if settings.SEGWAY_BASE_URL:
-                headers = {
-                    "Content-Type": "application/json",
-                    "x-api-key": settings.SEGWAY_KEY,
-                }
-                data = {"installationId": installation_id}
-                res = requests.post(
-                    f"{settings.SEGWAY_BASE_URL}/api/github/metadata",
-                    data=json.dumps(data),
-                    headers=headers,
-                )
-                if "error" in res.json():
-                    return Response(res.json(), status=status.HTTP_400_BAD_REQUEST)
-                metadata = res.json()
+            metadata = get_github_metadata(installation_id)
            config = {"installation_id": installation_id}

        if provider == "slack":
            code = request.data.get("code", False)

            if not code:
-                return Response(
-                    {"error": "Code is required"}, status=status.HTTP_400_BAD_REQUEST
-                )
+                return Response({"error": "Code is required"}, status=status.HTTP_400_BAD_REQUEST)

            slack_response = slack_oauth(code=code)

@@ -141,7 +123,9 @@ class WorkspaceIntegrationViewSet(BaseViewSet):
            is_password_autoset=True,
            is_bot=True,
            first_name=integration.title,
-            avatar=integration.avatar_url if integration.avatar_url is not None else "",
+            avatar=integration.avatar_url
+            if integration.avatar_url is not None
+            else "",
        )

        # Create an API Token for the bot user
@@ -177,7 +161,9 @@ class WorkspaceIntegrationViewSet(BaseViewSet):
        )

        if workspace_integration.integration.provider == "github":
-            installation_id = workspace_integration.config.get("installation_id", False)
+            installation_id = workspace_integration.config.get(
+                "installation_id", False
+            )
            if installation_id:
                delete_github_installation(installation_id=installation_id)

@@ -1,15 +1,8 @@
-# Python imports
-import json
-import requests
-
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
 from sentry_sdk import capture_exception

-# Django imports
-from django.conf import settings
-
 # Module imports
 from plane.app.views import BaseViewSet, BaseAPIView
 from plane.db.models import (
@@ -42,32 +35,19 @@ class GithubRepositoriesEndpoint(BaseAPIView):
            workspace__slug=slug, pk=workspace_integration_id
        )

-        installation_id = workspace_integration.config.get("installation_id")
-
-        if not installation_id:
+        if workspace_integration.integration.provider != "github":
            return Response(
                {"error": "Not a github integration"},
                status=status.HTTP_400_BAD_REQUEST,
            )
-        # Push it to segway
-        if settings.SEGWAY_BASE_URL:
-            headers = {
-                "Content-Type": "application/json",
-                "x-api-key": settings.SEGWAY_KEY,
-            }
-            data = {
-                "installationId": installation_id,
-                "page": page,
-            }
-            res = requests.post(
-                f"{settings.SEGWAY_BASE_URL}/api/github/repos",
-                data=json.dumps(data),
-                headers=headers,
-            )
-            if "error" in res.json():
-                return Response(res.json(), status=status.HTTP_400_BAD_REQUEST)
-            else:
-                return Response(res.json(), status=status.HTTP_200_OK)
+
+        access_tokens_url = workspace_integration.metadata["access_tokens_url"]
+        repositories_url = (
+            workspace_integration.metadata["repositories_url"]
+            + f"?per_page=100&page={page}"
+        )
+        repositories = get_github_repos(access_tokens_url, repositories_url)
+        return Response(repositories, status=status.HTTP_200_OK)


 class GithubRepositorySyncViewSet(BaseViewSet):
@@ -30,8 +30,9 @@ from plane.db.models import (
 )
 from plane.bgtasks.event_tracking_task import auth_events
 from .base import BaseAPIView
-from plane.license.models import Instance
+from plane.license.models import InstanceConfiguration, 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):
@@ -86,14 +87,7 @@ def get_access_token(request_token: str, client_id: str) -> str:
    if not request_token:
        raise ValueError("The request token has to be supplied!")

-    (CLIENT_SECRET,) = get_configuration_value(
-        [
-            {
-                "key": "GITHUB_CLIENT_SECRET",
-                "default": os.environ.get("GITHUB_CLIENT_SECRET", None),
-            },
-        ]
-    )
+    CLIENT_SECRET = os.environ.get("GITHUB_CLIENT_SECRET")

    url = f"https://github.com/login/oauth/access_token?client_id={client_id}&client_secret={CLIENT_SECRET}&code={request_token}"
    headers = {"accept": "application/json"}
@@ -154,18 +148,22 @@ class OauthEndpoint(BaseAPIView):
            id_token = request.data.get("credential", False)
            client_id = request.data.get("clientId", False)

-            GOOGLE_CLIENT_ID, GITHUB_CLIENT_ID = get_configuration_value(
-                [
-                    {
-                        "key": "GOOGLE_CLIENT_ID",
-                        "default": os.environ.get("GOOGLE_CLIENT_ID"),
-                    },
-                    {
-                        "key": "GITHUB_CLIENT_ID",
-                        "default": os.environ.get("GITHUB_CLIENT_ID"),
-                    },
-                ]
+            instance_configuration = InstanceConfiguration.objects.values(
+                "key", "value"
            )
+            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(
@@ -176,19 +174,9 @@ class OauthEndpoint(BaseAPIView):
                )

            if medium == "google":
-                if not GOOGLE_CLIENT_ID:
-                    return Response(
-                        {"error": "Google login is not configured"},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
                data = validate_google_token(id_token, client_id)

            if medium == "github":
-                if not GITHUB_CLIENT_ID:
-                    return Response(
-                        {"error": "Github login is not configured"},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
                access_token = get_access_token(id_token, client_id)
                data = get_user_data(access_token)

@@ -291,15 +279,16 @@ class OauthEndpoint(BaseAPIView):
            )

            # Send event
-            auth_events.delay(
-                user=user.id,
-                email=email,
-                user_agent=request.META.get("HTTP_USER_AGENT"),
-                ip=request.META.get("REMOTE_ADDR"),
-                event_name="SIGN_IN",
-                medium=medium.upper(),
-                first_time=False,
-            )
+            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,
+                )

            access_token, refresh_token = get_tokens_for_user(user)

@@ -310,16 +299,25 @@ class OauthEndpoint(BaseAPIView):
            return Response(data, status=status.HTTP_200_OK)

        except User.DoesNotExist:
-            (ENABLE_SIGNUP,) = get_configuration_value(
-                [
-                    {
-                        "key": "ENABLE_SIGNUP",
-                        "default": os.environ.get("ENABLE_SIGNUP", "0"),
-                    }
-                ]
+            ## Signup Case
+            instance_configuration = InstanceConfiguration.objects.values(
+                "key", "value"
            )
+            # 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 (
-                ENABLE_SIGNUP == "0"
+                get_configuration_value(
+                    instance_configuration,
+                    "ENABLE_SIGNUP",
+                    os.environ.get("ENABLE_SIGNUP", "0"),
+                )
+                == "0"
                and not WorkspaceMemberInvite.objects.filter(
                    email=email,
                ).exists()
@@ -422,15 +420,16 @@ class OauthEndpoint(BaseAPIView):
            project_member_invites.delete()

            # Send event
-            auth_events.delay(
-                user=user.id,
-                email=email,
-                user_agent=request.META.get("HTTP_USER_AGENT"),
-                ip=request.META.get("REMOTE_ADDR"),
-                event_name="SIGN_IN",
-                medium=medium.upper(),
-                first_time=True,
-            )
+            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,
+                )

            SocialLoginConnection.objects.update_or_create(
                medium=medium,
@@ -448,4 +447,6 @@ 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)
@@ -22,7 +22,6 @@ from plane.db.models import (
    IssueAssignee,
    IssueActivity,
    PageLog,
-    ProjectMember,
 )
 from plane.app.serializers import (
    PageSerializer,
@@ -141,6 +140,12 @@ 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)
@@ -150,6 +155,12 @@ 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()

@@ -164,16 +175,10 @@ class PageViewSet(BaseViewSet):
    def archive(self, request, slug, project_id, page_id):
        page = Page.objects.get(pk=page_id, workspace__slug=slug, project_id=project_id)

-        # only the owner and admin can archive the page
-        if (
-            ProjectMember.objects.filter(
-                project_id=project_id, member=request.user, is_active=True, role__gt=20
-            ).exists()
-            or request.user.id != page.owned_by_id
-        ):
+        if page.owned_by_id != request.user.id:
            return Response(
-                {"error": "Only the owner and admin can archive the page"},
-                status=status.HTTP_400_BAD_REQUEST,
+                {"error": "Only the owner of the page can archive a page"},
+                status=status.HTTP_204_NO_CONTENT,
            )

        unarchive_archive_page_and_descendants(page_id, datetime.now())
@@ -183,15 +188,9 @@ class PageViewSet(BaseViewSet):
    def unarchive(self, request, slug, project_id, page_id):
        page = Page.objects.get(pk=page_id, workspace__slug=slug, project_id=project_id)

-        # only the owner and admin can un archive the page
-        if (
-            ProjectMember.objects.filter(
-                project_id=project_id, member=request.user, is_active=True, role__gt=20
-            ).exists()
-            or request.user.id != page.owned_by_id
-        ):
+        if page.owned_by_id != request.user.id:
            return Response(
-                {"error": "Only the owner and admin can un archive the page"},
+                {"error": "Only the owner of the page can unarchive a page"},
                status=status.HTTP_400_BAD_REQUEST,
            )

@@ -217,18 +216,6 @@ class PageViewSet(BaseViewSet):
    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"},
@@ -240,6 +227,7 @@ 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)

@@ -322,6 +310,36 @@ class PageLogEndpoint(BaseAPIView):
        return Response(status=status.HTTP_204_NO_CONTENT)


+class CreateIssueFromBlockEndpoint(BaseAPIView):
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def post(self, request, slug, project_id, page_id):
+        page = Page.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            pk=page_id,
+        )
+        issue = Issue.objects.create(
+            name=request.data.get("name"),
+            project_id=project_id,
+        )
+        _ = IssueAssignee.objects.create(
+            issue=issue, assignee=request.user, project_id=project_id
+        )
+
+        _ = IssueActivity.objects.create(
+            issue=issue,
+            actor=request.user,
+            project_id=project_id,
+            comment=f"created the issue from {page.name} block",
+            verb="created",
+        )
+
+        return Response(IssueLiteSerializer(issue).data, status=status.HTTP_200_OK)
+
+
 class SubPagesEndpoint(BaseAPIView):
    permission_classes = [
        ProjectEntityPermission,
@@ -39,10 +39,8 @@ from plane.app.serializers import (
 )

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

 from plane.db.models import (
@@ -145,16 +143,6 @@ class ProjectViewSet(WebhookMixin, BaseViewSet):
                    )
                )
            )
-            .prefetch_related(
-                Prefetch(
-                    "project_projectmember",
-                    queryset=ProjectMember.objects.filter(
-                        workspace__slug=self.kwargs.get("slug"),
-                        is_active=True,
-                    ).select_related("member"),
-                    to_attr="members_list",
-                )
-            )
            .distinct()
        )

@@ -170,6 +158,15 @@ class ProjectViewSet(WebhookMixin, BaseViewSet):
        projects = (
            self.get_queryset()
            .annotate(sort_order=Subquery(sort_order_query))
+            .prefetch_related(
+                Prefetch(
+                    "project_projectmember",
+                    queryset=ProjectMember.objects.filter(
+                        workspace__slug=slug,
+                        is_active=True,
+                    ).select_related("member"),
+                )
+            )
            .order_by("sort_order", "name")
        )
        if request.GET.get("per_page", False) and request.GET.get("cursor", False):
@@ -603,18 +600,6 @@ class ProjectMemberViewSet(BaseViewSet):
        ProjectMemberPermission,
    ]

-    def get_permissions(self):
-        if self.action == "leave":
-            self.permission_classes = [
-                ProjectLitePermission,
-            ]
-        else:
-            self.permission_classes = [
-                ProjectMemberPermission,
-            ]
-
-        return super(ProjectMemberViewSet, self).get_permissions()
-
    search_fields = [
        "member__display_name",
        "member__first_name",
@@ -679,25 +664,6 @@ class ProjectMemberViewSet(BaseViewSet):
                )
            )

-            # Check if the user is already a member of the project and is inactive
-            if ProjectMember.objects.filter(
-                workspace__slug=slug,
-                project_id=project_id,
-                member_id=member.get("member_id"),
-                is_active=False,
-            ).exists():
-                member_detail = ProjectMember.objects.get(
-                    workspace__slug=slug,
-                    project_id=project_id,
-                    member_id=member.get("member_id"),
-                    is_active=False,
-                )
-                # Check if the user has not deactivated the account
-                user = User.objects.filter(pk=member.get("member_id")).first()
-                if user.is_active:
-                    member_detail.is_active = True
-                    member_detail.save(update_fields=["is_active"])
-
        project_members = ProjectMember.objects.bulk_create(
            bulk_project_members,
            batch_size=10,
@@ -1010,18 +976,11 @@ class ProjectPublicCoverImagesEndpoint(BaseAPIView):

    def get(self, request):
        files = []
-        s3_client_params = {
-            "service_name": "s3",
-            "aws_access_key_id": settings.AWS_ACCESS_KEY_ID,
-            "aws_secret_access_key": settings.AWS_SECRET_ACCESS_KEY,
-        }
-
-        # Use AWS_S3_ENDPOINT_URL if it is present in the settings
-        if hasattr(settings, "AWS_S3_ENDPOINT_URL") and settings.AWS_S3_ENDPOINT_URL:
-            s3_client_params["endpoint_url"] = settings.AWS_S3_ENDPOINT_URL
-
-        s3 = boto3.client(**s3_client_params)
-
+        s3 = boto3.client(
+            "s3",
+            aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
+            aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
+        )
        params = {
            "Bucket": settings.AWS_STORAGE_BUCKET_NAME,
            "Prefix": "static/project-cover/",
@@ -1034,19 +993,9 @@ class ProjectPublicCoverImagesEndpoint(BaseAPIView):
                if not content["Key"].endswith(
                    "/"
                ):  # This line ensures we're only getting files, not "sub-folders"
-                    if (
-                        hasattr(settings, "AWS_S3_CUSTOM_DOMAIN")
-                        and settings.AWS_S3_CUSTOM_DOMAIN
-                        and hasattr(settings, "AWS_S3_URL_PROTOCOL")
-                        and settings.AWS_S3_URL_PROTOCOL
-                    ):
-                        files.append(
-                            f"{settings.AWS_S3_URL_PROTOCOL}//{settings.AWS_S3_CUSTOM_DOMAIN}/{content['Key']}"
-                        )
-                    else:
-                        files.append(
-                            f"https://{settings.AWS_STORAGE_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
-                        )
+                    files.append(
+                        f"https://{settings.AWS_STORAGE_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
+                    )

        return Response(files, status=status.HTTP_200_OK)

@@ -1099,20 +1048,3 @@ 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)
@@ -77,7 +77,7 @@ class StateViewSet(BaseViewSet):
        )

        if state.default:
-            return Response({"error": "Default state cannot be deleted"}, status=status.HTTP_400_BAD_REQUEST)
+            return Response({"error": "Default state cannot be deleted"}, status=False)

        # Check for any issues in the state
        issue_exist = Issue.issue_objects.filter(state=pk).exists()
@@ -49,10 +49,6 @@ 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 = []

@@ -70,11 +70,11 @@ from plane.app.permissions import (
    WorkSpaceAdminPermission,
    WorkspaceEntityPermission,
    WorkspaceViewerPermission,
-    WorkspaceUserPermission,
 )
 from plane.bgtasks.workspace_invitation_task import workspace_invitation
 from plane.utils.issue_filters import issue_filters
-from plane.bgtasks.event_tracking_task import workspace_invite_event
+from plane.utils.grouper import group_results
+

 class WorkSpaceViewSet(BaseViewSet):
    model = Workspace
@@ -407,16 +407,6 @@ class WorkspaceJoinEndpoint(BaseAPIView):

                    # Delete the invitation
                    workspace_invite.delete()
-                
-                # Send event
-                workspace_invite_event.delay(
-                    user=user.id if user is not None else None,
-                    email=email,
-                    user_agent=request.META.get("HTTP_USER_AGENT"),
-                    ip=request.META.get("REMOTE_ADDR"),
-                    event_name="MEMBER_ACCEPTED",
-                    accepted_from="EMAIL",
-                )

                return Response(
                    {"message": "Workspace Invitation Accepted"},
@@ -496,18 +486,6 @@ class WorkSpaceMemberViewSet(BaseViewSet):
        WorkspaceEntityPermission,
    ]

-    def get_permissions(self):
-        if self.action == "leave":
-            self.permission_classes = [
-                WorkspaceUserPermission,
-            ]
-        else:
-            self.permission_classes = [
-                WorkspaceEntityPermission,
-            ]
-
-        return super(WorkSpaceMemberViewSet, self).get_permissions()
-
    search_fields = [
        "member__display_name",
        "member__first_name",
@@ -1 +0,0 @@
-from .issue_sync_task import issue_sync
@@ -1,8 +1,7 @@
 # Python imports
 import csv
 import io
-import requests
-import json
+import os

 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
@@ -18,7 +17,8 @@ from sentry_sdk import capture_exception
 from plane.db.models import Issue
 from plane.utils.analytics_plot import build_graph_plot
 from plane.utils.issue_filters import issue_filters
-from plane.license.utils.instance_value import get_email_configuration
+from plane.license.models import InstanceConfiguration
+from plane.license.utils.instance_value import get_configuration_value

 row_mapping = {
    "state__name": "State",
@@ -43,7 +43,7 @@ CYCLE_ID = "issue_cycle__cycle_id"
 MODULE_ID = "issue_module__module_id"


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

    csv_buffer.seek(0)

-    (
-        EMAIL_HOST,
-        EMAIL_HOST_USER,
-        EMAIL_HOST_PASSWORD,
-        EMAIL_PORT,
-        EMAIL_USE_TLS,
-        EMAIL_FROM,
-    ) = get_email_configuration()
-
+    # Configure email connection from the database
+    instance_configuration = InstanceConfiguration.objects.filter(
+        key__startswith="EMAIL_"
+    ).values("key", "value")
    connection = get_connection(
-        host=EMAIL_HOST,
-        port=int(EMAIL_PORT),
-        username=EMAIL_HOST_USER,
-        password=EMAIL_HOST_PASSWORD,
-        use_tls=EMAIL_USE_TLS == "1",
+        host=get_configuration_value(
+            instance_configuration, "EMAIL_HOST", 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"),
+            )
+        ),
    )

    msg = EmailMultiAlternatives(
        subject=subject,
        body=text_content,
-        from_email=EMAIL_FROM,
+        from_email=get_configuration_value(
+            instance_configuration,
+            "EMAIL_FROM",
+            os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
+        ),
        to=[email],
        connection=connection,
    )
    msg.attach(f"{slug}-analytics.csv", csv_buffer.getvalue())
    msg.send(fail_silently=False)
-    return


 def get_assignee_details(slug, filters):
@@ -373,7 +391,7 @@ def generate_non_segmented_rows(
    return [tuple(row_zero)] + rows


-@shared_task(queue='internal_tasks')
+@shared_task
 def analytic_export_task(email, data, slug):
    try:
        filters = issue_filters(data, "POST")
@@ -445,11 +463,8 @@ def analytic_export_task(email, data, slug):
            )

        csv_buffer = generate_csv_from_rows(rows)
-        send_export_email(email, slug, csv_buffer, rows)
-        return
+        send_export_email(email, slug, csv_buffer)
    except Exception as e:
-        print(e)
        if settings.DEBUG:
            print(e)
        capture_exception(e)
-        return
@@ -1,78 +1,30 @@
 import uuid
-import os

-# third party imports
+from posthog import Posthog
+from django.conf import settings
+
+#third party imports
 from celery import shared_task
 from sentry_sdk import capture_exception
-from posthog import Posthog
-
-# module imports
-from plane.license.utils.instance_value import get_configuration_value


-def posthogConfiguration():
-    POSTHOG_API_KEY, POSTHOG_HOST = get_configuration_value(
-        [
-            {
-                "key": "POSTHOG_API_KEY",
-                "default": os.environ.get("POSTHOG_API_KEY", None),
-            },
-            {
-                "key": "POSTHOG_HOST",
-                "default": os.environ.get("POSTHOG_HOST", None),
-            },
-        ]
-    )
-    if POSTHOG_API_KEY and POSTHOG_HOST:
-        return POSTHOG_API_KEY, POSTHOG_HOST
-    else:
-        return None, None
-
-
-@shared_task(queue='internal_tasks')
+@shared_task
 def auth_events(user, email, user_agent, ip, event_name, medium, first_time):
    try:
-        POSTHOG_API_KEY, POSTHOG_HOST = posthogConfiguration()
-
-        if POSTHOG_API_KEY and POSTHOG_HOST:
-            posthog = Posthog(POSTHOG_API_KEY, host=POSTHOG_HOST)
-            posthog.capture(
-                email,
-                event=event_name,
-                properties={
-                        "event_id": uuid.uuid4().hex,
-                        "user": {"email": email, "id": str(user)},
-                        "device_ctx": {
-                            "ip": ip,
-                            "user_agent": user_agent,
-                        },
-                        "medium": medium,
-                        "first_time": first_time
-                }
-            )
-    except Exception as e:
-        capture_exception(e)
- 
-
-@shared_task(queue='internal_tasks')
-def workspace_invite_event(user, email, user_agent, ip, event_name, accepted_from):
-    try:
-        POSTHOG_API_KEY, POSTHOG_HOST = posthogConfiguration()
-
-        if POSTHOG_API_KEY and POSTHOG_HOST:
-            posthog = Posthog(POSTHOG_API_KEY, host=POSTHOG_HOST)
-            posthog.capture(
-                email,
-                event=event_name,
-                properties={
-                        "event_id": uuid.uuid4().hex,
-                        "user": {"email": email, "id": str(user)},
-                        "device_ctx": {
-                            "ip": ip,
-                            "user_agent": user_agent,
-                        },
-                        "accepted_from": accepted_from
-                }
-            )
+        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
+            }
+        )
    except Exception as e:
        capture_exception(e)
@@ -259,7 +259,7 @@ def generate_xlsx(header, project_id, issues, files):
    files.append((f"{project_id}.xlsx", xlsx_file))


-@shared_task(queue='internal_tasks')
+@shared_task
 def issue_export_task(provider, workspace_id, project_ids, token_id, multiple, slug):
    try:
        exporter_instance = ExporterHistory.objects.get(token=token_id)
@@ -15,7 +15,7 @@ from botocore.client import Config
 from plane.db.models import ExporterHistory


-@shared_task(queue='internal_tasks')
+@shared_task
 def delete_old_s3_link():
    # Get a list of keys and IDs to process
    expired_exporter_history = ExporterHistory.objects.filter(
@@ -12,7 +12,7 @@ from celery import shared_task
 from plane.db.models import FileAsset


-@shared_task(queue='internal_tasks')
+@shared_task
 def delete_file_asset():

    # file assets to delete
@@ -14,10 +14,11 @@ 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(queue='internal_tasks')
+@shared_task
 def forgot_password(first_name, email, uidb64, token, current_site):
    try:
        relative_link = (
@@ -25,6 +26,10 @@ 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,
@@ -32,7 +37,36 @@ def forgot_password(first_name, email, uidb64, token, current_site):
            EMAIL_PORT,
            EMAIL_USE_TLS,
            EMAIL_FROM,
-        ) = get_email_configuration()
+        ) = 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

        subject = "A new password to your Plane account has been requested"

@@ -46,12 +80,15 @@ 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=EMAIL_USE_TLS == "1",
+            use_tls=bool(EMAIL_USE_TLS),
        )

        msg = EmailMultiAlternatives(
@@ -1,467 +1,204 @@
 # Python imports
+import json
+import requests
 import uuid

 # Django imports
-from django.db.models import Q, Max
+from django.conf import settings
+from django.core.serializers.json import DjangoJSONEncoder
 from django.contrib.auth.hashers import make_password

 # Third Party imports
 from celery import shared_task
-from celery.exceptions import MaxRetriesExceededError
+from sentry_sdk import capture_exception

 # Module imports
+from plane.app.serializers import ImporterSerializer
 from plane.db.models import (
    Importer,
    WorkspaceMember,
+    GithubRepositorySync,
+    GithubRepository,
    ProjectMember,
+    WorkspaceIntegration,
    Label,
    User,
    IssueProperty,
-    IssueAssignee,
-    IssueLabel,
-    IssueSequence,
-    IssueActivity,
-    IssueComment,
-    IssueLink,
-    ModuleIssue,
-    State,
-    Module,
-    Issue,
-    Cycle,
 )
 from plane.bgtasks.user_welcome_task import send_welcome_slack
+from plane.bgtasks.user_count_task import update_user_instance_user_count


-@shared_task(queue="internal_tasks")
+@shared_task
 def service_importer(service, importer_id):
-    pass
-
-
-## Utility functions
-def get_label_id(name, data):
    try:
-        existing_label = (
-            Label.objects.filter(
-                project_id=data.get("project_id"),
-                workspace_id=data.get("workspace_id"),
-                name__iexact=name,
-            )
-            .values("id")
-            .first()
-        )
-        return existing_label
-    except Label.DoesNotExist:
-        return None
+        importer = Importer.objects.get(pk=importer_id)
+        importer.status = "processing"
+        importer.save()

+        users = importer.data.get("users", [])

-def get_state_id(name, data):
-    try:
-        existing_state = (
-            State.objects.filter(
-                name__iexact=name,
-                project_id=data.get("project_id"),
-                workspace_id=data.get("workspace_id"),
-            )
-            .values("id")
-            .first()
-        )
-        return existing_state
-    except State.DoesNotExist:
-        return None
-
-
-def get_user_id(name):
-    try:
-        existing_user = User.objects.filter(email=name).values("id").first()
-        return existing_user
-    except User.DoesNotExist:
-        return None
-
-
-def update_imported_items(importer_id, entity, entity_id):
-    importer = Importer.objects.get(pk=importer_id)
-    if importer.imported_data:
-        importer.imported_data.setdefault(str(entity), []).append(str(entity_id))
-    else:
-        importer.imported_data = {
-            str(entity): [str(entity_id)]
-        }
-    importer.save()
-
-
-## Sync functions
-def members_sync(data):
-    try:
-        user = User.objects.get(email=data.get("email"))
-        _ = WorkspaceMember.objects.get_or_create(
-            member_id=user.id, workspace_id=data.get("workspace_id")
-        )
-        _ = ProjectMember.objects.get_or_create(
-            member_id=user.id,
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-        _ = IssueProperty.objects.get_or_create(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            user_id=user.id,
-            created_by_id=data.get("created_by"),
-        )
-
-    except User.DoesNotExist:
-        # For all invited users create the users
-        new_user = User.objects.create(
-            email=data.get("email").strip().lower(),
-            username=uuid.uuid4().hex,
-            password=make_password(uuid.uuid4().hex),
-            is_password_autoset=True,
-        )
-
-        service = data.get("external_source")
-
-        WorkspaceMember.objects.create(
-            member_id=new_user.id,
-            workspace_id=data.get("workspace_id"),
-            created_by_id=data.get("created_by"),
-        )
-
-        ProjectMember.objects.create(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            member_id=new_user.id,
-            created_by_id=data.get("created_by"),
-        )
-
-        IssueProperty.objects.create(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            user_id=new_user.id,
-            created_by_id=data.get("created_by"),
-        )
-        if data.get("source", False) == "slack":
-            send_welcome_slack.delay(
-                str(new_user.id),
-                True,
-                f"{new_user.email} was imported to Plane from {service}",
+        # Check if we need to import users as well
+        if len(users):
+            # For all invited users create the users
+            new_users = User.objects.bulk_create(
+                [
+                    User(
+                        email=user.get("email").strip().lower(),
+                        username=uuid.uuid4().hex,
+                        password=make_password(uuid.uuid4().hex),
+                        is_password_autoset=True,
+                    )
+                    for user in users
+                    if user.get("import", False) == "invite"
+                ],
+                batch_size=10,
+                ignore_conflicts=True,
            )

+            _ = [
+                send_welcome_slack.delay(
+                    str(user.id),
+                    True,
+                    f"{user.email} was imported to Plane from {service}",
+                )
+                for user in new_users
+            ]

-def label_sync(data):
-    existing_label = Label.objects.filter(
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-        name__iexact=data.get("name"),
-        external_id=data.get("external_id", None),
-        external_source=data.get("external_source"),
-    )
-
-    if not existing_label.exists() and data.get("name"):
-        label = Label.objects.create(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            name=data.get("name"),
-            color=data.get("color"),
-            created_by_id=data.get("created_by"),
-            external_id=data.get("external_id", None),
-            external_source=data.get("external_source"),
-        )
-        update_imported_items(data.get("importer_id"), "labels", label.id)
-
-
-def state_sync(data):
-    try:
-        state = State.objects.get(
-            external_id=data.get("external_id"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-
-    except State.DoesNotExist:
-        existing_states = State.objects.filter(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            group=data.get("state_group"),
-            name__iexact=data.get("state_name"),
-        )
-
-        if existing_states.exists():
-            existing_state = existing_states.first()
-            existing_state.external_id = data.get("external_id")
-            existing_state.external_source = data.get("external_source")
-            existing_state.save()
-        else:
-            state = State.objects.create(
-                project_id=data.get("project_id"),
-                workspace_id=data.get("workspace_id"),
-                name=data.get("state_name"),
-                group=data.get("state_group"),
-                created_by_id=data.get("created_by"),
-                external_id=data.get("external_id"),
-                external_source=data.get("external_source"),
+            workspace_users = User.objects.filter(
+                email__in=[
+                    user.get("email").strip().lower()
+                    for user in users
+                    if user.get("import", False) == "invite"
+                    or user.get("import", False) == "map"
+                ]
            )
-            update_imported_items(data.get("importer_id"), "states", state.id)

+            # Check if any of the users are already member of workspace
+            _ = WorkspaceMember.objects.filter(
+                member__in=[user for user in workspace_users],
+                workspace_id=importer.workspace_id,
+            ).update(is_active=True)

-def issue_sync(data):
-    try:
-        issue = Issue.objects.get(
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-    except Issue.DoesNotExist:
-        # Get the default state
-        default_state = State.objects.filter(
-            ~Q(name="Triage"), project_id=data.get("project_id"), default=True
-        ).first()
+            # Add new users to Workspace and project automatically
+            WorkspaceMember.objects.bulk_create(
+                [
+                    WorkspaceMember(
+                        member=user,
+                        workspace_id=importer.workspace_id,
+                        created_by=importer.created_by,
+                    )
+                    for user in workspace_users
+                ],
+                batch_size=100,
+                ignore_conflicts=True,
+            )

-        # if there is no default state assign any random state
-        if default_state is None:
-            default_state = State.objects.filter(
-                ~Q(name="Triage"), project_id=data.get("project_id")
+            ProjectMember.objects.bulk_create(
+                [
+                    ProjectMember(
+                        project_id=importer.project_id,
+                        workspace_id=importer.workspace_id,
+                        member=user,
+                        created_by=importer.created_by,
+                    )
+                    for user in workspace_users
+                ],
+                batch_size=100,
+                ignore_conflicts=True,
+            )
+
+            IssueProperty.objects.bulk_create(
+                [
+                    IssueProperty(
+                        project_id=importer.project_id,
+                        workspace_id=importer.workspace_id,
+                        user=user,
+                        created_by=importer.created_by,
+                    )
+                    for user in workspace_users
+                ],
+                batch_size=100,
+                ignore_conflicts=True,
+            )
+        
+        # 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):
+            name = importer.metadata.get("name", False)
+            url = importer.metadata.get("url", False)
+            config = importer.metadata.get("config", {})
+            owner = importer.metadata.get("owner", False)
+            repository_id = importer.metadata.get("repository_id", False)
+
+            workspace_integration = WorkspaceIntegration.objects.get(
+                workspace_id=importer.workspace_id, integration__provider="github"
+            )
+
+            # Delete the old repository object
+            GithubRepositorySync.objects.filter(project_id=importer.project_id).delete()
+            GithubRepository.objects.filter(project_id=importer.project_id).delete()
+
+            # Create a Label for github
+            label = Label.objects.filter(
+                name="GitHub", project_id=importer.project_id
            ).first()

-        # Get the maximum sequence_id
-        last_id = IssueSequence.objects.filter(
-            project_id=data.get("project_id")
-        ).aggregate(largest=Max("sequence"))["largest"]
+            if label is None:
+                label = Label.objects.create(
+                    name="GitHub",
+                    project_id=importer.project_id,
+                    description="Label to sync Plane issues with GitHub issues",
+                    color="#003773",
+                )
+            # Create repository
+            repo = GithubRepository.objects.create(
+                name=name,
+                url=url,
+                config=config,
+                repository_id=repository_id,
+                owner=owner,
+                project_id=importer.project_id,
+            )

-        last_id = 1 if last_id is None else last_id + 1
+            # Create repo sync
+            _ = GithubRepositorySync.objects.create(
+                repository=repo,
+                workspace_integration=workspace_integration,
+                actor=workspace_integration.actor,
+                credentials=importer.data.get("credentials", {}),
+                project_id=importer.project_id,
+                label=label,
+            )

-        # Get the maximum sort order
-        largest_sort_order = Issue.objects.filter(
-            project_id=data.get("project_id"), state=default_state
-        ).aggregate(largest=Max("sort_order"))["largest"]
+            # Add bot as a member in the project
+            _ = ProjectMember.objects.get_or_create(
+                member=workspace_integration.actor,
+                role=20,
+                project_id=importer.project_id,
+            )

-        largest_sort_order = (
-            65535 if largest_sort_order is None else largest_sort_order + 10000
-        )
-        parent_id = None
-        if data.get("parent_id", False):
-            parent_id = Issue.objects.filter(
-                external_id=data.get("parent_id"),
-                external_source=data.get("external_source"),
-                project_id=data.get("project_id"),
-                workspace_id=data.get("workspace_id"),
-            ).values("id")
+        if settings.PROXY_BASE_URL:
+            headers = {"Content-Type": "application/json"}
+            import_data_json = json.dumps(
+                ImporterSerializer(importer).data,
+                cls=DjangoJSONEncoder,
+            )
+            _ = requests.post(
+                f"{settings.PROXY_BASE_URL}/hooks/workspaces/{str(importer.workspace_id)}/projects/{str(importer.project_id)}/importers/{str(service)}/",
+                json=import_data_json,
+                headers=headers,
+            )

-        # Issues
-        issue = Issue.objects.create(
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            state_id=get_state_id(data.get("state"), data).get("id")
-            if get_state_id(data.get("state"), data)
-            else default_state.id,
-            name=data.get("name", "Issue Created through Importer")[:255],
-            description_html=data.get("description_html", "<p></p>"),
-            sequence_id=last_id,
-            sort_order=largest_sort_order,
-            start_date=data.get("start_date", None),
-            target_date=data.get("target_date", None),
-            priority=data.get("priority", "none"),
-            created_by_id=data.get("created_by_id"),
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-            parent_id=parent_id,
-        )
-
-        # Sequences
-        _ = IssueSequence.objects.create(
-            issue=issue,
-            sequence=issue.sequence_id,
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-
-        # Attach Links
-        _ = IssueLink.objects.create(
-            issue=issue,
-            url=data.get("link", {}).get("url", "https://github.com"),
-            title=data.get("link", {}).get("title", "Original Issue"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            created_by_id=data.get("created_by_id"),
-        )
-
-        # Track the issue activities
-        _ = IssueActivity.objects.create(
-            issue=issue,
-            actor_id=data.get("created_by_id"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            comment=f"imported the issue from {data.get('external_source')}",
-            verb="created",
-            created_by_id=data.get("created_by_id"),
-        )
-
-        update_imported_items(data.get("importer_id"), "issues", issue.id)
-
-
-def issue_label_sync(data):
-    issue = Issue.objects.get(
-        external_source=data.get("external_issue_source"),
-        external_id=data.get("external_issue_id"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-    )
-    if get_label_id(data.get("name"), data):
-        IssueLabel.objects.create(
-            issue=issue,
-            label_id=get_label_id(data.get("name"), data).get("id"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            created_by_id=data.get("created_by_id"),
-        )
-
-
-def issue_assignee_sync(data):
-    issue = Issue.objects.get(
-        external_source=data.get("external_issue_source"),
-        external_id=data.get("external_issue_id"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-    )
-    user = User.objects.filter(email=data.get("email")).values("id")
-
-    IssueAssignee.objects.create(
-        issue=issue,
-        assignee_id=user,
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-        created_by_id=data.get("created_by_id"),
-    )
-
-
-def issue_comment_sync(data):
-    # Create Comments
-    issue = Issue.objects.get(
-        external_source=data.get("external_issue_source"),
-        external_id=data.get("external_issue_id"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-    )
-    IssueComment.objects.create(
-        issue=issue,
-        comment_html=data.get("comment_html", "<p></p>"),
-        actor_id=data.get("created_by_id"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-        created_by_id=get_user_id(data.get("created_by_id")).get("id")
-        if get_user_id(data.get("created_by_id"))
-        else data.get("created_by_id"),
-        external_id=data.get("external_id"),
-        external_source=data.get("external_source"),
-    )
-
-
-def cycles_sync(data):
-    try:
-        _ = Cycle.objects.get(
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-    except Cycle.DoesNotExist:
-        cycle = Cycle.objects.create(
-            name=data.get("name"),
-            description_html=data.get("description_html", "<p></p>"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            created_by_id=data.get("created_by"),
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-        )
-        update_imported_items(data.get("importer_id"), "cycles", cycle.id)
-
-
-def module_sync(data):
-    try:
-        _ = Module.objects.get(
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-        )
-    except Module.DoesNotExist:
-        module = Module.objects.create(
-            name=data.get("name"),
-            description_html=data.get("description_html", "<p></p>"),
-            project_id=data.get("project_id"),
-            workspace_id=data.get("workspace_id"),
-            created_by_id=data.get("created_by"),
-            external_id=data.get("external_id"),
-            external_source=data.get("external_source"),
-        )
-        update_imported_items(data.get("importer_id"), "modules", module.id)
-
-
-def modules_issue_sync(data):
-    module = Module.objects.get(
-        external_id=data.get("module_id"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-        external_source=data.get("external_source"),
-    )
-    issue = Issue.objects.get(
-        external_id=data.get("issue_id"),
-        external_source=data.get("external_source"),
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-    )
-
-    _ = ModuleIssue.objects.create(
-        module=module,
-        issue=issue,
-        project_id=data.get("project_id"),
-        workspace_id=data.get("workspace_id"),
-        created_by_id=data.get("created_by"),
-    )
-
-
-def import_sync(data):
-    importer = Importer.objects.get(pk=data.get("importer_id"))
-    importer.status = data.get("status")
-    importer.save(update_fields=["status"])
-
-
-@shared_task(bind=True, queue="segway_task", max_retries=5)
-def import_task(self, data):
-    type = data.get("type")
-
-    if type is None:
-        return
-
-    TYPE_MAPPER = {
-        "member.sync": members_sync,
-        "label.sync": label_sync,
-        "state.sync": state_sync,
-        "issue.sync": issue_sync,
-        "issue.label.sync": issue_label_sync,
-        "issue.assignee.sync": issue_assignee_sync,
-        "issue.comment.sync": issue_comment_sync,
-        "cycle.sync": cycles_sync,
-        "module.sync": module_sync,
-        "module.issue.sync": modules_issue_sync,
-        "import.sync": import_sync,
-    }
-    try:
-        func = TYPE_MAPPER.get(type)
-        if func is None:
-            return
-        # Call the function
-        func(data)
        return
    except Exception as e:
-        try:
-            # Retry with exponential backoff
-            self.retry(exc=e, countdown=50, backoff=2)
-        except MaxRetriesExceededError:
-            # For max retries reached items fail the import
-            importer = Importer.objects.get(pk=data.get("importer_id"))
-            importer.status = "failed"
-            importer.reason = e
-            importer.save()
-
+        importer = Importer.objects.get(pk=importer_id)
+        importer.status = "failed"
+        importer.save()
+        # Print logs if in DEBUG mode
+        if settings.DEBUG:
+            print(e)
+        capture_exception(e)
        return
@@ -1460,7 +1460,7 @@ def delete_draft_issue_activity(


 # Receive message from room group
-@shared_task(queue='internal_tasks')
+@shared_task
 def issue_activity(
    type,
    requested_data,
@@ -16,7 +16,7 @@ from plane.db.models import Issue, Project, State
 from plane.bgtasks.issue_activites_task import issue_activity


-@shared_task(queue='internal_tasks')
+@shared_task
 def archive_and_close_old_issues():
    archive_old_issues()
    close_old_issues()
@@ -1,5 +0,0 @@
-from celery import shared_task
-
-@shared_task(queue="segway_tasks")
-def issue_sync(data):
-    print(f"Received data from Segway: {data}")
@@ -14,12 +14,18 @@ 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(queue='internal_tasks')
+@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,
@@ -27,7 +33,34 @@ def magic_link(email, key, token, current_site):
            EMAIL_PORT,
            EMAIL_USE_TLS,
            EMAIL_FROM,
-        ) = get_email_configuration()
+        ) = 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

        # Send the mail
        subject = f"Your unique Plane login code is {token}"
@@ -41,7 +74,7 @@ def magic_link(email, key, token, current_site):
            port=int(EMAIL_PORT),
            username=EMAIL_HOST_USER,
            password=EMAIL_HOST_PASSWORD,
-            use_tls=EMAIL_USE_TLS == "1",
+            use_tls=bool(EMAIL_USE_TLS),
        )

        msg = EmailMultiAlternatives(
@@ -183,7 +183,7 @@ def createMentionNotification(project, notification_comment, issue, actor_id, me
    )


-@shared_task(queue='internal_tasks')
+@shared_task
 def notifications(type, issue_id, project_id, actor_id, subscriber, issue_activities_created, requested_data, current_instance):
    issue_activities_created = (
        json.loads(
@@ -13,9 +13,10 @@ from sentry_sdk import capture_exception

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

-@shared_task(queue='internal_tasks')
+@shared_task
 def project_invitation(email, project_id, token, current_site, invitor):
    try:
        user = User.objects.get(email=invitor)
@@ -46,27 +47,43 @@ def project_invitation(email, project_id, token, current_site, invitor):
        project_member_invite.save()

        # Configure email connection from the database
-        (
-            EMAIL_HOST,
-            EMAIL_HOST_USER,
-            EMAIL_HOST_PASSWORD,
-            EMAIL_PORT,
-            EMAIL_USE_TLS,
-            EMAIL_FROM,
-        ) = get_email_configuration()
-
+        instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
        connection = get_connection(
-            host=EMAIL_HOST,
-            port=int(EMAIL_PORT),
-            username=EMAIL_HOST_USER,
-            password=EMAIL_HOST_PASSWORD,
-            use_tls=EMAIL_USE_TLS == "1",
+            host=get_configuration_value(
+                instance_configuration, "EMAIL_HOST", 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"),
+                )
+            ),
        )

        msg = EmailMultiAlternatives(
            subject=subject,
            body=text_content,
-            from_email=EMAIL_FROM,
+            from_email=get_configuration_value(
+                instance_configuration,
+                "EMAIL_FROM",
+                os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
+            ),
            to=[email],
            connection=connection,
        )
@@ -0,0 +1,49 @@
+# 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)
@@ -11,7 +11,7 @@ from slack_sdk.errors import SlackApiError
 from plane.db.models import User


-@shared_task(queue='internal_tasks')
+@shared_task
 def send_welcome_slack(user_id, created, message):
    try:
        instance = User.objects.get(pk=user_id)
@@ -71,7 +71,6 @@ def get_model_data(event, event_id, many=False):
    retry_backoff=600,
    max_retries=5,
    retry_jitter=True,
-    queue='internal_tasks'
 )
 def webhook_task(self, webhook, slug, event, event_data, action):
    try:
@@ -110,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).encode("utf-8"),
+                json.dumps(payload, sort_keys=True).encode("utf-8"),
                hashlib.sha256,
            )
            signature = hmac_signature.hexdigest()
@@ -162,7 +161,7 @@ def webhook_task(self, webhook, slug, event, event_data, action):
        return


-@shared_task(queue='internal_tasks')
+@shared_task()
 def send_webhook(event, payload, kw, action, slug, bulk):
    try:
        webhooks = Webhook.objects.filter(workspace__slug=slug, is_active=True)
@@ -17,10 +17,11 @@ 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


-@shared_task(queue='internal_tasks')
+@shared_task
 def workspace_invitation(email, workspace_id, token, current_site, invitor):
    try:
        user = User.objects.get(email=invitor)
@@ -36,6 +37,9 @@ 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,
@@ -44,7 +48,37 @@ def workspace_invitation(email, workspace_id, token, current_site, invitor):
            EMAIL_PORT,
            EMAIL_USE_TLS,
            EMAIL_FROM,
-        ) = get_email_configuration()
+        ) = 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

        # 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"
@@ -65,12 +99,15 @@ 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=EMAIL_USE_TLS == "1",
+            use_tls=bool(EMAIL_USE_TLS),
        )

        msg = EmailMultiAlternatives(
@@ -8,7 +8,7 @@ os.environ.setdefault("DJANGO_SETTINGS_MODULE", "plane.settings.production")

 ri = redis_instance()

-app = Celery('tasks', broker='pyamqp://guest:guest@localhost:5672//')
+app = Celery("plane")

 # Using a string here means the worker will not have to
 # pickle the object when using Windows.
@@ -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'
@@ -1,54 +0,0 @@
-# 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"))
@@ -1,23 +0,0 @@
-# Generated by Django 4.2.7 on 2023-12-20 14:33
-
-from django.db import migrations, models
-import django.db.models.deletion
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('db', '0050_user_use_case_alter_workspace_organization_size'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='estimate',
-            name='project',
-            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='project_%(class)s', to='db.project'),
-        ),
-        migrations.AlterField(
-            model_name='estimatepoint',
-            name='project',
-            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='project_%(class)s', to='db.project'),
-        ),
-    ]
@@ -9,7 +9,6 @@ from .workspace import (
    WorkspaceMemberInvite,
    TeamMember,
    WorkspaceTheme,
-    WorkspaceBaseModel,
 )

 from .project import (
@@ -22,6 +22,8 @@ class BaseModel(AuditModel):
        user = get_current_user()

        if user is None or user.is_anonymous:
+            self.created_by = None
+            self.updated_by = None
            super(BaseModel, self).save(*args, **kwargs)
        else:
            # Check if the model is being created or updated
@@ -18,8 +18,6 @@ class Cycle(ProjectBaseModel):
    )
    view_props = models.JSONField(default=dict)
    sort_order = models.FloatField(default=65535)
-    external_source = models.CharField(null=True, blank=True)
-    external_id = models.CharField(max_length=255, blank=True, null=True)

    class Meta:
        verbose_name = "Cycle"
@@ -29,9 +27,9 @@ class Cycle(ProjectBaseModel):

    def save(self, *args, **kwargs):
        if self._state.adding:
-            smallest_sort_order = Cycle.objects.filter(project=self.project).aggregate(
-                smallest=models.Min("sort_order")
-            )["smallest"]
+            smallest_sort_order = Cycle.objects.filter(
+                project=self.project
+            ).aggregate(smallest=models.Min("sort_order"))["smallest"]

            if smallest_sort_order is not None:
                self.sort_order = smallest_sort_order - 10000
@@ -3,10 +3,10 @@ from django.db import models
 from django.core.validators import MinValueValidator, MaxValueValidator

 # Module imports
-from . import WorkspaceBaseModel
+from . import ProjectBaseModel


-class Estimate(WorkspaceBaseModel):
+class Estimate(ProjectBaseModel):
    name = models.CharField(max_length=255)
    description = models.TextField(verbose_name="Estimate Description", blank=True)

@@ -22,7 +22,7 @@ class Estimate(WorkspaceBaseModel):
        ordering = ("name",)


-class EstimatePoint(WorkspaceBaseModel):
+class EstimatePoint(ProjectBaseModel):
    estimate = models.ForeignKey(
        "db.Estimate",
        on_delete=models.CASCADE,
@@ -34,7 +34,6 @@ class Importer(ProjectBaseModel):
        "db.APIToken", on_delete=models.CASCADE, related_name="importer"
    )
    imported_data = models.JSONField(null=True)
-    reason = models.TextField(blank=True)

    class Meta:
        verbose_name = "Importer"
@@ -102,8 +102,6 @@ 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(null=True, blank=True)
-    external_id = models.CharField(max_length=255, blank=True, null=True)

    objects = models.Manager()
    issue_objects = IssueManager()
@@ -134,6 +132,7 @@ class Issue(ProjectBaseModel):
            except ImportError:
                pass

+
        if self._state.adding:
            # Get the maximum display_id value from the database
            last_id = IssueSequence.objects.filter(project=self.project).aggregate(
@@ -211,9 +210,8 @@ class IssueRelation(ProjectBaseModel):
        ordering = ("-created_at",)

    def __str__(self):
-        return f"{self.issue.name} {self.related_issue.name}"
-
-
+        return f"{self.issue.name} {self.related_issue.name}"    
+    
 class IssueMention(ProjectBaseModel):
    issue = models.ForeignKey(
        Issue, on_delete=models.CASCADE, related_name="issue_mention"
@@ -223,7 +221,6 @@ class IssueMention(ProjectBaseModel):
        on_delete=models.CASCADE,
        related_name="issue_mention",
    )
-
    class Meta:
        unique_together = ["issue", "mention"]
        verbose_name = "Issue Mention"
@@ -232,7 +229,7 @@ class IssueMention(ProjectBaseModel):
        ordering = ("-created_at",)

    def __str__(self):
-        return f"{self.issue.name} {self.mention.email}"
+        return f"{self.issue.name} {self.mention.email}" 


 class IssueAssignee(ProjectBaseModel):
@@ -369,8 +366,6 @@ class IssueComment(ProjectBaseModel):
        default="INTERNAL",
        max_length=100,
    )
-    external_source = models.CharField(null=True, blank=True)
-    external_id = models.CharField(max_length=255, blank=True, null=True)

    def save(self, *args, **kwargs):
        self.comment_stripped = (
@@ -421,8 +416,6 @@ 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(null=True, blank=True)
-    external_id = models.CharField(max_length=255, blank=True, null=True)

    class Meta:
        unique_together = ["name", "project"]
@@ -41,8 +41,6 @@ class Module(ProjectBaseModel):
    )
    view_props = models.JSONField(default=dict)
    sort_order = models.FloatField(default=65535)
-    external_source = models.CharField(null=True, blank=True)
-    external_id = models.CharField(max_length=255, blank=True, null=True)

    class Meta:
        unique_together = ["name", "project"]
@@ -24,8 +24,6 @@ class State(ProjectBaseModel):
        max_length=20,
    )
    default = models.BooleanField(default=False)
-    external_source = models.CharField(null=True, blank=True)
-    external_id = models.CharField(max_length=255, blank=True, null=True)

    def __str__(self):
        """Return name of the state"""
@@ -103,23 +103,6 @@ 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"
@@ -43,7 +43,7 @@ class InstanceConfigurationSerializer(BaseSerializer):
    def to_representation(self, instance):
        data = super().to_representation(instance)
        # Decrypt secrets value
-        if instance.is_encrypted and instance.value is not None:
+        if instance.key in ["OPENAI_API_KEY", "GITHUB_CLIENT_SECRET", "EMAIL_HOST_PASSWORD", "UNSPLASH_ACESS_KEY"] and instance.value is not None:
            data["value"] = decrypt_data(instance.value)

-        return data
+        return data
@@ -2,6 +2,8 @@ from .instance import (
    InstanceEndpoint,
    InstanceAdminEndpoint,
    InstanceConfigurationEndpoint,
-    InstanceAdminSignInEndpoint,
+    AdminSetupMagicSignInEndpoint,
    SignUpScreenVisitedEndpoint,
+    AdminMagicSignInGenerateEndpoint,
+    AdminSetUserPasswordEndpoint,
 )
@@ -11,7 +11,6 @@ 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
@@ -27,11 +26,15 @@ 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, WorkspaceMember, ProjectMember
+from plane.db.models import User
 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):
@@ -44,6 +47,69 @@ 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
@@ -136,7 +202,12 @@ class InstanceConfigurationEndpoint(BaseAPIView):
        bulk_configurations = []
        for configuration in configurations:
            value = request.data.get(configuration.key, configuration.value)
-            if configuration.is_encrypted:
+            if value is not None and configuration.key in [
+                "OPENAI_API_KEY",
+                "GITHUB_CLIENT_SECRET",
+                "EMAIL_HOST_PASSWORD",
+                "UNSPLASH_ACESS_KEY",
+            ]:
                configuration.value = encrypt_data(value)
            else:
                configuration.value = value
@@ -158,13 +229,15 @@ def get_tokens_for_user(user):
    )


-class InstanceAdminSignInEndpoint(BaseAPIView):
+class AdminMagicSignInGenerateEndpoint(BaseAPIView):
    permission_classes = [
        AllowAny,
    ]

    def post(self, request):
-        # Check instance first
+        email = request.data.get("email", False)
+
+        # Check the instance registration
        instance = Instance.objects.first()
        if instance is None:
            return Response(
@@ -172,63 +245,201 @@ class InstanceAdminSignInEndpoint(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,
            )

-        # Get the email and password from all the user
-        email = request.data.get("email", False)
-        password = request.data.get("password", False)

-        # return error if the email and password is not present
-        if not email or not password:
+        if not email:
            return Response(
-                {"error": "Email and password are required"},
+                {"error": "Please provide a valid email address"},
                status=status.HTTP_400_BAD_REQUEST,
            )

-        # Validate the email
+        # Clean up
        email = email.strip().lower()
-        try:
-            validate_email(email)
-        except ValidationError as e:
-            return Response(
-                {"error": "Please provide a valid email address."},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        validate_email(email)

-        # 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(
+        # 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(password),
-                is_password_autoset=False,
+                password=make_password(uuid.uuid4().hex),
+                is_password_autoset=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()
+        ## 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)
+        password = request.data.get("password", False)
+
+        # If the user password is not autoset then return error
+        if not user.is_password_autoset:
+            return Response(
+                {
+                    "error": "Your password is already set please change your password from profile"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check password validation
+        if not password and len(str(password)) < 8:
+            return Response(
+                {"error": "Password is not valid"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        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,
+            )
+
+        # 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,
+                }
+            ),
+        )

        # Register the user as an instance admin
        _ = InstanceAdmin.objects.create(
@@ -239,13 +450,12 @@ class InstanceAdminSignInEndpoint(BaseAPIView):
        instance.is_setup_done = True
        instance.save()

-        # 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)
+        # Set the user password
+        user.set_password(password)
+        user.is_password_autoset = False
+        user.save()
+        serializer = UserSerializer(user)
+        return Response(serializer.data, status=status.HTTP_200_OK)


 class SignUpScreenVisitedEndpoint(BaseAPIView):
@@ -255,11 +465,31 @@ 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,
            )
-        instance.is_signup_screen_visited = True
-        instance.save()
+
+        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),
+        )
        return Response(status=status.HTTP_204_NO_CONTENT)
@@ -21,91 +21,84 @@ 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": os.environ.get("GITHUB_CLIENT_SECRET"),
+                "value": encrypt_data(os.environ.get("GITHUB_CLIENT_SECRET"))
+                if os.environ.get("GITHUB_CLIENT_SECRET")
+                else None,
                "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": os.environ.get("EMAIL_HOST_PASSWORD", ""),
+                "value": encrypt_data(os.environ.get("EMAIL_HOST_PASSWORD"))
+                if os.environ.get("EMAIL_HOST_PASSWORD")
+                else None,
                "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": os.environ.get("OPENAI_API_KEY"),
+                "value": encrypt_data(os.environ.get("OPENAI_API_KEY"))
+                if os.environ.get("OPENAI_API_KEY")
+                else None,
                "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": os.environ.get("UNSPLASH_ACESS_KEY", ""),
+                "value": encrypt_data(os.environ.get("UNSPLASH_ACESS_KEY", ""))
+                if os.environ.get("UNSPLASH_ACESS_KEY")
+                else None,
                "category": "UNSPLASH",
-                "is_encrypted": True,
            },
        ]

@@ -114,12 +107,8 @@ 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(
@@ -1,12 +1,11 @@
 # 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
@@ -30,33 +29,56 @@ class Command(BaseCommand):
                # Load JSON content from the file
                data = json.load(file)

-            machine_signature = options.get("machine_signature", "machine-signature")
+            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")

            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": settings.INSTANCE_KEY,
+                "instance_key": instance_key,
                "version": data.get("version", 0.1),
                "machine_signature": machine_signature,
                "user_count": User.objects.filter(is_bot=False).count(),
            }

-            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),
+            response = requests.post(
+                f"{license_engine_base_url}/api/instances/",
+                headers=headers,
+                data=json.dumps(payload),
            )

-            self.stdout.write(
-                self.style.SUCCESS(
-                    f"Instance registered"
+            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 successfully registered"
+                    )
+                )
+                return
+            raise CommandError("Instance could not be registered")
        else:
            self.stdout.write(
                self.style.SUCCESS(
@@ -1,4 +1,4 @@
-# Generated by Django 4.2.7 on 2023-12-06 06:49
+# Generated by Django 4.2.7 on 2023-11-29 14:39

 from django.conf import settings
 from django.db import migrations, models
@@ -34,7 +34,6 @@ 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')),
            ],
@@ -54,7 +53,6 @@ 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')),
            ],
@@ -72,7 +70,6 @@ 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')),
@@ -30,7 +30,6 @@ 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"
@@ -48,7 +47,6 @@ 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"]
@@ -63,7 +61,6 @@ 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"
@@ -4,7 +4,9 @@ from plane.license.api.views import (
    InstanceEndpoint,
    InstanceAdminEndpoint,
    InstanceConfigurationEndpoint,
-    InstanceAdminSignInEndpoint,
+    AdminMagicSignInGenerateEndpoint,
+    AdminSetupMagicSignInEndpoint,
+    AdminSetUserPasswordEndpoint,
    SignUpScreenVisitedEndpoint,
 )

@@ -30,9 +32,19 @@ urlpatterns = [
        name="instance-configuration",
    ),
    path(
-        "instances/admins/sign-in/",
-        InstanceAdminSignInEndpoint.as_view(),
-        name="instance-admin-sign-in",
+        "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",
    ),
    path(
        "instances/admins/sign-up-screen-visited/",
@@ -9,20 +9,14 @@ def derive_key(secret_key):
    dk = hashlib.pbkdf2_hmac('sha256', secret_key.encode(), b'salt', 100000)
    return base64.urlsafe_b64encode(dk)

-# Encrypt data
-def encrypt_data(data):
-    if data:
-        cipher_suite = Fernet(derive_key(settings.SECRET_KEY))
-        encrypted_data = cipher_suite.encrypt(data.encode())
-        return encrypted_data.decode()  # Convert bytes to string
-    else:
-        return ""

-# Decrypt data 
+def encrypt_data(data):
+    cipher_suite = Fernet(derive_key(settings.SECRET_KEY))
+    encrypted_data = cipher_suite.encrypt(data.encode())
+    return encrypted_data.decode()  # Convert bytes to string
+
+
 def decrypt_data(encrypted_data):
-    if encrypted_data:
-        cipher_suite = Fernet(derive_key(settings.SECRET_KEY))
-        decrypted_data = cipher_suite.decrypt(encrypted_data.encode())  # Convert string back to bytes
-        return decrypted_data.decode()
-    else:
-        return ""
+    cipher_suite = Fernet(derive_key(settings.SECRET_KEY))
+    decrypted_data = cipher_suite.decrypt(encrypted_data.encode())  # Convert string back to bytes
+    return decrypted_data.decode()
@@ -1,71 +1,63 @@
-# Python imports
 import os

-# Django imports
-from django.conf import settings
-
-# Module imports
-from plane.license.models import InstanceConfiguration
-from plane.license.utils.encryption import decrypt_data
-

 # Helper function to return value from the passed key
-def get_configuration_value(keys):
-    environment_list = []
-    if settings.SKIP_ENV_VAR:
-        # Get the configurations
-        instance_configuration = InstanceConfiguration.objects.values(
-            "key", "value", "is_encrypted"
-        )
-
-        for key in keys:
-            for item in instance_configuration:
-                if key.get("key") == item.get("key"):
-                    if item.get("is_encrypted", False):
-                        environment_list.append(decrypt_data(item.get("value")))
-                    else:
-                        environment_list.append(item.get("value"))
-
-                    break
-            else:
-                environment_list.append(key.get("default"))
-    else:
-        # Get the configuration from os
-        for key in keys:
-            environment_list.append(os.environ.get(key.get("key"), key.get("default")))
-
-    return tuple(environment_list)
+def get_configuration_value(query, key, default=None):
+    for item in query:
+        if item["key"] == key:
+            return item.get("value", default)
+    return default


-def get_email_configuration():
-    return (
-        get_configuration_value(
-            [
-                {
-                    "key": "EMAIL_HOST",
-                    "default": os.environ.get("EMAIL_HOST"),
-                },
-                {
-                    "key": "EMAIL_HOST_USER",
-                    "default": os.environ.get("EMAIL_HOST_USER"),
-                },
-                {
-                    "key": "EMAIL_HOST_PASSWORD",
-                    "default": os.environ.get("EMAIL_HOST_PASSWORD"),
-                },
-                {
-                    "key": "EMAIL_PORT",
-                    "default": os.environ.get("EMAIL_PORT", 587),
-                },
-                {
-                    "key": "EMAIL_USE_TLS",
-                    "default": os.environ.get("EMAIL_USE_TLS", "1"),
-                },
-                {
-                    "key": "EMAIL_FROM",
-                    "default": os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
-                },
-            ]
-        )
+def get_email_configuration(instance_configuration):
+    # Get the configuration variables
+    EMAIL_HOST_USER = get_configuration_value(
+        instance_configuration,
+        "EMAIL_HOST_USER",
+        os.environ.get("EMAIL_HOST_USER", None),
    )

+    EMAIL_HOST_PASSWORD = get_configuration_value(
+        instance_configuration,
+        "EMAIL_HOST_PASSWORD",
+        os.environ.get("EMAIL_HOST_PASSWORD", None),
+    )
+
+    EMAIL_HOST = get_configuration_value(
+        instance_configuration,
+        "EMAIL_HOST",
+        os.environ.get("EMAIL_HOST", None),
+    )
+
+    EMAIL_FROM = get_configuration_value(
+        instance_configuration,
+        "EMAIL_FROM",
+        os.environ.get("EMAIL_FROM", None),
+    )
+
+    EMAIL_USE_TLS = get_configuration_value(
+        instance_configuration,
+        "EMAIL_USE_TLS",
+        os.environ.get("EMAIL_USE_TLS", "1"),
+    )
+
+    EMAIL_PORT = get_configuration_value(
+        instance_configuration,
+        "EMAIL_PORT",
+        587,
+    )
+
+    EMAIL_FROM = get_configuration_value(
+        instance_configuration,
+        "EMAIL_FROM",
+        os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
+    )
+
+    return (
+        EMAIL_HOST,
+        EMAIL_HOST_USER,
+        EMAIL_HOST_PASSWORD,
+        EMAIL_PORT,
+        EMAIL_USE_TLS,
+        EMAIL_FROM,
+    )
@@ -5,7 +5,6 @@ import ssl
 import certifi
 from datetime import timedelta
 from urllib.parse import urlparse
-from kombu import Exchange, Queue

 # Django imports
 from django.core.management.utils import get_random_secret_key
@@ -49,6 +48,7 @@ INSTALLED_APPS = [
    "rest_framework.authtoken",
    "rest_framework_simplejwt.token_blacklist",
    "corsheaders",
+    "taggit",
    "django_celery_beat",
    "storages",
 ]
@@ -110,9 +110,7 @@ CSRF_COOKIE_SECURE = True
 CORS_ALLOW_CREDENTIALS = True
 cors_origins_raw = os.environ.get("CORS_ALLOWED_ORIGINS", "")
 # filter out empty strings
-cors_allowed_origins = [
-    origin.strip() for origin in cors_origins_raw.split(",") if origin.strip()
-]
+cors_allowed_origins = [origin.strip() for origin in cors_origins_raw.split(",") if origin.strip()]
 if cors_allowed_origins:
    CORS_ALLOWED_ORIGINS = cors_allowed_origins
 else:
@@ -149,9 +147,6 @@ else:
 REDIS_URL = os.environ.get("REDIS_URL")
 REDIS_SSL = REDIS_URL and "rediss" in REDIS_URL

-# RabbitMq Config
-RABBITMQ_URL = os.environ.get("RABBITMQ_URL")
-
 if REDIS_SSL:
    CACHES = {
        "default": {
@@ -274,28 +269,18 @@ SIMPLE_JWT = {
 # Celery Configuration
 CELERY_TIMEZONE = TIME_ZONE
 CELERY_TASK_SERIALIZER = "json"
-CELERY_ACCEPT_CONTENT = ["json"]
+CELERY_ACCEPT_CONTENT = ["application/json"]

-CELERY_BROKER_URL = RABBITMQ_URL
-CELERY_RESULT_BACKEND = REDIS_URL
-
-CELERY_QUEUES = (
-    Queue(
-        "internal_tasks",
-        Exchange("internal_exchange", type="direct"),
-        routing_key="internal",
-    ),
-    Queue(
-        "external_tasks",
-        Exchange("external_exchange", type="direct"),
-        routing_key="external",
-    ),
-    Queue(
-        "segway_tasks",
-        Exchange("segway_exchange", type="direct"),
-        routing_key="segway",
-    ),
-)
+if REDIS_SSL:
+    redis_url = os.environ.get("REDIS_URL")
+    broker_url = (
+        f"{redis_url}?ssl_cert_reqs={ssl.CERT_NONE.name}&ssl_ca_certs={certifi.where()}"
+    )
+    CELERY_BROKER_URL = broker_url
+    CELERY_RESULT_BACKEND = broker_url
+else:
+    CELERY_BROKER_URL = REDIS_URL
+    CELERY_RESULT_BACKEND = REDIS_URL

 CELERY_IMPORTS = (
    "plane.bgtasks.issue_automation_task",
@@ -305,9 +290,7 @@ CELERY_IMPORTS = (

 # Sentry Settings
 # Enable Sentry Settings
-if bool(os.environ.get("SENTRY_DSN", False)) and os.environ.get(
-    "SENTRY_DSN"
-).startswith("https://"):
+if bool(os.environ.get("SENTRY_DSN", False)):
    sentry_sdk.init(
        dsn=os.environ.get("SENTRY_DSN", ""),
        integrations=[
@@ -341,13 +324,4 @@ USE_MINIO = int(os.environ.get("USE_MINIO", 0)) == 1

 # Posthog settings
 POSTHOG_API_KEY = os.environ.get("POSTHOG_API_KEY", False)
-POSTHOG_HOST = os.environ.get("POSTHOG_HOST", False)
-
-# Skip environment variable configuration
-SKIP_ENV_VAR = os.environ.get("SKIP_ENV_VAR", "1") == "1"
-
-DATA_UPLOAD_MAX_MEMORY_SIZE = int(os.environ.get("FILE_SIZE_LIMIT", 5242880))
-
-# Segway
-SEGWAY_BASE_URL = os.environ.get("SEGWAY_BASE_URL", "http://localhost:9000")
-SEGWAY_KEY = os.environ.get("SEGWAY_KEY", False)
+POSTHOG_HOST = os.environ.get("POSTHOG_HOST", False)
@@ -19,11 +19,8 @@ urlpatterns = [


 if settings.DEBUG:
-    try:
-        import debug_toolbar
+    import debug_toolbar

-        urlpatterns = [
-            re_path(r"^__debug__/", include(debug_toolbar.urls)),
-        ] + urlpatterns
-    except ImportError:
-        pass
+    urlpatterns = [
+        re_path(r"^__debug__/", include(debug_toolbar.urls)),
+    ] + urlpatterns
@@ -63,7 +63,7 @@ def date_filter(filter, date_term, queries):
                        duration=int(digit),
                        subsequent=date_query[1],
                        term=term,
-                        date_filter=date_term,
+                        date_filter="created_at__date",
                        offset=date_query[2],
                    )
            else:
@@ -1,9 +1,14 @@
 # base requirements

 Django==4.2.7
+django-braces==1.15.0
+django-taggit==4.0.0
 psycopg==3.1.12
+django-oauth-toolkit==2.3.0
+mistune==3.0.1
 djangorestframework==3.14.0
 redis==4.6.0
+django-nested-admin==4.0.2
 django-cors-headers==4.2.0
 whitenoise==6.5.0
 django-allauth==0.55.2
@@ -14,6 +19,8 @@ djangorestframework-simplejwt==5.3.0
 sentry-sdk==1.30.0
 django-storages==1.14
 django-crum==0.7.9
+django-guardian==2.4.0
+dj_rest_auth==2.2.5
 google-auth==2.22.0
 google-api-python-client==2.97.0
 django-redis==5.3.0
@@ -30,7 +37,4 @@ openpyxl==3.1.2
 beautifulsoup4==4.12.2
 dj-database-url==2.1.0
 posthog==3.0.2
-cryptography==41.0.6
-lxml==4.9.3
-boto3==1.28.40
-
+cryptography==41.0.5
@@ -1,3 +1,9 @@
 -r base.txt

 gunicorn==21.2.0
+whitenoise==6.5.0
+boto3==1.28.40
+django-anymail==10.1
+django-debug-toolbar==4.1.0
+gevent==23.7.0
+psycogreen==1.0.2
@@ -149,20 +149,20 @@
          padding-top: 10px !important;
        }
        .r13-o {
-          border-bottom-color: #d9e4ff !important;
+          border-bottom-color: #efefef !important;
          border-bottom-width: 1px !important;
-          border-left-color: #d9e4ff !important;
+          border-left-color: #efefef !important;
          border-left-width: 1px !important;
-          border-right-color: #d9e4ff !important;
+          border-right-color: #efefef !important;
          border-right-width: 1px !important;
          border-style: solid !important;
-          border-top-color: #d9e4ff !important;
+          border-top-color: #efefef !important;
          border-top-width: 1px !important;
          margin: 0 auto 0 0 !important;
          width: 100% !important;
        }
        .r14-i {
-          background-color: #ecf1ff !important;
+          background-color: #e3e6f1 !important;
          padding-bottom: 10px !important;
          padding-left: 10px !important;
          padding-right: 10px !important;
@@ -225,11 +225,16 @@
          padding-top: 5px !important;
        }
        .r24-o {
+          border-style: solid !important;
+          margin-right: 8px !important;
+          width: 32px !important;
+        }
+        .r25-o {
          border-style: solid !important;
          margin-right: 0px !important;
          width: 32px !important;
        }
-        .r25-i {
+        .r26-i {
          padding-bottom: 0px !important;
          padding-top: 5px !important;
          text-align: center !important;
@@ -659,17 +664,17 @@
                                          width="100%"
                                          class="r13-o"
                                          style="
-                                            background-color: #ecf1ff;
-                                            border-bottom-color: #d9e4ff;
+                                            background-color: #e3e6f1;
+                                            border-bottom-color: #efefef;
                                            border-bottom-width: 1px;
                                            border-collapse: separate;
-                                            border-left-color: #d9e4ff;
+                                            border-left-color: #efefef;
                                            border-left-width: 1px;
                                            border-radius: 5px;
-                                            border-right-color: #d9e4ff;
+                                            border-right-color: #efefef;
                                            border-right-width: 1px;
                                            border-style: solid;
-                                            border-top-color: #d9e4ff;
+                                            border-top-color: #efefef;
                                            border-top-width: 1px;
                                            table-layout: fixed;
                                            width: 100%;
@@ -685,7 +690,7 @@
                                                font-family: georgia, serif;
                                                font-size: 16px;
                                                word-break: break-word;
-                                                background-color: #ecf1ff;
+                                                background-color: #e3e6f1;
                                                border-radius: 4px;
                                                line-height: 3;
                                                padding-bottom: 10px;
@@ -709,10 +714,10 @@
                                                <p style="margin: 0">
                                                  <span
                                                    style="
-                                                      color: #5f5e5e;
+                                                      color: #716c6c;
                                                      font-family: Arial,
                                                        helvetica, sans-serif;
-                                                      font-size: 14px;
+                                                      font-size: 15px;
                                                    "
                                                    >Please copy and paste this
                                                    on the screen where you
@@ -1246,14 +1251,13 @@
                                                                  role="presentation"
                                                                  width="100%"
                                                                  class="r22-o"
+                                                                  class="r24-o"
                                                                  style="
-                                                                    table-layout: fixed;
-                                                                    width: 100%;
-                                                                  "
                                                                >
                                                                  <tr>
                                                                    <td
                                                                      class="r23-i"
+                                                                      class="r17-i"
                                                                      style="
                                                                        font-size: 0px;
                                                                        line-height: 0px;
@@ -1305,7 +1309,7 @@
                                                                  border="0"
                                                                  role="presentation"
                                                                  width="100%"
-                                                                  class="r24-o"
+                                                                  class="r25-o"
                                                                  style="
                                                                    table-layout: fixed;
                                                                    width: 100%;
@@ -1437,7 +1441,7 @@
                                            <td
                                              align="center"
                                              valign="top"
-                                              class="r25-i nl2go-default-textstyle"
+                                              class="r26-i nl2go-default-textstyle"
                                              style="
                                                color: #3b3f44;
                                                font-family: georgia, serif;
@@ -0,0 +1,9 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html>
+    Dear {{username}},<br/>
+    Your requested Issue's data has been successfully exported from Plane. The export includes all relevant information about issues you requested from your selected projects.</br>
+    Please find the attachment and download the CSV file. If you have any questions or need further assistance, please don't hesitate to contact our support team at <a href = "mailto: engineering@plane.com">engineering@plane.so</a>. We're here to help!</br>
+    Thank you for using Plane. We hope this export will aid you in effectively managing your projects.</br>
+    Regards,
+    Team Plane
+</html>
@@ -1,8 +1,8 @@
-## Coolify Setup
+## Coolify Setup 

 Access the `coolify-docker-compose` file [here](https://raw.githubusercontent.com/makeplane/plane/master/deploy/coolify/coolify-docker-compose.yml) or download using using below command

 ```
 curl -fsSL https://raw.githubusercontent.com/makeplane/plane/master/deploy/coolify/coolify-docker-compose.yml

-```
+```
--- a/Show More
+++ b/Show More