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

.deepsource.toml

@@ -0,0 +1,23 @@
+version = 1
+
+exclude_patterns = [  
+  "bin/**",  
+  "**/node_modules/",  
+  "**/*.min.js"  
+]
+
+[[analyzers]]
+name = "shell"
+
+[[analyzers]]
+name = "javascript"
+
+  [analyzers.meta]
+  plugins = ["react"]
+  environment = ["nodejs"]
+
+[[analyzers]]
+name = "python"
+
+  [analyzers.meta]
+  runtime_version = "3.x.x"

.env.example

@@ -21,15 +21,15 @@ AWS_S3_BUCKET_NAME="uploads"
 FILE_SIZE_LIMIT=5242880
 
 # GPT settings
-OPENAI_API_BASE="https://api.openai.com/v1" # change if using a custom endpoint
+OPENAI_API_BASE="https://api.openai.com/v1" # deprecated
-OPENAI_API_KEY="sk-" # add your openai key here
+OPENAI_API_KEY="sk-" # deprecated
-GPT_ENGINE="gpt-3.5-turbo" # use "gpt-4" if you have access
+GPT_ENGINE="gpt-3.5-turbo" # deprecated
 
 # Settings related to Docker
-DOCKERIZED=1
+DOCKERIZED=1  # deprecated
+
 # set to 1 If using the pre-configured minio setup
 USE_MINIO=1
 
 # Nginx Configuration
 NGINX_PORT=80
-

.github/workflows/build-branch.yml

@@ -0,0 +1,227 @@
+name: Branch Build
+
+on:
+  pull_request:
+    types:
+      - closed
+    branches:
+      - master
+      - release
+      - preview
+      - qa
+      - develop
+
+env:
+  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) }}
+    name: Build-Push Web/Space/API/Proxy Docker Image
+    runs-on: ubuntu-20.04
+
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v3.3.0
+
+      - name: Uploading Proxy Source
+        uses: actions/upload-artifact@v3
+        with:
+          name: proxy-src-code
+          path: ./nginx
+      - name: Uploading Backend Source
+        uses: actions/upload-artifact@v3
+        with:
+          name: backend-src-code
+          path: ./apiserver
+      - name: Uploading Web Source
+        uses: actions/upload-artifact@v3
+        with:
+          name: web-src-code
+          path: |
+            ./
+            !./apiserver
+            !./nginx
+            !./deploy
+            !./space
+      - name: Uploading Space Source
+        uses: actions/upload-artifact@v3
+        with:
+          name: space-src-code
+          path: |
+            ./
+            !./apiserver
+            !./nginx
+            !./deploy
+            !./web
+    outputs:
+      gh_branch_name: ${{ env.TARGET_BRANCH }}
+
+  branch_build_push_frontend:
+    runs-on: ubuntu-20.04
+    needs: [branch_build_setup]
+    env:
+      FRONTEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend-private:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+    steps:
+      - name: Set Frontend Docker Tag 
+        run: |
+          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-frontend-private:latest
+          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "release" ] || [ "${{ needs.branch_build_setup.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 }}
+          fi
+          echo "FRONTEND_TAG=${TAG}" >> $GITHUB_ENV
+      - 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: Downloading Web Source Code
+        uses: actions/download-artifact@v3
+        with:
+          name: web-src-code
+
+      - 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: ${{ env.FRONTEND_TAG }}
+          push: true
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
+  branch_build_push_space:
+    runs-on: ubuntu-20.04
+    needs: [branch_build_setup]
+    env:
+      SPACE_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-space-private:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+    steps:
+      - name: Set Space Docker Tag 
+        run: |
+          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-space:latest
+          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "release" ] || [ "${{ needs.branch_build_setup.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 }}
+          fi
+          echo "SPACE_TAG=${TAG}" >> $GITHUB_ENV
+      - 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: Downloading Space Source Code
+        uses: actions/download-artifact@v3
+        with:
+          name: space-src-code
+
+      - name: Build and Push Space to Docker Hub
+        uses: docker/build-push-action@v4.0.0
+        with:
+          context: .
+          file: ./space/Dockerfile.space
+          platforms: linux/amd64
+          tags: ${{ env.SPACE_TAG }}
+          push: true
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
+  branch_build_push_backend:
+    runs-on: ubuntu-20.04
+    needs: [branch_build_setup]
+    env:
+      BACKEND_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-backend-private:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+    steps:
+      - name: Set Backend Docker Tag 
+        run: |
+          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-backend-private:latest
+          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "release" ] || [ "${{ needs.branch_build_setup.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
+          echo "BACKEND_TAG=${TAG}" >> $GITHUB_ENV
+      - 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: Downloading Backend Source Code
+        uses: actions/download-artifact@v3
+        with:
+          name: backend-src-code
+
+      - name: Build and Push Backend to Docker Hub
+        uses: docker/build-push-action@v4.0.0
+        with:
+          context: .
+          file: ./Dockerfile.api
+          platforms: linux/amd64
+          push: true
+          tags: ${{ env.BACKEND_TAG }}
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
+  branch_build_push_proxy:
+    runs-on: ubuntu-20.04
+    needs: [branch_build_setup]
+    env:
+      PROXY_TAG: ${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy-private:${{ needs.branch_build_setup.outputs.gh_branch_name }}
+    steps:
+      - name: Set Proxy Docker Tag 
+        run: |
+          if [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "master" ]; then
+            TAG=${{ secrets.DOCKERHUB_USERNAME }}/plane-proxy-private:latest
+          elif [ "${{ needs.branch_build_setup.outputs.gh_branch_name }}" == "release" ] || [ "${{ needs.branch_build_setup.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
+          echo "PROXY_TAG=${TAG}" >> $GITHUB_ENV
+      - 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: Downloading Proxy Source Code
+        uses: actions/download-artifact@v3
+        with:
+          name: proxy-src-code
+
+      - name: Build and Push Plane-Proxy to Docker Hub
+        uses: docker/build-push-action@v4.0.0
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: linux/amd64
+          tags: ${{ env.PROXY_TAG }}
+          push: true
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}

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

@@ -36,15 +36,13 @@ jobs:
       - name: Build Plane's Main App
         if: steps.changed-files.outputs.web_any_changed == 'true'
         run: |
-          cd web
           yarn
-          yarn build
+          yarn build --filter=web
 
       - name: Build Plane's Deploy App
         if: steps.changed-files.outputs.deploy_any_changed == 'true'
         run: |
-          cd space
           yarn 
-          yarn build
+          yarn build --filter=space
 
 

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

@@ -2,6 +2,8 @@ name: Create PR in Plane EE Repository to sync the changes
 
 on:
   pull_request:
+    branches:
+      - master
     types:
       - closed
 

.gitignore

@@ -16,6 +16,8 @@ node_modules
 
 # Production
 /build
+dist/
+out/
 
 # Misc
 .DS_Store
@@ -73,3 +75,8 @@ pnpm-lock.yaml
 pnpm-workspace.yaml
 
 .npmrc
+.secrets
+tmp/
+## packages
+dist
+.temp/

CODE_OF_CONDUCT.md

@@ -60,7 +60,7 @@ representative at an online or offline event.
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
 reported to the community leaders responsible for enforcement at
-hello@plane.so.
+squawk@plane.so.
 All complaints will be reviewed and investigated promptly and fairly.
 
 All community leaders are obligated to respect the privacy and security of the

CONTRIBUTING.md

@@ -8,8 +8,8 @@ Before submitting a new issue, please search the [issues](https://github.com/mak
 
 While we want to fix all the [issues](https://github.com/makeplane/plane/issues), before fixing a bug we need to be able to reproduce and confirm it. Please provide us with a minimal reproduction scenario using a repository or [Gist](https://gist.github.com/). Having a live, reproducible scenario gives us the information without asking questions back & forth with additional questions like:
 
--   3rd-party libraries being used and their versions
+- 3rd-party libraries being used and their versions
--   a use-case that fails
+- a use-case that fails
 
 Without said minimal reproduction, we won't be able to investigate all [issues](https://github.com/makeplane/plane/issues), and the issue might not be resolved.
 
@@ -19,10 +19,10 @@ You can open a new issue with this [issue form](https://github.com/makeplane/pla
 
 ### Requirements
 
--   Node.js version v16.18.0
+- Node.js version v16.18.0
--   Python version 3.8+
+- Python version 3.8+
--   Postgres version v14
+- Postgres version v14
--   Redis version v6.2.7
+- Redis version v6.2.7
 
 ### Setup the project
 
@@ -81,8 +81,8 @@ If you would like to _implement_ it, an issue with your proposal must be submitt
 
 To ensure consistency throughout the source code, please keep these rules in mind as you are working:
 
--   All features or bug fixes must be tested by one or more specs (unit-tests).
+- All features or bug fixes must be tested by one or more specs (unit-tests).
--   We use [Eslint default rule guide](https://eslint.org/docs/rules/), with minor changes. An automated formatter is available using prettier.
+- We use [Eslint default rule guide](https://eslint.org/docs/rules/), with minor changes. An automated formatter is available using prettier.
 
 ## Need help? Questions and suggestions
 
@@ -90,11 +90,11 @@ Questions, suggestions, and thoughts are most welcome. We can also be reached in
 
 ## Ways to contribute
 
--   Try Plane Cloud and the self hosting platform and give feedback
+- Try Plane Cloud and the self hosting platform and give feedback
--   Add new integrations
+- Add new integrations
--   Help with open [issues](https://github.com/makeplane/plane/issues) or [create your own](https://github.com/makeplane/plane/issues/new/choose)
+- Help with open [issues](https://github.com/makeplane/plane/issues) or [create your own](https://github.com/makeplane/plane/issues/new/choose)
--   Share your thoughts and suggestions with us
+- Share your thoughts and suggestions with us
--   Help create tutorials and blog posts
+- Help create tutorials and blog posts
--   Request a feature by submitting a proposal
+- Request a feature by submitting a proposal
--   Report a bug
+- Report a bug
--   **Improve documentation** - fix incomplete or missing [docs](https://docs.plane.so/), bad wording, examples or explanations.
+- **Improve documentation** - fix incomplete or missing [docs](https://docs.plane.so/), bad wording, examples or explanations.

Dockerfile

@@ -43,8 +43,6 @@ FROM python:3.11.1-alpine3.17 AS backend
 ENV PYTHONDONTWRITEBYTECODE 1
 ENV PYTHONUNBUFFERED 1
 ENV PIP_DISABLE_PIP_VERSION_CHECK=1 
-ENV DJANGO_SETTINGS_MODULE plane.settings.production
-ENV DOCKERIZED 1
 
 WORKDIR /code
 

ENV_SETUP.md

@@ -0,0 +1,145 @@
+# Environment Variables
+
+​
+Environment variables are distributed in various files. Please refer them carefully.
+
+## {PROJECT_FOLDER}/.env
+
+File is available in the project root folder​
+
+```
+# Database Settings
+PGUSER="plane"
+PGPASSWORD="plane"
+PGHOST="plane-db"
+PGDATABASE="plane"
+DATABASE_URL=postgresql://${PGUSER}:${PGPASSWORD}@${PGHOST}/${PGDATABASE}
+​
+# Redis Settings
+REDIS_HOST="plane-redis"
+REDIS_PORT="6379"
+REDIS_URL="redis://${REDIS_HOST}:6379/"
+​
+# AWS Settings
+AWS_REGION=""
+AWS_ACCESS_KEY_ID="access-key"
+AWS_SECRET_ACCESS_KEY="secret-key"
+AWS_S3_ENDPOINT_URL="http://plane-minio:9000"
+# Changing this requires change in the nginx.conf for uploads if using minio setup
+AWS_S3_BUCKET_NAME="uploads"
+# Maximum file upload limit
+FILE_SIZE_LIMIT=5242880
+​
+# GPT settings
+OPENAI_API_BASE="https://api.openai.com/v1" # deprecated
+OPENAI_API_KEY="sk-" # deprecated
+GPT_ENGINE="gpt-3.5-turbo" # deprecated
+​
+# set to 1 If using the pre-configured minio setup
+USE_MINIO=1
+​
+# Nginx Configuration
+NGINX_PORT=80
+```
+
+​
+
+## {PROJECT_FOLDER}/web/.env.example
+
+​
+
+```
+# 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
+
+​
+
+```
+# Backend
+# Debug value for api server use it as 0 for production use
+DEBUG=0
+​
+# Error logs
+SENTRY_DSN=""
+​
+# Database Settings
+PGUSER="plane"
+PGPASSWORD="plane"
+PGHOST="plane-db"
+PGDATABASE="plane"
+DATABASE_URL=postgresql://${PGUSER}:${PGPASSWORD}@${PGHOST}/${PGDATABASE}
+​
+# Redis Settings
+REDIS_HOST="plane-redis"
+REDIS_PORT="6379"
+REDIS_URL="redis://${REDIS_HOST}:6379/"
+​
+# Email Settings
+EMAIL_HOST=""
+EMAIL_HOST_USER=""
+EMAIL_HOST_PASSWORD=""
+EMAIL_PORT=587
+EMAIL_FROM="Team Plane <team@mailer.plane.so>"
+EMAIL_USE_TLS="1"
+EMAIL_USE_SSL="0"
+​
+# AWS Settings
+AWS_REGION=""
+AWS_ACCESS_KEY_ID="access-key"
+AWS_SECRET_ACCESS_KEY="secret-key"
+AWS_S3_ENDPOINT_URL="http://plane-minio:9000"
+# Changing this requires change in the nginx.conf for uploads if using minio setup
+AWS_S3_BUCKET_NAME="uploads"
+# Maximum file upload limit
+FILE_SIZE_LIMIT=5242880
+​
+# GPT settings
+OPENAI_API_BASE="https://api.openai.com/v1" # deprecated
+OPENAI_API_KEY="sk-" # deprecated
+GPT_ENGINE="gpt-3.5-turbo" # deprecated
+​
+# Settings related to Docker
+DOCKERIZED=1  # Deprecated
+
+# Github
+GITHUB_CLIENT_SECRET="" # For fetching release notes
+​
+# set to 1 If using the pre-configured minio setup
+USE_MINIO=1
+​
+# Nginx Configuration
+NGINX_PORT=80
+​
+​
+# SignUps
+ENABLE_SIGNUP="1"
+​
+# Email Redirection URL
+WEB_URL="http://localhost"
+```
+
+## Updates​
+
+- The environment variable NEXT_PUBLIC_API_BASE_URL has been removed from both the web and space projects.
+- The naming convention for containers and images has been updated.
+- The plane-worker image will no longer be maintained, as it has been merged with plane-backend.
+- The Tiptap pro-extension dependency has been removed, eliminating the need for Tiptap API keys.
+- The image name for Plane deployment has been changed to plane-space.

README.md

@@ -7,7 +7,7 @@
 </p>
 
 <h3 align="center"><b>Plane</b></h3>
-<p align="center"><b>Open-source, self-hosted project planning tool</b></p>
+<p align="center"><b>Flexible, extensible open-source project management</b></p>
 
 <p align="center">
 <a href="https://discord.com/invite/A92xrEGCge">
@@ -39,33 +39,31 @@ Meet [Plane](https://plane.so). An open-source software development tool to mana
 
 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).
 
-## ⚡️ Quick start with Docker Compose
+## ⚡️ Contributors Quick Start
 
-### Docker Compose Setup
+### Prerequisite
 
-- Clone the repository
+Development system must have docker engine installed and running.
 
-```bash
+### Steps
-git clone https://github.com/makeplane/plane
-cd plane
-chmod +x setup.sh
-```
 
-- Run setup.sh
+Setting up local environment is extremely easy and straight forward. Follow the below step and you will be ready to contribute
 
-```bash
+1. Clone the code locally using `git clone https://github.com/makeplane/plane.git`
-./setup.sh
+1. Switch to the code folder `cd plane`
-```
+1. Create your feature or fix branch you plan to work on using `git checkout -b <feature-branch-name>`
+1. Open terminal and run `./setup.sh`
+1. Open the code on VSCode or similar equivalent IDE
+1. Review the `.env` files available in various folders. Visit [Environment Setup](./ENV_SETUP.md) to know about various environment variables used in system
+1. Run the docker command to initiate various services `docker compose -f docker-compose-local.yml up -d`
 
-> If running in a cloud env replace localhost with public facing IP address of the VM
+You are ready to make changes to the code. Do not forget to refresh the browser (in case id does not auto-reload)
 
-- Run Docker compose up
+Thats it!
 
-```bash
+## 🍙 Self Hosting
-docker compose up -d
-```
 
-<strong>You can use the default email and password for your first login `captain@plane.so` and `password123`.</strong>
+For self hosting environment setup, visit the [Self Hosting](https://docs.plane.so/self-hosting) documentation page
 
 ## 🚀 Features
 

apiserver/.env.example

@@ -1,10 +1,11 @@
 # Backend
 # Debug value for api server use it as 0 for production use
 DEBUG=0
-DJANGO_SETTINGS_MODULE="plane.settings.production"
+CORS_ALLOWED_ORIGINS=""
 
 # Error logs
 SENTRY_DSN=""
+SENTRY_ENVIRONMENT="development"
 
 # Database Settings
 PGUSER="plane"
@@ -18,15 +19,6 @@ REDIS_HOST="plane-redis"
 REDIS_PORT="6379"
 REDIS_URL="redis://${REDIS_HOST}:6379/"
 
-# Email Settings
-EMAIL_HOST=""
-EMAIL_HOST_USER=""
-EMAIL_HOST_PASSWORD=""
-EMAIL_PORT=587
-EMAIL_FROM="Team Plane <team@mailer.plane.so>"
-EMAIL_USE_TLS="1"
-EMAIL_USE_SSL="0"
-
 # AWS Settings
 AWS_REGION=""
 AWS_ACCESS_KEY_ID="access-key"
@@ -38,24 +30,22 @@ AWS_S3_BUCKET_NAME="uploads"
 FILE_SIZE_LIMIT=5242880
 
 # GPT settings
-OPENAI_API_BASE="https://api.openai.com/v1" # change if using a custom endpoint
+OPENAI_API_BASE="https://api.openai.com/v1" # deprecated
-OPENAI_API_KEY="sk-" # add your openai key here
+OPENAI_API_KEY="sk-" # deprecated
-GPT_ENGINE="gpt-3.5-turbo" # use "gpt-4" if you have access
+GPT_ENGINE="gpt-3.5-turbo" # deprecated
 
 # Github
 GITHUB_CLIENT_SECRET="" # For fetching release notes
 
 # Settings related to Docker
-DOCKERIZED=1
+DOCKERIZED=1 # deprecated
+
 # set to 1 If using the pre-configured minio setup
 USE_MINIO=1
 
 # Nginx Configuration
 NGINX_PORT=80
 
-# Default Creds
-DEFAULT_EMAIL="captain@plane.so"
-DEFAULT_PASSWORD="password123"
 
 # SignUps
 ENABLE_SIGNUP="1"
@@ -70,3 +60,6 @@ ENABLE_MAGIC_LINK_LOGIN="0"
 # Email redirections and minio domain settings
 WEB_URL="http://localhost"
 
+# Gunicorn Workers
+GUNICORN_WORKERS=2
+

apiserver/Dockerfile.api

@@ -43,7 +43,7 @@ USER captain
 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"

apiserver/Dockerfile.dev

@@ -0,0 +1,52 @@
+FROM python:3.11.1-alpine3.17 AS backend
+
+# set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+ENV PIP_DISABLE_PIP_VERSION_CHECK=1 
+
+RUN apk --no-cache add \
+    "bash~=5.2" \
+    "libpq~=15" \
+    "libxslt~=1.1" \
+    "nodejs-current~=19" \
+    "xmlsec~=1.2" \
+    "libffi-dev" \
+    "bash~=5.2" \
+    "g++~=12.2" \
+    "gcc~=12.2" \
+    "cargo~=1.64" \
+    "git~=2" \
+    "make~=4.3" \
+    "postgresql13-dev~=13" \
+    "libc-dev" \
+    "linux-headers"
+
+WORKDIR /code
+
+COPY requirements.txt ./requirements.txt
+ADD requirements ./requirements
+
+RUN pip install -r requirements.txt --compile --no-cache-dir
+
+RUN addgroup -S plane && \
+    adduser -S captain -G plane
+
+RUN chown captain.plane /code
+
+USER captain
+
+# Add in Django deps and generate Django's static files
+
+USER root
+
+# RUN chmod +x ./bin/takeoff ./bin/worker ./bin/beat
+RUN chmod -R 777 /code
+
+USER captain
+
+# Expose container port and run entry point script
+EXPOSE 8000
+
+# CMD [ "./bin/takeoff" ]
+

apiserver/bin/takeoff

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

apiserver/bin/user_script.py

@@ -1,28 +0,0 @@
-import os, sys, random, string
-import uuid
-
-sys.path.append("/code")
-
-os.environ.setdefault("DJANGO_SETTINGS_MODULE", "plane.settings.production")
-import django
-
-django.setup()
-
-from plane.db.models import User
-
-
-def populate():
-    default_email = os.environ.get("DEFAULT_EMAIL", "captain@plane.so")
-    default_password = os.environ.get("DEFAULT_PASSWORD", "password123")
-
-    if not User.objects.filter(email=default_email).exists():
-        user = User.objects.create(email=default_email, username=uuid.uuid4().hex)
-        user.set_password(default_password)
-        user.save()
-        print(f"User created with an email: {default_email}")
-    else:
-        print(f"User already exists with the default email: {default_email}")
-
-
-if __name__ == "__main__":
-    populate()

apiserver/gunicorn.config.py

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

apiserver/package.json

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

apiserver/plane/api/apps.py

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

apiserver/plane/api/middleware/api_authentication.py

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

apiserver/plane/api/permissions/__init__.py

@@ -1,2 +0,0 @@
-from .workspace import WorkSpaceBasePermission, WorkSpaceAdminPermission, WorkspaceEntityPermission, WorkspaceViewerPermission
-from .project import ProjectBasePermission, ProjectEntityPermission, ProjectMemberPermission, ProjectLitePermission

apiserver/plane/api/rate_limit.py

@@ -0,0 +1,41 @@
+from rest_framework.throttling import SimpleRateThrottle
+
+class ApiKeyRateThrottle(SimpleRateThrottle):
+    scope = 'api_key'
+    rate = '60/minute'
+
+    def get_cache_key(self, request, view):
+        # Retrieve the API key from the request header
+        api_key = request.headers.get('X-Api-Key')
+        if not api_key:
+            return None  # Allow the request if there's no API key
+
+        # Use the API key as part of the cache key
+        return f'{self.scope}:{api_key}'
+
+    def allow_request(self, request, view):
+        allowed = super().allow_request(request, view)
+
+        if allowed:
+            now = self.timer()
+            # Calculate the remaining limit and reset time
+            history = self.cache.get(self.key, [])
+
+            # Remove old histories
+            while history and history[-1] <= now - self.duration:
+                history.pop()
+            
+            # Calculate the requests
+            num_requests = len(history)
+
+            # Check available requests
+            available = self.num_requests - num_requests
+
+            # Unix timestamp for when the rate limit will reset
+            reset_time = int(now + self.duration)
+
+            # Add headers
+            request.META['X-RateLimit-Remaining'] = max(0, available)
+            request.META['X-RateLimit-Reset'] = reset_time
+
+        return allowed

apiserver/plane/api/serializers/__init__.py

@@ -1,87 +1,17 @@
-from .base import BaseSerializer
+from .user import UserLiteSerializer
-from .user import UserSerializer, UserLiteSerializer, ChangePasswordSerializer, ResetPasswordSerializer, UserAdminLiteSerializer
+from .workspace import WorkspaceLiteSerializer
-from .workspace import (
+from .project import ProjectSerializer, ProjectLiteSerializer
-    WorkSpaceSerializer,
-    WorkSpaceMemberSerializer,
-    TeamSerializer,
-    WorkSpaceMemberInviteSerializer,
-    WorkspaceLiteSerializer,
-    WorkspaceThemeSerializer,
-    WorkspaceMemberAdminSerializer,
-)
-from .project import (
-    ProjectSerializer,
-    ProjectDetailSerializer,
-    ProjectMemberSerializer,
-    ProjectMemberInviteSerializer,
-    ProjectIdentifierSerializer,
-    ProjectFavoriteSerializer,
-    ProjectLiteSerializer,
-    ProjectMemberLiteSerializer,
-    ProjectDeployBoardSerializer,
-    ProjectMemberAdminSerializer,
-    ProjectPublicMemberSerializer
-)
-from .state import StateSerializer, StateLiteSerializer
-from .view import GlobalViewSerializer, IssueViewSerializer, IssueViewFavoriteSerializer
-from .cycle import CycleSerializer, CycleIssueSerializer, CycleFavoriteSerializer, CycleWriteSerializer
-from .asset import FileAssetSerializer
 from .issue import (
-    IssueCreateSerializer,
-    IssueActivitySerializer,
-    IssueCommentSerializer,
-    IssuePropertySerializer,
-    IssueAssigneeSerializer,
-    LabelSerializer,
     IssueSerializer,
-    IssueFlatSerializer,
+    LabelSerializer,
-    IssueStateSerializer,
     IssueLinkSerializer,
-    IssueLiteSerializer,
     IssueAttachmentSerializer,
-    IssueSubscriberSerializer,
+    IssueCommentSerializer,
-    IssueReactionSerializer,
+    IssueAttachmentSerializer,
-    CommentReactionSerializer,
+    IssueActivitySerializer,
-    IssueVoteSerializer,
+    IssueExpandSerializer,
-    IssueRelationSerializer,
-    RelatedIssueSerializer,
-    IssuePublicSerializer,
 )
-
+from .state import StateLiteSerializer, StateSerializer
-from .module import (
+from .cycle import CycleSerializer, CycleIssueSerializer, CycleLiteSerializer
-    ModuleWriteSerializer,
+from .module import ModuleSerializer, ModuleIssueSerializer, ModuleLiteSerializer
-    ModuleSerializer,
+from .inbox import InboxIssueSerializer
-    ModuleIssueSerializer,
-    ModuleLinkSerializer,
-    ModuleFavoriteSerializer,
-)
-
-from .api_token import APITokenSerializer
-
-from .integration import (
-    IntegrationSerializer,
-    WorkspaceIntegrationSerializer,
-    GithubIssueSyncSerializer,
-    GithubRepositorySerializer,
-    GithubRepositorySyncSerializer,
-    GithubCommentSyncSerializer,
-    SlackProjectSyncSerializer,
-)
-
-from .importer import ImporterSerializer
-
-from .page import PageSerializer, PageBlockSerializer, PageFavoriteSerializer
-
-from .estimate import (
-    EstimateSerializer,
-    EstimatePointSerializer,
-    EstimateReadSerializer,
-)
-
-from .inbox import InboxSerializer, InboxIssueSerializer, IssueStateInboxSerializer
-
-from .analytic import AnalyticViewSerializer
-
-from .notification import NotificationSerializer
-
-from .exporter import ExporterHistorySerializer

apiserver/plane/api/serializers/api_token.py

@@ -1,14 +0,0 @@
-from .base import BaseSerializer
-from plane.db.models import APIToken
-
-
-class APITokenSerializer(BaseSerializer):
-    class Meta:
-        model = APIToken
-        fields = [
-            "label",
-            "user",
-            "user_type",
-            "workspace",
-            "created_at",
-        ]

apiserver/plane/api/serializers/base.py

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

apiserver/plane/api/serializers/cycle.py

@@ -1,67 +1,30 @@
-# Django imports
-from django.db.models.functions import TruncDate
-
 # Third party imports
 from rest_framework import serializers
 
 # Module imports
 from .base import BaseSerializer
-from .user import UserLiteSerializer
+from plane.db.models import Cycle, CycleIssue
-from .issue import IssueStateSerializer
-from .workspace import WorkspaceLiteSerializer
-from .project import ProjectLiteSerializer
-from plane.db.models import Cycle, CycleIssue, CycleFavorite
-
-class CycleWriteSerializer(BaseSerializer):
-
-    def validate(self, data):
-        if data.get("start_date", None) is not None and data.get("end_date", None) is not None and data.get("start_date", None) > data.get("end_date", None):
-            raise serializers.ValidationError("Start date cannot exceed end date")
-        return data
-
-    class Meta:
-        model = Cycle
-        fields = "__all__"
 
 
 class CycleSerializer(BaseSerializer):
-    owned_by = UserLiteSerializer(read_only=True)
-    is_favorite = serializers.BooleanField(read_only=True)
     total_issues = serializers.IntegerField(read_only=True)
     cancelled_issues = serializers.IntegerField(read_only=True)
     completed_issues = serializers.IntegerField(read_only=True)
     started_issues = serializers.IntegerField(read_only=True)
     unstarted_issues = serializers.IntegerField(read_only=True)
     backlog_issues = serializers.IntegerField(read_only=True)
-    assignees = serializers.SerializerMethodField(read_only=True)
     total_estimates = serializers.IntegerField(read_only=True)
     completed_estimates = serializers.IntegerField(read_only=True)
     started_estimates = serializers.IntegerField(read_only=True)
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
 
     def validate(self, data):
-        if data.get("start_date", None) is not None and data.get("end_date", None) is not None and data.get("start_date", None) > data.get("end_date", None):
+        if (
+            data.get("start_date", None) is not None
+            and data.get("end_date", None) is not None
+            and data.get("start_date", None) > data.get("end_date", None)
+        ):
             raise serializers.ValidationError("Start date cannot exceed end date")
         return data
-    
-    def get_assignees(self, obj):
-        members = [
-            {
-                "avatar": assignee.avatar,
-                "display_name": assignee.display_name,
-                "id": assignee.id,
-            }
-            for issue_cycle in obj.issue_cycle.prefetch_related("issue__assignees").all()
-            for assignee in issue_cycle.issue.assignees.all()
-        ]
-        # Use a set comprehension to return only the unique objects
-        unique_objects = {frozenset(item.items()) for item in members}
-
-        # Convert the set back to a list of dictionaries
-        unique_list = [dict(item) for item in unique_objects]
-
-        return unique_list
 
     class Meta:
         model = Cycle
@@ -74,7 +37,6 @@ class CycleSerializer(BaseSerializer):
 
 
 class CycleIssueSerializer(BaseSerializer):
-    issue_detail = IssueStateSerializer(read_only=True, source="issue")
     sub_issues_count = serializers.IntegerField(read_only=True)
 
     class Meta:
@@ -87,14 +49,8 @@ class CycleIssueSerializer(BaseSerializer):
         ]
 
 
-class CycleFavoriteSerializer(BaseSerializer):
+class CycleLiteSerializer(BaseSerializer):
-    cycle_detail = CycleSerializer(source="cycle", read_only=True)
 
     class Meta:
-        model = CycleFavorite
+        model = Cycle
-        fields = "__all__"
+        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "user",
-        ]

apiserver/plane/api/serializers/inbox.py

@@ -1,58 +1,19 @@
-# Third party frameworks
+# Module improts
-from rest_framework import serializers
-
-# Module imports
 from .base import BaseSerializer
-from .issue import IssueFlatSerializer, LabelLiteSerializer
+from plane.db.models import InboxIssue
-from .project import ProjectLiteSerializer
-from .state import StateLiteSerializer
-from .project import ProjectLiteSerializer
-from .user import UserLiteSerializer
-from plane.db.models import Inbox, InboxIssue, Issue
-
-
-class InboxSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
-    pending_issue_count = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = Inbox
-        fields = "__all__"
-        read_only_fields = [
-            "project",
-            "workspace",
-        ]
-
 
 class InboxIssueSerializer(BaseSerializer):
-    issue_detail = IssueFlatSerializer(source="issue", read_only=True)
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
 
     class Meta:
         model = InboxIssue
         fields = "__all__"
         read_only_fields = [
-            "project",
+            "id",
             "workspace",
-        ]
+            "project",
-
+            "issue",
-
+            "created_by",
-class InboxIssueLiteSerializer(BaseSerializer):
+            "updated_by",
-    class Meta:
+            "created_at",
-        model = InboxIssue
+            "updated_at",
-        fields = ["id", "status", "duplicate_to", "snoozed_till", "source"]
+        ]
-        read_only_fields = fields
-
-
-class IssueStateInboxSerializer(BaseSerializer):
-    state_detail = StateLiteSerializer(read_only=True, source="state")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
-    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
-    sub_issues_count = serializers.IntegerField(read_only=True)
-    bridge_id = serializers.UUIDField(read_only=True)
-    issue_inbox = InboxIssueLiteSerializer(read_only=True, many=True)
-
-    class Meta:
-        model = Issue
-        fields = "__all__"

apiserver/plane/api/serializers/issue.py

@@ -1,88 +1,41 @@
 # Django imports
 from django.utils import timezone
 
-# Third Party imports
+#  Third party imports
 from rest_framework import serializers
 
 # Module imports
-from .base import BaseSerializer
-from .user import UserLiteSerializer
-from .state import StateSerializer, StateLiteSerializer
-from .user import UserLiteSerializer
-from .project import ProjectSerializer, ProjectLiteSerializer
-from .workspace import WorkspaceLiteSerializer
 from plane.db.models import (
     User,
     Issue,
-    IssueActivity,
+    State,
-    IssueComment,
-    IssueProperty,
     IssueAssignee,
-    IssueSubscriber,
-    IssueLabel,
     Label,
-    CycleIssue,
+    IssueLabel,
-    Cycle,
-    Module,
-    ModuleIssue,
     IssueLink,
+    IssueComment,
     IssueAttachment,
-    IssueReaction,
+    IssueActivity,
-    CommentReaction,
+    ProjectMember,
-    IssueVote,
-    IssueRelation,
 )
+from .base import BaseSerializer
+from .cycle import CycleSerializer, CycleLiteSerializer
+from .module import ModuleSerializer, ModuleLiteSerializer
 
 
-class IssueFlatSerializer(BaseSerializer):
+class IssueSerializer(BaseSerializer):
-    ## Contain only flat fields
+    assignees = serializers.ListField(
-
+        child=serializers.PrimaryKeyRelatedField(
-    class Meta:
+            queryset=User.objects.values_list("id", flat=True)
-        model = Issue
+        ),
-        fields = [
-            "id",
-            "name",
-            "description",
-            "description_html",
-            "priority",
-            "start_date",
-            "target_date",
-            "sequence_id",
-            "sort_order",
-            "is_draft",
-        ]
-
-
-class IssueProjectLiteSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
-
-    class Meta:
-        model = Issue
-        fields = [
-            "id",
-            "project_detail",
-            "name",
-            "sequence_id",
-        ]
-        read_only_fields = fields
-
-
-##TODO: Find a better way to write this serializer
-## Find a better approach to save manytomany?
-class IssueCreateSerializer(BaseSerializer):
-    state_detail = StateSerializer(read_only=True, source="state")
-    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-
-    assignees_list = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
         write_only=True,
         required=False,
     )
 
-    labels_list = serializers.ListField(
+    labels = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
+        child=serializers.PrimaryKeyRelatedField(
+            queryset=Label.objects.values_list("id", flat=True)
+        ),
         write_only=True,
         required=False,
     )
@@ -91,6 +44,7 @@ class IssueCreateSerializer(BaseSerializer):
         model = Issue
         fields = "__all__"
         read_only_fields = [
+            "id",
             "workspace",
             "project",
             "created_by",
@@ -106,11 +60,49 @@ class IssueCreateSerializer(BaseSerializer):
             and data.get("start_date", None) > data.get("target_date", None)
         ):
             raise serializers.ValidationError("Start date cannot exceed target date")
+
+        # Validate assignees are from project
+        if data.get("assignees", []):
+            data["assignees"] = ProjectMember.objects.filter(
+                project_id=self.context.get("project_id"),
+                is_active=True,
+                member_id__in=data["assignees"],
+            ).values_list("member_id", flat=True)
+
+        # Validate labels are from project
+        if data.get("labels", []):
+            data["labels"] = Label.objects.filter(
+                project_id=self.context.get("project_id"),
+                id__in=data["labels"],
+            ).values_list("id", flat=True)
+
+        # Check state is from the project only else raise validation error
+        if (
+            data.get("state")
+            and not State.objects.filter(
+                project_id=self.context.get("project_id"), pk=data.get("state")
+            ).exists()
+        ):
+            raise serializers.ValidationError(
+                "State is not valid please pass a valid state_id"
+            )
+
+        # Check parent issue is from workspace as it can be cross workspace
+        if (
+            data.get("parent")
+            and not Issue.objects.filter(
+                workspace_id=self.context.get("workspace_id"), pk=data.get("parent")
+            ).exists()
+        ):
+            raise serializers.ValidationError(
+                "Parent is not valid issue_id please pass a valid issue_id"
+            )
+
         return data
 
     def create(self, validated_data):
-        assignees = validated_data.pop("assignees_list", None)
+        assignees = validated_data.pop("assignees", None)
-        labels = validated_data.pop("labels_list", None)
+        labels = validated_data.pop("labels", None)
 
         project_id = self.context["project_id"]
         workspace_id = self.context["workspace_id"]
@@ -126,14 +118,14 @@ class IssueCreateSerializer(BaseSerializer):
             IssueAssignee.objects.bulk_create(
                 [
                     IssueAssignee(
-                        assignee=user,
+                        assignee_id=assignee_id,
                         issue=issue,
                         project_id=project_id,
                         workspace_id=workspace_id,
                         created_by_id=created_by_id,
                         updated_by_id=updated_by_id,
                     )
-                    for user in assignees
+                    for assignee_id in assignees
                 ],
                 batch_size=10,
             )
@@ -153,14 +145,14 @@ class IssueCreateSerializer(BaseSerializer):
             IssueLabel.objects.bulk_create(
                 [
                     IssueLabel(
-                        label=label,
+                        label_id=label_id,
                         issue=issue,
                         project_id=project_id,
                         workspace_id=workspace_id,
                         created_by_id=created_by_id,
                         updated_by_id=updated_by_id,
                     )
-                    for label in labels
+                    for label_id in labels
                 ],
                 batch_size=10,
             )
@@ -168,8 +160,8 @@ class IssueCreateSerializer(BaseSerializer):
         return issue
 
     def update(self, instance, validated_data):
-        assignees = validated_data.pop("assignees_list", None)
+        assignees = validated_data.pop("assignees", None)
-        labels = validated_data.pop("labels_list", None)
+        labels = validated_data.pop("labels", None)
 
         # Related models
         project_id = instance.project_id
@@ -182,14 +174,14 @@ class IssueCreateSerializer(BaseSerializer):
             IssueAssignee.objects.bulk_create(
                 [
                     IssueAssignee(
-                        assignee=user,
+                        assignee_id=assignee_id,
                         issue=instance,
                         project_id=project_id,
                         workspace_id=workspace_id,
                         created_by_id=created_by_id,
                         updated_by_id=updated_by_id,
                     )
-                    for user in assignees
+                    for assignee_id in assignees
                 ],
                 batch_size=10,
             )
@@ -199,14 +191,14 @@ class IssueCreateSerializer(BaseSerializer):
             IssueLabel.objects.bulk_create(
                 [
                     IssueLabel(
-                        label=label,
+                        label_id=label_id,
                         issue=instance,
                         project_id=project_id,
                         workspace_id=workspace_id,
                         created_by_id=created_by_id,
                         updated_by_id=updated_by_id,
                     )
-                    for label in labels
+                    for label_id in labels
                 ],
                 batch_size=10,
             )
@@ -215,177 +207,34 @@ class IssueCreateSerializer(BaseSerializer):
         instance.updated_at = timezone.now()
         return super().update(instance, validated_data)
 
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        if "assignees" in self.fields:
+            if "assignees" in self.expand:
+                from .user import UserLiteSerializer
 
-class IssueActivitySerializer(BaseSerializer):
+                data["assignees"] = UserLiteSerializer(
-    actor_detail = UserLiteSerializer(read_only=True, source="actor")
+                    instance.assignees.all(), many=True
-    issue_detail = IssueFlatSerializer(read_only=True, source="issue")
+                ).data
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+            else:
+                data["assignees"] = [
+                    str(assignee.id) for assignee in instance.assignees.all()
+                ]
+        if "labels" in self.fields:
+            if "labels" in self.expand:
+                data["labels"] = LabelSerializer(instance.labels.all(), many=True).data
+            else:
+                data["labels"] = [str(label.id) for label in instance.labels.all()]
 
-    class Meta:
+        return data
-        model = IssueActivity
-        fields = "__all__"
-
-
-class IssueCommentSerializer(BaseSerializer):
-    actor_detail = UserLiteSerializer(read_only=True, source="actor")
-    issue_detail = IssueFlatSerializer(read_only=True, source="issue")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-
-    class Meta:
-        model = IssueComment
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssuePropertySerializer(BaseSerializer):
-    class Meta:
-        model = IssueProperty
-        fields = "__all__"
-        read_only_fields = [
-            "user",
-            "workspace",
-            "project",
-        ]
 
 
 class LabelSerializer(BaseSerializer):
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
-
     class Meta:
         model = Label
         fields = "__all__"
         read_only_fields = [
-            "workspace",
-            "project",
-        ]
-
-
-class LabelLiteSerializer(BaseSerializer):
-    class Meta:
-        model = Label
-        fields = [
             "id",
-            "name",
-            "color",
-        ]
-
-
-class IssueLabelSerializer(BaseSerializer):
-    # label_details = LabelSerializer(read_only=True, source="label")
-
-    class Meta:
-        model = IssueLabel
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-        ]
-
-
-class IssueRelationSerializer(BaseSerializer):
-    issue_detail = IssueProjectLiteSerializer(read_only=True, source="related_issue")
-
-    class Meta:
-        model = IssueRelation
-        fields = [
-            "issue_detail",
-            "relation_type",
-            "related_issue",
-            "issue",
-            "id"
-        ]
-        read_only_fields = [
-            "workspace",
-            "project",
-        ]
-
-class RelatedIssueSerializer(BaseSerializer):
-    issue_detail = IssueProjectLiteSerializer(read_only=True, source="issue")
-
-    class Meta:
-        model = IssueRelation
-        fields = [
-            "issue_detail",
-            "relation_type",
-            "related_issue",
-            "issue",
-            "id"
-        ]
-        read_only_fields = [
-            "workspace",
-            "project",
-        ]
-
-
-class IssueAssigneeSerializer(BaseSerializer):
-    assignee_details = UserLiteSerializer(read_only=True, source="assignee")
-
-    class Meta:
-        model = IssueAssignee
-        fields = "__all__"
-
-
-class CycleBaseSerializer(BaseSerializer):
-    class Meta:
-        model = Cycle
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueCycleDetailSerializer(BaseSerializer):
-    cycle_detail = CycleBaseSerializer(read_only=True, source="cycle")
-
-    class Meta:
-        model = CycleIssue
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class ModuleBaseSerializer(BaseSerializer):
-    class Meta:
-        model = Module
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueModuleDetailSerializer(BaseSerializer):
-    module_detail = ModuleBaseSerializer(read_only=True, source="module")
-
-    class Meta:
-        model = ModuleIssue
-        fields = "__all__"
-        read_only_fields = [
             "workspace",
             "project",
             "created_by",
@@ -396,19 +245,18 @@ class IssueModuleDetailSerializer(BaseSerializer):
 
 
 class IssueLinkSerializer(BaseSerializer):
-    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
-
     class Meta:
         model = IssueLink
         fields = "__all__"
         read_only_fields = [
+            "id",
             "workspace",
             "project",
+            "issue",
             "created_by",
             "updated_by",
             "created_at",
             "updated_at",
-            "issue",
         ]
 
     # Validation if url already exists
@@ -427,73 +275,25 @@ class IssueAttachmentSerializer(BaseSerializer):
         model = IssueAttachment
         fields = "__all__"
         read_only_fields = [
+            "id",
+            "workspace",
+            "project",
+            "issue",
             "created_by",
             "updated_by",
             "created_at",
             "updated_at",
-            "workspace",
-            "project",
-            "issue",
         ]
 
 
-class IssueReactionSerializer(BaseSerializer):
-    
-    actor_detail = UserLiteSerializer(read_only=True, source="actor")
-    
-    class Meta:
-        model = IssueReaction
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "issue",
-            "actor",
-        ]
-
-
-class CommentReactionLiteSerializer(BaseSerializer):
-    actor_detail = UserLiteSerializer(read_only=True, source="actor")
-
-    class Meta:
-        model = CommentReaction
-        fields = [
-            "id",
-            "reaction",
-            "comment",
-            "actor_detail",
-        ]
-
-
-class CommentReactionSerializer(BaseSerializer):
-    class Meta:
-        model = CommentReaction
-        fields = "__all__"
-        read_only_fields = ["workspace", "project", "comment", "actor"]
-
-
-class IssueVoteSerializer(BaseSerializer):
-
-    actor_detail = UserLiteSerializer(read_only=True, source="actor")
-
-    class Meta:
-        model = IssueVote
-        fields = ["issue", "vote", "workspace", "project", "actor", "actor_detail"]
-        read_only_fields = fields
-
-
 class IssueCommentSerializer(BaseSerializer):
-    actor_detail = UserLiteSerializer(read_only=True, source="actor")
-    issue_detail = IssueFlatSerializer(read_only=True, source="issue")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-    comment_reactions = CommentReactionLiteSerializer(read_only=True, many=True)
     is_member = serializers.BooleanField(read_only=True)
 
     class Meta:
         model = IssueComment
         fields = "__all__"
         read_only_fields = [
+            "id",
             "workspace",
             "project",
             "issue",
@@ -504,127 +304,49 @@ class IssueCommentSerializer(BaseSerializer):
         ]
 
 
-class IssueStateFlatSerializer(BaseSerializer):
+class IssueActivitySerializer(BaseSerializer):
-    state_detail = StateLiteSerializer(read_only=True, source="state")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-
     class Meta:
-        model = Issue
+        model = IssueActivity
-        fields = [
+        exclude = [
-            "id",
+            "created_by",
-            "sequence_id",
+            "updated_by",
-            "name",
-            "state_detail",
-            "project_detail",
         ]
 
 
-# Issue Serializer with state details
+class CycleIssueSerializer(BaseSerializer):
-class IssueStateSerializer(BaseSerializer):
+    cycle = CycleSerializer(read_only=True)
-    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
-    state_detail = StateLiteSerializer(read_only=True, source="state")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
-    sub_issues_count = serializers.IntegerField(read_only=True)
-    bridge_id = serializers.UUIDField(read_only=True)
-    attachment_count = serializers.IntegerField(read_only=True)
-    link_count = serializers.IntegerField(read_only=True)
 
     class Meta:
-        model = Issue
+        fields = [
-        fields = "__all__"
+            "cycle",
+        ]
 
 
-class IssueSerializer(BaseSerializer):
+class ModuleIssueSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    module = ModuleSerializer(read_only=True)
-    state_detail = StateSerializer(read_only=True, source="state")
+
-    parent_detail = IssueStateFlatSerializer(read_only=True, source="parent")
+    class Meta:
-    label_details = LabelSerializer(read_only=True, source="labels", many=True)
+        fields = [
-    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
+            "module",
-    related_issues = IssueRelationSerializer(read_only=True, source="issue_relation", many=True)
+        ]
-    issue_relations = RelatedIssueSerializer(read_only=True, source="issue_related", many=True)
+
-    issue_cycle = IssueCycleDetailSerializer(read_only=True)
+
-    issue_module = IssueModuleDetailSerializer(read_only=True)
+class IssueExpandSerializer(BaseSerializer):
-    issue_link = IssueLinkSerializer(read_only=True, many=True)
+    # Serialize the related cycle. It's a OneToOne relation.
-    issue_attachment = IssueAttachmentSerializer(read_only=True, many=True)
+    cycle = CycleLiteSerializer(source="issue_cycle.cycle", read_only=True)
-    sub_issues_count = serializers.IntegerField(read_only=True)
+
-    issue_reactions = IssueReactionSerializer(read_only=True, many=True)
+    # Serialize the related module. It's a OneToOne relation.
+    module = ModuleLiteSerializer(source="issue_module.module", read_only=True)
 
     class Meta:
         model = Issue
         fields = "__all__"
         read_only_fields = [
+            "id",
             "workspace",
             "project",
             "created_by",
             "updated_by",
             "created_at",
             "updated_at",
-        ]
+        ]
-
-
-class IssueLiteSerializer(BaseSerializer):
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    state_detail = StateLiteSerializer(read_only=True, source="state")
-    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
-    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
-    sub_issues_count = serializers.IntegerField(read_only=True)
-    cycle_id = serializers.UUIDField(read_only=True)
-    module_id = serializers.UUIDField(read_only=True)
-    attachment_count = serializers.IntegerField(read_only=True)
-    link_count = serializers.IntegerField(read_only=True)
-    issue_reactions = IssueReactionSerializer(read_only=True, many=True)
-
-    class Meta:
-        model = Issue
-        fields = "__all__"
-        read_only_fields = [
-            "start_date",
-            "target_date",
-            "completed_at",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssuePublicSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    state_detail = StateLiteSerializer(read_only=True, source="state")
-    reactions = IssueReactionSerializer(read_only=True, many=True, source="issue_reactions")
-    votes = IssueVoteSerializer(read_only=True, many=True)
-
-    class Meta:
-        model = Issue
-        fields = [
-            "id",
-            "name",
-            "description_html",
-            "sequence_id",
-            "state",
-            "state_detail",
-            "project",
-            "project_detail",
-            "workspace",
-            "priority",
-            "target_date",
-            "reactions",
-            "votes",
-        ]
-        read_only_fields = fields
-
-
-
-class IssueSubscriberSerializer(BaseSerializer):
-    class Meta:
-        model = IssueSubscriber
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "issue",
-        ]

apiserver/plane/api/serializers/module.py

@@ -1,37 +1,38 @@
-# Third Party imports
+# Third party imports
 from rest_framework import serializers
 
 # Module imports
 from .base import BaseSerializer
-from .user import UserLiteSerializer
-from .project import ProjectSerializer, ProjectLiteSerializer
-from .workspace import WorkspaceLiteSerializer
-from .issue import IssueStateSerializer
-
 from plane.db.models import (
     User,
     Module,
+    ModuleLink,
     ModuleMember,
     ModuleIssue,
-    ModuleLink,
+    ProjectMember,
-    ModuleFavorite,
 )
 
 
-class ModuleWriteSerializer(BaseSerializer):
+class ModuleSerializer(BaseSerializer):
-    members_list = serializers.ListField(
+    members = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
+        child=serializers.PrimaryKeyRelatedField(
+            queryset=User.objects.values_list("id", flat=True)
+        ),
         write_only=True,
         required=False,
     )
-
+    total_issues = serializers.IntegerField(read_only=True)
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+    cancelled_issues = serializers.IntegerField(read_only=True)
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+    completed_issues = serializers.IntegerField(read_only=True)
+    started_issues = serializers.IntegerField(read_only=True)
+    unstarted_issues = serializers.IntegerField(read_only=True)
+    backlog_issues = serializers.IntegerField(read_only=True)
 
     class Meta:
         model = Module
         fields = "__all__"
         read_only_fields = [
+            "id",
             "workspace",
             "project",
             "created_by",
@@ -40,13 +41,29 @@ class ModuleWriteSerializer(BaseSerializer):
             "updated_at",
         ]
 
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        data["members"] = [str(member.id) for member in instance.members.all()]
+        return data
+
     def validate(self, data):
-        if data.get("start_date", None) is not None and data.get("target_date", None) is not None and data.get("start_date", None) > data.get("target_date", None):
+        if (
+            data.get("start_date", None) is not None
+            and data.get("target_date", None) is not None
+            and data.get("start_date", None) > data.get("target_date", None)
+        ):
             raise serializers.ValidationError("Start date cannot exceed target date")
-        return data    
+
+        if data.get("members", []):
+            data["members"] = ProjectMember.objects.filter(
+                project_id=self.context.get("project_id"),
+                member_id__in=data["members"],
+            ).values_list("member_id", flat=True)
+
+        return data
 
     def create(self, validated_data):
-        members = validated_data.pop("members_list", None)
+        members = validated_data.pop("members", None)
 
         project = self.context["project"]
 
@@ -72,7 +89,7 @@ class ModuleWriteSerializer(BaseSerializer):
         return module
 
     def update(self, instance, validated_data):
-        members = validated_data.pop("members_list", None)
+        members = validated_data.pop("members", None)
 
         if members is not None:
             ModuleMember.objects.filter(module=instance).delete()
@@ -95,23 +112,7 @@ class ModuleWriteSerializer(BaseSerializer):
         return super().update(instance, validated_data)
 
 
-class ModuleFlatSerializer(BaseSerializer):
-    class Meta:
-        model = Module
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
 class ModuleIssueSerializer(BaseSerializer):
-    module_detail = ModuleFlatSerializer(read_only=True, source="module")
-    issue_detail = ProjectLiteSerializer(read_only=True, source="issue")
     sub_issues_count = serializers.IntegerField(read_only=True)
 
     class Meta:
@@ -129,8 +130,6 @@ class ModuleIssueSerializer(BaseSerializer):
 
 
 class ModuleLinkSerializer(BaseSerializer):
-    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
-
     class Meta:
         model = ModuleLink
         fields = "__all__"
@@ -153,42 +152,10 @@ class ModuleLinkSerializer(BaseSerializer):
                 {"error": "URL already exists for this Issue"}
             )
         return ModuleLink.objects.create(**validated_data)
+    
 
-
+class ModuleLiteSerializer(BaseSerializer):
-class ModuleSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    lead_detail = UserLiteSerializer(read_only=True, source="lead")
-    members_detail = UserLiteSerializer(read_only=True, many=True, source="members")
-    link_module = ModuleLinkSerializer(read_only=True, many=True)
-    is_favorite = serializers.BooleanField(read_only=True)
-    total_issues = serializers.IntegerField(read_only=True)
-    cancelled_issues = serializers.IntegerField(read_only=True)
-    completed_issues = serializers.IntegerField(read_only=True)
-    started_issues = serializers.IntegerField(read_only=True)
-    unstarted_issues = serializers.IntegerField(read_only=True)
-    backlog_issues = serializers.IntegerField(read_only=True)
 
     class Meta:
         model = Module
-        fields = "__all__"
+        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class ModuleFavoriteSerializer(BaseSerializer):
-    module_detail = ModuleFlatSerializer(source="module", read_only=True)
-
-    class Meta:
-        model = ModuleFavorite
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "user",
-        ]

apiserver/plane/api/serializers/project.py

@@ -1,34 +1,60 @@
-# Django imports
-from django.db import IntegrityError
-
 # Third party imports
 from rest_framework import serializers
 
 # Module imports
+from plane.db.models import Project, ProjectIdentifier, WorkspaceMember, State, Estimate
 from .base import BaseSerializer
-from plane.api.serializers.workspace import WorkSpaceSerializer, WorkspaceLiteSerializer
-from plane.api.serializers.user import UserLiteSerializer, UserAdminLiteSerializer
-from plane.db.models import (
-    Project,
-    ProjectMember,
-    ProjectMemberInvite,
-    ProjectIdentifier,
-    ProjectFavorite,
-    ProjectDeployBoard,
-    ProjectPublicMember,
-)
 
 
 class ProjectSerializer(BaseSerializer):
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+
+    total_members = serializers.IntegerField(read_only=True)
+    total_cycles = serializers.IntegerField(read_only=True)
+    total_modules = serializers.IntegerField(read_only=True)
+    is_member = serializers.BooleanField(read_only=True)
+    sort_order = serializers.FloatField(read_only=True)
+    member_role = serializers.IntegerField(read_only=True)
+    is_deployed = serializers.BooleanField(read_only=True)
 
     class Meta:
         model = Project
         fields = "__all__"
         read_only_fields = [
+            "id",
             "workspace",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
         ]
 
+    def validate(self, data):
+        # Check project lead should be a member of the workspace
+        if (
+            data.get("project_lead", None) is not None
+            and not WorkspaceMember.objects.filter(
+                workspace_id=self.context["workspace_id"],
+                member_id=data.get("project_lead"),
+            ).exists()
+        ):
+            raise serializers.ValidationError(
+                "Project lead should be a user in the workspace"
+            )
+
+        # Check default assignee should be a member of the workspace
+        if (
+            data.get("default_assignee", None) is not None
+            and not WorkspaceMember.objects.filter(
+                workspace_id=self.context["workspace_id"],
+                member_id=data.get("default_assignee"),
+            ).exists()
+        ):
+            raise serializers.ValidationError(
+                "Default assignee should be a user in the workspace"
+            )
+
+        return data
+
     def create(self, validated_data):
         identifier = validated_data.get("identifier", "").strip().upper()
         if identifier == "":
@@ -38,6 +64,7 @@ class ProjectSerializer(BaseSerializer):
             name=identifier, workspace_id=self.context["workspace_id"]
         ).exists():
             raise serializers.ValidationError(detail="Project Identifier is taken")
+
         project = Project.objects.create(
             **validated_data, workspace_id=self.context["workspace_id"]
         )
@@ -48,36 +75,6 @@ class ProjectSerializer(BaseSerializer):
         )
         return project
 
-    def update(self, instance, validated_data):
-        identifier = validated_data.get("identifier", "").strip().upper()
-
-        # If identifier is not passed update the project and return
-        if identifier == "":
-            project = super().update(instance, validated_data)
-            return project
-
-        # If no Project Identifier is found create it
-        project_identifier = ProjectIdentifier.objects.filter(
-            name=identifier, workspace_id=instance.workspace_id
-        ).first()
-        if project_identifier is None:
-            project = super().update(instance, validated_data)
-            project_identifier = ProjectIdentifier.objects.filter(
-                project=project
-            ).first()
-            if project_identifier is not None:
-                project_identifier.name = identifier
-                project_identifier.save()
-            return project
-        # If found check if the project_id to be updated and identifier project id is same
-        if project_identifier.project_id == instance.id:
-            # If same pass update
-            project = super().update(instance, validated_data)
-            return project
-
-        # If not same fail update
-        raise serializers.ValidationError(detail="Project Identifier is already taken")
-
 
 class ProjectLiteSerializer(BaseSerializer):
     class Meta:
@@ -91,104 +88,4 @@ class ProjectLiteSerializer(BaseSerializer):
             "emoji",
             "description",
         ]
-        read_only_fields = fields
+        read_only_fields = fields
-
-
-class ProjectDetailSerializer(BaseSerializer):
-    workspace = WorkSpaceSerializer(read_only=True)
-    default_assignee = UserLiteSerializer(read_only=True)
-    project_lead = UserLiteSerializer(read_only=True)
-    is_favorite = serializers.BooleanField(read_only=True)
-    total_members = serializers.IntegerField(read_only=True)
-    total_cycles = serializers.IntegerField(read_only=True)
-    total_modules = serializers.IntegerField(read_only=True)
-    is_member = serializers.BooleanField(read_only=True)
-    sort_order = serializers.FloatField(read_only=True)
-    member_role = serializers.IntegerField(read_only=True)
-    is_deployed = serializers.BooleanField(read_only=True)
-
-    class Meta:
-        model = Project
-        fields = "__all__"
-
-
-class ProjectMemberSerializer(BaseSerializer):
-    workspace = WorkspaceLiteSerializer(read_only=True)
-    project = ProjectLiteSerializer(read_only=True)
-    member = UserLiteSerializer(read_only=True)
-
-    class Meta:
-        model = ProjectMember
-        fields = "__all__"
-
-
-class ProjectMemberAdminSerializer(BaseSerializer):
-    workspace = WorkspaceLiteSerializer(read_only=True)
-    project = ProjectLiteSerializer(read_only=True)
-    member = UserAdminLiteSerializer(read_only=True)
-
-    class Meta:
-        model = ProjectMember
-        fields = "__all__"
-
-
-class ProjectMemberInviteSerializer(BaseSerializer):
-    project = ProjectLiteSerializer(read_only=True)
-    workspace = WorkspaceLiteSerializer(read_only=True)
-
-    class Meta:
-        model = ProjectMemberInvite
-        fields = "__all__"
-
-
-class ProjectIdentifierSerializer(BaseSerializer):
-    class Meta:
-        model = ProjectIdentifier
-        fields = "__all__"
-
-
-class ProjectFavoriteSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
-
-    class Meta:
-        model = ProjectFavorite
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "user",
-        ]
-
-
-class ProjectMemberLiteSerializer(BaseSerializer):
-    member = UserLiteSerializer(read_only=True)
-    is_subscribed = serializers.BooleanField(read_only=True)
-
-    class Meta:
-        model = ProjectMember
-        fields = ["member", "id", "is_subscribed"]
-        read_only_fields = fields
-
-
-class ProjectDeployBoardSerializer(BaseSerializer):
-    project_details = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-
-    class Meta:
-        model = ProjectDeployBoard
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project", "anchor",
-        ]
-
-
-class ProjectPublicMemberSerializer(BaseSerializer):
-
-    class Meta:
-        model = ProjectPublicMember
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "member",
-        ]

apiserver/plane/api/serializers/state.py

@@ -1,14 +1,16 @@
 # Module imports
 from .base import BaseSerializer
-from .workspace import WorkspaceLiteSerializer
-from .project import ProjectLiteSerializer
-
 from plane.db.models import State
 
 
 class StateSerializer(BaseSerializer):
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+    def validate(self, data):
-    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+        # If the default is being provided then make all other states default False
+        if data.get("default", False):
+            State.objects.filter(project_id=self.context.get("project_id")).update(
+                default=False
+            )
+        return data
 
     class Meta:
         model = State
@@ -28,4 +30,4 @@ class StateLiteSerializer(BaseSerializer):
             "color",
             "group",
         ]
-        read_only_fields = fields
+        read_only_fields = fields

apiserver/plane/api/serializers/user.py

@@ -1,36 +1,6 @@
-# Third party imports
+# Module imports
-from rest_framework import serializers
-
-# Module import
-from .base import BaseSerializer
 from plane.db.models import User
-
+from .base import BaseSerializer
-
-class UserSerializer(BaseSerializer):
-    class Meta:
-        model = User
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "created_at",
-            "updated_at",
-            "is_superuser",
-            "is_staff",
-            "last_active",
-            "last_login_time",
-            "last_logout_time",
-            "last_login_ip",
-            "last_logout_ip",
-            "last_login_uagent",
-            "token_updated_at",
-            "is_onboarded",
-            "is_bot",
-        ]
-        extra_kwargs = {"password": {"write_only": True}}
-
-        # If the user has already filled first name or last name then he is onboarded
-        def get_is_onboarded(self, obj):
-            return bool(obj.first_name) or bool(obj.last_name)
 
 
 class UserLiteSerializer(BaseSerializer):
@@ -47,43 +17,4 @@ class UserLiteSerializer(BaseSerializer):
         read_only_fields = [
             "id",
             "is_bot",
-        ]
+        ]
-
-
-class UserAdminLiteSerializer(BaseSerializer):
-
-    class Meta:
-        model = User
-        fields = [
-            "id",
-            "first_name",
-            "last_name",
-            "avatar",
-            "is_bot",
-            "display_name",
-            "email",
-        ]
-        read_only_fields = [
-            "id",
-            "is_bot",
-        ]
-
-
-class ChangePasswordSerializer(serializers.Serializer):
-    model = User
-
-    """
-    Serializer for password change endpoint.
-    """
-    old_password = serializers.CharField(required=True)
-    new_password = serializers.CharField(required=True)
-
-
-class ResetPasswordSerializer(serializers.Serializer):
-    model = User
-
-    """
-    Serializer for password change endpoint.
-    """
-    new_password = serializers.CharField(required=True)
-    confirm_password = serializers.CharField(required=True)

apiserver/plane/api/serializers/workspace.py

@@ -1,39 +1,10 @@
-# Third party imports
-from rest_framework import serializers
-
 # Module imports
+from plane.db.models import Workspace
 from .base import BaseSerializer
-from .user import UserLiteSerializer, UserAdminLiteSerializer
 
-from plane.db.models import (
-    User,
-    Workspace,
-    WorkspaceMember,
-    Team,
-    TeamMember,
-    WorkspaceMemberInvite,
-    WorkspaceTheme,
-)
-
-
-class WorkSpaceSerializer(BaseSerializer):
-    owner = UserLiteSerializer(read_only=True)
-    total_members = serializers.IntegerField(read_only=True)
-    total_issues = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = Workspace
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-            "owner",
-        ]
 
 class WorkspaceLiteSerializer(BaseSerializer):
+    """Lite serializer with only required fields"""
     class Meta:
         model = Workspace
         fields = [
@@ -41,91 +12,4 @@ class WorkspaceLiteSerializer(BaseSerializer):
             "slug",
             "id",
         ]
-        read_only_fields = fields
+        read_only_fields = fields
-
-
-
-class WorkSpaceMemberSerializer(BaseSerializer):
-    member = UserLiteSerializer(read_only=True)
-    workspace = WorkspaceLiteSerializer(read_only=True)
-
-    class Meta:
-        model = WorkspaceMember
-        fields = "__all__"
-
-
-class WorkspaceMemberAdminSerializer(BaseSerializer):
-    member = UserAdminLiteSerializer(read_only=True)
-    workspace = WorkspaceLiteSerializer(read_only=True)
-
-    class Meta:
-        model = WorkspaceMember
-        fields = "__all__"
-
-
-class WorkSpaceMemberInviteSerializer(BaseSerializer):
-    workspace = WorkSpaceSerializer(read_only=True)
-    total_members = serializers.IntegerField(read_only=True)
-    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
-
-    class Meta:
-        model = WorkspaceMemberInvite
-        fields = "__all__"
-
-
-class TeamSerializer(BaseSerializer):
-    members_detail = UserLiteSerializer(read_only=True, source="members", many=True)
-    members = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
-        write_only=True,
-        required=False,
-    )
-
-    class Meta:
-        model = Team
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-    def create(self, validated_data, **kwargs):
-        if "members" in validated_data:
-            members = validated_data.pop("members")
-            workspace = self.context["workspace"]
-            team = Team.objects.create(**validated_data, workspace=workspace)
-            team_members = [
-                TeamMember(member=member, team=team, workspace=workspace)
-                for member in members
-            ]
-            TeamMember.objects.bulk_create(team_members, batch_size=10)
-            return team
-        else:
-            team = Team.objects.create(**validated_data)
-            return team
-
-    def update(self, instance, validated_data):
-        if "members" in validated_data:
-            members = validated_data.pop("members")
-            TeamMember.objects.filter(team=instance).delete()
-            team_members = [
-                TeamMember(member=member, team=instance, workspace=instance.workspace)
-                for member in members
-            ]
-            TeamMember.objects.bulk_create(team_members, batch_size=10)
-            return super().update(instance, validated_data)
-        else:
-            return super().update(instance, validated_data)
-
-
-class WorkspaceThemeSerializer(BaseSerializer):
-    class Meta:
-        model = WorkspaceTheme
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "actor",
-        ]

apiserver/plane/api/urls/__init__.py

@@ -0,0 +1,15 @@
+from .project import urlpatterns as project_patterns
+from .state import urlpatterns as state_patterns
+from .issue import urlpatterns as issue_patterns
+from .cycle import urlpatterns as cycle_patterns
+from .module import urlpatterns as module_patterns
+from .inbox import urlpatterns as inbox_patterns
+
+urlpatterns = [
+    *project_patterns,
+    *state_patterns,
+    *issue_patterns,
+    *cycle_patterns,
+    *module_patterns,
+    *inbox_patterns,
+]

apiserver/plane/api/urls/cycle.py

@@ -0,0 +1,35 @@
+from django.urls import path
+
+from plane.api.views.cycle import (
+    CycleAPIEndpoint,
+    CycleIssueAPIEndpoint,
+    TransferCycleIssueAPIEndpoint,
+)
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/",
+        CycleAPIEndpoint.as_view(),
+        name="cycles",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:pk>/",
+        CycleAPIEndpoint.as_view(),
+        name="cycles",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/",
+        CycleIssueAPIEndpoint.as_view(),
+        name="cycle-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:issue_id>/",
+        CycleIssueAPIEndpoint.as_view(),
+        name="cycle-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/transfer-issues/",
+        TransferCycleIssueAPIEndpoint.as_view(),
+        name="transfer-issues",
+    ),
+]

apiserver/plane/api/urls/inbox.py

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

apiserver/plane/api/urls/issue.py

@@ -0,0 +1,62 @@
+from django.urls import path
+
+from plane.api.views import (
+    IssueAPIEndpoint,
+    LabelAPIEndpoint,
+    IssueLinkAPIEndpoint,
+    IssueCommentAPIEndpoint,
+    IssueActivityAPIEndpoint,
+)
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/",
+        IssueAPIEndpoint.as_view(),
+        name="issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/",
+        IssueAPIEndpoint.as_view(),
+        name="issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/labels/",
+        LabelAPIEndpoint.as_view(),
+        name="label",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/labels/<uuid:pk>/",
+        LabelAPIEndpoint.as_view(),
+        name="label",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/links/",
+        IssueLinkAPIEndpoint.as_view(),
+        name="link",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/links/<uuid:pk>/",
+        IssueLinkAPIEndpoint.as_view(),
+        name="link",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/",
+        IssueCommentAPIEndpoint.as_view(),
+        name="comment",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/<uuid:pk>/",
+        IssueCommentAPIEndpoint.as_view(),
+        name="comment",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/activities/",
+        IssueActivityAPIEndpoint.as_view(),
+        name="activity",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/activities/<uuid:pk>/",
+        IssueActivityAPIEndpoint.as_view(),
+        name="activity",
+    ),
+]

apiserver/plane/api/urls/module.py

@@ -0,0 +1,26 @@
+from django.urls import path
+
+from plane.api.views import ModuleAPIEndpoint, ModuleIssueAPIEndpoint
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/",
+        ModuleAPIEndpoint.as_view(),
+        name="modules",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:pk>/",
+        ModuleAPIEndpoint.as_view(),
+        name="modules",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/",
+        ModuleIssueAPIEndpoint.as_view(),
+        name="module-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/<uuid:issue_id>/",
+        ModuleIssueAPIEndpoint.as_view(),
+        name="module-issues",
+    ),
+]

apiserver/plane/api/urls/project.py

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

apiserver/plane/api/urls/state.py

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

apiserver/plane/api/views/__init__.py

@@ -1,172 +1,21 @@
-from .project import (
+from .project import ProjectAPIEndpoint
-    ProjectViewSet,
-    ProjectMemberViewSet,
-    UserProjectInvitationsViewset,
-    InviteProjectEndpoint,
-    AddTeamToProjectEndpoint,
-    ProjectMemberInvitationsViewset,
-    ProjectMemberInviteDetailViewSet,
-    ProjectIdentifierEndpoint,
-    AddMemberToProjectEndpoint,
-    ProjectJoinEndpoint,
-    ProjectUserViewsEndpoint,
-    ProjectMemberUserEndpoint,
-    ProjectFavoritesViewSet,
-    ProjectDeployBoardViewSet,
-    ProjectDeployBoardPublicSettingsEndpoint,
-    ProjectMemberEndpoint,
-    WorkspaceProjectDeployBoardEndpoint,
-    LeaveProjectEndpoint,
-    ProjectPublicCoverImagesEndpoint,
-)
-from .user import (
-    UserEndpoint,
-    UpdateUserOnBoardedEndpoint,
-    UpdateUserTourCompletedEndpoint,
-    UserActivityEndpoint,
-)
 
-from .oauth import OauthEndpoint
+from .state import StateAPIEndpoint
 
-from .base import BaseAPIView, BaseViewSet
-
-from .workspace import (
-    WorkSpaceViewSet,
-    UserWorkSpacesEndpoint,
-    WorkSpaceAvailabilityCheckEndpoint,
-    InviteWorkspaceEndpoint,
-    JoinWorkspaceEndpoint,
-    WorkSpaceMemberViewSet,
-    TeamMemberViewSet,
-    WorkspaceInvitationsViewset,
-    UserWorkspaceInvitationsEndpoint,
-    UserWorkspaceInvitationEndpoint,
-    UserLastProjectWithWorkspaceEndpoint,
-    WorkspaceMemberUserEndpoint,
-    WorkspaceMemberUserViewsEndpoint,
-    UserActivityGraphEndpoint,
-    UserIssueCompletedGraphEndpoint,
-    UserWorkspaceDashboardEndpoint,
-    WorkspaceThemeViewSet,
-    WorkspaceUserProfileStatsEndpoint,
-    WorkspaceUserActivityEndpoint,
-    WorkspaceUserProfileEndpoint,
-    WorkspaceUserProfileIssuesEndpoint,
-    WorkspaceLabelsEndpoint,
-    WorkspaceMembersEndpoint,
-    LeaveWorkspaceEndpoint,
-)
-from .state import StateViewSet
-from .view import GlobalViewViewSet, GlobalViewIssuesViewSet, IssueViewViewSet, ViewIssuesEndpoint, IssueViewFavoriteViewSet
-from .cycle import (
-    CycleViewSet,
-    CycleIssueViewSet,
-    CycleDateCheckEndpoint,
-    CycleFavoriteViewSet,
-    TransferCycleIssueEndpoint,
-)
-from .asset import FileAssetEndpoint, UserAssetsEndpoint
 from .issue import (
-    IssueViewSet,
+    IssueAPIEndpoint,
-    WorkSpaceIssuesEndpoint,
+    LabelAPIEndpoint,
-    IssueActivityEndpoint,
+    IssueLinkAPIEndpoint,
-    IssueCommentViewSet,
+    IssueCommentAPIEndpoint,
-    IssuePropertyViewSet,
+    IssueActivityAPIEndpoint,
-    LabelViewSet,
-    BulkDeleteIssuesEndpoint,
-    UserWorkSpaceIssues,
-    SubIssuesEndpoint,
-    IssueLinkViewSet,
-    BulkCreateIssueLabelsEndpoint,
-    IssueAttachmentEndpoint,
-    IssueArchiveViewSet,
-    IssueSubscriberViewSet,
-    IssueCommentPublicViewSet,
-    CommentReactionViewSet,
-    IssueReactionViewSet,
-    IssueReactionPublicViewSet,
-    CommentReactionPublicViewSet,
-    IssueVotePublicViewSet,
-    IssueRelationViewSet,
-    IssueRetrievePublicEndpoint,
-    ProjectIssuesPublicEndpoint,
-    IssueDraftViewSet,
 )
 
-from .auth_extended import (
+from .cycle import (
-    VerifyEmailEndpoint,
+    CycleAPIEndpoint,
-    RequestEmailVerificationEndpoint,
+    CycleIssueAPIEndpoint,
-    ForgotPasswordEndpoint,
+    TransferCycleIssueAPIEndpoint,
-    ResetPasswordEndpoint,
-    ChangePasswordEndpoint,
 )
 
+from .module import ModuleAPIEndpoint, ModuleIssueAPIEndpoint
 
-from .authentication import (
+from .inbox import InboxIssueAPIEndpoint
-    SignUpEndpoint,
-    SignInEndpoint,
-    SignOutEndpoint,
-    MagicSignInEndpoint,
-    MagicSignInGenerateEndpoint,
-)
-
-from .module import (
-    ModuleViewSet,
-    ModuleIssueViewSet,
-    ModuleLinkViewSet,
-    ModuleFavoriteViewSet,
-)
-
-from .api_token import ApiTokenEndpoint
-
-from .integration import (
-    WorkspaceIntegrationViewSet,
-    IntegrationViewSet,
-    GithubIssueSyncViewSet,
-    GithubRepositorySyncViewSet,
-    GithubCommentSyncViewSet,
-    GithubRepositoriesEndpoint,
-    BulkCreateGithubIssueSyncEndpoint,
-    SlackProjectSyncViewSet,
-)
-
-from .importer import (
-    ServiceIssueImportSummaryEndpoint,
-    ImportServiceEndpoint,
-    UpdateServiceImportStatusEndpoint,
-    BulkImportIssuesEndpoint,
-    BulkImportModulesEndpoint,
-)
-
-from .page import (
-    PageViewSet,
-    PageBlockViewSet,
-    PageFavoriteViewSet,
-    CreateIssueFromPageBlockEndpoint,
-)
-
-from .search import GlobalSearchEndpoint, IssueSearchEndpoint
-
-
-from .external import GPTIntegrationEndpoint, ReleaseNotesEndpoint, UnsplashEndpoint
-
-from .estimate import (
-    ProjectEstimatePointEndpoint,
-    BulkEstimatePointEndpoint,
-)
-
-from .inbox import InboxViewSet, InboxIssueViewSet, InboxIssuePublicViewSet
-
-from .analytic import (
-    AnalyticsEndpoint,
-    AnalyticViewViewset,
-    SavedAnalyticEndpoint,
-    ExportAnalyticsEndpoint,
-    DefaultAnalyticsEndpoint,
-)
-
-from .notification import NotificationViewSet, UnreadNotificationEndpoint, MarkAllReadNotificationViewSet
-
-from .exporter import ExportIssuesEndpoint
-
-from .config import ConfigurationEndpoint

apiserver/plane/api/views/analytic.py

@@ -1,297 +0,0 @@
-# Django imports
-from django.db.models import (
-    Count,
-    Sum,
-    F,
-    Q
-)
-from django.db.models.functions import ExtractMonth
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from sentry_sdk import capture_exception
-
-# Module imports
-from plane.api.views import BaseAPIView, BaseViewSet
-from plane.api.permissions import WorkSpaceAdminPermission
-from plane.db.models import Issue, AnalyticView, Workspace, State, Label
-from plane.api.serializers import AnalyticViewSerializer
-from plane.utils.analytics_plot import build_graph_plot
-from plane.bgtasks.analytic_plot_export import analytic_export_task
-from plane.utils.issue_filters import issue_filters
-
-
-class AnalyticsEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkSpaceAdminPermission,
-    ]
-
-    def get(self, request, slug):
-        try:
-            x_axis = request.GET.get("x_axis", False)
-            y_axis = request.GET.get("y_axis", False)
-
-            if not x_axis or not y_axis:
-                return Response(
-                    {"error": "x-axis and y-axis dimensions are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            segment = request.GET.get("segment", False)
-            filters = issue_filters(request.GET, "GET")
-
-            queryset = Issue.issue_objects.filter(workspace__slug=slug, **filters)
-
-            total_issues = queryset.count()
-            distribution = build_graph_plot(
-                queryset=queryset, x_axis=x_axis, y_axis=y_axis, segment=segment
-            )
-
-            colors = dict()
-            if x_axis in ["state__name", "state__group"] or segment in [
-                "state__name",
-                "state__group",
-            ]:
-                if x_axis in ["state__name", "state__group"]:
-                    key = "name" if x_axis == "state__name" else "group"
-                else:
-                    key = "name" if segment == "state__name" else "group"
-
-                colors = (
-                    State.objects.filter(
-                        ~Q(name="Triage"),
-                        workspace__slug=slug, project_id__in=filters.get("project__in")
-                    ).values(key, "color")
-                    if filters.get("project__in", False)
-                    else State.objects.filter(~Q(name="Triage"), workspace__slug=slug).values(key, "color")
-                )
-
-            if x_axis in ["labels__name"] or segment in ["labels__name"]:
-                colors = (
-                    Label.objects.filter(
-                        workspace__slug=slug, project_id__in=filters.get("project__in")
-                    ).values("name", "color")
-                    if filters.get("project__in", False)
-                    else Label.objects.filter(workspace__slug=slug).values(
-                        "name", "color"
-                    )
-                )
-
-            assignee_details = {}
-            if x_axis in ["assignees__id"] or segment in ["assignees__id"]:
-                assignee_details = (
-                    Issue.issue_objects.filter(workspace__slug=slug, **filters, assignees__avatar__isnull=False)
-                    .order_by("assignees__id")
-                    .distinct("assignees__id")
-                    .values("assignees__avatar", "assignees__display_name", "assignees__first_name", "assignees__last_name", "assignees__id")
-                )
-
-
-            return Response(
-                {
-                    "total": total_issues,
-                    "distribution": distribution,
-                    "extras": {"colors": colors, "assignee_details": assignee_details},
-                },
-                status=status.HTTP_200_OK,
-            )
-
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class AnalyticViewViewset(BaseViewSet):
-    permission_classes = [
-        WorkSpaceAdminPermission,
-    ]
-    model = AnalyticView
-    serializer_class = AnalyticViewSerializer
-
-    def perform_create(self, serializer):
-        workspace = Workspace.objects.get(slug=self.kwargs.get("slug"))
-        serializer.save(workspace_id=workspace.id)
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super().get_queryset().filter(workspace__slug=self.kwargs.get("slug"))
-        )
-
-
-class SavedAnalyticEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkSpaceAdminPermission,
-    ]
-
-    def get(self, request, slug, analytic_id):
-        try:
-            analytic_view = AnalyticView.objects.get(
-                pk=analytic_id, workspace__slug=slug
-            )
-
-            filter = analytic_view.query
-            queryset = Issue.issue_objects.filter(**filter)
-
-            x_axis = analytic_view.query_dict.get("x_axis", False)
-            y_axis = analytic_view.query_dict.get("y_axis", False)
-
-            if not x_axis or not y_axis:
-                return Response(
-                    {"error": "x-axis and y-axis dimensions are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            segment = request.GET.get("segment", False)
-            distribution = build_graph_plot(
-                queryset=queryset, x_axis=x_axis, y_axis=y_axis, segment=segment
-            )
-            total_issues = queryset.count()
-            return Response(
-                {"total": total_issues, "distribution": distribution},
-                status=status.HTTP_200_OK,
-            )
-
-        except AnalyticView.DoesNotExist:
-            return Response(
-                {"error": "Analytic View Does not exist"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class ExportAnalyticsEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkSpaceAdminPermission,
-    ]
-
-    def post(self, request, slug):
-        try:
-            x_axis = request.data.get("x_axis", False)
-            y_axis = request.data.get("y_axis", False)
-
-            if not x_axis or not y_axis:
-                return Response(
-                    {"error": "x-axis and y-axis dimensions are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            analytic_export_task.delay(
-                email=request.user.email, data=request.data, slug=slug
-            )
-
-            return Response(
-                {
-                    "message": f"Once the export is ready it will be emailed to you at {str(request.user.email)}"
-                },
-                status=status.HTTP_200_OK,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class DefaultAnalyticsEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkSpaceAdminPermission,
-    ]
-
-    def get(self, request, slug):
-        try:
-            filters = issue_filters(request.GET, "GET")
-
-            queryset = Issue.issue_objects.filter(workspace__slug=slug, **filters)
-
-            total_issues = queryset.count()
-
-            total_issues_classified = (
-                queryset.annotate(state_group=F("state__group"))
-                .values("state_group")
-                .annotate(state_count=Count("state_group"))
-                .order_by("state_group")
-            )
-
-            open_issues = queryset.filter(
-                state__group__in=["backlog", "unstarted", "started"]
-            ).count()
-
-            open_issues_classified = (
-                queryset.filter(state__group__in=["backlog", "unstarted", "started"])
-                .annotate(state_group=F("state__group"))
-                .values("state_group")
-                .annotate(state_count=Count("state_group"))
-                .order_by("state_group")
-            )
-
-            issue_completed_month_wise = (
-                queryset.filter(completed_at__isnull=False)
-                .annotate(month=ExtractMonth("completed_at"))
-                .values("month")
-                .annotate(count=Count("*"))
-                .order_by("month")
-            )
-            most_issue_created_user = (
-                queryset.exclude(created_by=None)
-                .values("created_by__first_name", "created_by__last_name", "created_by__avatar", "created_by__display_name", "created_by__id")
-                .annotate(count=Count("id"))
-                .order_by("-count")
-            )[:5]
-
-            most_issue_closed_user = (
-                queryset.filter(completed_at__isnull=False, assignees__isnull=False)
-                .values("assignees__first_name", "assignees__last_name", "assignees__avatar", "assignees__display_name", "assignees__id")
-                .annotate(count=Count("id"))
-                .order_by("-count")
-            )[:5]
-
-            pending_issue_user = (
-                queryset.filter(completed_at__isnull=True)
-                .values("assignees__first_name", "assignees__last_name", "assignees__avatar", "assignees__display_name", "assignees__id")
-                .annotate(count=Count("id"))
-                .order_by("-count")
-            )
-
-            open_estimate_sum = (
-                queryset.filter(
-                    state__group__in=["backlog", "unstarted", "started"]
-                ).aggregate(open_estimate_sum=Sum("estimate_point"))
-            )["open_estimate_sum"]
-            print(open_estimate_sum)
-            
-            total_estimate_sum = queryset.aggregate(
-                total_estimate_sum=Sum("estimate_point")
-            )["total_estimate_sum"]
-
-            return Response(
-                {
-                    "total_issues": total_issues,
-                    "total_issues_classified": total_issues_classified,
-                    "open_issues": open_issues,
-                    "open_issues_classified": open_issues_classified,
-                    "issue_completed_month_wise": issue_completed_month_wise,
-                    "most_issue_created_user": most_issue_created_user,
-                    "most_issue_closed_user": most_issue_closed_user,
-                    "pending_issue_user": pending_issue_user,
-                    "open_estimate_sum": open_estimate_sum,
-                    "total_estimate_sum": total_estimate_sum,
-                },
-                status=status.HTTP_200_OK,
-            )
-
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/api_token.py

@@ -1,70 +0,0 @@
-# Python import
-from uuid import uuid4
-
-# Third party
-from rest_framework.response import Response
-from rest_framework import status
-from sentry_sdk import capture_exception
-
-# Module import
-from .base import BaseAPIView
-from plane.db.models import APIToken
-from plane.api.serializers import APITokenSerializer
-
-
-class ApiTokenEndpoint(BaseAPIView):
-    def post(self, request):
-        try:
-            label = request.data.get("label", str(uuid4().hex))
-            workspace = request.data.get("workspace", False)
-
-            if not workspace:
-                return Response(
-                    {"error": "Workspace is required"}, status=status.HTTP_200_OK
-                )
-
-            api_token = APIToken.objects.create(
-                label=label, user=request.user, workspace_id=workspace
-            )
-
-            serializer = APITokenSerializer(api_token)
-            # Token will be only vissible while creating
-            return Response(
-                {"api_token": serializer.data, "token": api_token.token},
-                status=status.HTTP_201_CREATED,
-            )
-
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def get(self, request):
-        try:
-            api_tokens = APIToken.objects.filter(user=request.user)
-            serializer = APITokenSerializer(api_tokens, many=True)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def delete(self, request, pk):
-        try:
-            api_token = APIToken.objects.get(pk=pk)
-            api_token.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except APIToken.DoesNotExist:
-            return Response(
-                {"error": "Token does not exists"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/asset.py

@@ -1,125 +0,0 @@
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.parsers import MultiPartParser, FormParser
-from sentry_sdk import capture_exception
-from django.conf import settings
-# Module imports
-from .base import BaseAPIView
-from plane.db.models import FileAsset, Workspace
-from plane.api.serializers import FileAssetSerializer
-
-
-class FileAssetEndpoint(BaseAPIView):
-    parser_classes = (MultiPartParser, FormParser)
-
-    """
-    A viewset for viewing and editing task instances.
-    """
-
-    def get(self, request, workspace_id, asset_key):
-        try:
-            asset_key = str(workspace_id) + "/" + asset_key
-            files = FileAsset.objects.filter(asset=asset_key)
-            if files.exists():
-                serializer = FileAssetSerializer(files, context={"request": request}, many=True)
-                return Response({"data": serializer.data, "status": True}, status=status.HTTP_200_OK)
-            else:
-                return Response({"error": "Asset key does not exist", "status": False}, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-    def post(self, request, slug):
-        try:
-            serializer = FileAssetSerializer(data=request.data)
-            if serializer.is_valid():
-                # Get the workspace
-                workspace = Workspace.objects.get(slug=slug)
-                serializer.save(workspace_id=workspace.id)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Workspace.DoesNotExist:
-            return Response({"error": "Workspace does not exist"}, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def delete(self, request, workspace_id, asset_key):
-        try:
-            asset_key = str(workspace_id) + "/" + asset_key
-            file_asset = FileAsset.objects.get(asset=asset_key)
-            # Delete the file from storage
-            file_asset.asset.delete(save=False)
-            # Delete the file object
-            file_asset.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except FileAsset.DoesNotExist:
-            return Response(
-                {"error": "File Asset doesn't exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class UserAssetsEndpoint(BaseAPIView):
-    parser_classes = (MultiPartParser, FormParser)
-
-    def get(self, request, asset_key):
-        try:
-            files = FileAsset.objects.filter(asset=asset_key, created_by=request.user)
-            if files.exists():
-                serializer = FileAssetSerializer(files, context={"request": request})
-                return Response({"data": serializer.data, "status": True}, status=status.HTTP_200_OK)
-            else:
-                return Response({"error": "Asset key does not exist", "status": False}, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def post(self, request):
-        try:
-            serializer = FileAssetSerializer(data=request.data)
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def delete(self, request, asset_key):
-        try:
-            file_asset = FileAsset.objects.get(asset=asset_key, created_by=request.user)
-            # Delete the file from storage
-            file_asset.asset.delete(save=False)
-            # Delete the file object
-            file_asset.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except FileAsset.DoesNotExist:
-            return Response(
-                {"error": "File Asset doesn't exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/auth_extended.py

@@ -1,159 +0,0 @@
-## Python imports
-import jwt
-
-## Django imports
-from django.contrib.auth.tokens import PasswordResetTokenGenerator
-from django.utils.encoding import (
-    smart_str,
-    smart_bytes,
-    DjangoUnicodeDecodeError,
-)
-from django.utils.http import urlsafe_base64_decode, urlsafe_base64_encode
-from django.contrib.sites.shortcuts import get_current_site
-from django.conf import settings
-
-## Third Party Imports
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework import permissions
-from rest_framework_simplejwt.tokens import RefreshToken
-
-from sentry_sdk import capture_exception
-
-## Module imports
-from . import BaseAPIView
-from plane.api.serializers import (
-    ChangePasswordSerializer,
-    ResetPasswordSerializer,
-)
-from plane.db.models import User
-from plane.bgtasks.email_verification_task import email_verification
-from plane.bgtasks.forgot_password_task import forgot_password
-
-
-class RequestEmailVerificationEndpoint(BaseAPIView):
-    def get(self, request):
-        token = RefreshToken.for_user(request.user).access_token
-        current_site = settings.WEB_URL
-        email_verification.delay(
-            request.user.first_name, request.user.email, token, current_site
-        )
-        return Response(
-            {"message": "Email sent successfully"}, status=status.HTTP_200_OK
-        )
-
-
-class VerifyEmailEndpoint(BaseAPIView):
-    def get(self, request):
-        token = request.GET.get("token")
-        try:
-            payload = jwt.decode(token, settings.SECRET_KEY, algorithms="HS256")
-            user = User.objects.get(id=payload["user_id"])
-
-            if not user.is_email_verified:
-                user.is_email_verified = True
-                user.save()
-            return Response(
-                {"email": "Successfully activated"}, status=status.HTTP_200_OK
-            )
-        except jwt.ExpiredSignatureError as indentifier:
-            return Response(
-                {"email": "Activation expired"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except jwt.exceptions.DecodeError as indentifier:
-            return Response(
-                {"email": "Invalid token"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-
-class ForgotPasswordEndpoint(BaseAPIView):
-    permission_classes = [permissions.AllowAny]
-
-    def post(self, request):
-        email = request.data.get("email")
-
-        if User.objects.filter(email=email).exists():
-            user = User.objects.get(email=email)
-            uidb64 = urlsafe_base64_encode(smart_bytes(user.id))
-            token = PasswordResetTokenGenerator().make_token(user)
-
-            current_site = settings.WEB_URL
-
-            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,
-            )
-        return Response(
-            {"error": "Please check the email"}, status=status.HTTP_400_BAD_REQUEST
-        )
-
-
-class ResetPasswordEndpoint(BaseAPIView):
-    permission_classes = [permissions.AllowAny]
-
-    def post(self, request, uidb64, token):
-        try:
-            id = smart_str(urlsafe_base64_decode(uidb64))
-            user = User.objects.get(id=id)
-            if not PasswordResetTokenGenerator().check_token(user, token):
-                return Response(
-                    {"error": "token is not valid, please check the new one"},
-                    status=status.HTTP_401_UNAUTHORIZED,
-                )
-            serializer = ResetPasswordSerializer(data=request.data)
-
-            if serializer.is_valid():
-                # set_password also hashes the password that the user will get
-                user.set_password(serializer.data.get("new_password"))
-                user.save()
-                response = {
-                    "status": "success",
-                    "code": status.HTTP_200_OK,
-                    "message": "Password updated successfully",
-                }
-
-                return Response(response)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-        except DjangoUnicodeDecodeError as indentifier:
-            return Response(
-                {"error": "token is not valid, please check the new one"},
-                status=status.HTTP_401_UNAUTHORIZED,
-            )
-
-
-class ChangePasswordEndpoint(BaseAPIView):
-    def post(self, request):
-        try:
-            serializer = ChangePasswordSerializer(data=request.data)
-
-            user = User.objects.get(pk=request.user.id)
-            if serializer.is_valid():
-                # Check old password
-                if not user.object.check_password(serializer.data.get("old_password")):
-                    return Response(
-                        {"old_password": ["Wrong password."]},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                # set_password also hashes the password that the user will get
-                self.object.set_password(serializer.data.get("new_password"))
-                self.object.save()
-                response = {
-                    "status": "success",
-                    "code": status.HTTP_200_OK,
-                    "message": "Password updated successfully",
-                }
-
-                return Response(response)
-
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/authentication.py

@@ -1,458 +0,0 @@
-# Python imports
-import uuid
-import random
-import string
-import json
-import requests
-
-# Django imports
-from django.utils import timezone
-from django.core.exceptions import ValidationError
-from django.core.validators import validate_email
-from django.conf import settings
-from django.contrib.auth.hashers import make_password
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework.permissions import AllowAny
-from rest_framework import status
-from rest_framework_simplejwt.tokens import RefreshToken
-
-from sentry_sdk import capture_exception, capture_message
-
-# Module imports
-from . import BaseAPIView
-from plane.db.models import User
-from plane.api.serializers import UserSerializer
-from plane.settings.redis import redis_instance
-from plane.bgtasks.magic_link_code_task import magic_link
-
-
-def get_tokens_for_user(user):
-    refresh = RefreshToken.for_user(user)
-    return (
-        str(refresh.access_token),
-        str(refresh),
-    )
-
-
-class SignUpEndpoint(BaseAPIView):
-    permission_classes = (AllowAny,)
-
-    def post(self, request):
-        try:
-            if not settings.ENABLE_SIGNUP:
-                return Response(
-                    {
-                        "error": "New account creation is disabled. Please contact your site administrator"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            email = request.data.get("email", False)
-            password = request.data.get("password", False)
-
-            ## Raise exception if any of the above are missing
-            if not email or not password:
-                return Response(
-                    {"error": "Both email and password are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            email = email.strip().lower()
-
-            try:
-                validate_email(email)
-            except ValidationError as e:
-                return Response(
-                    {"error": "Please provide a valid email address."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            # Check if the user already exists
-            if User.objects.filter(email=email).exists():
-                return Response(
-                    {"error": "User with this email already exists"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            user = User.objects.create(email=email, username=uuid.uuid4().hex)
-            user.set_password(password)
-
-            # settings last actives for the user
-            user.last_active = timezone.now()
-            user.last_login_time = timezone.now()
-            user.last_login_ip = request.META.get("REMOTE_ADDR")
-            user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
-            user.token_updated_at = timezone.now()
-            user.save()
-
-            serialized_user = UserSerializer(user).data
-
-            access_token, refresh_token = get_tokens_for_user(user)
-
-            data = {
-                "access_token": access_token,
-                "refresh_token": refresh_token,
-                "user": serialized_user,
-            }
-
-            # Send Analytics
-            if settings.ANALYTICS_BASE_API:
-                _ = requests.post(
-                    settings.ANALYTICS_BASE_API,
-                    headers={
-                        "Content-Type": "application/json",
-                        "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
-                    },
-                    json={
-                        "event_id": uuid.uuid4().hex,
-                        "event_data": {
-                            "medium": "email",
-                        },
-                        "user": {"email": email, "id": str(user.id)},
-                        "device_ctx": {
-                            "ip": request.META.get("REMOTE_ADDR"),
-                            "user_agent": request.META.get("HTTP_USER_AGENT"),
-                        },
-                        "event_type": "SIGN_UP",
-                    },
-                )
-
-            return Response(data, status=status.HTTP_200_OK)
-
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class SignInEndpoint(BaseAPIView):
-    permission_classes = (AllowAny,)
-
-    def post(self, request):
-        try:
-            email = request.data.get("email", False)
-            password = request.data.get("password", False)
-
-            ## Raise exception if any of the above are missing
-            if not email or not password:
-                return Response(
-                    {"error": "Both email and password are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            email = email.strip().lower()
-
-            try:
-                validate_email(email)
-            except ValidationError as e:
-                return Response(
-                    {"error": "Please provide a valid email address."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            user = User.objects.filter(email=email).first()
-
-            if user is None:
-                return Response(
-                    {
-                        "error": "Sorry, we could not find a user with the provided credentials. Please try again."
-                    },
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-
-            # Sign up Process
-            if not user.check_password(password):
-                return Response(
-                    {
-                        "error": "Sorry, we could not find a user with the provided credentials. Please try again."
-                    },
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-            if not user.is_active:
-                return Response(
-                    {
-                        "error": "Your account has been deactivated. Please contact your site administrator."
-                    },
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-
-            serialized_user = UserSerializer(user).data
-
-            # settings last active for the user
-            user.last_active = timezone.now()
-            user.last_login_time = timezone.now()
-            user.last_login_ip = request.META.get("REMOTE_ADDR")
-            user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
-            user.token_updated_at = timezone.now()
-            user.save()
-
-            access_token, refresh_token = get_tokens_for_user(user)
-            # Send Analytics
-            if settings.ANALYTICS_BASE_API:
-                _ = requests.post(
-                    settings.ANALYTICS_BASE_API,
-                    headers={
-                        "Content-Type": "application/json",
-                        "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
-                    },
-                    json={
-                        "event_id": uuid.uuid4().hex,
-                        "event_data": {
-                            "medium": "email",
-                        },
-                        "user": {"email": email, "id": str(user.id)},
-                        "device_ctx": {
-                            "ip": request.META.get("REMOTE_ADDR"),
-                            "user_agent": request.META.get("HTTP_USER_AGENT"),
-                        },
-                        "event_type": "SIGN_IN",
-                    },
-                )
-            data = {
-                "access_token": access_token,
-                "refresh_token": refresh_token,
-                "user": serialized_user,
-            }
-
-            return Response(data, status=status.HTTP_200_OK)
-
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {
-                    "error": "Something went wrong. Please try again later or contact the support team."
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class SignOutEndpoint(BaseAPIView):
-    def post(self, request):
-        try:
-            refresh_token = request.data.get("refresh_token", False)
-
-            if not refresh_token:
-                capture_message("No refresh token provided")
-                return Response(
-                    {
-                        "error": "Something went wrong. Please try again later or contact the support team."
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            user = User.objects.get(pk=request.user.id)
-
-            user.last_logout_time = timezone.now()
-            user.last_logout_ip = request.META.get("REMOTE_ADDR")
-
-            user.save()
-
-            token = RefreshToken(refresh_token)
-            token.blacklist()
-            return Response({"message": "success"}, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {
-                    "error": "Something went wrong. Please try again later or contact the support team."
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class MagicSignInGenerateEndpoint(BaseAPIView):
-    permission_classes = [
-        AllowAny,
-    ]
-
-    def post(self, request):
-        try:
-            email = request.data.get("email", False)
-
-            if not email:
-                return Response(
-                    {"error": "Please provide a valid email address"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            # Clean up
-            email = email.strip().lower()
-            validate_email(email)
-
-            ## Generate a random token
-            token = (
-                "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
-                + "-"
-                + "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
-                + "-"
-                + "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
-            )
-
-            ri = redis_instance()
-
-            key = "magic_" + str(email)
-
-            # Check if the key already exists in python
-            if ri.exists(key):
-                data = json.loads(ri.get(key))
-
-                current_attempt = data["current_attempt"] + 1
-
-                if data["current_attempt"] > 2:
-                    return Response(
-                        {"error": "Max attempts exhausted. Please try again later."},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-
-                value = {
-                    "current_attempt": current_attempt,
-                    "email": email,
-                    "token": token,
-                }
-                expiry = 600
-
-                ri.set(key, json.dumps(value), ex=expiry)
-
-            else:
-                value = {"current_attempt": 0, "email": email, "token": token}
-                expiry = 600
-
-                ri.set(key, json.dumps(value), ex=expiry)
-
-            current_site = settings.WEB_URL
-            magic_link.delay(email, key, token, current_site)
-
-            return Response({"key": key}, status=status.HTTP_200_OK)
-        except ValidationError:
-            return Response(
-                {"error": "Please provide a valid email address."},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class MagicSignInEndpoint(BaseAPIView):
-    permission_classes = [
-        AllowAny,
-    ]
-
-    def post(self, request):
-        try:
-            user_token = request.data.get("token", "").strip()
-            key = request.data.get("key", False).strip().lower()
-
-            if not key or user_token == "":
-                return Response(
-                    {"error": "User token and key are required"},
-                    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):
-                    if User.objects.filter(email=email).exists():
-                        user = User.objects.get(email=email)
-                        # Send event to Jitsu for tracking
-                        if settings.ANALYTICS_BASE_API:
-                            _ = requests.post(
-                                settings.ANALYTICS_BASE_API,
-                                headers={
-                                    "Content-Type": "application/json",
-                                    "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
-                                },
-                                json={
-                                    "event_id": uuid.uuid4().hex,
-                                    "event_data": {
-                                        "medium": "code",
-                                    },
-                                    "user": {"email": email, "id": str(user.id)},
-                                    "device_ctx": {
-                                        "ip": request.META.get("REMOTE_ADDR"),
-                                        "user_agent": request.META.get(
-                                            "HTTP_USER_AGENT"
-                                        ),
-                                    },
-                                    "event_type": "SIGN_IN",
-                                },
-                            )
-                    else:
-                        user = User.objects.create(
-                            email=email,
-                            username=uuid.uuid4().hex,
-                            password=make_password(uuid.uuid4().hex),
-                            is_password_autoset=True,
-                        )
-                        # Send event to Jitsu for tracking
-                        if settings.ANALYTICS_BASE_API:
-                            _ = requests.post(
-                                settings.ANALYTICS_BASE_API,
-                                headers={
-                                    "Content-Type": "application/json",
-                                    "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
-                                },
-                                json={
-                                    "event_id": uuid.uuid4().hex,
-                                    "event_data": {
-                                        "medium": "code",
-                                    },
-                                    "user": {"email": email, "id": str(user.id)},
-                                    "device_ctx": {
-                                        "ip": request.META.get("REMOTE_ADDR"),
-                                        "user_agent": request.META.get(
-                                            "HTTP_USER_AGENT"
-                                        ),
-                                    },
-                                    "event_type": "SIGN_UP",
-                                },
-                            )
-
-                    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()
-                    serialized_user = UserSerializer(user).data
-
-                    access_token, refresh_token = get_tokens_for_user(user)
-                    data = {
-                        "access_token": access_token,
-                        "refresh_token": refresh_token,
-                        "user": serialized_user,
-                    }
-
-                    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,
-                )
-
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/base.py

@@ -1,23 +1,25 @@
 # Python imports
 import zoneinfo
+import json
 
 # Django imports
-from django.urls import resolve
 from django.conf import settings
+from django.db import IntegrityError
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.utils import timezone
-# Third part imports
 
-from rest_framework import status
+# Third party imports
-from rest_framework.viewsets import ModelViewSet
-from rest_framework.exceptions import APIException
 from rest_framework.views import APIView
-from rest_framework.filters import SearchFilter
+from rest_framework.response import Response
 from rest_framework.permissions import IsAuthenticated
+from rest_framework import status
 from sentry_sdk import capture_exception
-from django_filters.rest_framework import DjangoFilterBackend
 
 # Module imports
+from plane.api.middleware.api_authentication import APIKeyAuthentication
+from plane.api.rate_limit import ApiKeyRateThrottle
 from plane.utils.paginator import BasePaginator
+from plane.bgtasks.webhook_task import send_webhook
 
 
 class TimezoneMixin:
@@ -25,6 +27,7 @@ class TimezoneMixin:
     This enables timezone conversion according
     to the user set timezone
     """
+
     def initial(self, request, *args, **kwargs):
         super().initial(request, *args, **kwargs)
         if request.user.is_authenticated:
@@ -33,86 +36,121 @@ class TimezoneMixin:
             timezone.deactivate()
 
 
+class WebhookMixin:
+    webhook_event = None
+    bulk = False
 
+    def finalize_response(self, request, response, *args, **kwargs):
+        response = super().finalize_response(request, response, *args, **kwargs)
 
-class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
+        # Check for the case should webhook be sent
-
+        if (
-    model = None
+            self.webhook_event
-
+            and self.request.method in ["POST", "PATCH", "DELETE"]
-    permission_classes = [
+            and response.status_code in [200, 201, 204]
-        IsAuthenticated,
+        ):
-    ]
+            # Push the object to delay
-
+            send_webhook.delay(
-    filter_backends = (
+                event=self.webhook_event,
-        DjangoFilterBackend,
+                payload=response.data,
-        SearchFilter,
+                kw=self.kwargs,
-    )
+                action=self.request.method,
-
+                slug=self.workspace_slug,
-    filterset_fields = []
+                bulk=self.bulk,
-
-    search_fields = []
-
-    def get_queryset(self):
-        try:
-            return self.model.objects.all()
-        except Exception as e:
-            capture_exception(e)
-            raise APIException("Please check the view", status.HTTP_400_BAD_REQUEST)
-
-    def dispatch(self, request, *args, **kwargs):
-        response = super().dispatch(request, *args, **kwargs)
-
-        if settings.DEBUG:
-            from django.db import connection
-
-            print(
-                f"{request.method} - {request.get_full_path()} of Queries: {len(connection.queries)}"
             )
+
         return response
 
-    @property
-    def workspace_slug(self):
-        return self.kwargs.get("slug", None)
-
-    @property
-    def project_id(self):
-        project_id = self.kwargs.get("project_id", None)
-        if project_id:
-            return project_id
-
-        if resolve(self.request.path_info).url_name == "project":
-            return self.kwargs.get("pk", None)
-
 
 class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
+    authentication_classes = [
+        APIKeyAuthentication,
+    ]
 
     permission_classes = [
         IsAuthenticated,
     ]
 
-    filter_backends = (
+    throttle_classes = [
-        DjangoFilterBackend,
+        ApiKeyRateThrottle,
-        SearchFilter,
+    ]
-    )
-
-    filterset_fields = []
-
-    search_fields = []
 
     def filter_queryset(self, queryset):
         for backend in list(self.filter_backends):
             queryset = backend().filter_queryset(self.request, queryset, self)
         return queryset
 
-    def dispatch(self, request, *args, **kwargs):
+    def handle_exception(self, exc):
-        response = super().dispatch(request, *args, **kwargs)
+        """
+        Handle any exception that occurs, by returning an appropriate response,
+        or re-raising the error.
+        """
+        try:
+            response = super().handle_exception(exc)
+            return response
+        except Exception as e:
+            if isinstance(e, IntegrityError):
+                return Response(
+                    {"error": "The payload is not valid"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
 
-        if settings.DEBUG:
+            if isinstance(e, ValidationError):
-            from django.db import connection
+                return Response(
+                    {
+                        "error": "The provided payload is not valid please try with a valid payload"
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
 
-            print(
+            if isinstance(e, ObjectDoesNotExist):
-                f"{request.method} - {request.get_full_path()} of Queries: {len(connection.queries)}"
+                model_name = str(exc).split(" matching query does not exist.")[0]
+                return Response(
+                    {"error": f"{model_name} does not exist."},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            if isinstance(e, KeyError):
+                return Response(
+                    {"error": f"key {e} does not exist"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if settings.DEBUG:
+                print(e)
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
+
+    def dispatch(self, request, *args, **kwargs):
+        try:
+            response = super().dispatch(request, *args, **kwargs)
+            if settings.DEBUG:
+                from django.db import connection
+
+                print(
+                    f"{request.method} - {request.get_full_path()} of Queries: {len(connection.queries)}"
+                )
+            return response
+        except Exception as exc:
+            response = self.handle_exception(exc)
+            return exc
+
+    def finalize_response(self, request, response, *args, **kwargs):
+        # Call super to get the default response
+        response = super().finalize_response(request, response, *args, **kwargs)
+
+        # Add custom headers if they exist in the request META
+        ratelimit_remaining = request.META.get("X-RateLimit-Remaining")
+        if ratelimit_remaining is not None:
+            response["X-RateLimit-Remaining"] = ratelimit_remaining
+
+        ratelimit_reset = request.META.get("X-RateLimit-Reset")
+        if ratelimit_reset is not None:
+            response["X-RateLimit-Reset"] = ratelimit_reset
+
         return response
 
     @property
@@ -122,3 +160,17 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
     @property
     def project_id(self):
         return self.kwargs.get("project_id", None)
+
+    @property
+    def fields(self):
+        fields = [
+            field for field in self.request.GET.get("fields", "").split(",") if field
+        ]
+        return fields if fields else None
+
+    @property
+    def expand(self):
+        expand = [
+            expand for expand in self.request.GET.get("expand", "").split(",") if expand
+        ]
+        return expand if expand else None

apiserver/plane/api/views/config.py

@@ -1,40 +0,0 @@
-# Python imports
-import os
-
-# Django imports
-from django.conf import settings
-
-# Third party imports
-from rest_framework.permissions import AllowAny
-from rest_framework import status
-from rest_framework.response import Response
-from sentry_sdk import capture_exception
-
-# Module imports
-from .base import BaseAPIView
-
-
-class ConfigurationEndpoint(BaseAPIView):
-    permission_classes = [
-        AllowAny,
-    ]
-
-    def get(self, request):
-        try:
-            data = {}
-            data["google"] = os.environ.get("GOOGLE_CLIENT_ID", None)
-            data["github"] = os.environ.get("GITHUB_CLIENT_ID", None)
-            data["github_app_name"] = os.environ.get("GITHUB_APP_NAME", None)
-            data["magic_login"] = (
-                bool(settings.EMAIL_HOST_USER) and bool(settings.EMAIL_HOST_PASSWORD)
-            ) and os.environ.get("ENABLE_MAGIC_LINK_LOGIN", "0") == "1"
-            data["email_password_login"] = (
-                os.environ.get("ENABLE_EMAIL_PASSWORD", "0") == "1"
-            )
-            return Response(data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/estimate.py

@@ -1,253 +0,0 @@
-# Django imports
-from django.db import IntegrityError
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-from sentry_sdk import capture_exception
-
-# Module imports
-from .base import BaseViewSet, BaseAPIView
-from plane.api.permissions import ProjectEntityPermission
-from plane.db.models import Project, Estimate, EstimatePoint
-from plane.api.serializers import (
-    EstimateSerializer,
-    EstimatePointSerializer,
-    EstimateReadSerializer,
-)
-
-
-class ProjectEstimatePointEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get(self, request, slug, project_id):
-        try:
-            project = Project.objects.get(workspace__slug=slug, pk=project_id)
-            if project.estimate_id is not None:
-                estimate_points = EstimatePoint.objects.filter(
-                    estimate_id=project.estimate_id,
-                    project_id=project_id,
-                    workspace__slug=slug,
-                )
-                serializer = EstimatePointSerializer(estimate_points, many=True)
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response([], status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class BulkEstimatePointEndpoint(BaseViewSet):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-    model = Estimate
-    serializer_class = EstimateSerializer
-
-    def list(self, request, slug, project_id):
-        try:
-            estimates = Estimate.objects.filter(
-                workspace__slug=slug, project_id=project_id
-            ).prefetch_related("points").select_related("workspace", "project")
-            serializer = EstimateReadSerializer(estimates, many=True)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def create(self, request, slug, project_id):
-        try:
-            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
-                )
-            try:
-                estimate = estimate_serializer.save(project_id=project_id)
-            except IntegrityError:
-                return Response(
-                    {"errror": "Estimate with the name already exists"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            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", ""),
-                        project_id=project_id,
-                        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,
-            )
-        except Estimate.DoesNotExist:
-            return Response(
-                {"error": "Estimate does not exist"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def retrieve(self, request, slug, project_id, estimate_id):
-        try:
-            estimate = Estimate.objects.get(
-                pk=estimate_id, workspace__slug=slug, project_id=project_id
-            )
-            serializer = EstimateReadSerializer(estimate)
-            return Response(
-                serializer.data,
-                status=status.HTTP_200_OK,
-            )
-        except Estimate.DoesNotExist:
-            return Response(
-                {"error": "Estimate does not exist"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def partial_update(self, request, slug, project_id, estimate_id):
-        try:
-            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
-                )
-            try:
-                estimate = estimate_serializer.save()
-            except IntegrityError:
-                return Response(
-                    {"errror": "Estimate with the name already exists"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            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,
-                project_id=project_id,
-                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)
-
-            try:
-                EstimatePoint.objects.bulk_update(
-                    updated_estimate_points, ["value"], batch_size=10,
-                )
-            except IntegrityError as e:
-                return Response(
-                    {"error": "Values need to be unique for each key"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            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,
-            )
-        except Estimate.DoesNotExist:
-            return Response(
-                {"error": "Estimate does not exist"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def destroy(self, request, slug, project_id, estimate_id):
-        try:
-            estimate = Estimate.objects.get(
-                pk=estimate_id, workspace__slug=slug, project_id=project_id
-            )
-            estimate.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/exporter.py

@@ -1,100 +0,0 @@
-# Third Party imports
-from rest_framework.response import Response
-from rest_framework import status
-from sentry_sdk import capture_exception
-
-# Module imports
-from . import BaseAPIView
-from plane.api.permissions import WorkSpaceAdminPermission
-from plane.bgtasks.export_task import issue_export_task
-from plane.db.models import Project, ExporterHistory, Workspace
-
-from plane.api.serializers import ExporterHistorySerializer
-
-
-class ExportIssuesEndpoint(BaseAPIView):
-    permission_classes = [
-        WorkSpaceAdminPermission,
-    ]
-    model = ExporterHistory
-    serializer_class = ExporterHistorySerializer
-
-    def post(self, request, slug):
-        try:
-            # Get the workspace
-            workspace = Workspace.objects.get(slug=slug)
-            
-            provider = request.data.get("provider", False)
-            multiple = request.data.get("multiple", False)
-            project_ids = request.data.get("project", [])
-            
-            if provider in ["csv", "xlsx", "json"]:
-                if not project_ids:
-                    project_ids = Project.objects.filter(
-                        workspace__slug=slug
-                    ).values_list("id", flat=True)
-                    project_ids = [str(project_id) for project_id in project_ids]
-
-                exporter = ExporterHistory.objects.create(
-                    workspace=workspace,
-                    project=project_ids,
-                    initiated_by=request.user,
-                    provider=provider,
-                )
-
-                issue_export_task.delay(
-                    provider=exporter.provider,
-                    workspace_id=workspace.id,
-                    project_ids=project_ids,
-                    token_id=exporter.token,
-                    multiple=multiple,
-                    slug=slug,
-                )
-                return Response(
-                    {
-                        "message": f"Once the export is ready you will be able to download it"
-                    },
-                    status=status.HTTP_200_OK,
-                )
-            else:
-                return Response(
-                    {"error": f"Provider '{provider}' not found."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-        except Workspace.DoesNotExist:
-            return Response(
-                {"error": "Workspace does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def get(self, request, slug):
-        try:
-            exporter_history = ExporterHistory.objects.filter(
-                workspace__slug=slug
-            ).select_related("workspace","initiated_by")
-
-            if request.GET.get("per_page", False) and request.GET.get("cursor", False):
-                return self.paginate(
-                    request=request,
-                    queryset=exporter_history,
-                    on_results=lambda exporter_history: ExporterHistorySerializer(
-                        exporter_history, many=True
-                    ).data,
-                )
-            else:
-                return Response(
-                    {"error": "per_page and cursor are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/external.py

@@ -1,118 +0,0 @@
-# Python imports
-import requests
-
-# Third party imports
-import openai
-from rest_framework.response import Response
-from rest_framework import status
-from rest_framework.permissions import AllowAny
-from sentry_sdk import capture_exception
-
-# Django imports
-from django.conf import settings
-
-# Module imports
-from .base import BaseAPIView
-from plane.api.permissions import ProjectEntityPermission
-from plane.db.models import Workspace, Project
-from plane.api.serializers import ProjectLiteSerializer, WorkspaceLiteSerializer
-from plane.utils.integrations.github import get_release_notes
-
-
-class GPTIntegrationEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def post(self, request, slug, project_id):
-        try:
-            if not settings.OPENAI_API_KEY or not settings.GPT_ENGINE:
-                return Response(
-                    {"error": "OpenAI API key and engine is required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            prompt = request.data.get("prompt", False)
-            task = request.data.get("task", False)
-
-            if not task:
-                return Response(
-                    {"error": "Task is required"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            final_text = task + "\n" + prompt
-
-            openai.api_key = settings.OPENAI_API_KEY
-            response = openai.ChatCompletion.create(
-                model=settings.GPT_ENGINE,
-                messages=[{"role": "user", "content": final_text}],
-                temperature=0.7,
-                max_tokens=1024,
-            )
-
-            workspace = Workspace.objects.get(slug=slug)
-            project = Project.objects.get(pk=project_id)
-
-            text = response.choices[0].message.content.strip()
-            text_html = text.replace("\n", "<br/>")
-            return Response(
-                {
-                    "response": text,
-                    "response_html": text_html,
-                    "project_detail": ProjectLiteSerializer(project).data,
-                    "workspace_detail": WorkspaceLiteSerializer(workspace).data,
-                },
-                status=status.HTTP_200_OK,
-            )
-        except (Workspace.DoesNotExist, Project.DoesNotExist) as e:
-            return Response(
-                {"error": "Workspace or Project Does not exist"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class ReleaseNotesEndpoint(BaseAPIView):
-    def get(self, request):
-        try:
-            release_notes = get_release_notes()
-            return Response(release_notes, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class UnsplashEndpoint(BaseAPIView):
-
-    def get(self, request):
-        try:
-            query = request.GET.get("query", False)
-            page = request.GET.get("page", 1)
-            per_page = request.GET.get("per_page", 20)
-
-            url = (
-                f"https://api.unsplash.com/search/photos/?client_id={settings.UNSPLASH_ACCESS_KEY}&query={query}&page=${page}&per_page={per_page}"
-                if query
-                else f"https://api.unsplash.com/photos/?client_id={settings.UNSPLASH_ACCESS_KEY}&page={page}&per_page={per_page}"
-            )
-
-            headers = {
-                "Content-Type": "application/json",
-            }
-
-            resp = requests.get(url=url, headers=headers)
-            return Response(resp.json(), status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/importer.py

@@ -1,602 +0,0 @@
-# Python imports
-import uuid
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from sentry_sdk import capture_exception
-
-# Django imports
-from django.db.models import Max, Q
-
-# Module imports
-from plane.api.views import BaseAPIView
-from plane.db.models import (
-    WorkspaceIntegration,
-    Importer,
-    APIToken,
-    Project,
-    State,
-    IssueSequence,
-    Issue,
-    IssueActivity,
-    IssueComment,
-    IssueLink,
-    IssueLabel,
-    Workspace,
-    IssueAssignee,
-    Module,
-    ModuleLink,
-    ModuleIssue,
-    Label,
-)
-from plane.api.serializers import (
-    ImporterSerializer,
-    IssueFlatSerializer,
-    ModuleSerializer,
-)
-from plane.utils.integrations.github import get_github_repo_details
-from plane.utils.importers.jira import jira_project_issue_summary
-from plane.bgtasks.importer_task import service_importer
-from plane.utils.html_processor import strip_tags
-
-
-class ServiceIssueImportSummaryEndpoint(BaseAPIView):
-
-    def get(self, request, slug, service):
-        try:
-            if service == "github":
-                owner = request.GET.get("owner", False)
-                repo = request.GET.get("repo", False)
-
-                if not owner or not repo:
-                    return Response(
-                        {"error": "Owner and repo are required"},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-
-                workspace_integration = WorkspaceIntegration.objects.get(
-                    integration__provider="github", workspace__slug=slug
-                )
-
-                access_tokens_url = workspace_integration.metadata.get(
-                    "access_tokens_url", False
-                )
-
-                if not access_tokens_url:
-                    return Response(
-                        {
-                            "error": "There was an error during the installation of the GitHub app. To resolve this issue, we recommend reinstalling the GitHub app."
-                        },
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-
-                issue_count, labels, collaborators = get_github_repo_details(
-                    access_tokens_url, owner, repo
-                )
-                return Response(
-                    {
-                        "issue_count": issue_count,
-                        "labels": labels,
-                        "collaborators": collaborators,
-                    },
-                    status=status.HTTP_200_OK,
-                )
-
-            if service == "jira":
-                # Check for all the keys
-                params = {
-                    "project_key": "Project key is required",
-                    "api_token": "API token is required",
-                    "email": "Email is required",
-                    "cloud_hostname": "Cloud hostname is required",
-                }
-
-                for key, error_message in params.items():
-                    if not request.GET.get(key, False):
-                        return Response(
-                            {"error": error_message}, status=status.HTTP_400_BAD_REQUEST
-                        )
-
-                project_key = request.GET.get("project_key", "")
-                api_token = request.GET.get("api_token", "")
-                email = request.GET.get("email", "")
-                cloud_hostname = request.GET.get("cloud_hostname", "")
-
-                response = jira_project_issue_summary(
-                    email, api_token, project_key, cloud_hostname
-                )
-                if "error" in response:
-                    return Response(response, status=status.HTTP_400_BAD_REQUEST)
-                else:
-                    return Response(
-                        response,
-                        status=status.HTTP_200_OK,
-                    )
-            return Response(
-                {"error": "Service not supported yet"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except WorkspaceIntegration.DoesNotExist:
-            return Response(
-                {"error": "Requested integration was not installed in the workspace"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class ImportServiceEndpoint(BaseAPIView):
-    def post(self, request, slug, service):
-        try:
-            project_id = request.data.get("project_id", False)
-
-            if not project_id:
-                return Response(
-                    {"error": "Project ID is required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            workspace = Workspace.objects.get(slug=slug)
-
-            if service == "github":
-                data = request.data.get("data", False)
-                metadata = request.data.get("metadata", False)
-                config = request.data.get("config", False)
-                if not data or not metadata or not config:
-                    return Response(
-                        {"error": "Data, config and metadata are required"},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-
-                api_token = APIToken.objects.filter(
-                    user=request.user, workspace=workspace
-                ).first()
-                if api_token is None:
-                    api_token = APIToken.objects.create(
-                        user=request.user,
-                        label="Importer",
-                        workspace=workspace,
-                    )
-
-                importer = Importer.objects.create(
-                    service=service,
-                    project_id=project_id,
-                    status="queued",
-                    initiated_by=request.user,
-                    data=data,
-                    metadata=metadata,
-                    token=api_token,
-                    config=config,
-                    created_by=request.user,
-                    updated_by=request.user,
-                )
-
-                service_importer.delay(service, importer.id)
-                serializer = ImporterSerializer(importer)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-            if service == "jira":
-                data = request.data.get("data", False)
-                metadata = request.data.get("metadata", False)
-                config = request.data.get("config", False)
-                if not data or not metadata:
-                    return Response(
-                        {"error": "Data, config and metadata are required"},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                api_token = APIToken.objects.filter(
-                    user=request.user, workspace=workspace
-                ).first()
-                if api_token is None:
-                    api_token = APIToken.objects.create(
-                        user=request.user,
-                        label="Importer",
-                        workspace=workspace,
-                    )
-
-                importer = Importer.objects.create(
-                    service=service,
-                    project_id=project_id,
-                    status="queued",
-                    initiated_by=request.user,
-                    data=data,
-                    metadata=metadata,
-                    token=api_token,
-                    config=config,
-                    created_by=request.user,
-                    updated_by=request.user,
-                )
-
-                service_importer.delay(service, importer.id)
-                serializer = ImporterSerializer(importer)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-            return Response(
-                {"error": "Servivce not supported yet"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except (
-            Workspace.DoesNotExist,
-            WorkspaceIntegration.DoesNotExist,
-            Project.DoesNotExist,
-        ) as e:
-            return Response(
-                {"error": "Workspace Integration or Project does not exist"},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def get(self, request, slug):
-        try:
-            imports = (
-                Importer.objects.filter(workspace__slug=slug)
-                .order_by("-created_at")
-                .select_related("initiated_by", "project", "workspace")
-            )
-            serializer = ImporterSerializer(imports, many=True)
-            return Response(serializer.data)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def delete(self, request, slug, service, pk):
-        try:
-            importer = Importer.objects.get(
-                pk=pk, service=service, workspace__slug=slug
-            )
-
-            if importer.imported_data is not None:
-                # Delete all imported Issues
-                imported_issues = importer.imported_data.get("issues", [])
-                Issue.issue_objects.filter(id__in=imported_issues).delete()
-
-                # Delete all imported Labels
-                imported_labels = importer.imported_data.get("labels", [])
-                Label.objects.filter(id__in=imported_labels).delete()
-
-                if importer.service == "jira":
-                    imported_modules = importer.imported_data.get("modules", [])
-                    Module.objects.filter(id__in=imported_modules).delete()
-            importer.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def patch(self, request, slug, service, pk):
-        try:
-            importer = Importer.objects.get(
-                pk=pk, service=service, workspace__slug=slug
-            )
-            serializer = ImporterSerializer(importer, data=request.data, partial=True)
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Importer.DoesNotExist:
-            return Response(
-                {"error": "Importer Does not exists"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class UpdateServiceImportStatusEndpoint(BaseAPIView):
-    def post(self, request, slug, project_id, service, importer_id):
-        try:
-            importer = Importer.objects.get(
-                pk=importer_id,
-                workspace__slug=slug,
-                project_id=project_id,
-                service=service,
-            )
-            importer.status = request.data.get("status", "processing")
-            importer.save()
-            return Response(status.HTTP_200_OK)
-        except Importer.DoesNotExist:
-            return Response(
-                {"error": "Importer does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-
-
-class BulkImportIssuesEndpoint(BaseAPIView):
-    def post(self, request, slug, project_id, service):
-        try:
-            # Get the project
-            project = Project.objects.get(pk=project_id, workspace__slug=slug)
-
-            # Get the default state
-            default_state = State.objects.filter(
-                ~Q(name="Triage"), project_id=project_id, default=True
-            ).first()
-            # if there is no default state assign any random state
-            if default_state is None:
-                default_state = State.objects.filter(
-                    ~Q(name="Triage"), project_id=project_id
-                ).first()
-
-            # Get the maximum sequence_id
-            last_id = IssueSequence.objects.filter(project_id=project_id).aggregate(
-                largest=Max("sequence")
-            )["largest"]
-
-            last_id = 1 if last_id is None else last_id + 1
-
-            # Get the maximum sort order
-            largest_sort_order = Issue.objects.filter(
-                project_id=project_id, state=default_state
-            ).aggregate(largest=Max("sort_order"))["largest"]
-
-            largest_sort_order = (
-                65535 if largest_sort_order is None else largest_sort_order + 10000
-            )
-
-            # Get the issues_data
-            issues_data = request.data.get("issues_data", [])
-
-            if not len(issues_data):
-                return Response(
-                    {"error": "Issue data is required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            # Issues
-            bulk_issues = []
-            for issue_data in issues_data:
-                bulk_issues.append(
-                    Issue(
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                        state_id=issue_data.get("state")
-                        if issue_data.get("state", False)
-                        else default_state.id,
-                        name=issue_data.get("name", "Issue Created through Bulk"),
-                        description_html=issue_data.get("description_html", "<p></p>"),
-                        description_stripped=(
-                            None
-                            if (
-                                issue_data.get("description_html") == ""
-                                or issue_data.get("description_html") is None
-                            )
-                            else strip_tags(issue_data.get("description_html"))
-                        ),
-                        sequence_id=last_id,
-                        sort_order=largest_sort_order,
-                        start_date=issue_data.get("start_date", None),
-                        target_date=issue_data.get("target_date", None),
-                        priority=issue_data.get("priority", "none"),
-                        created_by=request.user,
-                    )
-                )
-
-                largest_sort_order = largest_sort_order + 10000
-                last_id = last_id + 1
-
-            issues = Issue.objects.bulk_create(
-                bulk_issues,
-                batch_size=100,
-                ignore_conflicts=True,
-            )
-
-            # Sequences
-            _ = IssueSequence.objects.bulk_create(
-                [
-                    IssueSequence(
-                        issue=issue,
-                        sequence=issue.sequence_id,
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                    )
-                    for issue in issues
-                ],
-                batch_size=100,
-            )
-
-            # Attach Labels
-            bulk_issue_labels = []
-            for issue, issue_data in zip(issues, issues_data):
-                labels_list = issue_data.get("labels_list", [])
-                bulk_issue_labels = bulk_issue_labels + [
-                    IssueLabel(
-                        issue=issue,
-                        label_id=label_id,
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                        created_by=request.user,
-                    )
-                    for label_id in labels_list
-                ]
-
-            _ = IssueLabel.objects.bulk_create(
-                bulk_issue_labels, batch_size=100, ignore_conflicts=True
-            )
-
-            # Attach Assignees
-            bulk_issue_assignees = []
-            for issue, issue_data in zip(issues, issues_data):
-                assignees_list = issue_data.get("assignees_list", [])
-                bulk_issue_assignees = bulk_issue_assignees + [
-                    IssueAssignee(
-                        issue=issue,
-                        assignee_id=assignee_id,
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                        created_by=request.user,
-                    )
-                    for assignee_id in assignees_list
-                ]
-
-            _ = IssueAssignee.objects.bulk_create(
-                bulk_issue_assignees, batch_size=100, ignore_conflicts=True
-            )
-
-            # Track the issue activities
-            IssueActivity.objects.bulk_create(
-                [
-                    IssueActivity(
-                        issue=issue,
-                        actor=request.user,
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                        comment=f"imported the issue from {service}",
-                        verb="created",
-                        created_by=request.user,
-                    )
-                    for issue in issues
-                ],
-                batch_size=100,
-            )
-
-            # Create Comments
-            bulk_issue_comments = []
-            for issue, issue_data in zip(issues, issues_data):
-                comments_list = issue_data.get("comments_list", [])
-                bulk_issue_comments = bulk_issue_comments + [
-                    IssueComment(
-                        issue=issue,
-                        comment_html=comment.get("comment_html", "<p></p>"),
-                        actor=request.user,
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                        created_by=request.user,
-                    )
-                    for comment in comments_list
-                ]
-
-            _ = IssueComment.objects.bulk_create(bulk_issue_comments, batch_size=100)
-
-            # Attach Links
-            _ = IssueLink.objects.bulk_create(
-                [
-                    IssueLink(
-                        issue=issue,
-                        url=issue_data.get("link", {}).get("url", "https://github.com"),
-                        title=issue_data.get("link", {}).get("title", "Original Issue"),
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                        created_by=request.user,
-                    )
-                    for issue, issue_data in zip(issues, issues_data)
-                ]
-            )
-
-            return Response(
-                {"issues": IssueFlatSerializer(issues, many=True).data},
-                status=status.HTTP_201_CREATED,
-            )
-        except Project.DoesNotExist:
-            return Response(
-                {"error": "Project Does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class BulkImportModulesEndpoint(BaseAPIView):
-    def post(self, request, slug, project_id, service):
-        try:
-            modules_data = request.data.get("modules_data", [])
-            project = Project.objects.get(pk=project_id, workspace__slug=slug)
-
-            modules = Module.objects.bulk_create(
-                [
-                    Module(
-                        name=module.get("name", uuid.uuid4().hex),
-                        description=module.get("description", ""),
-                        start_date=module.get("start_date", None),
-                        target_date=module.get("target_date", None),
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                        created_by=request.user,
-                    )
-                    for module in modules_data
-                ],
-                batch_size=100,
-                ignore_conflicts=True,
-            )
-
-            modules = Module.objects.filter(id__in=[module.id for module in modules])
-
-            if len(modules) == len(modules_data):
-                _ = ModuleLink.objects.bulk_create(
-                    [
-                        ModuleLink(
-                            module=module,
-                            url=module_data.get("link", {}).get(
-                                "url", "https://plane.so"
-                            ),
-                            title=module_data.get("link", {}).get(
-                                "title", "Original Issue"
-                            ),
-                            project_id=project_id,
-                            workspace_id=project.workspace_id,
-                            created_by=request.user,
-                        )
-                        for module, module_data in zip(modules, modules_data)
-                    ],
-                    batch_size=100,
-                    ignore_conflicts=True,
-                )
-
-                bulk_module_issues = []
-                for module, module_data in zip(modules, modules_data):
-                    module_issues_list = module_data.get("module_issues_list", [])
-                    bulk_module_issues = bulk_module_issues + [
-                        ModuleIssue(
-                            issue_id=issue,
-                            module=module,
-                            project_id=project_id,
-                            workspace_id=project.workspace_id,
-                            created_by=request.user,
-                        )
-                        for issue in module_issues_list
-                    ]
-
-                _ = ModuleIssue.objects.bulk_create(
-                    bulk_module_issues, batch_size=100, ignore_conflicts=True
-                )
-
-                serializer = ModuleSerializer(modules, many=True)
-                return Response(
-                    {"modules": serializer.data}, status=status.HTTP_201_CREATED
-                )
-
-            else:
-                return Response(
-                    {"message": "Modules created but issues could not be imported"},
-                    status=status.HTTP_200_OK,
-                )
-        except Project.DoesNotExist:
-            return Response(
-                {"error": "Project does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/inbox.py

@@ -1,90 +1,30 @@
 # Python imports
 import json
 
-# Django import
+# Django improts
 from django.utils import timezone
-from django.db.models import Q, Count, OuterRef, Func, F, Prefetch
+from django.db.models import Q
 from django.core.serializers.json import DjangoJSONEncoder
 
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
-from sentry_sdk import capture_exception
 
 # Module imports
-from .base import BaseViewSet
+from .base import BaseAPIView
-from plane.api.permissions import ProjectBasePermission, ProjectLitePermission
+from plane.app.permissions import ProjectLitePermission
-from plane.db.models import (
+from plane.api.serializers import InboxIssueSerializer, IssueSerializer
-    Inbox,
+from plane.db.models import InboxIssue, Issue, State, ProjectMember, Project, Inbox
-    InboxIssue,
-    Issue,
-    State,
-    IssueLink,
-    IssueAttachment,
-    ProjectMember,
-    ProjectDeployBoard,
-)
-from plane.api.serializers import (
-    IssueSerializer,
-    InboxSerializer,
-    InboxIssueSerializer,
-    IssueCreateSerializer,
-    IssueStateInboxSerializer,
-)
-from plane.utils.issue_filters import issue_filters
 from plane.bgtasks.issue_activites_task import issue_activity
 
 
-class InboxViewSet(BaseViewSet):
+class InboxIssueAPIEndpoint(BaseAPIView):
-    permission_classes = [
+    """
-        ProjectBasePermission,
+    This viewset automatically provides `list`, `create`, `retrieve`,
-    ]
+    `update` and `destroy` actions related to inbox issues.
 
-    serializer_class = InboxSerializer
+    """
-    model = Inbox
 
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .filter(
-                workspace__slug=self.kwargs.get("slug"),
-                project_id=self.kwargs.get("project_id"),
-            )
-            .annotate(
-                pending_issue_count=Count(
-                    "issue_inbox",
-                    filter=Q(issue_inbox__status=-2),
-                )
-            )
-            .select_related("workspace", "project")
-        )
-
-    def perform_create(self, serializer):
-        serializer.save(project_id=self.kwargs.get("project_id"))
-
-    def destroy(self, request, slug, project_id, pk):
-        try:
-            inbox = Inbox.objects.get(
-                workspace__slug=slug, project_id=project_id, pk=pk
-            )
-            # Handle default inbox delete
-            if inbox.is_default:
-                return Response(
-                    {"error": "You cannot delete the default inbox"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            inbox.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wronf please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class InboxIssueViewSet(BaseViewSet):
     permission_classes = [
         ProjectLitePermission,
     ]
@@ -97,483 +37,195 @@ class InboxIssueViewSet(BaseViewSet):
     ]
 
     def get_queryset(self):
-        return self.filter_queryset(
+        inbox = Inbox.objects.filter(
-            super()
+            workspace__slug=self.kwargs.get("slug"),
-            .get_queryset()
+            project_id=self.kwargs.get("project_id"),
-            .filter(
+        ).first()
+
+        project = Project.objects.get(
+            workspace__slug=self.kwargs.get("slug"), pk=self.kwargs.get("project_id")
+        )
+
+        if inbox is None and not project.inbox_view:
+            return InboxIssue.objects.none()
+
+        return (
+            InboxIssue.objects.filter(
                 Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
                 workspace__slug=self.kwargs.get("slug"),
                 project_id=self.kwargs.get("project_id"),
-                inbox_id=self.kwargs.get("inbox_id"),
+                inbox_id=inbox.id,
             )
             .select_related("issue", "workspace", "project")
+            .order_by(self.kwargs.get("order_by", "-created_at"))
         )
 
-    def list(self, request, slug, project_id, inbox_id):
+    def get(self, request, slug, project_id, issue_id=None):
-        try:
+        if issue_id:
-            filters = issue_filters(request.query_params, "GET")
+            inbox_issue_queryset = self.get_queryset().get(issue_id=issue_id)
-            issues = (
+            inbox_issue_data = InboxIssueSerializer(
-                Issue.objects.filter(
+                inbox_issue_queryset,
-                    issue_inbox__inbox_id=inbox_id,
+                fields=self.fields,
-                    workspace__slug=slug,
+                expand=self.expand,
-                    project_id=project_id,
+            ).data
-                )
-                .filter(**filters)
-                .annotate(bridge_id=F("issue_inbox__id"))
-                .select_related("workspace", "project", "state", "parent")
-                .prefetch_related("assignees", "labels")
-                .order_by("issue_inbox__snoozed_till", "issue_inbox__status")
-                .annotate(
-                    sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    attachment_count=IssueAttachment.objects.filter(
-                        issue=OuterRef("id")
-                    )
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .prefetch_related(
-                    Prefetch(
-                        "issue_inbox",
-                        queryset=InboxIssue.objects.only(
-                            "status", "duplicate_to", "snoozed_till", "source"
-                        ),
-                    )
-                )
-            )
-            issues_data = IssueStateInboxSerializer(issues, many=True).data
             return Response(
-                issues_data,
+                inbox_issue_data,
                 status=status.HTTP_200_OK,
             )
+        issue_queryset = self.get_queryset()
+        return self.paginate(
+            request=request,
+            queryset=(issue_queryset),
+            on_results=lambda inbox_issues: InboxIssueSerializer(
+                inbox_issues,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+            ).data,
+        )
 
-        except Exception as e:
+    def post(self, request, slug, project_id):
-            capture_exception(e)
+        if not request.data.get("issue", {}).get("name", False):
             return Response(
-                {"error": "Something went wrong please try again later"},
+                {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        inbox = Inbox.objects.filter(
+            workspace__slug=slug, project_id=project_id
+        ).first()
+
+        project = Project.objects.get(
+            workspace__slug=slug,
+            pk=project_id,
+        )
+
+        # Inbox view
+        if inbox is None and not project.inbox_view:
+            return Response(
+                {
+                    "error": "Inbox is not enabled for this project enable it through the project settings"
+                },
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-    def create(self, request, slug, project_id, inbox_id):
+        # Check for valid priority
-        try:
+        if not request.data.get("issue", {}).get("priority", "none") in [
-            if not request.data.get("issue", {}).get("name", False):
+            "low",
-                return Response(
+            "medium",
-                    {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
+            "high",
-                )
+            "urgent",
-
+            "none",
-            # Check for valid priority
+        ]:
-            if not request.data.get("issue", {}).get("priority", "none") in [
-                "low",
-                "medium",
-                "high",
-                "urgent",
-                "none",
-            ]:
-                return Response(
-                    {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            # Create or get state
-            state, _ = State.objects.get_or_create(
-                name="Triage",
-                group="backlog",
-                description="Default state for managing all Inbox Issues",
-                project_id=project_id,
-                color="#ff7700",
-            )
-
-            # create an issue
-            issue = Issue.objects.create(
-                name=request.data.get("issue", {}).get("name"),
-                description=request.data.get("issue", {}).get("description", {}),
-                description_html=request.data.get("issue", {}).get(
-                    "description_html", "<p></p>"
-                ),
-                priority=request.data.get("issue", {}).get("priority", "low"),
-                project_id=project_id,
-                state=state,
-            )
-
-            # Create an Issue Activity
-            issue_activity.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
-            InboxIssue.objects.create(
-                inbox_id=inbox_id,
-                project_id=project_id,
-                issue=issue,
-                source=request.data.get("source", "in-app"),
-            )
-
-            serializer = IssueStateInboxSerializer(issue)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
             return Response(
-                {"error": "Something went wrong please try again later"},
+                {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # Create or get state
+        state, _ = State.objects.get_or_create(
+            name="Triage",
+            group="backlog",
+            description="Default state for managing all Inbox Issues",
+            project_id=project_id,
+            color="#ff7700",
+        )
+
+        # create an issue
+        issue = Issue.objects.create(
+            name=request.data.get("issue", {}).get("name"),
+            description=request.data.get("issue", {}).get("description", {}),
+            description_html=request.data.get("issue", {}).get(
+                "description_html", "<p></p>"
+            ),
+            priority=request.data.get("issue", {}).get("priority", "low"),
+            project_id=project_id,
+            state=state,
+        )
+
+        # Create an Issue Activity
+        issue_activity.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
+        inbox_issue = InboxIssue.objects.create(
+            inbox_id=inbox.id,
+            project_id=project_id,
+            issue=issue,
+            source=request.data.get("source", "in-app"),
+        )
+
+        serializer = InboxIssueSerializer(inbox_issue)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def patch(self, request, slug, project_id, issue_id):
+        inbox = Inbox.objects.filter(
+            workspace__slug=slug, project_id=project_id
+        ).first()
+
+        project = Project.objects.get(
+            workspace__slug=slug,
+            pk=project_id,
+        )
+
+        # Inbox view
+        if inbox is None and not project.inbox_view:
+            return Response(
+                {
+                    "error": "Inbox is not enabled for this project enable it through the project settings"
+                },
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-    def partial_update(self, request, slug, project_id, inbox_id, pk):
+        # Get the inbox issue
-        try:
+        inbox_issue = InboxIssue.objects.get(
-            inbox_issue = InboxIssue.objects.get(
+            issue_id=issue_id,
-                pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+            workspace__slug=slug,
-            )
+            project_id=project_id,
-            # Get the project member
+            inbox_id=inbox.id,
-            project_member = ProjectMember.objects.get(workspace__slug=slug, project_id=project_id, member=request.user)
+        )
-            # Only project members admins and created_by users can access this endpoint
-            if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(request.user.id):
-                return Response({"error": "You cannot edit inbox issues"}, status=status.HTTP_400_BAD_REQUEST)
 
-            # Get issue data
+        # Get the project member
-            issue_data = request.data.pop("issue", False)
+        project_member = ProjectMember.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            member=request.user,
+            is_active=True,
+        )
 
-            if bool(issue_data):
+        # Only project members admins and created_by users can access this endpoint
-                issue = Issue.objects.get(
+        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
-                    pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
+            request.user.id
-                )
+        ):
-                # Only allow guests and viewers to edit name and description
-                if project_member.role <= 10:
-                    # viewers and guests since only viewers and guests 
-                    issue_data = {
-                        "name": issue_data.get("name", issue.name),
-                        "description_html": issue_data.get("description_html", issue.description_html),
-                        "description": issue_data.get("description", issue.description)
-                    }
-
-                issue_serializer = IssueCreateSerializer(
-                    issue, data=issue_data, partial=True
-                )
-
-                if issue_serializer.is_valid():
-                    current_instance = issue
-                    # Log all the updates
-                    requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
-                    if issue is not None:
-                        issue_activity.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:
-                    return Response(
-                        issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
-                    )
-
-            # Only project admins and members can edit inbox issue attributes
-            if project_member.role > 10:
-                serializer = InboxIssueSerializer(
-                    inbox_issue, data=request.data, partial=True
-                )
-
-                if serializer.is_valid():
-                    serializer.save()
-                    # Update the issue state if the issue is rejected or marked as duplicate
-                    if serializer.data["status"] in [-1, 2]:
-                        issue = Issue.objects.get(
-                            pk=inbox_issue.issue_id,
-                            workspace__slug=slug,
-                            project_id=project_id,
-                        )
-                        state = State.objects.filter(
-                            group="cancelled", workspace__slug=slug, project_id=project_id
-                        ).first()
-                        if state is not None:
-                            issue.state = state
-                            issue.save()
-
-                    # Update the issue state if it is accepted
-                    if serializer.data["status"] in [1]:
-                        issue = Issue.objects.get(
-                            pk=inbox_issue.issue_id,
-                            workspace__slug=slug,
-                            project_id=project_id,
-                        )
-
-                        # Update the issue state only if it is in triage state
-                        if issue.state.name == "Triage":
-                            # Move to default state
-                            state = State.objects.filter(
-                                workspace__slug=slug, project_id=project_id, default=True
-                            ).first()
-                            if state is not None:
-                                issue.state = state
-                                issue.save()
-
-                    return Response(serializer.data, status=status.HTTP_200_OK)
-                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-            else:
-                return Response(InboxIssueSerializer(inbox_issue).data, status=status.HTTP_200_OK)
-        except InboxIssue.DoesNotExist:
             return Response(
-                {"error": "Inbox Issue does not exist"},
+                {"error": "You cannot edit inbox issues"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-    def retrieve(self, request, slug, project_id, inbox_id, pk):
+        # Get issue data
-        try:
+        issue_data = request.data.pop("issue", False)
-            inbox_issue = InboxIssue.objects.get(
+
-                pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+        if bool(issue_data):
-            )
             issue = Issue.objects.get(
-                pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
+                pk=issue_id, workspace__slug=slug, project_id=project_id
-            )
-            serializer = IssueStateInboxSerializer(issue)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
             )
+            # Only allow guests and viewers to edit name and description
+            if project_member.role <= 10:
+                # viewers and guests since only viewers and guests
+                issue_data = {
+                    "name": issue_data.get("name", issue.name),
+                    "description_html": issue_data.get(
+                        "description_html", issue.description_html
+                    ),
+                    "description": issue_data.get("description", issue.description),
+                }
 
-    def destroy(self, request, slug, project_id, inbox_id, pk):
+            issue_serializer = IssueSerializer(issue, data=issue_data, partial=True)
-        try:
-            inbox_issue = InboxIssue.objects.get(
-                pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
-            )
-            # Get the project member
-            project_member = ProjectMember.objects.get(workspace__slug=slug, project_id=project_id, member=request.user)
-
-            if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(request.user.id):
-                return Response({"error": "You cannot delete inbox issue"}, status=status.HTTP_400_BAD_REQUEST)
-
-            # Check the issue status
-            if inbox_issue.status in [-2, -1, 0, 2]:
-                # Delete the issue also
-                Issue.objects.filter(workspace__slug=slug, project_id=project_id, pk=inbox_issue.issue_id).delete() 
-
-            inbox_issue.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except InboxIssue.DoesNotExist:
-            return Response({"error": "Inbox Issue does not exists"}, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class InboxIssuePublicViewSet(BaseViewSet):
-    serializer_class = InboxIssueSerializer
-    model = InboxIssue
-
-    filterset_fields = [
-        "status",
-    ]
-
-    def get_queryset(self):
-        project_deploy_board = ProjectDeployBoard.objects.get(workspace__slug=self.kwargs.get("slug"), project_id=self.kwargs.get("project_id"))
-        if project_deploy_board is not None:
-            return self.filter_queryset(
-                super()
-                .get_queryset()
-                .filter(
-                    Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
-                    project_id=self.kwargs.get("project_id"),
-                    workspace__slug=self.kwargs.get("slug"),
-                    inbox_id=self.kwargs.get("inbox_id"),
-                )
-                .select_related("issue", "workspace", "project")
-            )
-        else:
-            return InboxIssue.objects.none()
-
-    def list(self, request, slug, project_id, inbox_id):
-        try:
-            project_deploy_board = ProjectDeployBoard.objects.get(workspace__slug=slug, project_id=project_id)
-            if project_deploy_board.inbox is None:
-                return Response({"error": "Inbox is not enabled for this Project Board"}, status=status.HTTP_400_BAD_REQUEST)
-
-            filters = issue_filters(request.query_params, "GET")
-            issues = (
-                Issue.objects.filter(
-                    issue_inbox__inbox_id=inbox_id,
-                    workspace__slug=slug,
-                    project_id=project_id,
-                )
-                .filter(**filters)
-                .annotate(bridge_id=F("issue_inbox__id"))
-                .select_related("workspace", "project", "state", "parent")
-                .prefetch_related("assignees", "labels")
-                .order_by("issue_inbox__snoozed_till", "issue_inbox__status")
-                .annotate(
-                    sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    attachment_count=IssueAttachment.objects.filter(
-                        issue=OuterRef("id")
-                    )
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .prefetch_related(
-                    Prefetch(
-                        "issue_inbox",
-                        queryset=InboxIssue.objects.only(
-                            "status", "duplicate_to", "snoozed_till", "source"
-                        ),
-                    )
-                )
-            )
-            issues_data = IssueStateInboxSerializer(issues, many=True).data
-            return Response(
-                issues_data,
-                status=status.HTTP_200_OK,
-            )
-        except ProjectDeployBoard.DoesNotExist:
-            return Response({"error": "Project Deploy Board does not exist"}, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def create(self, request, slug, project_id, inbox_id):
-        try:
-            project_deploy_board = ProjectDeployBoard.objects.get(workspace__slug=slug, project_id=project_id)
-            if project_deploy_board.inbox is None:
-                return Response({"error": "Inbox is not enabled for this Project Board"}, status=status.HTTP_400_BAD_REQUEST)
-
-            if not request.data.get("issue", {}).get("name", False):
-                return Response(
-                    {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            # Check for valid priority
-            if not request.data.get("issue", {}).get("priority", "none") in [
-                "low",
-                "medium",
-                "high",
-                "urgent",
-                "none",
-            ]:
-                return Response(
-                    {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            # Create or get state
-            state, _ = State.objects.get_or_create(
-                name="Triage",
-                group="backlog",
-                description="Default state for managing all Inbox Issues",
-                project_id=project_id,
-                color="#ff7700",
-            )
-
-            # create an issue
-            issue = Issue.objects.create(
-                name=request.data.get("issue", {}).get("name"),
-                description=request.data.get("issue", {}).get("description", {}),
-                description_html=request.data.get("issue", {}).get(
-                    "description_html", "<p></p>"
-                ),
-                priority=request.data.get("issue", {}).get("priority", "low"),
-                project_id=project_id,
-                state=state,
-            )
-
-            # Create an Issue Activity
-            issue_activity.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
-            InboxIssue.objects.create(
-                inbox_id=inbox_id,
-                project_id=project_id,
-                issue=issue,
-                source=request.data.get("source", "in-app"),
-            )
-
-            serializer = IssueStateInboxSerializer(issue)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def partial_update(self, request, slug, project_id, inbox_id, pk):
-        try:
-            project_deploy_board = ProjectDeployBoard.objects.get(workspace__slug=slug, project_id=project_id)
-            if project_deploy_board.inbox is None:
-                return Response({"error": "Inbox is not enabled for this Project Board"}, status=status.HTTP_400_BAD_REQUEST)
-
-            inbox_issue = InboxIssue.objects.get(
-                pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
-            )
-            # Get the project member
-            if str(inbox_issue.created_by_id) != str(request.user.id):
-                return Response({"error": "You cannot edit inbox issues"}, status=status.HTTP_400_BAD_REQUEST)
-
-            # Get issue data
-            issue_data = request.data.pop("issue", False)
-
-
-            issue = Issue.objects.get(
-                pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
-            )
-            # viewers and guests since only viewers and guests 
-            issue_data = {
-                "name": issue_data.get("name", issue.name),
-                "description_html": issue_data.get("description_html", issue.description_html),
-                "description": issue_data.get("description", issue.description)
-            }
-
-            issue_serializer = IssueCreateSerializer(
-                issue, data=issue_data, partial=True
-            )
 
             if issue_serializer.is_valid():
                 current_instance = issue
@@ -584,71 +236,117 @@ class InboxIssuePublicViewSet(BaseViewSet):
                         type="issue.activity.updated",
                         requested_data=requested_data,
                         actor_id=str(request.user.id),
-                        issue_id=str(issue.id),
+                        issue_id=str(issue_id),
                         project_id=str(project_id),
                         current_instance=json.dumps(
                             IssueSerializer(current_instance).data,
                             cls=DjangoJSONEncoder,
                         ),
-                        epoch=int(timezone.now().timestamp())
+                        epoch=int(timezone.now().timestamp()),
                     )
                 issue_serializer.save()
-                return Response(issue_serializer.data, status=status.HTTP_200_OK)
+            else:
-            return Response(issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+                return Response(
-        except InboxIssue.DoesNotExist:
+                    issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
-            return Response(
+                )
-                {"error": "Inbox Issue does not exist"},
+
-                status=status.HTTP_400_BAD_REQUEST,
+        # Only project admins and members can edit inbox issue attributes
+        if project_member.role > 10:
+            serializer = InboxIssueSerializer(
+                inbox_issue, data=request.data, partial=True
             )
-        except Exception as e:
+
-            capture_exception(e)
+            if serializer.is_valid():
+                serializer.save()
+                # Update the issue state if the issue is rejected or marked as duplicate
+                if serializer.data["status"] in [-1, 2]:
+                    issue = Issue.objects.get(
+                        pk=issue_id,
+                        workspace__slug=slug,
+                        project_id=project_id,
+                    )
+                    state = State.objects.filter(
+                        group="cancelled", workspace__slug=slug, project_id=project_id
+                    ).first()
+                    if state is not None:
+                        issue.state = state
+                        issue.save()
+
+                # Update the issue state if it is accepted
+                if serializer.data["status"] in [1]:
+                    issue = Issue.objects.get(
+                        pk=issue_id,
+                        workspace__slug=slug,
+                        project_id=project_id,
+                    )
+
+                    # Update the issue state only if it is in triage state
+                    if issue.state.name == "Triage":
+                        # Move to default state
+                        state = State.objects.filter(
+                            workspace__slug=slug, project_id=project_id, default=True
+                        ).first()
+                        if state is not None:
+                            issue.state = state
+                            issue.save()
+
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        else:
             return Response(
-                {"error": "Something went wrong please try again later"},
+                InboxIssueSerializer(inbox_issue).data, status=status.HTTP_200_OK
+            )
+
+    def delete(self, request, slug, project_id, issue_id):
+        inbox = Inbox.objects.filter(
+            workspace__slug=slug, project_id=project_id
+        ).first()
+
+        project = Project.objects.get(
+            workspace__slug=slug,
+            pk=project_id,
+        )
+
+        # Inbox view
+        if inbox is None and not project.inbox_view:
+            return Response(
+                {
+                    "error": "Inbox is not enabled for this project enable it through the project settings"
+                },
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-    def retrieve(self, request, slug, project_id, inbox_id, pk):
+        # Get the inbox issue
-        try:
+        inbox_issue = InboxIssue.objects.get(
-            project_deploy_board = ProjectDeployBoard.objects.get(workspace__slug=slug, project_id=project_id)
+            issue_id=issue_id,
-            if project_deploy_board.inbox is None:
+            workspace__slug=slug,
-                return Response({"error": "Inbox is not enabled for this Project Board"}, status=status.HTTP_400_BAD_REQUEST)
+            project_id=project_id,
-        
+            inbox_id=inbox.id,
-            inbox_issue = InboxIssue.objects.get(
+        )
-                pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+
-            )
+        # Get the project member
-            issue = Issue.objects.get(
+        project_member = ProjectMember.objects.get(
-                pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
+            workspace__slug=slug,
-            )
+            project_id=project_id,
-            serializer = IssueStateInboxSerializer(issue)
+            member=request.user,
-            return Response(serializer.data, status=status.HTTP_200_OK)
+            is_active=True,
-        except Exception as e:
+        )
-            capture_exception(e)
+
+        # Check the inbox issue created
+        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
+            request.user.id
+        ):
             return Response(
-                {"error": "Something went wrong please try again later"},
+                {"error": "You cannot delete inbox issue"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-    def destroy(self, request, slug, project_id, inbox_id, pk):
+        # Check the issue status
-        try:
+        if inbox_issue.status in [-2, -1, 0, 2]:
-            project_deploy_board = ProjectDeployBoard.objects.get(workspace__slug=slug, project_id=project_id)
+            # Delete the issue also
-            if project_deploy_board.inbox is None:
+            Issue.objects.filter(
-                return Response({"error": "Inbox is not enabled for this Project Board"}, status=status.HTTP_400_BAD_REQUEST)
+                workspace__slug=slug, project_id=project_id, pk=issue_id
-
+            ).delete()
-            inbox_issue = InboxIssue.objects.get(
-                pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
-            )
-
-            if str(inbox_issue.created_by_id) != str(request.user.id):
-                return Response({"error": "You cannot delete inbox issue"}, status=status.HTTP_400_BAD_REQUEST)
-
-            inbox_issue.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except InboxIssue.DoesNotExist:
-            return Response({"error": "Inbox Issue does not exists"}, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
 
+        inbox_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

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

@@ -1,229 +0,0 @@
-# Python improts
-import uuid
-
-# Django imports
-from django.db import IntegrityError
-from django.contrib.auth.hashers import make_password
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-from sentry_sdk import capture_exception
-
-# Module imports
-from plane.api.views import BaseViewSet
-from plane.db.models import (
-    Integration,
-    WorkspaceIntegration,
-    Workspace,
-    User,
-    WorkspaceMember,
-    APIToken,
-)
-from plane.api.serializers import IntegrationSerializer, WorkspaceIntegrationSerializer
-from plane.utils.integrations.github import (
-    get_github_metadata,
-    delete_github_installation,
-)
-from plane.api.permissions import WorkSpaceAdminPermission
-
-
-class IntegrationViewSet(BaseViewSet):
-    serializer_class = IntegrationSerializer
-    model = Integration
-
-    def create(self, request):
-        try:
-            serializer = IntegrationSerializer(data=request.data)
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def partial_update(self, request, pk):
-        try:
-            integration = Integration.objects.get(pk=pk)
-            if integration.verified:
-                return Response(
-                    {"error": "Verified integrations cannot be updated"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            serializer = IntegrationSerializer(
-                integration, data=request.data, partial=True
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-        except Integration.DoesNotExist:
-            return Response(
-                {"error": "Integration Does not exist"},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def destroy(self, request, pk):
-        try:
-            integration = Integration.objects.get(pk=pk)
-            if integration.verified:
-                return Response(
-                    {"error": "Verified integrations cannot be updated"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            integration.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except Integration.DoesNotExist:
-            return Response(
-                {"error": "Integration Does not exist"},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-
-
-class WorkspaceIntegrationViewSet(BaseViewSet):
-    serializer_class = WorkspaceIntegrationSerializer
-    model = WorkspaceIntegration
-
-    permission_classes = [
-        WorkSpaceAdminPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .select_related("integration")
-        )
-
-    def create(self, request, slug, provider):
-        try:
-            workspace = Workspace.objects.get(slug=slug)
-            integration = Integration.objects.get(provider=provider)
-            config = {}
-            if provider == "github":
-                installation_id = request.data.get("installation_id", None)
-                if not installation_id:
-                    return Response(
-                        {"error": "Installation ID is required"},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                metadata = get_github_metadata(installation_id)
-                config = {"installation_id": installation_id}
-
-            if provider == "slack":
-                metadata = request.data.get("metadata", {})
-                access_token = metadata.get("access_token", False)
-                team_id = metadata.get("team", {}).get("id", False)
-                if not metadata or not access_token or not team_id:
-                    return Response(
-                        {"error": "Access token and team id is required"},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                config = {"team_id": team_id, "access_token": access_token}
-
-            # Create a bot user
-            bot_user = User.objects.create(
-                email=f"{uuid.uuid4().hex}@plane.so",
-                username=uuid.uuid4().hex,
-                password=make_password(uuid.uuid4().hex),
-                is_password_autoset=True,
-                is_bot=True,
-                first_name=integration.title,
-                avatar=integration.avatar_url
-                if integration.avatar_url is not None
-                else "",
-            )
-
-            # Create an API Token for the bot user
-            api_token = APIToken.objects.create(
-                user=bot_user,
-                user_type=1,  # bot user
-                workspace=workspace,
-            )
-
-            workspace_integration = WorkspaceIntegration.objects.create(
-                workspace=workspace,
-                integration=integration,
-                actor=bot_user,
-                api_token=api_token,
-                metadata=metadata,
-                config=config,
-            )
-
-            # Add bot user as a member of workspace
-            _ = WorkspaceMember.objects.create(
-                workspace=workspace_integration.workspace,
-                member=bot_user,
-                role=20,
-            )
-            return Response(
-                WorkspaceIntegrationSerializer(workspace_integration).data,
-                status=status.HTTP_201_CREATED,
-            )
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"error": "Integration is already active in the workspace"},
-                    status=status.HTTP_410_GONE,
-                )
-            else:
-                capture_exception(e)
-                return Response(
-                    {"error": "Something went wrong please try again later"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-        except (Workspace.DoesNotExist, Integration.DoesNotExist) as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Workspace or Integration not found"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def destroy(self, request, slug, pk):
-        try:
-            workspace_integration = WorkspaceIntegration.objects.get(
-                pk=pk, workspace__slug=slug
-            )
-
-            if workspace_integration.integration.provider == "github":
-                installation_id = workspace_integration.config.get(
-                    "installation_id", False
-                )
-                if installation_id:
-                    delete_github_installation(installation_id=installation_id)
-
-            workspace_integration.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-
-        except WorkspaceIntegration.DoesNotExist:
-            return Response(
-                {"error": "Workspace Integration Does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

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

@@ -1,231 +0,0 @@
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from sentry_sdk import capture_exception
-
-# Module imports
-from plane.api.views import BaseViewSet, BaseAPIView
-from plane.db.models import (
-    GithubIssueSync,
-    GithubRepositorySync,
-    GithubRepository,
-    WorkspaceIntegration,
-    ProjectMember,
-    Label,
-    GithubCommentSync,
-    Project,
-)
-from plane.api.serializers import (
-    GithubIssueSyncSerializer,
-    GithubRepositorySyncSerializer,
-    GithubCommentSyncSerializer,
-)
-from plane.utils.integrations.github import get_github_repos
-from plane.api.permissions import ProjectBasePermission, ProjectEntityPermission
-
-
-class GithubRepositoriesEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectBasePermission,
-    ]
-
-    def get(self, request, slug, workspace_integration_id):
-        try:
-            page = request.GET.get("page", 1)
-            workspace_integration = WorkspaceIntegration.objects.get(
-                workspace__slug=slug, pk=workspace_integration_id
-            )
-
-            if workspace_integration.integration.provider != "github":
-                return Response(
-                    {"error": "Not a github integration"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            access_tokens_url = workspace_integration.metadata["access_tokens_url"]
-            repositories_url = (
-                workspace_integration.metadata["repositories_url"]
-                + f"?per_page=100&page={page}"
-            )
-            repositories = get_github_repos(access_tokens_url, repositories_url)
-            return Response(repositories, status=status.HTTP_200_OK)
-        except WorkspaceIntegration.DoesNotExist:
-            return Response(
-                {"error": "Workspace Integration Does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class GithubRepositorySyncViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectBasePermission,
-    ]
-
-    serializer_class = GithubRepositorySyncSerializer
-    model = GithubRepositorySync
-
-    def perform_create(self, serializer):
-        serializer.save(project_id=self.kwargs.get("project_id"))
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-        )
-
-    def create(self, request, slug, project_id, workspace_integration_id):
-        try:
-            name = request.data.get("name", False)
-            url = request.data.get("url", False)
-            config = request.data.get("config", {})
-            repository_id = request.data.get("repository_id", False)
-            owner = request.data.get("owner", False)
-
-            if not name or not url or not repository_id or not owner:
-                return Response(
-                    {"error": "Name, url, repository_id and owner are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            # Get the workspace integration
-            workspace_integration = WorkspaceIntegration.objects.get(
-                pk=workspace_integration_id
-            )
-
-            # Delete the old repository object
-            GithubRepositorySync.objects.filter(
-                project_id=project_id, workspace__slug=slug
-            ).delete()
-            GithubRepository.objects.filter(
-                project_id=project_id, workspace__slug=slug
-            ).delete()
-
-            # Create repository
-            repo = GithubRepository.objects.create(
-                name=name,
-                url=url,
-                config=config,
-                repository_id=repository_id,
-                owner=owner,
-                project_id=project_id,
-            )
-
-            # Create a Label for github
-            label = Label.objects.filter(
-                name="GitHub",
-                project_id=project_id,
-            ).first()
-
-            if label is None:
-                label = Label.objects.create(
-                    name="GitHub",
-                    project_id=project_id,
-                    description="Label to sync Plane issues with GitHub issues",
-                    color="#003773",
-                )
-
-            # Create repo sync
-            repo_sync = GithubRepositorySync.objects.create(
-                repository=repo,
-                workspace_integration=workspace_integration,
-                actor=workspace_integration.actor,
-                credentials=request.data.get("credentials", {}),
-                project_id=project_id,
-                label=label,
-            )
-
-            # Add bot as a member in the project
-            _ = ProjectMember.objects.get_or_create(
-                member=workspace_integration.actor, role=20, project_id=project_id
-            )
-
-            # Return Response
-            return Response(
-                GithubRepositorySyncSerializer(repo_sync).data,
-                status=status.HTTP_201_CREATED,
-            )
-
-        except WorkspaceIntegration.DoesNotExist:
-            return Response(
-                {"error": "Workspace Integration does not exist"},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class GithubIssueSyncViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    serializer_class = GithubIssueSyncSerializer
-    model = GithubIssueSync
-
-    def perform_create(self, serializer):
-        serializer.save(
-            project_id=self.kwargs.get("project_id"),
-            repository_sync_id=self.kwargs.get("repo_sync_id"),
-        )
-
-
-class BulkCreateGithubIssueSyncEndpoint(BaseAPIView):
-    def post(self, request, slug, project_id, repo_sync_id):
-        try:
-            project = Project.objects.get(pk=project_id, workspace__slug=slug)
-
-            github_issue_syncs = request.data.get("github_issue_syncs", [])
-            github_issue_syncs = GithubIssueSync.objects.bulk_create(
-                [
-                    GithubIssueSync(
-                        issue_id=github_issue_sync.get("issue"),
-                        repo_issue_id=github_issue_sync.get("repo_issue_id"),
-                        issue_url=github_issue_sync.get("issue_url"),
-                        github_issue_id=github_issue_sync.get("github_issue_id"),
-                        repository_sync_id=repo_sync_id,
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                        created_by=request.user,
-                        updated_by=request.user,
-                    )
-                    for github_issue_sync in github_issue_syncs
-                ],
-                batch_size=100,
-                ignore_conflicts=True,
-            )
-
-            serializer = GithubIssueSyncSerializer(github_issue_syncs, many=True)
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        except Project.DoesNotExist:
-            return Response(
-                {"error": "Project does not exist"},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class GithubCommentSyncViewSet(BaseViewSet):
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-    
-    serializer_class = GithubCommentSyncSerializer
-    model = GithubCommentSync
-
-    def perform_create(self, serializer):
-        serializer.save(
-            project_id=self.kwargs.get("project_id"),
-            issue_sync_id=self.kwargs.get("issue_sync_id"),
-        )

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

@@ -1,73 +0,0 @@
-# Django import
-from django.db import IntegrityError
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from sentry_sdk import capture_exception
-
-# Module imports
-from plane.api.views import BaseViewSet, BaseAPIView
-from plane.db.models import SlackProjectSync, WorkspaceIntegration, ProjectMember
-from plane.api.serializers import SlackProjectSyncSerializer
-from plane.api.permissions import ProjectBasePermission, ProjectEntityPermission
-
-
-class SlackProjectSyncViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectBasePermission,
-    ]
-    serializer_class = SlackProjectSyncSerializer
-    model = SlackProjectSync
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .filter(
-                workspace__slug=self.kwargs.get("slug"),
-                project_id=self.kwargs.get("project_id"),
-            )
-            .filter(project__project_projectmember__member=self.request.user)
-        )
-
-    def create(self, request, slug, project_id, workspace_integration_id):
-        try:
-            serializer = SlackProjectSyncSerializer(data=request.data)
-
-            workspace_integration = WorkspaceIntegration.objects.get(
-                workspace__slug=slug, pk=workspace_integration_id
-            )
-
-            if serializer.is_valid():
-                serializer.save(
-                    project_id=project_id,
-                    workspace_integration_id=workspace_integration_id,
-                )
-
-                workspace_integration = WorkspaceIntegration.objects.get(
-                    pk=workspace_integration_id, workspace__slug=slug
-                )
-
-                _ = ProjectMember.objects.get_or_create(
-                    member=workspace_integration.actor, role=20, project_id=project_id
-                )
-
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError:
-            return Response(
-                {"error": "Slack is already enabled for the project"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except WorkspaceIntegration.DoesNotExist:
-            return Response(
-                {"error": "Workspace Integration does not exist"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            print(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/module.py

@@ -1,74 +1,53 @@
 # Python imports
 import json
 
-# Django Imports
+# Django imports
+from django.db.models import Count, Prefetch, Q, F, Func, OuterRef
 from django.utils import timezone
-from django.db import IntegrityError
-from django.db.models import Prefetch, F, OuterRef, Func, Exists, Count, Q
 from django.core import serializers
-from django.utils.decorators import method_decorator
-from django.views.decorators.gzip import gzip_page
 
 # Third party imports
-from rest_framework.response import Response
 from rest_framework import status
-from sentry_sdk import capture_exception
+from rest_framework.response import Response
 
 # Module imports
-from . import BaseViewSet
+from .base import BaseAPIView, WebhookMixin
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import (
+    Project,
+    Module,
+    ModuleLink,
+    Issue,
+    ModuleIssue,
+    IssueAttachment,
+    IssueLink,
+)
 from plane.api.serializers import (
-    ModuleWriteSerializer,
     ModuleSerializer,
     ModuleIssueSerializer,
-    ModuleLinkSerializer,
+    IssueSerializer,
-    ModuleFavoriteSerializer,
-    IssueStateSerializer,
-)
-from plane.api.permissions import ProjectEntityPermission
-from plane.db.models import (
-    Module,
-    ModuleIssue,
-    Project,
-    Issue,
-    ModuleLink,
-    ModuleFavorite,
-    IssueLink,
-    IssueAttachment,
 )
 from plane.bgtasks.issue_activites_task import issue_activity
-from plane.utils.grouper import group_results
-from plane.utils.issue_filters import issue_filters
-from plane.utils.analytics_plot import burndown_plot
 
 
-class ModuleViewSet(BaseViewSet):
+class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to module.
+
+    """
+
     model = Module
     permission_classes = [
         ProjectEntityPermission,
     ]
-
+    serializer_class = ModuleSerializer
-    def get_serializer_class(self):
+    webhook_event = "module"
-        return (
-            ModuleWriteSerializer
-            if self.action in ["create", "update", "partial_update"]
-            else ModuleSerializer
-        )
 
     def get_queryset(self):
-        order_by = self.request.GET.get("order_by", "sort_order")
-
-        subquery = ModuleFavorite.objects.filter(
-            user=self.request.user,
-            module_id=OuterRef("pk"),
-            project_id=self.kwargs.get("project_id"),
-            workspace__slug=self.kwargs.get("slug"),
-        )
         return (
-            super()
+            Module.objects.filter(project_id=self.kwargs.get("project_id"))
-            .get_queryset()
-            .filter(project_id=self.kwargs.get("project_id"))
             .filter(workspace__slug=self.kwargs.get("slug"))
-            .annotate(is_favorite=Exists(subquery))
             .select_related("project")
             .select_related("workspace")
             .select_related("lead")
@@ -138,219 +117,93 @@ class ModuleViewSet(BaseViewSet):
                     ),
                 )
             )
-            .order_by(order_by, "name")
+            .order_by(self.kwargs.get("order_by", "-created_at"))
         )
 
-    def perform_destroy(self, instance):
+    def post(self, request, slug, project_id):
-        module_issues = list(
+        project = Project.objects.get(workspace__slug=slug, pk=project_id)
-            ModuleIssue.objects.filter(module_id=self.kwargs.get("pk")).values_list(
+        serializer = ModuleSerializer(data=request.data, context={"project": project})
-                "issue", flat=True
+        if serializer.is_valid():
+            serializer.save()
+            module = Module.objects.get(pk=serializer.data["id"])
+            serializer = ModuleSerializer(module)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+    
+    def patch(self, request, slug, project_id, pk):
+        module = Module.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
+        serializer = ModuleSerializer(module, data=request.data)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def get(self, request, slug, project_id, pk=None):
+        if pk:
+            queryset = self.get_queryset().get(pk=pk)
+            data = ModuleSerializer(
+                queryset,
+                fields=self.fields,
+                expand=self.expand,
+            ).data
+            return Response(
+                data,
+                status=status.HTTP_200_OK,
             )
+        return self.paginate(
+            request=request,
+            queryset=(self.get_queryset()),
+            on_results=lambda modules: ModuleSerializer(
+                modules,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+            ).data,
+        )
+
+    def delete(self, request, slug, project_id, pk):
+        module = Module.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+        module_issues = list(
+            ModuleIssue.objects.filter(module_id=pk).values_list("issue", flat=True)
         )
         issue_activity.delay(
             type="module.activity.deleted",
             requested_data=json.dumps(
                 {
-                    "module_id": str(self.kwargs.get("pk")),
+                    "module_id": str(pk),
+                    "module_name": str(module.name),
                     "issues": [str(issue_id) for issue_id in module_issues],
                 }
             ),
-            actor_id=str(self.request.user.id),
+            actor_id=str(request.user.id),
-            issue_id=str(self.kwargs.get("pk", None)),
+            issue_id=None,
-            project_id=str(self.kwargs.get("project_id", None)),
+            project_id=str(project_id),
             current_instance=None,
-            epoch=int(timezone.now().timestamp())
+            epoch=int(timezone.now().timestamp()),
         )
-
+        module.delete()
-        return super().perform_destroy(instance)
+        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    def create(self, request, slug, project_id):
-        try:
-            project = Project.objects.get(workspace__slug=slug, pk=project_id)
-            serializer = ModuleWriteSerializer(
-                data=request.data, context={"project": project}
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-        except Project.DoesNotExist:
-            return Response(
-                {"error": "Project was not found"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"name": "The module name is already taken"},
-                    status=status.HTTP_410_GONE,
-                )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def retrieve(self, request, slug, project_id, pk):
-        try:
-            queryset = self.get_queryset().get(pk=pk)
-
-            assignee_distribution = (
-                Issue.objects.filter(
-                    issue_module__module_id=pk,
-                    workspace__slug=slug,
-                    project_id=project_id,
-                )
-                .annotate(first_name=F("assignees__first_name"))
-                .annotate(last_name=F("assignees__last_name"))
-                .annotate(assignee_id=F("assignees__id"))
-                .annotate(display_name=F("assignees__display_name"))
-                .annotate(avatar=F("assignees__avatar"))
-                .values(
-                    "first_name", "last_name", "assignee_id", "avatar", "display_name"
-                )
-                .annotate(
-                    total_issues=Count(
-                        "assignee_id",
-                        filter=Q(
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    completed_issues=Count(
-                        "assignee_id",
-                        filter=Q(
-                            completed_at__isnull=False,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    pending_issues=Count(
-                        "assignee_id",
-                        filter=Q(
-                            completed_at__isnull=True,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .order_by("first_name", "last_name")
-            )
-
-            label_distribution = (
-                Issue.objects.filter(
-                    issue_module__module_id=pk,
-                    workspace__slug=slug,
-                    project_id=project_id,
-                )
-                .annotate(label_name=F("labels__name"))
-                .annotate(color=F("labels__color"))
-                .annotate(label_id=F("labels__id"))
-                .values("label_name", "color", "label_id")
-                .annotate(
-                    total_issues=Count(
-                        "label_id",
-                        filter=Q(
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    ),
-                )
-                .annotate(
-                    completed_issues=Count(
-                        "label_id",
-                        filter=Q(
-                            completed_at__isnull=False,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    pending_issues=Count(
-                        "label_id",
-                        filter=Q(
-                            completed_at__isnull=True,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .order_by("label_name")
-            )
-
-            data = ModuleSerializer(queryset).data
-            data["distribution"] = {
-                "assignees": assignee_distribution,
-                "labels": label_distribution,
-                "completion_chart": {},
-            }
-
-            if queryset.start_date and queryset.target_date:
-                data["distribution"]["completion_chart"] = burndown_plot(
-                    queryset=queryset, slug=slug, project_id=project_id, module_id=pk
-                )
-
-            return Response(
-                data,
-                status=status.HTTP_200_OK,
-            )
-
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
 
 
-class ModuleIssueViewSet(BaseViewSet):
+class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to module issues.
+
+    """
+
     serializer_class = ModuleIssueSerializer
     model = ModuleIssue
-
+    webhook_event = "module_issue"
-    filterset_fields = [
+    bulk = True
-        "issue__labels__id",
-        "issue__assignees__id",
-    ]
 
     permission_classes = [
         ProjectEntityPermission,
     ]
 
-    def perform_create(self, serializer):
-        serializer.save(
-            project_id=self.kwargs.get("project_id"),
-            module_id=self.kwargs.get("module_id"),
-        )
-
-    def perform_destroy(self, instance):
-        issue_activity.delay(
-            type="module.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "module_id": str(self.kwargs.get("module_id")),
-                    "issues": [str(instance.issue_id)],
-                }
-            ),
-            actor_id=str(self.request.user.id),
-            issue_id=str(self.kwargs.get("pk", None)),
-            project_id=str(self.kwargs.get("project_id", None)),
-            current_instance=None,
-            epoch=int(timezone.now().timestamp())
-        )
-        return super().perform_destroy(instance)
-
     def get_queryset(self):
-        return self.filter_queryset(
+        return (
-            super()
+            ModuleIssue.objects.annotate(
-            .get_queryset()
-            .annotate(
                 sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("issue"))
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
@@ -366,253 +219,156 @@ class ModuleIssueViewSet(BaseViewSet):
             .select_related("issue", "issue__state", "issue__project")
             .prefetch_related("issue__assignees", "issue__labels")
             .prefetch_related("module__members")
+            .order_by(self.kwargs.get("order_by", "-created_at"))
             .distinct()
         )
 
-    @method_decorator(gzip_page)
+    def get(self, request, slug, project_id, module_id):
-    def list(self, request, slug, project_id, module_id):
+        order_by = request.GET.get("order_by", "created_at")
-        try:
+        issues = (
-            order_by = request.GET.get("order_by", "created_at")
+            Issue.issue_objects.filter(issue_module__module_id=module_id)
-            group_by = request.GET.get("group_by", False)
+            .annotate(
-            sub_group_by = request.GET.get("sub_group_by", False)
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-            filters = issue_filters(request.query_params, "GET")
+                .order_by()
-            issues = (
+                .annotate(count=Func(F("id"), function="Count"))
-                Issue.issue_objects.filter(issue_module__module_id=module_id)
+                .values("count")
-                .annotate(
+            )
-                    sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+            .annotate(bridge_id=F("issue_module__id"))
-                    .order_by()
+            .filter(project_id=project_id)
-                    .annotate(count=Func(F("id"), function="Count"))
+            .filter(workspace__slug=slug)
-                    .values("count")
+            .select_related("project")
-                )
+            .select_related("workspace")
-                .annotate(bridge_id=F("issue_module__id"))
+            .select_related("state")
-                .filter(project_id=project_id)
+            .select_related("parent")
-                .filter(workspace__slug=slug)
+            .prefetch_related("assignees")
-                .select_related("project")
+            .prefetch_related("labels")
-                .select_related("workspace")
+            .order_by(order_by)
-                .select_related("state")
+            .annotate(
-                .select_related("parent")
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .prefetch_related("assignees")
+                .order_by()
-                .prefetch_related("labels")
+                .annotate(count=Func(F("id"), function="Count"))
-                .order_by(order_by)
+                .values("count")
-                .filter(**filters)
+            )
-                .annotate(
+            .annotate(
-                    link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
-                    .order_by()
+                .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
+                .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
+                .values("count")
-                )
+            )
-                .annotate(
+        )
-                    attachment_count=IssueAttachment.objects.filter(
+        return self.paginate(
-                        issue=OuterRef("id")
+            request=request,
+            queryset=(issues),
+            on_results=lambda issues: IssueSerializer(
+                issues,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+            ).data,
+        )
+
+    def post(self, request, slug, project_id, module_id):
+        issues = request.data.get("issues", [])
+        if not len(issues):
+            return Response(
+                {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
+            )
+        module = Module.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=module_id
+        )
+
+        issues = Issue.objects.filter(
+            workspace__slug=slug, project_id=project_id, pk__in=issues
+        ).values_list("id", flat=True)
+
+        module_issues = list(ModuleIssue.objects.filter(issue_id__in=issues))
+
+        update_module_issue_activity = []
+        records_to_update = []
+        record_to_create = []
+
+        for issue in issues:
+            module_issue = [
+                module_issue
+                for module_issue in module_issues
+                if str(module_issue.issue_id) in issues
+            ]
+
+            if len(module_issue):
+                if module_issue[0].module_id != module_id:
+                    update_module_issue_activity.append(
+                        {
+                            "old_module_id": str(module_issue[0].module_id),
+                            "new_module_id": str(module_id),
+                            "issue_id": str(module_issue[0].issue_id),
+                        }
                     )
-                    .order_by()
+                    module_issue[0].module_id = module_id
-                    .annotate(count=Func(F("id"), function="Count"))
+                    records_to_update.append(module_issue[0])
-                    .values("count")
-                )
-            )
-
-            issues_data = IssueStateSerializer(issues, many=True).data
-
-            if sub_group_by and sub_group_by == group_by:
-                return Response(
-                    {"error": "Group by and sub group by cannot be same"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if group_by:
-                return Response(
-                    group_results(issues_data, group_by, sub_group_by),
-                    status=status.HTTP_200_OK,
-                )
-
-            return Response(
-                issues_data,
-                status=status.HTTP_200_OK,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def create(self, request, slug, project_id, module_id):
-        try:
-            issues = request.data.get("issues", [])
-            if not len(issues):
-                return Response(
-                    {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
-                )
-            module = Module.objects.get(
-                workspace__slug=slug, project_id=project_id, pk=module_id
-            )
-
-            module_issues = list(ModuleIssue.objects.filter(issue_id__in=issues))
-
-            update_module_issue_activity = []
-            records_to_update = []
-            record_to_create = []
-
-            for issue in issues:
-                module_issue = [
-                    module_issue
-                    for module_issue in module_issues
-                    if str(module_issue.issue_id) in issues
-                ]
-
-                if len(module_issue):
-                    if module_issue[0].module_id != module_id:
-                        update_module_issue_activity.append(
-                            {
-                                "old_module_id": str(module_issue[0].module_id),
-                                "new_module_id": str(module_id),
-                                "issue_id": str(module_issue[0].issue_id),
-                            }
-                        )
-                        module_issue[0].module_id = module_id
-                        records_to_update.append(module_issue[0])
-                else:
-                    record_to_create.append(
-                        ModuleIssue(
-                            module=module,
-                            issue_id=issue,
-                            project_id=project_id,
-                            workspace=module.workspace,
-                            created_by=request.user,
-                            updated_by=request.user,
-                        )
-                    )
-
-            ModuleIssue.objects.bulk_create(
-                record_to_create,
-                batch_size=10,
-                ignore_conflicts=True,
-            )
-
-            ModuleIssue.objects.bulk_update(
-                records_to_update,
-                ["module"],
-                batch_size=10,
-            )
-
-            # Capture Issue Activity
-            issue_activity.delay(
-                type="module.activity.created",
-                requested_data=json.dumps({"modules_list": issues}),
-                actor_id=str(self.request.user.id),
-                issue_id=str(self.kwargs.get("pk", None)),
-                project_id=str(self.kwargs.get("project_id", None)),
-                current_instance=json.dumps(
-                    {
-                        "updated_module_issues": update_module_issue_activity,
-                        "created_module_issues": serializers.serialize(
-                            "json", record_to_create
-                        ),
-                    }
-                ),
-                epoch=int(timezone.now().timestamp())
-            )
-
-            return Response(
-                ModuleIssueSerializer(self.get_queryset(), many=True).data,
-                status=status.HTTP_200_OK,
-            )
-        except Module.DoesNotExist:
-            return Response(
-                {"error": "Module Does not exists"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class ModuleLinkViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    model = ModuleLink
-    serializer_class = ModuleLinkSerializer
-
-    def perform_create(self, serializer):
-        serializer.save(
-            project_id=self.kwargs.get("project_id"),
-            module_id=self.kwargs.get("module_id"),
-        )
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(module_id=self.kwargs.get("module_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .order_by("-created_at")
-            .distinct()
-        )
-
-
-class ModuleFavoriteViewSet(BaseViewSet):
-    serializer_class = ModuleFavoriteSerializer
-    model = ModuleFavorite
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(user=self.request.user)
-            .select_related("module")
-        )
-
-    def create(self, request, slug, project_id):
-        try:
-            serializer = ModuleFavoriteSerializer(data=request.data)
-            if serializer.is_valid():
-                serializer.save(user=request.user, project_id=project_id)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"error": "The module is already added to favorites"},
-                    status=status.HTTP_410_GONE,
-                )
             else:
-                capture_exception(e)
+                record_to_create.append(
-                return Response(
+                    ModuleIssue(
-                    {"error": "Something went wrong please try again later"},
+                        module=module,
-                    status=status.HTTP_400_BAD_REQUEST,
+                        issue_id=issue,
+                        project_id=project_id,
+                        workspace=module.workspace,
+                        created_by=request.user,
+                        updated_by=request.user,
+                    )
                 )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
 
-    def destroy(self, request, slug, project_id, module_id):
+        ModuleIssue.objects.bulk_create(
-        try:
+            record_to_create,
-            module_favorite = ModuleFavorite.objects.get(
+            batch_size=10,
-                project=project_id,
+            ignore_conflicts=True,
-                user=request.user,
+        )
-                workspace__slug=slug,
+
-                module_id=module_id,
+        ModuleIssue.objects.bulk_update(
-            )
+            records_to_update,
-            module_favorite.delete()
+            ["module"],
-            return Response(status=status.HTTP_204_NO_CONTENT)
+            batch_size=10,
-        except ModuleFavorite.DoesNotExist:
+        )
-            return Response(
+
-                {"error": "Module is not in favorites"},
+        # Capture Issue Activity
-                status=status.HTTP_400_BAD_REQUEST,
+        issue_activity.delay(
-            )
+            type="module.activity.created",
-        except Exception as e:
+            requested_data=json.dumps({"modules_list": str(issues)}),
-            capture_exception(e)
+            actor_id=str(self.request.user.id),
-            return Response(
+            issue_id=None,
-                {"error": "Something went wrong please try again later"},
+            project_id=str(self.kwargs.get("project_id", None)),
-                status=status.HTTP_400_BAD_REQUEST,
+            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()),
+        )
+
+        return Response(
+            ModuleIssueSerializer(self.get_queryset(), many=True).data,
+            status=status.HTTP_200_OK,
+        )
+
+    def delete(self, request, slug, project_id, module_id, issue_id):
+        module_issue = ModuleIssue.objects.get(
+            workspace__slug=slug, project_id=project_id, module_id=module_id, issue_id=issue_id
+        )
+        module_issue.delete()
+        issue_activity.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()),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/notification.py

@@ -1,363 +0,0 @@
-# Django imports
-from django.db.models import Q
-from django.utils import timezone
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from sentry_sdk import capture_exception
-from plane.utils.paginator import BasePaginator
-
-# Module imports
-from .base import BaseViewSet, BaseAPIView
-from plane.db.models import (
-    Notification,
-    IssueAssignee,
-    IssueSubscriber,
-    Issue,
-    WorkspaceMember,
-)
-from plane.api.serializers import NotificationSerializer
-
-
-class NotificationViewSet(BaseViewSet, BasePaginator):
-    model = Notification
-    serializer_class = NotificationSerializer
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .filter(
-                workspace__slug=self.kwargs.get("slug"),
-                receiver_id=self.request.user.id,
-            )
-            .select_related("workspace", "project," "triggered_by", "receiver")
-        )
-
-    def list(self, request, slug):
-        try:
-            snoozed = request.GET.get("snoozed", "false")
-            archived = request.GET.get("archived", "false")
-            read = request.GET.get("read", "true")
-
-            # Filter type
-            type = request.GET.get("type", "all")
-
-            notifications = (
-                Notification.objects.filter(
-                    workspace__slug=slug, receiver_id=request.user.id
-                )
-                .select_related("workspace", "project", "triggered_by", "receiver")
-                .order_by("snoozed_till", "-created_at")
-            )
-
-            # Filter for snoozed notifications
-            if snoozed == "false":
-                notifications = notifications.filter(
-                    Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
-                )
-
-            if snoozed == "true":
-                notifications = notifications.filter(
-                    Q(snoozed_till__lt=timezone.now()) | Q(snoozed_till__isnull=False)
-                )
-
-            if read == "false":
-                notifications = notifications.filter(read_at__isnull=True)
-
-            # Filter for archived or unarchive
-            if archived == "false":
-                notifications = notifications.filter(archived_at__isnull=True)
-
-            if archived == "true":
-                notifications = notifications.filter(archived_at__isnull=False)
-
-            # Subscribed issues
-            if type == "watching":
-                issue_ids = IssueSubscriber.objects.filter(
-                    workspace__slug=slug, subscriber_id=request.user.id
-                ).values_list("issue_id", flat=True)
-                notifications = notifications.filter(entity_identifier__in=issue_ids)
-
-            # Assigned Issues
-            if type == "assigned":
-                issue_ids = IssueAssignee.objects.filter(
-                    workspace__slug=slug, assignee_id=request.user.id
-                ).values_list("issue_id", flat=True)
-                notifications = notifications.filter(entity_identifier__in=issue_ids)
-
-            # Created issues
-            if type == "created":
-                if WorkspaceMember.objects.filter(
-                    workspace__slug=slug, member=request.user, role__lt=15
-                ).exists():
-                    notifications = Notification.objects.none()
-                else:
-                    issue_ids = Issue.objects.filter(
-                        workspace__slug=slug, created_by=request.user
-                    ).values_list("pk", flat=True)
-                    notifications = notifications.filter(
-                        entity_identifier__in=issue_ids
-                    )
-
-            # Pagination
-            if request.GET.get("per_page", False) and request.GET.get("cursor", False):
-                return self.paginate(
-                    request=request,
-                    queryset=(notifications),
-                    on_results=lambda notifications: NotificationSerializer(
-                        notifications, many=True
-                    ).data,
-                )
-
-            serializer = NotificationSerializer(notifications, many=True)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def partial_update(self, request, slug, pk):
-        try:
-            notification = Notification.objects.get(
-                workspace__slug=slug, pk=pk, receiver=request.user
-            )
-            # Only read_at and snoozed_till can be updated
-            notification_data = {
-                "snoozed_till": request.data.get("snoozed_till", None),
-            }
-            serializer = NotificationSerializer(
-                notification, data=notification_data, partial=True
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Notification.DoesNotExist:
-            return Response(
-                {"error": "Notification does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def mark_read(self, request, slug, pk):
-        try:
-            notification = Notification.objects.get(
-                receiver=request.user, workspace__slug=slug, pk=pk
-            )
-            notification.read_at = timezone.now()
-            notification.save()
-            serializer = NotificationSerializer(notification)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Notification.DoesNotExist:
-            return Response(
-                {"error": "Notification does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def mark_unread(self, request, slug, pk):
-        try:
-            notification = Notification.objects.get(
-                receiver=request.user, workspace__slug=slug, pk=pk
-            )
-            notification.read_at = None
-            notification.save()
-            serializer = NotificationSerializer(notification)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Notification.DoesNotExist:
-            return Response(
-                {"error": "Notification does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def archive(self, request, slug, pk):
-        try:
-            notification = Notification.objects.get(
-                receiver=request.user, workspace__slug=slug, pk=pk
-            )
-            notification.archived_at = timezone.now()
-            notification.save()
-            serializer = NotificationSerializer(notification)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Notification.DoesNotExist:
-            return Response(
-                {"error": "Notification does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def unarchive(self, request, slug, pk):
-        try:
-            notification = Notification.objects.get(
-                receiver=request.user, workspace__slug=slug, pk=pk
-            )
-            notification.archived_at = None
-            notification.save()
-            serializer = NotificationSerializer(notification)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Notification.DoesNotExist:
-            return Response(
-                {"error": "Notification does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class UnreadNotificationEndpoint(BaseAPIView):
-    def get(self, request, slug):
-        try:
-            # Watching Issues Count
-            watching_issues_count = Notification.objects.filter(
-                workspace__slug=slug,
-                receiver_id=request.user.id,
-                read_at__isnull=True,
-                archived_at__isnull=True,
-                entity_identifier__in=IssueSubscriber.objects.filter(
-                    workspace__slug=slug, subscriber_id=request.user.id
-                ).values_list("issue_id", flat=True),
-            ).count()
-
-            # My Issues Count
-            my_issues_count = Notification.objects.filter(
-                workspace__slug=slug,
-                receiver_id=request.user.id,
-                read_at__isnull=True,
-                archived_at__isnull=True,
-                entity_identifier__in=IssueAssignee.objects.filter(
-                    workspace__slug=slug, assignee_id=request.user.id
-                ).values_list("issue_id", flat=True),
-            ).count()
-
-            # Created Issues Count
-            created_issues_count = Notification.objects.filter(
-                workspace__slug=slug,
-                receiver_id=request.user.id,
-                read_at__isnull=True,
-                archived_at__isnull=True,
-                entity_identifier__in=Issue.objects.filter(
-                    workspace__slug=slug, created_by=request.user
-                ).values_list("pk", flat=True),
-            ).count()
-
-            return Response(
-                {
-                    "watching_issues": watching_issues_count,
-                    "my_issues": my_issues_count,
-                    "created_issues": created_issues_count,
-                },
-                status=status.HTTP_200_OK,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class MarkAllReadNotificationViewSet(BaseViewSet):
-    def create(self, request, slug):
-        try:
-            snoozed = request.data.get("snoozed", False)
-            archived = request.data.get("archived", False)
-            type = request.data.get("type", "all")
-
-            notifications = (
-                Notification.objects.filter(
-                    workspace__slug=slug,
-                    receiver_id=request.user.id,
-                    read_at__isnull=True,
-                )
-                .select_related("workspace", "project", "triggered_by", "receiver")
-                .order_by("snoozed_till", "-created_at")
-            )
-
-            # Filter for snoozed notifications
-            if snoozed:
-                notifications = notifications.filter(
-                    Q(snoozed_till__lt=timezone.now()) | Q(snoozed_till__isnull=False)
-                )
-            else:
-                notifications = notifications.filter(
-                    Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
-                )
-
-            # Filter for archived or unarchive
-            if archived:
-                notifications = notifications.filter(archived_at__isnull=False)
-            else:
-                notifications = notifications.filter(archived_at__isnull=True)
-
-            # Subscribed issues
-            if type == "watching":
-                issue_ids = IssueSubscriber.objects.filter(
-                    workspace__slug=slug, subscriber_id=request.user.id
-                ).values_list("issue_id", flat=True)
-                notifications = notifications.filter(entity_identifier__in=issue_ids)
-
-            # Assigned Issues
-            if type == "assigned":
-                issue_ids = IssueAssignee.objects.filter(
-                    workspace__slug=slug, assignee_id=request.user.id
-                ).values_list("issue_id", flat=True)
-                notifications = notifications.filter(entity_identifier__in=issue_ids)
-
-            # Created issues
-            if type == "created":
-                if WorkspaceMember.objects.filter(
-                    workspace__slug=slug, member=request.user, role__lt=15
-                ).exists():
-                    notifications = Notification.objects.none()
-                else:
-                    issue_ids = Issue.objects.filter(
-                        workspace__slug=slug, created_by=request.user
-                    ).values_list("pk", flat=True)
-                    notifications = notifications.filter(
-                        entity_identifier__in=issue_ids
-                    )
-
-            updated_notifications = []
-            for notification in notifications:
-                notification.read_at = timezone.now()
-                updated_notifications.append(notification)
-            Notification.objects.bulk_update(
-                updated_notifications, ["read_at"], batch_size=100
-            )
-            return Response({"message": "Successful"}, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/oauth.py

@@ -1,314 +0,0 @@
-# Python imports
-import uuid
-import requests
-import os
-
-# Django imports
-from django.utils import timezone
-from django.conf import settings
-
-# Third Party modules
-from rest_framework.response import Response
-from rest_framework import exceptions
-from rest_framework.permissions import AllowAny
-from rest_framework.views import APIView
-from rest_framework_simplejwt.tokens import RefreshToken
-from rest_framework import status
-from sentry_sdk import capture_exception
-# sso authentication
-from google.oauth2 import id_token
-from google.auth.transport import requests as google_auth_request
-
-# Module imports
-from plane.db.models import SocialLoginConnection, User
-from plane.api.serializers import UserSerializer
-from .base import BaseAPIView
-
-
-def get_tokens_for_user(user):
-    refresh = RefreshToken.for_user(user)
-    return (
-        str(refresh.access_token),
-        str(refresh),
-    )
-
-
-def validate_google_token(token, client_id):
-    try:
-        id_info = id_token.verify_oauth2_token(
-            token, google_auth_request.Request(), client_id
-        )
-        email = id_info.get("email")
-        first_name = id_info.get("given_name")
-        last_name = id_info.get("family_name", "")
-        data = {
-            "email": email,
-            "first_name": first_name,
-            "last_name": last_name,
-        }
-        return data
-    except Exception as e:
-        capture_exception(e)
-        raise exceptions.AuthenticationFailed("Error with Google connection.")
-
-
-def get_access_token(request_token: str, client_id: str) -> str:
-    """Obtain the request token from github.
-    Given the client id, client secret and request issued out by GitHub, this method
-    should give back an access token
-    Parameters
-    ----------
-    CLIENT_ID: str
-        A string representing the client id issued out by github
-    CLIENT_SECRET: str
-        A string representing the client secret issued out by github
-    request_token: str
-        A string representing the request token issued out by github
-    Throws
-    ------
-    ValueError:
-        if CLIENT_ID or CLIENT_SECRET or request_token is empty or not a string
-    Returns
-    -------
-    access_token: str
-        A string representing the access token issued out by github
-    """
-
-    if not request_token:
-        raise ValueError("The request token has to be supplied!")
-
-    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"}
-
-    res = requests.post(url, headers=headers)
-
-    data = res.json()
-    access_token = data["access_token"]
-
-    return access_token
-
-
-def get_user_data(access_token: str) -> dict:
-    """
-    Obtain the user data from github.
-    Given the access token, this method should give back the user data
-    """
-    if not access_token:
-        raise ValueError("The request token has to be supplied!")
-    if not isinstance(access_token, str):
-        raise ValueError("The request token has to be a string!")
-
-    access_token = "token " + access_token
-    url = "https://api.github.com/user"
-    headers = {"Authorization": access_token}
-
-    resp = requests.get(url=url, headers=headers)
-
-    user_data = resp.json()
-
-    response = requests.get(
-        url="https://api.github.com/user/emails", headers=headers
-    ).json()
-
-    [
-        user_data.update({"email": item.get("email")})
-        for item in response
-        if item.get("primary") is True
-    ]
-
-    return user_data
-
-
-class OauthEndpoint(BaseAPIView):
-    permission_classes = [AllowAny]
-
-    def post(self, request):
-        try:
-            medium = request.data.get("medium", False)
-            id_token = request.data.get("credential", False)
-            client_id = request.data.get("clientId", False)
-
-            if not medium or not id_token:
-                return Response(
-                    {
-                        "error": "Something went wrong. Please try again later or contact the support team."
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if medium == "google":
-                data = validate_google_token(id_token, client_id)
-
-            if medium == "github":
-                access_token = get_access_token(id_token, client_id)
-                data = get_user_data(access_token)
-
-            email = data.get("email", None)
-            if email == None:
-                return Response(
-                    {
-                        "error": "Something went wrong. Please try again later or contact the support team."
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if "@" in email:
-                user = User.objects.get(email=email)
-                email = data["email"]
-                channel = "email"
-                mobile_number = uuid.uuid4().hex
-                email_verified = True
-            else:
-                return Response(
-                    {
-                        "error": "Something went wrong. Please try again later or contact the support team."
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            ## Login Case
-
-            if not user.is_active:
-                return Response(
-                    {
-                        "error": "Your account has been deactivated. Please contact your site administrator."
-                    },
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-
-            user.last_active = timezone.now()
-            user.last_login_time = timezone.now()
-            user.last_login_ip = request.META.get("REMOTE_ADDR")
-            user.last_login_medium = f"oauth"
-            user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
-            user.is_email_verified = email_verified
-            user.save()
-
-            serialized_user = UserSerializer(user).data
-
-            access_token, refresh_token = get_tokens_for_user(user)
-
-            data = {
-                "access_token": access_token,
-                "refresh_token": refresh_token,
-                "user": serialized_user,
-            }
-
-            SocialLoginConnection.objects.update_or_create(
-                medium=medium,
-                extra_data={},
-                user=user,
-                defaults={
-                    "token_data": {"id_token": id_token},
-                    "last_login_at": timezone.now(),
-                },
-            )
-            if settings.ANALYTICS_BASE_API:
-                _ = requests.post(
-                    settings.ANALYTICS_BASE_API,
-                    headers={
-                        "Content-Type": "application/json",
-                        "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
-                    },
-                    json={
-                        "event_id": uuid.uuid4().hex,
-                        "event_data": {
-                            "medium": f"oauth-{medium}",
-                        },
-                        "user": {"email": email, "id": str(user.id)},
-                        "device_ctx": {
-                            "ip": request.META.get("REMOTE_ADDR"),
-                            "user_agent": request.META.get("HTTP_USER_AGENT"),
-                        },
-                        "event_type": "SIGN_IN",
-                    },
-                )
-            return Response(data, status=status.HTTP_200_OK)
-
-        except User.DoesNotExist:
-            ## Signup Case
-
-            username = uuid.uuid4().hex
-
-            if "@" in email:
-                email = data["email"]
-                mobile_number = uuid.uuid4().hex
-                channel = "email"
-                email_verified = True
-            else:
-                return Response(
-                    {
-                        "error": "Something went wrong. Please try again later or contact the support team."
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            user = User(
-                username=username,
-                email=email,
-                mobile_number=mobile_number,
-                first_name=data.get("first_name", ""),
-                last_name=data.get("last_name", ""),
-                is_email_verified=email_verified,
-                is_password_autoset=True,
-            )
-
-            user.set_password(uuid.uuid4().hex)
-            user.is_password_autoset = True
-            user.last_active = timezone.now()
-            user.last_login_time = timezone.now()
-            user.last_login_ip = request.META.get("REMOTE_ADDR")
-            user.last_login_medium = "oauth"
-            user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
-            user.token_updated_at = timezone.now()
-            user.save()
-            serialized_user = UserSerializer(user).data
-
-            access_token, refresh_token = get_tokens_for_user(user)
-            data = {
-                "access_token": access_token,
-                "refresh_token": refresh_token,
-                "user": serialized_user,
-                "permissions": [],
-            }
-            if settings.ANALYTICS_BASE_API:
-                _ = requests.post(
-                    settings.ANALYTICS_BASE_API,
-                    headers={
-                        "Content-Type": "application/json",
-                        "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
-                    },
-                    json={
-                        "event_id": uuid.uuid4().hex,
-                        "event_data": {
-                            "medium": f"oauth-{medium}",
-                        },
-                        "user": {"email": email, "id": str(user.id)},
-                        "device_ctx": {
-                            "ip": request.META.get("REMOTE_ADDR"),
-                            "user_agent": request.META.get("HTTP_USER_AGENT"),
-                        },
-                        "event_type": "SIGN_UP",
-                    },
-                )
-
-            SocialLoginConnection.objects.update_or_create(
-                medium=medium,
-                extra_data={},
-                user=user,
-                defaults={
-                    "token_data": {"id_token": id_token},
-                    "last_login_at": timezone.now(),
-                },
-            )
-            return Response(data, status=status.HTTP_201_CREATED)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {
-                    "error": "Something went wrong. Please try again later or contact the support team."
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/page.py

@@ -1,321 +0,0 @@
-# Python imports
-from datetime import timedelta, datetime, date
-
-# Django imports
-from django.db import IntegrityError
-from django.db.models import Exists, OuterRef, Q, Prefetch
-from django.utils import timezone
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from sentry_sdk import capture_exception
-
-# Module imports
-from .base import BaseViewSet, BaseAPIView
-from plane.api.permissions import ProjectEntityPermission
-from plane.db.models import (
-    Page,
-    PageBlock,
-    PageFavorite,
-    Issue,
-    IssueAssignee,
-    IssueActivity,
-)
-from plane.api.serializers import (
-    PageSerializer,
-    PageBlockSerializer,
-    PageFavoriteSerializer,
-    IssueLiteSerializer,
-)
-
-
-class PageViewSet(BaseViewSet):
-    serializer_class = PageSerializer
-    model = Page
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-    search_fields = [
-        "name",
-    ]
-
-    def get_queryset(self):
-        subquery = PageFavorite.objects.filter(
-            user=self.request.user,
-            page_id=OuterRef("pk"),
-            project_id=self.kwargs.get("project_id"),
-            workspace__slug=self.kwargs.get("slug"),
-        )
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .filter(Q(owned_by=self.request.user) | Q(access=0))
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("owned_by")
-            .annotate(is_favorite=Exists(subquery))
-            .order_by(self.request.GET.get("order_by", "-created_at"))
-            .prefetch_related("labels")
-            .order_by("name", "-is_favorite")
-            .prefetch_related(
-                Prefetch(
-                    "blocks",
-                    queryset=PageBlock.objects.select_related(
-                        "page", "issue", "workspace", "project"
-                    ),
-                )
-            )
-            .distinct()
-        )
-
-    def perform_create(self, serializer):
-        serializer.save(
-            project_id=self.kwargs.get("project_id"), owned_by=self.request.user
-        )
-
-    def create(self, request, slug, project_id):
-        try:
-            serializer = PageSerializer(
-                data=request.data,
-                context={"project_id": project_id, "owned_by_id": request.user.id},
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def partial_update(self, request, slug, project_id, pk):
-        try:
-            page = Page.objects.get(pk=pk, workspace__slug=slug, project_id=project_id)
-            # Only update access if the page owner is the requesting  user
-            if (
-                page.access != request.data.get("access", page.access)
-                and page.owned_by_id != request.user.id
-            ):
-                return Response(
-                    {
-                        "error": "Access cannot be updated since this page is owned by someone else"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            serializer = PageSerializer(page, data=request.data, partial=True)
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Page.DoesNotExist:
-            return Response(
-                {"error": "Page Does not exist"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        
-    def list(self, request, slug, project_id):
-        try:
-            queryset = self.get_queryset()
-            page_view = request.GET.get("page_view", False)
-
-            if not page_view:
-                return Response({"error": "Page View parameter is required"}, status=status.HTTP_400_BAD_REQUEST)
-
-            # All Pages
-            if page_view == "all":
-                return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
-
-            # Recent pages
-            if page_view == "recent":
-                current_time = date.today()
-                day_before = current_time - timedelta(days=1)
-                todays_pages = queryset.filter(updated_at__date=date.today())
-                yesterdays_pages = queryset.filter(updated_at__date=day_before)
-                earlier_this_week = queryset.filter(                    updated_at__date__range=(
-                        (timezone.now() - timedelta(days=7)),
-                        (timezone.now() - timedelta(days=2)),
-                    ))
-                return Response(
-                {
-                    "today": PageSerializer(todays_pages, many=True).data,
-                    "yesterday": PageSerializer(yesterdays_pages, many=True).data,
-                    "earlier_this_week": PageSerializer(earlier_this_week, many=True).data,
-                },
-                status=status.HTTP_200_OK,
-            )
-
-            # Favorite Pages
-            if page_view == "favorite":
-                queryset = queryset.filter(is_favorite=True)
-                return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
-            
-            # My pages
-            if page_view == "created_by_me":
-                queryset = queryset.filter(owned_by=request.user)
-                return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
-
-            # Created by other Pages
-            if page_view == "created_by_other":
-                queryset = queryset.filter(~Q(owned_by=request.user),  access=0)
-                return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
-
-            return Response({"error": "No matching view found"}, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response({"error": "Something went wrong please try again later"}, status=status.HTTP_400_BAD_REQUEST)
-
-class PageBlockViewSet(BaseViewSet):
-    serializer_class = PageBlockSerializer
-    model = PageBlock
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(page_id=self.kwargs.get("page_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("page")
-            .select_related("issue")
-            .order_by("sort_order")
-            .distinct()
-        )
-
-    def perform_create(self, serializer):
-        serializer.save(
-            project_id=self.kwargs.get("project_id"),
-            page_id=self.kwargs.get("page_id"),
-        )
-
-
-class PageFavoriteViewSet(BaseViewSet):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    serializer_class = PageFavoriteSerializer
-    model = PageFavorite
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(user=self.request.user)
-            .select_related("page", "page__owned_by")
-        )
-
-    def create(self, request, slug, project_id):
-        try:
-            serializer = PageFavoriteSerializer(data=request.data)
-            if serializer.is_valid():
-                serializer.save(user=request.user, project_id=project_id)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"error": "The page is already added to favorites"},
-                    status=status.HTTP_410_GONE,
-                )
-            else:
-                capture_exception(e)
-                return Response(
-                    {"error": "Something went wrong please try again later"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def destroy(self, request, slug, project_id, page_id):
-        try:
-            page_favorite = PageFavorite.objects.get(
-                project=project_id,
-                user=request.user,
-                workspace__slug=slug,
-                page_id=page_id,
-            )
-            page_favorite.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except PageFavorite.DoesNotExist:
-            return Response(
-                {"error": "Page is not in favorites"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class CreateIssueFromPageBlockEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def post(self, request, slug, project_id, page_id, page_block_id):
-        try:
-            page_block = PageBlock.objects.get(
-                pk=page_block_id,
-                workspace__slug=slug,
-                project_id=project_id,
-                page_id=page_id,
-            )
-            issue = Issue.objects.create(
-                name=page_block.name,
-                project_id=project_id,
-                description=page_block.description,
-                description_html=page_block.description_html,
-                description_stripped=page_block.description_stripped,
-            )
-            _ = 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_block.name} block",
-                verb="created",
-            )
-
-            page_block.issue = issue
-            page_block.save()
-
-            return Response(IssueLiteSerializer(issue).data, status=status.HTTP_200_OK)
-        except PageBlock.DoesNotExist:
-            return Response(
-                {"error": "Page Block does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/state.py

@@ -2,36 +2,29 @@
 from itertools import groupby
 
 # Django imports
-from django.db import IntegrityError
 from django.db.models import Q
 
 # Third party imports
 from rest_framework.response import Response
 from rest_framework import status
-from sentry_sdk import capture_exception
 
 # Module imports
-from . import BaseViewSet, BaseAPIView
+from .base import BaseAPIView
 from plane.api.serializers import StateSerializer
-from plane.api.permissions import ProjectEntityPermission
+from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import State, Issue
 
 
-class StateViewSet(BaseViewSet):
+class StateAPIEndpoint(BaseAPIView):
     serializer_class = StateSerializer
     model = State
     permission_classes = [
         ProjectEntityPermission,
     ]
 
-    def perform_create(self, serializer):
-        serializer.save(project_id=self.kwargs.get("project_id"))
-
     def get_queryset(self):
-        return self.filter_queryset(
+        return (
-            super()
+            State.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
             .filter(project_id=self.kwargs.get("project_id"))
             .filter(project__project_projectmember__member=self.request.user)
             .filter(~Q(name="Triage"))
@@ -40,68 +33,55 @@ class StateViewSet(BaseViewSet):
             .distinct()
         )
 
-    def create(self, request, slug, project_id):
+    def post(self, request, slug, project_id):
-        try:
+        serializer = StateSerializer(data=request.data, context={"project_id": project_id})
-            serializer = StateSerializer(data=request.data)
+        if serializer.is_valid():
-            if serializer.is_valid():
+            serializer.save(project_id=project_id)
-                serializer.save(project_id=project_id)
+            return Response(serializer.data, status=status.HTTP_200_OK)
-                return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
-        except IntegrityError:
+    def get(self, request, slug, project_id, state_id=None):
+        if state_id:
+            serializer = StateSerializer(self.get_queryset().get(pk=state_id))
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return self.paginate(
+            request=request,
+            queryset=(self.get_queryset()),
+            on_results=lambda states: StateSerializer(
+                states,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+            ).data,
+        )
+
+    def delete(self, request, slug, project_id, state_id):
+        state = State.objects.get(
+            ~Q(name="Triage"),
+            pk=state_id,
+            project_id=project_id,
+            workspace__slug=slug,
+        )
+
+        if state.default:
+            return Response({"error": "Default state cannot be deleted"}, status=False)
+
+        # Check for any issues in the state
+        issue_exist = Issue.issue_objects.filter(state=state_id).exists()
+
+        if issue_exist:
             return Response(
-                {"error": "State with the name already exists"},
+                {"error": "The state is not empty, only empty states can be deleted"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-    def list(self, request, slug, project_id):
+        state.delete()
-        try:
+        return Response(status=status.HTTP_204_NO_CONTENT)
-            state_dict = dict()
-            states = StateSerializer(self.get_queryset(), many=True).data
 
-            for key, value in groupby(
+    def patch(self, request, slug, project_id, state_id=None):
-                sorted(states, key=lambda state: state["group"]),
+        state = State.objects.get(workspace__slug=slug, project_id=project_id, pk=state_id)
-                lambda state: state.get("group"),
+        serializer = StateSerializer(state, data=request.data, partial=True)
-            ):
+        if serializer.is_valid():
-                state_dict[str(key)] = list(value)
+            serializer.save()
-
+            return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(state_dict, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def destroy(self, request, slug, project_id, pk):
-        try:
-            state = State.objects.get(
-                ~Q(name="Triage"),
-                pk=pk, project_id=project_id, workspace__slug=slug,
-            )
-
-            if state.default:
-                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()
-
-            if issue_exist:
-                return Response(
-                    {
-                        "error": "The state is not empty, only empty states can be deleted"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            state.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except State.DoesNotExist:
-            return Response({"error": "State does not exists"}, status=status.HTTP_404)

apiserver/plane/api/views/user.py

@@ -1,158 +0,0 @@
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-
-from sentry_sdk import capture_exception
-
-# Module imports
-from plane.api.serializers import (
-    UserSerializer,
-    IssueActivitySerializer,
-)
-
-from plane.api.views.base import BaseViewSet, BaseAPIView
-from plane.db.models import (
-    User,
-    Workspace,
-    WorkspaceMemberInvite,
-    Issue,
-    IssueActivity,
-    WorkspaceMember,
-)
-from plane.utils.paginator import BasePaginator
-
-
-class UserEndpoint(BaseViewSet):
-    serializer_class = UserSerializer
-    model = User
-
-    def get_object(self):
-        return self.request.user
-
-    def retrieve(self, request):
-        try:
-            workspace = Workspace.objects.get(
-                pk=request.user.last_workspace_id, workspace_member__member=request.user
-            )
-            workspace_invites = WorkspaceMemberInvite.objects.filter(
-                email=request.user.email
-            ).count()
-            assigned_issues = Issue.issue_objects.filter(
-                assignees__in=[request.user]
-            ).count()
-
-            serialized_data = UserSerializer(request.user).data
-            serialized_data["workspace"] = {
-                "last_workspace_id": request.user.last_workspace_id,
-                "last_workspace_slug": workspace.slug,
-                "fallback_workspace_id": request.user.last_workspace_id,
-                "fallback_workspace_slug": workspace.slug,
-                "invites": workspace_invites,
-            }
-            serialized_data.setdefault("issues", {})[
-                "assigned_issues"
-            ] = assigned_issues
-
-            return Response(
-                serialized_data,
-                status=status.HTTP_200_OK,
-            )
-        except Workspace.DoesNotExist:
-            # This exception will be hit even when the `last_workspace_id` is None
-
-            workspace_invites = WorkspaceMemberInvite.objects.filter(
-                email=request.user.email
-            ).count()
-            assigned_issues = Issue.issue_objects.filter(
-                assignees__in=[request.user]
-            ).count()
-
-            fallback_workspace = (
-                Workspace.objects.filter(workspace_member__member=request.user)
-                .order_by("created_at")
-                .first()
-            )
-
-            serialized_data = UserSerializer(request.user).data
-
-            serialized_data["workspace"] = {
-                "last_workspace_id": None,
-                "last_workspace_slug": None,
-                "fallback_workspace_id": fallback_workspace.id
-                if fallback_workspace is not None
-                else None,
-                "fallback_workspace_slug": fallback_workspace.slug
-                if fallback_workspace is not None
-                else None,
-                "invites": workspace_invites,
-            }
-            serialized_data.setdefault("issues", {})[
-                "assigned_issues"
-            ] = assigned_issues
-
-            return Response(
-                serialized_data,
-                status=status.HTTP_200_OK,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class UpdateUserOnBoardedEndpoint(BaseAPIView):
-    def patch(self, request):
-        try:
-            user = User.objects.get(pk=request.user.id)
-            user.is_onboarded = request.data.get("is_onboarded", False)
-            user.save()
-            return Response(
-                {"message": "Updated successfully"}, status=status.HTTP_200_OK
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class UpdateUserTourCompletedEndpoint(BaseAPIView):
-    def patch(self, request):
-        try:
-            user = User.objects.get(pk=request.user.id)
-            user.is_tour_completed = request.data.get("is_tour_completed", False)
-            user.save()
-            return Response(
-                {"message": "Updated successfully"}, status=status.HTTP_200_OK
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class UserActivityEndpoint(BaseAPIView, BasePaginator):
-    def get(self, request, slug):
-        try:
-            queryset = IssueActivity.objects.filter(
-                actor=request.user, workspace__slug=slug
-            ).select_related("actor", "workspace", "issue", "project")
-
-            return self.paginate(
-                request=request,
-                queryset=queryset,
-                on_results=lambda issue_activities: IssueActivitySerializer(
-                    issue_activities, many=True
-                ).data,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/api/views/view.py

@@ -1,350 +0,0 @@
-# Django imports
-from django.db.models import (
-    Prefetch,
-    OuterRef,
-    Func,
-    F,
-    Case,
-    Value,
-    CharField,
-    When,
-    Exists,
-    Max,
-)
-from django.utils.decorators import method_decorator
-from django.views.decorators.gzip import gzip_page
-from django.db import IntegrityError
-from django.db.models import Prefetch, OuterRef, Exists
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-from sentry_sdk import capture_exception
-
-# Module imports
-from . import BaseViewSet, BaseAPIView
-from plane.api.serializers import (
-    GlobalViewSerializer,
-    IssueViewSerializer,
-    IssueLiteSerializer,
-    IssueViewFavoriteSerializer,
-)
-from plane.api.permissions import WorkspaceEntityPermission, ProjectEntityPermission
-from plane.db.models import (
-    Workspace,
-    GlobalView,
-    IssueView,
-    Issue,
-    IssueViewFavorite,
-    IssueReaction,
-    IssueLink,
-    IssueAttachment,
-)
-from plane.utils.issue_filters import issue_filters
-from plane.utils.grouper import group_results
-
-
-class GlobalViewViewSet(BaseViewSet):
-    serializer_class = GlobalViewSerializer
-    model = GlobalView
-    permission_classes = [
-        WorkspaceEntityPermission,
-    ]
-
-    def perform_create(self, serializer):
-        workspace = Workspace.objects.get(slug=self.kwargs.get("slug"))
-        serializer.save(workspace_id=workspace.id)
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .select_related("workspace")
-            .order_by(self.request.GET.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-
-class GlobalViewIssuesViewSet(BaseViewSet):
-    permission_classes = [
-        WorkspaceEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("state")
-            .select_related("parent")
-            .prefetch_related("assignees")
-            .prefetch_related("labels")
-            .prefetch_related(
-                Prefetch(
-                    "issue_reactions",
-                    queryset=IssueReaction.objects.select_related("actor"),
-                )
-            )
-        )
-
-        
-    @method_decorator(gzip_page)
-    def list(self, request, slug):
-        try:
-            filters = issue_filters(request.query_params, "GET")
-
-            # Custom ordering for priority and state
-            priority_order = ["urgent", "high", "medium", "low", "none"]
-            state_order = ["backlog", "unstarted", "started", "completed", "cancelled"]
-
-            order_by_param = request.GET.get("order_by", "-created_at")
-
-            issue_queryset = (
-                self.get_queryset()
-                .filter(**filters)
-                .filter(project__project_projectmember__member=self.request.user)
-                .annotate(cycle_id=F("issue_cycle__cycle_id"))
-                .annotate(module_id=F("issue_module__module_id"))
-                .annotate(
-                    link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    attachment_count=IssueAttachment.objects.filter(
-                        issue=OuterRef("id")
-                    )
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-            )
-
-            # Priority Ordering
-            if order_by_param == "priority" or order_by_param == "-priority":
-                priority_order = (
-                    priority_order
-                    if order_by_param == "priority"
-                    else priority_order[::-1]
-                )
-                issue_queryset = issue_queryset.annotate(
-                    priority_order=Case(
-                        *[
-                            When(priority=p, then=Value(i))
-                            for i, p in enumerate(priority_order)
-                        ],
-                        output_field=CharField(),
-                    )
-                ).order_by("priority_order")
-
-            # State Ordering
-            elif order_by_param in [
-                "state__name",
-                "state__group",
-                "-state__name",
-                "-state__group",
-            ]:
-                state_order = (
-                    state_order
-                    if order_by_param in ["state__name", "state__group"]
-                    else state_order[::-1]
-                )
-                issue_queryset = issue_queryset.annotate(
-                    state_order=Case(
-                        *[
-                            When(state__group=state_group, then=Value(i))
-                            for i, state_group in enumerate(state_order)
-                        ],
-                        default=Value(len(state_order)),
-                        output_field=CharField(),
-                    )
-                ).order_by("state_order")
-            # assignee and label ordering
-            elif order_by_param in [
-                "labels__name",
-                "-labels__name",
-                "assignees__first_name",
-                "-assignees__first_name",
-            ]:
-                issue_queryset = issue_queryset.annotate(
-                    max_values=Max(
-                        order_by_param[1::]
-                        if order_by_param.startswith("-")
-                        else order_by_param
-                    )
-                ).order_by(
-                    "-max_values" if order_by_param.startswith("-") else "max_values"
-                )
-            else:
-                issue_queryset = issue_queryset.order_by(order_by_param)
-
-            issues = IssueLiteSerializer(issue_queryset, many=True).data
-
-            ## Grouping the results
-            group_by = request.GET.get("group_by", False)
-            sub_group_by = request.GET.get("sub_group_by", False)
-            if sub_group_by and sub_group_by == group_by:
-                return Response(
-                    {"error": "Group by and sub group by cannot be same"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            
-            if group_by:
-                return Response(
-                    group_results(issues, group_by, sub_group_by), status=status.HTTP_200_OK
-                )
-
-            return Response(issues, status=status.HTTP_200_OK)
-
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class IssueViewViewSet(BaseViewSet):
-    serializer_class = IssueViewSerializer
-    model = IssueView
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def perform_create(self, serializer):
-        serializer.save(project_id=self.kwargs.get("project_id"))
-
-    def get_queryset(self):
-        subquery = IssueViewFavorite.objects.filter(
-            user=self.request.user,
-            view_id=OuterRef("pk"),
-            project_id=self.kwargs.get("project_id"),
-            workspace__slug=self.kwargs.get("slug"),
-        )
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .select_related("project")
-            .select_related("workspace")
-            .annotate(is_favorite=Exists(subquery))
-            .order_by("-is_favorite", "name")
-            .distinct()
-        )
-
-
-class ViewIssuesEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get(self, request, slug, project_id, view_id):
-        try:
-            view = IssueView.objects.get(pk=view_id)
-            queries = view.query
-
-            filters = issue_filters(request.query_params, "GET")
-
-            issues = (
-                Issue.issue_objects.filter(
-                    **queries, project_id=project_id, workspace__slug=slug
-                )
-                .filter(**filters)
-                .select_related("project")
-                .select_related("workspace")
-                .select_related("state")
-                .select_related("parent")
-                .prefetch_related("assignees")
-                .prefetch_related("labels")
-                .prefetch_related(
-                    Prefetch(
-                        "issue_reactions",
-                        queryset=IssueReaction.objects.select_related("actor"),
-                    )
-                )
-            )
-
-            serializer = IssueLiteSerializer(issues, many=True)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except IssueView.DoesNotExist:
-            return Response(
-                {"error": "Issue View does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
-class IssueViewFavoriteViewSet(BaseViewSet):
-    serializer_class = IssueViewFavoriteSerializer
-    model = IssueViewFavorite
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(user=self.request.user)
-            .select_related("view")
-        )
-
-    def create(self, request, slug, project_id):
-        try:
-            serializer = IssueViewFavoriteSerializer(data=request.data)
-            if serializer.is_valid():
-                serializer.save(user=request.user, project_id=project_id)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"error": "The view is already added to favorites"},
-                    status=status.HTTP_410_GONE,
-                )
-            else:
-                capture_exception(e)
-                return Response(
-                    {"error": "Something went wrong please try again later"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def destroy(self, request, slug, project_id, view_id):
-        try:
-            view_favourite = IssueViewFavorite.objects.get(
-                project=project_id,
-                user=request.user,
-                workspace__slug=slug,
-                view_id=view_id,
-            )
-            view_favourite.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except IssueViewFavorite.DoesNotExist:
-            return Response(
-                {"error": "View is not in favorites"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

apiserver/plane/app/apps.py

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

apiserver/plane/app/middleware/api_authentication.py

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

apiserver/plane/app/permissions/__init__.py

@@ -0,0 +1,17 @@
+
+from .workspace import (
+    WorkSpaceBasePermission,
+    WorkspaceOwnerPermission,
+    WorkSpaceAdminPermission,
+    WorkspaceEntityPermission,
+    WorkspaceViewerPermission,
+    WorkspaceUserPermission,
+)
+from .project import (
+    ProjectBasePermission,
+    ProjectEntityPermission,
+    ProjectMemberPermission,
+    ProjectLitePermission,
+)
+
+

apiserver/plane/app/permissions/project.py

@@ -13,14 +13,15 @@ Guest = 5
 
 class ProjectBasePermission(BasePermission):
     def has_permission(self, request, view):
-
         if request.user.is_anonymous:
             return False
 
         ## Safe Methods -> Handle the filtering logic in queryset
         if request.method in SAFE_METHODS:
             return WorkspaceMember.objects.filter(
-                workspace__slug=view.workspace_slug, member=request.user
+                workspace__slug=view.workspace_slug,
+                member=request.user,
+                is_active=True,
             ).exists()
 
         ## Only workspace owners or admins can create the projects
@@ -29,6 +30,7 @@ class ProjectBasePermission(BasePermission):
                 workspace__slug=view.workspace_slug,
                 member=request.user,
                 role__in=[Admin, Member],
+                is_active=True,
             ).exists()
 
         ## Only Project Admins can update project attributes
@@ -37,19 +39,21 @@ class ProjectBasePermission(BasePermission):
             member=request.user,
             role=Admin,
             project_id=view.project_id,
+            is_active=True,
         ).exists()
 
 
 class ProjectMemberPermission(BasePermission):
     def has_permission(self, request, view):
-
         if request.user.is_anonymous:
             return False
 
         ## Safe Methods -> Handle the filtering logic in queryset
         if request.method in SAFE_METHODS:
             return ProjectMember.objects.filter(
-                workspace__slug=view.workspace_slug, member=request.user
+                workspace__slug=view.workspace_slug,
+                member=request.user,
+                is_active=True,
             ).exists()
         ## Only workspace owners or admins can create the projects
         if request.method == "POST":
@@ -57,6 +61,7 @@ class ProjectMemberPermission(BasePermission):
                 workspace__slug=view.workspace_slug,
                 member=request.user,
                 role__in=[Admin, Member],
+                is_active=True,
             ).exists()
 
         ## Only Project Admins can update project attributes
@@ -65,12 +70,12 @@ class ProjectMemberPermission(BasePermission):
             member=request.user,
             role__in=[Admin, Member],
             project_id=view.project_id,
+            is_active=True,
         ).exists()
 
 
 class ProjectEntityPermission(BasePermission):
     def has_permission(self, request, view):
-
         if request.user.is_anonymous:
             return False
 
@@ -80,6 +85,7 @@ class ProjectEntityPermission(BasePermission):
                 workspace__slug=view.workspace_slug,
                 member=request.user,
                 project_id=view.project_id,
+                is_active=True,
             ).exists()
 
         ## Only project members or admins can create and edit the project attributes
@@ -88,17 +94,18 @@ class ProjectEntityPermission(BasePermission):
             member=request.user,
             role__in=[Admin, Member],
             project_id=view.project_id,
+            is_active=True,
         ).exists()
 
 
 class ProjectLitePermission(BasePermission):
-
     def has_permission(self, request, view):
         if request.user.is_anonymous:
             return False
-        
+
         return ProjectMember.objects.filter(
             workspace__slug=view.workspace_slug,
             member=request.user,
             project_id=view.project_id,
-        ).exists()
+            is_active=True,
+        ).exists()

apiserver/plane/app/permissions/workspace.py

@@ -32,15 +32,31 @@ class WorkSpaceBasePermission(BasePermission):
                 member=request.user,
                 workspace__slug=view.workspace_slug,
                 role__in=[Owner, Admin],
+                is_active=True,
             ).exists()
 
         # allow only owner to delete the workspace
         if request.method == "DELETE":
             return WorkspaceMember.objects.filter(
-                member=request.user, workspace__slug=view.workspace_slug, role=Owner
+                member=request.user,
+                workspace__slug=view.workspace_slug,
+                role=Owner,
+                is_active=True,
             ).exists()
 
 
+class WorkspaceOwnerPermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        return WorkspaceMember.objects.filter(
+            workspace__slug=view.workspace_slug,
+            member=request.user,
+            role=Owner,
+        ).exists()
+
+
 class WorkSpaceAdminPermission(BasePermission):
     def has_permission(self, request, view):
         if request.user.is_anonymous:
@@ -50,6 +66,7 @@ class WorkSpaceAdminPermission(BasePermission):
             member=request.user,
             workspace__slug=view.workspace_slug,
             role__in=[Owner, Admin],
+            is_active=True,
         ).exists()
 
 
@@ -63,12 +80,14 @@ class WorkspaceEntityPermission(BasePermission):
             return WorkspaceMember.objects.filter(
                 workspace__slug=view.workspace_slug,
                 member=request.user,
+                is_active=True,
             ).exists()
 
         return WorkspaceMember.objects.filter(
             member=request.user,
             workspace__slug=view.workspace_slug,
             role__in=[Owner, Admin],
+            is_active=True,
         ).exists()
 
 
@@ -78,5 +97,19 @@ class WorkspaceViewerPermission(BasePermission):
             return False
 
         return WorkspaceMember.objects.filter(
-            member=request.user, workspace__slug=view.workspace_slug, role__gte=10
+            member=request.user,
+            workspace__slug=view.workspace_slug,
+            is_active=True,
+        ).exists()
+
+
+class WorkspaceUserPermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        return WorkspaceMember.objects.filter(
+            member=request.user,
+            workspace__slug=view.workspace_slug,
+            is_active=True,
         ).exists()

apiserver/plane/app/serializers/__init__.py

@@ -0,0 +1,104 @@
+from .base import BaseSerializer
+from .user import (
+    UserSerializer,
+    UserLiteSerializer,
+    ChangePasswordSerializer,
+    ResetPasswordSerializer,
+    UserAdminLiteSerializer,
+    UserMeSerializer,
+    UserMeSettingsSerializer,
+)
+from .workspace import (
+    WorkSpaceSerializer,
+    WorkSpaceMemberSerializer,
+    TeamSerializer,
+    WorkSpaceMemberInviteSerializer,
+    WorkspaceLiteSerializer,
+    WorkspaceThemeSerializer,
+    WorkspaceMemberAdminSerializer,
+    WorkspaceMemberMeSerializer,
+)
+from .project import (
+    ProjectSerializer,
+    ProjectListSerializer,
+    ProjectDetailSerializer,
+    ProjectMemberSerializer,
+    ProjectMemberInviteSerializer,
+    ProjectIdentifierSerializer,
+    ProjectFavoriteSerializer,
+    ProjectLiteSerializer,
+    ProjectMemberLiteSerializer,
+    ProjectDeployBoardSerializer,
+    ProjectMemberAdminSerializer,
+    ProjectPublicMemberSerializer,
+)
+from .state import StateSerializer, StateLiteSerializer
+from .view import GlobalViewSerializer, IssueViewSerializer, IssueViewFavoriteSerializer
+from .cycle import (
+    CycleSerializer,
+    CycleIssueSerializer,
+    CycleFavoriteSerializer,
+    CycleWriteSerializer,
+)
+from .asset import FileAssetSerializer
+from .issue import (
+    IssueCreateSerializer,
+    IssueActivitySerializer,
+    IssueCommentSerializer,
+    IssuePropertySerializer,
+    IssueAssigneeSerializer,
+    LabelSerializer,
+    IssueSerializer,
+    IssueFlatSerializer,
+    IssueStateSerializer,
+    IssueLinkSerializer,
+    IssueLiteSerializer,
+    IssueAttachmentSerializer,
+    IssueSubscriberSerializer,
+    IssueReactionSerializer,
+    CommentReactionSerializer,
+    IssueVoteSerializer,
+    IssueRelationSerializer,
+    RelatedIssueSerializer,
+    IssuePublicSerializer,
+)
+
+from .module import (
+    ModuleWriteSerializer,
+    ModuleSerializer,
+    ModuleIssueSerializer,
+    ModuleLinkSerializer,
+    ModuleFavoriteSerializer,
+)
+
+from .api import APITokenSerializer, APITokenReadSerializer
+
+from .integration import (
+    IntegrationSerializer,
+    WorkspaceIntegrationSerializer,
+    GithubIssueSyncSerializer,
+    GithubRepositorySerializer,
+    GithubRepositorySyncSerializer,
+    GithubCommentSyncSerializer,
+    SlackProjectSyncSerializer,
+)
+
+from .importer import ImporterSerializer
+
+from .page import PageSerializer, PageLogSerializer, SubPageSerializer, PageFavoriteSerializer
+
+from .estimate import (
+    EstimateSerializer,
+    EstimatePointSerializer,
+    EstimateReadSerializer,
+)
+
+from .inbox import InboxSerializer, InboxIssueSerializer, IssueStateInboxSerializer
+
+from .analytic import AnalyticViewSerializer
+
+from .notification import NotificationSerializer
+
+from .exporter import ExporterHistorySerializer
+
+from .webhook import WebhookSerializer, WebhookLogSerializer

apiserver/plane/app/serializers/analytic.py

@@ -17,7 +17,7 @@ class AnalyticViewSerializer(BaseSerializer):
         if bool(query_params):
             validated_data["query"] = issue_filters(query_params, "POST")
         else:
-            validated_data["query"] = dict()
+            validated_data["query"] = {}
         return AnalyticView.objects.create(**validated_data)
 
     def update(self, instance, validated_data):
@@ -25,6 +25,6 @@ class AnalyticViewSerializer(BaseSerializer):
         if bool(query_params):
             validated_data["query"] = issue_filters(query_params, "POST")
         else:
-            validated_data["query"] = dict()
+            validated_data["query"] = {}
         validated_data["query"] = issue_filters(query_params, "PATCH")
         return super().update(instance, validated_data)

apiserver/plane/app/serializers/api.py

@@ -0,0 +1,31 @@
+from .base import BaseSerializer
+from plane.db.models import APIToken, APIActivityLog
+
+
+class APITokenSerializer(BaseSerializer):
+    
+    class Meta:
+        model = APIToken
+        fields = "__all__"
+        read_only_fields = [
+            "token",
+            "expired_at",
+            "created_at",
+            "updated_at",
+            "workspace",
+            "user",
+        ]
+
+
+class APITokenReadSerializer(BaseSerializer):
+
+    class Meta:
+        model = APIToken
+        exclude = ('token',)
+
+
+class APIActivityLogSerializer(BaseSerializer):
+
+    class Meta:
+        model = APIActivityLog
+        fields = "__all__"

apiserver/plane/app/serializers/base.py

@@ -0,0 +1,58 @@
+from rest_framework import serializers
+
+
+class BaseSerializer(serializers.ModelSerializer):
+    id = serializers.PrimaryKeyRelatedField(read_only=True)
+
+class DynamicBaseSerializer(BaseSerializer):
+
+    def __init__(self, *args, **kwargs):
+        # If 'fields' is provided in the arguments, remove it and store it separately.
+        # This is done so as not to pass this custom argument up to the superclass.
+        fields = kwargs.pop("fields", None)
+
+        # Call the initialization of the superclass.
+        super().__init__(*args, **kwargs)
+
+        # If 'fields' was provided, filter the fields of the serializer accordingly.
+        if fields is not None:
+            self.fields = self._filter_fields(fields)
+
+    def _filter_fields(self, fields):
+        """
+        Adjust the serializer's fields based on the provided 'fields' list.
+
+        :param fields: List or dictionary specifying which fields to include in the serializer.
+        :return: The updated fields for the serializer.
+        """
+        # Check each field_name in the provided fields.
+        for field_name in fields:
+            # If the field is a dictionary (indicating nested fields),
+            # loop through its keys and values.
+            if isinstance(field_name, dict):
+                for key, value in field_name.items():
+                    # If the value of this nested field is a list, 
+                    # perform a recursive filter on it.
+                    if isinstance(value, list):
+                        self._filter_fields(self.fields[key], value)
+
+        # Create a list to store allowed fields.
+        allowed = []
+        for item in fields:
+            # If the item is a string, it directly represents a field's name.
+            if isinstance(item, str):
+                allowed.append(item)
+            # If the item is a dictionary, it represents a nested field.
+            # Add the key of this dictionary to the allowed list.
+            elif isinstance(item, dict):
+                allowed.append(list(item.keys())[0])
+
+        # Convert the current serializer's fields and the allowed fields to sets.
+        existing = set(self.fields)
+        allowed = set(allowed)
+
+        # Remove fields from the serializer that aren't in the 'allowed' list.
+        for field_name in (existing - allowed):
+            self.fields.pop(field_name)
+
+        return self.fields

apiserver/plane/app/serializers/cycle.py

@@ -0,0 +1,107 @@
+# Third party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from .user import UserLiteSerializer
+from .issue import IssueStateSerializer
+from .workspace import WorkspaceLiteSerializer
+from .project import ProjectLiteSerializer
+from plane.db.models import Cycle, CycleIssue, CycleFavorite
+
+
+class CycleWriteSerializer(BaseSerializer):
+    def validate(self, data):
+        if (
+            data.get("start_date", None) is not None
+            and data.get("end_date", None) is not None
+            and data.get("start_date", None) > data.get("end_date", None)
+        ):
+            raise serializers.ValidationError("Start date cannot exceed end date")
+        return data
+
+    class Meta:
+        model = Cycle
+        fields = "__all__"
+
+
+class CycleSerializer(BaseSerializer):
+    owned_by = UserLiteSerializer(read_only=True)
+    is_favorite = serializers.BooleanField(read_only=True)
+    total_issues = serializers.IntegerField(read_only=True)
+    cancelled_issues = serializers.IntegerField(read_only=True)
+    completed_issues = serializers.IntegerField(read_only=True)
+    started_issues = serializers.IntegerField(read_only=True)
+    unstarted_issues = serializers.IntegerField(read_only=True)
+    backlog_issues = serializers.IntegerField(read_only=True)
+    assignees = serializers.SerializerMethodField(read_only=True)
+    total_estimates = serializers.IntegerField(read_only=True)
+    completed_estimates = serializers.IntegerField(read_only=True)
+    started_estimates = serializers.IntegerField(read_only=True)
+    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+
+    def validate(self, data):
+        if (
+            data.get("start_date", None) is not None
+            and data.get("end_date", None) is not None
+            and data.get("start_date", None) > data.get("end_date", None)
+        ):
+            raise serializers.ValidationError("Start date cannot exceed end date")
+        return data
+
+    def get_assignees(self, obj):
+        members = [
+            {
+                "avatar": assignee.avatar,
+                "display_name": assignee.display_name,
+                "id": assignee.id,
+            }
+            for issue_cycle in obj.issue_cycle.prefetch_related(
+                "issue__assignees"
+            ).all()
+            for assignee in issue_cycle.issue.assignees.all()
+        ]
+        # Use a set comprehension to return only the unique objects
+        unique_objects = {frozenset(item.items()) for item in members}
+
+        # Convert the set back to a list of dictionaries
+        unique_list = [dict(item) for item in unique_objects]
+
+        return unique_list
+
+    class Meta:
+        model = Cycle
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "owned_by",
+        ]
+
+
+class CycleIssueSerializer(BaseSerializer):
+    issue_detail = IssueStateSerializer(read_only=True, source="issue")
+    sub_issues_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = CycleIssue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "cycle",
+        ]
+
+
+class CycleFavoriteSerializer(BaseSerializer):
+    cycle_detail = CycleSerializer(source="cycle", read_only=True)
+
+    class Meta:
+        model = CycleFavorite
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "user",
+        ]

apiserver/plane/app/serializers/estimate.py

@@ -2,7 +2,7 @@
 from .base import BaseSerializer
 
 from plane.db.models import Estimate, EstimatePoint
-from plane.api.serializers import WorkspaceLiteSerializer, ProjectLiteSerializer
+from plane.app.serializers import WorkspaceLiteSerializer, ProjectLiteSerializer
 
 
 class EstimateSerializer(BaseSerializer):

apiserver/plane/app/serializers/inbox.py

@@ -0,0 +1,57 @@
+# Third party frameworks
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from .issue import IssueFlatSerializer, LabelLiteSerializer
+from .project import ProjectLiteSerializer
+from .state import StateLiteSerializer
+from .user import UserLiteSerializer
+from plane.db.models import Inbox, InboxIssue, Issue
+
+
+class InboxSerializer(BaseSerializer):
+    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+    pending_issue_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = Inbox
+        fields = "__all__"
+        read_only_fields = [
+            "project",
+            "workspace",
+        ]
+
+
+class InboxIssueSerializer(BaseSerializer):
+    issue_detail = IssueFlatSerializer(source="issue", read_only=True)
+    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+
+    class Meta:
+        model = InboxIssue
+        fields = "__all__"
+        read_only_fields = [
+            "project",
+            "workspace",
+        ]
+
+
+class InboxIssueLiteSerializer(BaseSerializer):
+    class Meta:
+        model = InboxIssue
+        fields = ["id", "status", "duplicate_to", "snoozed_till", "source"]
+        read_only_fields = fields
+
+
+class IssueStateInboxSerializer(BaseSerializer):
+    state_detail = StateLiteSerializer(read_only=True, source="state")
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
+    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
+    sub_issues_count = serializers.IntegerField(read_only=True)
+    bridge_id = serializers.UUIDField(read_only=True)
+    issue_inbox = InboxIssueLiteSerializer(read_only=True, many=True)
+
+    class Meta:
+        model = Issue
+        fields = "__all__"

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

@@ -5,4 +5,4 @@ from .github import (
     GithubIssueSyncSerializer,
     GithubCommentSyncSerializer,
 )
-from .slack import SlackProjectSyncSerializer
+from .slack import SlackProjectSyncSerializer

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

@@ -1,5 +1,5 @@
 # Module imports
-from plane.api.serializers import BaseSerializer
+from plane.app.serializers import BaseSerializer
 from plane.db.models import Integration, WorkspaceIntegration
 
 

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

@@ -1,5 +1,5 @@
 # Module imports
-from plane.api.serializers import BaseSerializer
+from plane.app.serializers import BaseSerializer
 from plane.db.models import (
     GithubIssueSync,
     GithubRepository,

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

@@ -1,5 +1,5 @@
 # Module imports
-from plane.api.serializers import BaseSerializer
+from plane.app.serializers import BaseSerializer
 from plane.db.models import SlackProjectSync
 
 

apiserver/plane/app/serializers/issue.py

@@ -0,0 +1,616 @@
+# Django imports
+from django.utils import timezone
+
+# Third Party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer, DynamicBaseSerializer
+from .user import UserLiteSerializer
+from .state import StateSerializer, StateLiteSerializer
+from .project import ProjectLiteSerializer
+from .workspace import WorkspaceLiteSerializer
+from plane.db.models import (
+    User,
+    Issue,
+    IssueActivity,
+    IssueComment,
+    IssueProperty,
+    IssueAssignee,
+    IssueSubscriber,
+    IssueLabel,
+    Label,
+    CycleIssue,
+    Cycle,
+    Module,
+    ModuleIssue,
+    IssueLink,
+    IssueAttachment,
+    IssueReaction,
+    CommentReaction,
+    IssueVote,
+    IssueRelation,
+)
+
+
+class IssueFlatSerializer(BaseSerializer):
+    ## Contain only flat fields
+
+    class Meta:
+        model = Issue
+        fields = [
+            "id",
+            "name",
+            "description",
+            "description_html",
+            "priority",
+            "start_date",
+            "target_date",
+            "sequence_id",
+            "sort_order",
+            "is_draft",
+        ]
+
+
+class IssueProjectLiteSerializer(BaseSerializer):
+    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+
+    class Meta:
+        model = Issue
+        fields = [
+            "id",
+            "project_detail",
+            "name",
+            "sequence_id",
+        ]
+        read_only_fields = fields
+
+
+##TODO: Find a better way to write this serializer
+## Find a better approach to save manytomany?
+class IssueCreateSerializer(BaseSerializer):
+    state_detail = StateSerializer(read_only=True, source="state")
+    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+
+    assignees = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
+        write_only=True,
+        required=False,
+    )
+
+    labels = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
+        write_only=True,
+        required=False,
+    )
+
+    class Meta:
+        model = Issue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        data['assignees'] = [str(assignee.id) for assignee in instance.assignees.all()]
+        data['labels'] = [str(label.id) for label in instance.labels.all()]
+        return data
+
+    def validate(self, data):
+        if (
+            data.get("start_date", None) is not None
+            and data.get("target_date", None) is not None
+            and data.get("start_date", None) > data.get("target_date", None)
+        ):
+            raise serializers.ValidationError("Start date cannot exceed target date")
+        return data
+
+    def create(self, validated_data):
+        assignees = validated_data.pop("assignees", None)
+        labels = validated_data.pop("labels", None)
+
+        project_id = self.context["project_id"]
+        workspace_id = self.context["workspace_id"]
+        default_assignee_id = self.context["default_assignee_id"]
+
+        issue = Issue.objects.create(**validated_data, project_id=project_id)
+
+        # Issue Audit Users
+        created_by_id = issue.created_by_id
+        updated_by_id = issue.updated_by_id
+
+        if assignees is not None and len(assignees):
+            IssueAssignee.objects.bulk_create(
+                [
+                    IssueAssignee(
+                        assignee=user,
+                        issue=issue,
+                        project_id=project_id,
+                        workspace_id=workspace_id,
+                        created_by_id=created_by_id,
+                        updated_by_id=updated_by_id,
+                    )
+                    for user in assignees
+                ],
+                batch_size=10,
+            )
+        else:
+            # Then assign it to default assignee
+            if default_assignee_id is not None:
+                IssueAssignee.objects.create(
+                    assignee_id=default_assignee_id,
+                    issue=issue,
+                    project_id=project_id,
+                    workspace_id=workspace_id,
+                    created_by_id=created_by_id,
+                    updated_by_id=updated_by_id,
+                )
+
+        if labels is not None and len(labels):
+            IssueLabel.objects.bulk_create(
+                [
+                    IssueLabel(
+                        label=label,
+                        issue=issue,
+                        project_id=project_id,
+                        workspace_id=workspace_id,
+                        created_by_id=created_by_id,
+                        updated_by_id=updated_by_id,
+                    )
+                    for label in labels
+                ],
+                batch_size=10,
+            )
+
+        return issue
+
+    def update(self, instance, validated_data):
+        assignees = validated_data.pop("assignees", None)
+        labels = validated_data.pop("labels", None)
+
+        # Related models
+        project_id = instance.project_id
+        workspace_id = instance.workspace_id
+        created_by_id = instance.created_by_id
+        updated_by_id = instance.updated_by_id
+
+        if assignees is not None:
+            IssueAssignee.objects.filter(issue=instance).delete()
+            IssueAssignee.objects.bulk_create(
+                [
+                    IssueAssignee(
+                        assignee=user,
+                        issue=instance,
+                        project_id=project_id,
+                        workspace_id=workspace_id,
+                        created_by_id=created_by_id,
+                        updated_by_id=updated_by_id,
+                    )
+                    for user in assignees
+                ],
+                batch_size=10,
+            )
+
+        if labels is not None:
+            IssueLabel.objects.filter(issue=instance).delete()
+            IssueLabel.objects.bulk_create(
+                [
+                    IssueLabel(
+                        label=label,
+                        issue=instance,
+                        project_id=project_id,
+                        workspace_id=workspace_id,
+                        created_by_id=created_by_id,
+                        updated_by_id=updated_by_id,
+                    )
+                    for label in labels
+                ],
+                batch_size=10,
+            )
+
+        # Time updation occues even when other related models are updated
+        instance.updated_at = timezone.now()
+        return super().update(instance, validated_data)
+
+
+class IssueActivitySerializer(BaseSerializer):
+    actor_detail = UserLiteSerializer(read_only=True, source="actor")
+    issue_detail = IssueFlatSerializer(read_only=True, source="issue")
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+
+    class Meta:
+        model = IssueActivity
+        fields = "__all__"
+
+
+
+class IssuePropertySerializer(BaseSerializer):
+    class Meta:
+        model = IssueProperty
+        fields = "__all__"
+        read_only_fields = [
+            "user",
+            "workspace",
+            "project",
+        ]
+
+
+class LabelSerializer(BaseSerializer):
+    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+
+    class Meta:
+        model = Label
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]
+
+
+class LabelLiteSerializer(BaseSerializer):
+    class Meta:
+        model = Label
+        fields = [
+            "id",
+            "name",
+            "color",
+        ]
+
+
+class IssueLabelSerializer(BaseSerializer):
+
+    class Meta:
+        model = IssueLabel
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]
+
+
+class IssueRelationSerializer(BaseSerializer):
+    issue_detail = IssueProjectLiteSerializer(read_only=True, source="related_issue")
+
+    class Meta:
+        model = IssueRelation
+        fields = [
+            "issue_detail",
+            "relation_type",
+            "related_issue",
+            "issue",
+            "id"
+        ]
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]
+
+class RelatedIssueSerializer(BaseSerializer):
+    issue_detail = IssueProjectLiteSerializer(read_only=True, source="issue")
+
+    class Meta:
+        model = IssueRelation
+        fields = [
+            "issue_detail",
+            "relation_type",
+            "related_issue",
+            "issue",
+            "id"
+        ]
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]
+
+
+class IssueAssigneeSerializer(BaseSerializer):
+    assignee_details = UserLiteSerializer(read_only=True, source="assignee")
+
+    class Meta:
+        model = IssueAssignee
+        fields = "__all__"
+
+
+class CycleBaseSerializer(BaseSerializer):
+    class Meta:
+        model = Cycle
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class IssueCycleDetailSerializer(BaseSerializer):
+    cycle_detail = CycleBaseSerializer(read_only=True, source="cycle")
+
+    class Meta:
+        model = CycleIssue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class ModuleBaseSerializer(BaseSerializer):
+    class Meta:
+        model = Module
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class IssueModuleDetailSerializer(BaseSerializer):
+    module_detail = ModuleBaseSerializer(read_only=True, source="module")
+
+    class Meta:
+        model = ModuleIssue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class IssueLinkSerializer(BaseSerializer):
+    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
+
+    class Meta:
+        model = IssueLink
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "issue",
+        ]
+
+    # Validation if url already exists
+    def create(self, validated_data):
+        if IssueLink.objects.filter(
+            url=validated_data.get("url"), issue_id=validated_data.get("issue_id")
+        ).exists():
+            raise serializers.ValidationError(
+                {"error": "URL already exists for this Issue"}
+            )
+        return IssueLink.objects.create(**validated_data)
+
+
+class IssueAttachmentSerializer(BaseSerializer):
+    class Meta:
+        model = IssueAttachment
+        fields = "__all__"
+        read_only_fields = [
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "workspace",
+            "project",
+            "issue",
+        ]
+
+
+class IssueReactionSerializer(BaseSerializer):
+    
+    actor_detail = UserLiteSerializer(read_only=True, source="actor")
+    
+    class Meta:
+        model = IssueReaction
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "issue",
+            "actor",
+        ]
+
+
+class CommentReactionLiteSerializer(BaseSerializer):
+    actor_detail = UserLiteSerializer(read_only=True, source="actor")
+
+    class Meta:
+        model = CommentReaction
+        fields = [
+            "id",
+            "reaction",
+            "comment",
+            "actor_detail",
+        ]
+
+
+class CommentReactionSerializer(BaseSerializer):
+    class Meta:
+        model = CommentReaction
+        fields = "__all__"
+        read_only_fields = ["workspace", "project", "comment", "actor"]
+
+
+class IssueVoteSerializer(BaseSerializer):
+
+    actor_detail = UserLiteSerializer(read_only=True, source="actor")
+
+    class Meta:
+        model = IssueVote
+        fields = ["issue", "vote", "workspace", "project", "actor", "actor_detail"]
+        read_only_fields = fields
+
+
+class IssueCommentSerializer(BaseSerializer):
+    actor_detail = UserLiteSerializer(read_only=True, source="actor")
+    issue_detail = IssueFlatSerializer(read_only=True, source="issue")
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+    comment_reactions = CommentReactionLiteSerializer(read_only=True, many=True)
+    is_member = serializers.BooleanField(read_only=True)
+
+    class Meta:
+        model = IssueComment
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "issue",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class IssueStateFlatSerializer(BaseSerializer):
+    state_detail = StateLiteSerializer(read_only=True, source="state")
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+
+    class Meta:
+        model = Issue
+        fields = [
+            "id",
+            "sequence_id",
+            "name",
+            "state_detail",
+            "project_detail",
+        ]
+
+
+# Issue Serializer with state details
+class IssueStateSerializer(DynamicBaseSerializer):
+    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
+    state_detail = StateLiteSerializer(read_only=True, source="state")
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
+    sub_issues_count = serializers.IntegerField(read_only=True)
+    bridge_id = serializers.UUIDField(read_only=True)
+    attachment_count = serializers.IntegerField(read_only=True)
+    link_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = Issue
+        fields = "__all__"
+
+
+class IssueSerializer(BaseSerializer):
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    state_detail = StateSerializer(read_only=True, source="state")
+    parent_detail = IssueStateFlatSerializer(read_only=True, source="parent")
+    label_details = LabelSerializer(read_only=True, source="labels", many=True)
+    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
+    related_issues = IssueRelationSerializer(read_only=True, source="issue_relation", many=True)
+    issue_relations = RelatedIssueSerializer(read_only=True, source="issue_related", many=True)
+    issue_cycle = IssueCycleDetailSerializer(read_only=True)
+    issue_module = IssueModuleDetailSerializer(read_only=True)
+    issue_link = IssueLinkSerializer(read_only=True, many=True)
+    issue_attachment = IssueAttachmentSerializer(read_only=True, many=True)
+    sub_issues_count = serializers.IntegerField(read_only=True)
+    issue_reactions = IssueReactionSerializer(read_only=True, many=True)
+
+    class Meta:
+        model = Issue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class IssueLiteSerializer(DynamicBaseSerializer):
+    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    state_detail = StateLiteSerializer(read_only=True, source="state")
+    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
+    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
+    sub_issues_count = serializers.IntegerField(read_only=True)
+    cycle_id = serializers.UUIDField(read_only=True)
+    module_id = serializers.UUIDField(read_only=True)
+    attachment_count = serializers.IntegerField(read_only=True)
+    link_count = serializers.IntegerField(read_only=True)
+    issue_reactions = IssueReactionSerializer(read_only=True, many=True)
+
+    class Meta:
+        model = Issue
+        fields = "__all__"
+        read_only_fields = [
+            "start_date",
+            "target_date",
+            "completed_at",
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class IssuePublicSerializer(BaseSerializer):
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    state_detail = StateLiteSerializer(read_only=True, source="state")
+    reactions = IssueReactionSerializer(read_only=True, many=True, source="issue_reactions")
+    votes = IssueVoteSerializer(read_only=True, many=True)
+
+    class Meta:
+        model = Issue
+        fields = [
+            "id",
+            "name",
+            "description_html",
+            "sequence_id",
+            "state",
+            "state_detail",
+            "project",
+            "project_detail",
+            "workspace",
+            "priority",
+            "target_date",
+            "reactions",
+            "votes",
+        ]
+        read_only_fields = fields
+
+
+
+class IssueSubscriberSerializer(BaseSerializer):
+    class Meta:
+        model = IssueSubscriber
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "issue",
+        ]

apiserver/plane/app/serializers/module.py

@@ -0,0 +1,198 @@
+# Third Party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from .user import UserLiteSerializer
+from .project import ProjectLiteSerializer
+from .workspace import WorkspaceLiteSerializer
+
+from plane.db.models import (
+    User,
+    Module,
+    ModuleMember,
+    ModuleIssue,
+    ModuleLink,
+    ModuleFavorite,
+)
+
+
+class ModuleWriteSerializer(BaseSerializer):
+    members = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
+        write_only=True,
+        required=False,
+    )
+
+    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+
+    class Meta:
+        model = Module
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+    
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        data['members'] = [str(member.id) for member in instance.members.all()]
+        return data
+
+    def validate(self, data):
+        if data.get("start_date", None) is not None and data.get("target_date", None) is not None and data.get("start_date", None) > data.get("target_date", None):
+            raise serializers.ValidationError("Start date cannot exceed target date")
+        return data    
+
+    def create(self, validated_data):
+        members = validated_data.pop("members", None)
+
+        project = self.context["project"]
+
+        module = Module.objects.create(**validated_data, project=project)
+
+        if members is not None:
+            ModuleMember.objects.bulk_create(
+                [
+                    ModuleMember(
+                        module=module,
+                        member=member,
+                        project=project,
+                        workspace=project.workspace,
+                        created_by=module.created_by,
+                        updated_by=module.updated_by,
+                    )
+                    for member in members
+                ],
+                batch_size=10,
+                ignore_conflicts=True,
+            )
+
+        return module
+
+    def update(self, instance, validated_data):
+        members = validated_data.pop("members", None)
+
+        if members is not None:
+            ModuleMember.objects.filter(module=instance).delete()
+            ModuleMember.objects.bulk_create(
+                [
+                    ModuleMember(
+                        module=instance,
+                        member=member,
+                        project=instance.project,
+                        workspace=instance.project.workspace,
+                        created_by=instance.created_by,
+                        updated_by=instance.updated_by,
+                    )
+                    for member in members
+                ],
+                batch_size=10,
+                ignore_conflicts=True,
+            )
+
+        return super().update(instance, validated_data)
+
+
+class ModuleFlatSerializer(BaseSerializer):
+    class Meta:
+        model = Module
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class ModuleIssueSerializer(BaseSerializer):
+    module_detail = ModuleFlatSerializer(read_only=True, source="module")
+    issue_detail = ProjectLiteSerializer(read_only=True, source="issue")
+    sub_issues_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = ModuleIssue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "module",
+        ]
+
+
+class ModuleLinkSerializer(BaseSerializer):
+    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
+
+    class Meta:
+        model = ModuleLink
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "module",
+        ]
+
+    # Validation if url already exists
+    def create(self, validated_data):
+        if ModuleLink.objects.filter(
+            url=validated_data.get("url"), module_id=validated_data.get("module_id")
+        ).exists():
+            raise serializers.ValidationError(
+                {"error": "URL already exists for this Issue"}
+            )
+        return ModuleLink.objects.create(**validated_data)
+
+
+class ModuleSerializer(BaseSerializer):
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    lead_detail = UserLiteSerializer(read_only=True, source="lead")
+    members_detail = UserLiteSerializer(read_only=True, many=True, source="members")
+    link_module = ModuleLinkSerializer(read_only=True, many=True)
+    is_favorite = serializers.BooleanField(read_only=True)
+    total_issues = serializers.IntegerField(read_only=True)
+    cancelled_issues = serializers.IntegerField(read_only=True)
+    completed_issues = serializers.IntegerField(read_only=True)
+    started_issues = serializers.IntegerField(read_only=True)
+    unstarted_issues = serializers.IntegerField(read_only=True)
+    backlog_issues = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = Module
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class ModuleFavoriteSerializer(BaseSerializer):
+    module_detail = ModuleFlatSerializer(source="module", read_only=True)
+
+    class Meta:
+        model = ModuleFavorite
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "user",
+        ]

apiserver/plane/app/serializers/page.py

@@ -6,39 +6,17 @@ from .base import BaseSerializer
 from .issue import IssueFlatSerializer, LabelLiteSerializer
 from .workspace import WorkspaceLiteSerializer
 from .project import ProjectLiteSerializer
-from plane.db.models import Page, PageBlock, PageFavorite, PageLabel, Label
+from plane.db.models import Page, PageLog, PageFavorite, PageLabel, Label, Issue, Module
-
-
-class PageBlockSerializer(BaseSerializer):
-    issue_detail = IssueFlatSerializer(source="issue", read_only=True)
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
-    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
-
-    class Meta:
-        model = PageBlock
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "page",
-        ]
-
-class PageBlockLiteSerializer(BaseSerializer):
-
-    class Meta:
-        model = PageBlock
-        fields = "__all__"
 
 
 class PageSerializer(BaseSerializer):
     is_favorite = serializers.BooleanField(read_only=True)
     label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
-    labels_list = serializers.ListField(
+    labels = serializers.ListField(
         child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
         write_only=True,
         required=False,
     )
-    blocks = PageBlockLiteSerializer(read_only=True, many=True)
     project_detail = ProjectLiteSerializer(source="project", read_only=True)
     workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
 
@@ -50,9 +28,13 @@ class PageSerializer(BaseSerializer):
             "project",
             "owned_by",
         ]
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        data['labels'] = [str(label.id) for label in instance.labels.all()]
+        return data
 
     def create(self, validated_data):
-        labels = validated_data.pop("labels_list", None)
+        labels = validated_data.pop("labels", None)
         project_id = self.context["project_id"]
         owned_by_id = self.context["owned_by_id"]
         page = Page.objects.create(
@@ -77,7 +59,7 @@ class PageSerializer(BaseSerializer):
         return page
 
     def update(self, instance, validated_data):
-        labels = validated_data.pop("labels_list", None)
+        labels = validated_data.pop("labels", None)
         if labels is not None:
             PageLabel.objects.filter(page=instance).delete()
             PageLabel.objects.bulk_create(
@@ -98,6 +80,41 @@ class PageSerializer(BaseSerializer):
         return super().update(instance, validated_data)
 
 
+class SubPageSerializer(BaseSerializer):
+    entity_details = serializers.SerializerMethodField()
+
+    class Meta:
+        model = PageLog
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "page",
+        ]
+
+    def get_entity_details(self, obj):
+        entity_name = obj.entity_name
+        if entity_name == 'forward_link' or entity_name == 'back_link':
+            try:
+                page = Page.objects.get(pk=obj.entity_identifier)
+                return PageSerializer(page).data
+            except Page.DoesNotExist:
+                return None
+        return None
+
+
+class PageLogSerializer(BaseSerializer):
+
+    class Meta:
+        model = PageLog
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "page",
+        ]
+
+
 class PageFavoriteSerializer(BaseSerializer):
     page_detail = PageSerializer(source="page", read_only=True)
 

apiserver/plane/app/serializers/project.py

@@ -0,0 +1,217 @@
+# Third party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer, DynamicBaseSerializer
+from plane.app.serializers.workspace import WorkspaceLiteSerializer
+from plane.app.serializers.user import UserLiteSerializer, UserAdminLiteSerializer
+from plane.db.models import (
+    Project,
+    ProjectMember,
+    ProjectMemberInvite,
+    ProjectIdentifier,
+    ProjectFavorite,
+    ProjectDeployBoard,
+    ProjectPublicMember,
+)
+
+
+class ProjectSerializer(BaseSerializer):
+    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+
+    class Meta:
+        model = Project
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+        ]
+
+    def create(self, validated_data):
+        identifier = validated_data.get("identifier", "").strip().upper()
+        if identifier == "":
+            raise serializers.ValidationError(detail="Project Identifier is required")
+
+        if ProjectIdentifier.objects.filter(
+            name=identifier, workspace_id=self.context["workspace_id"]
+        ).exists():
+            raise serializers.ValidationError(detail="Project Identifier is taken")
+        project = Project.objects.create(
+            **validated_data, workspace_id=self.context["workspace_id"]
+        )
+        _ = ProjectIdentifier.objects.create(
+            name=project.identifier,
+            project=project,
+            workspace_id=self.context["workspace_id"],
+        )
+        return project
+
+    def update(self, instance, validated_data):
+        identifier = validated_data.get("identifier", "").strip().upper()
+
+        # If identifier is not passed update the project and return
+        if identifier == "":
+            project = super().update(instance, validated_data)
+            return project
+
+        # If no Project Identifier is found create it
+        project_identifier = ProjectIdentifier.objects.filter(
+            name=identifier, workspace_id=instance.workspace_id
+        ).first()
+        if project_identifier is None:
+            project = super().update(instance, validated_data)
+            project_identifier = ProjectIdentifier.objects.filter(
+                project=project
+            ).first()
+            if project_identifier is not None:
+                project_identifier.name = identifier
+                project_identifier.save()
+            return project
+        # If found check if the project_id to be updated and identifier project id is same
+        if project_identifier.project_id == instance.id:
+            # If same pass update
+            project = super().update(instance, validated_data)
+            return project
+
+        # If not same fail update
+        raise serializers.ValidationError(detail="Project Identifier is already taken")
+
+
+class ProjectLiteSerializer(BaseSerializer):
+    class Meta:
+        model = Project
+        fields = [
+            "id",
+            "identifier",
+            "name",
+            "cover_image",
+            "icon_prop",
+            "emoji",
+            "description",
+        ]
+        read_only_fields = fields
+
+
+class ProjectListSerializer(DynamicBaseSerializer):
+    is_favorite = serializers.BooleanField(read_only=True)
+    total_members = serializers.IntegerField(read_only=True)
+    total_cycles = serializers.IntegerField(read_only=True)
+    total_modules = serializers.IntegerField(read_only=True)
+    is_member = serializers.BooleanField(read_only=True)
+    sort_order = serializers.FloatField(read_only=True)
+    member_role = serializers.IntegerField(read_only=True)
+    is_deployed = serializers.BooleanField(read_only=True)
+    members = serializers.SerializerMethodField()
+
+    def get_members(self, obj):
+        project_members = ProjectMember.objects.filter(
+            project_id=obj.id,
+            is_active=True,
+        ).values(
+            "id",
+            "member_id",
+            "member__display_name",
+            "member__avatar",
+        )
+        return list(project_members)
+
+    class Meta:
+        model = Project
+        fields = "__all__"
+
+
+class ProjectDetailSerializer(BaseSerializer):
+    # workspace = WorkSpaceSerializer(read_only=True)
+    default_assignee = UserLiteSerializer(read_only=True)
+    project_lead = UserLiteSerializer(read_only=True)
+    is_favorite = serializers.BooleanField(read_only=True)
+    total_members = serializers.IntegerField(read_only=True)
+    total_cycles = serializers.IntegerField(read_only=True)
+    total_modules = serializers.IntegerField(read_only=True)
+    is_member = serializers.BooleanField(read_only=True)
+    sort_order = serializers.FloatField(read_only=True)
+    member_role = serializers.IntegerField(read_only=True)
+    is_deployed = serializers.BooleanField(read_only=True)
+
+    class Meta:
+        model = Project
+        fields = "__all__"
+
+
+class ProjectMemberSerializer(BaseSerializer):
+    workspace = WorkspaceLiteSerializer(read_only=True)
+    project = ProjectLiteSerializer(read_only=True)
+    member = UserLiteSerializer(read_only=True)
+
+    class Meta:
+        model = ProjectMember
+        fields = "__all__"
+
+
+class ProjectMemberAdminSerializer(BaseSerializer):
+    workspace = WorkspaceLiteSerializer(read_only=True)
+    project = ProjectLiteSerializer(read_only=True)
+    member = UserAdminLiteSerializer(read_only=True)
+
+    class Meta:
+        model = ProjectMember
+        fields = "__all__"
+
+
+class ProjectMemberInviteSerializer(BaseSerializer):
+    project = ProjectLiteSerializer(read_only=True)
+    workspace = WorkspaceLiteSerializer(read_only=True)
+
+    class Meta:
+        model = ProjectMemberInvite
+        fields = "__all__"
+
+
+class ProjectIdentifierSerializer(BaseSerializer):
+    class Meta:
+        model = ProjectIdentifier
+        fields = "__all__"
+
+
+class ProjectFavoriteSerializer(BaseSerializer):
+    class Meta:
+        model = ProjectFavorite
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "user",
+        ]
+
+
+class ProjectMemberLiteSerializer(BaseSerializer):
+    member = UserLiteSerializer(read_only=True)
+    is_subscribed = serializers.BooleanField(read_only=True)
+
+    class Meta:
+        model = ProjectMember
+        fields = ["member", "id", "is_subscribed"]
+        read_only_fields = fields
+
+
+class ProjectDeployBoardSerializer(BaseSerializer):
+    project_details = ProjectLiteSerializer(read_only=True, source="project")
+    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+
+    class Meta:
+        model = ProjectDeployBoard
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "anchor",
+        ]
+
+
+class ProjectPublicMemberSerializer(BaseSerializer):
+    class Meta:
+        model = ProjectPublicMember
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "member",
+        ]

apiserver/plane/app/serializers/state.py

@@ -0,0 +1,28 @@
+# Module imports
+from .base import BaseSerializer
+
+
+from plane.db.models import State
+
+
+class StateSerializer(BaseSerializer):
+
+    class Meta:
+        model = State
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]
+
+
+class StateLiteSerializer(BaseSerializer):
+    class Meta:
+        model = State
+        fields = [
+            "id",
+            "name",
+            "color",
+            "group",
+        ]
+        read_only_fields = fields

apiserver/plane/app/serializers/user.py

@@ -0,0 +1,195 @@
+# Third party imports
+from rest_framework import serializers
+
+# Module import
+from .base import BaseSerializer
+from plane.db.models import User, Workspace, WorkspaceMemberInvite
+from plane.license.models import InstanceAdmin, Instance
+
+
+class UserSerializer(BaseSerializer):
+    class Meta:
+        model = User
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "created_at",
+            "updated_at",
+            "is_superuser",
+            "is_staff",
+            "last_active",
+            "last_login_time",
+            "last_logout_time",
+            "last_login_ip",
+            "last_logout_ip",
+            "last_login_uagent",
+            "token_updated_at",
+            "is_onboarded",
+            "is_bot",
+            "is_password_autoset",
+            "is_email_verified",
+        ]
+        extra_kwargs = {"password": {"write_only": True}}
+
+        # If the user has already filled first name or last name then he is onboarded
+        def get_is_onboarded(self, obj):
+            return bool(obj.first_name) or bool(obj.last_name)
+
+
+class UserMeSerializer(BaseSerializer):
+    class Meta:
+        model = User
+        fields = [
+            "id",
+            "avatar",
+            "cover_image",
+            "date_joined",
+            "display_name",
+            "email",
+            "first_name",
+            "last_name",
+            "is_active",
+            "is_bot",
+            "is_email_verified",
+            "is_managed",
+            "is_onboarded",
+            "is_tour_completed",
+            "mobile_number",
+            "role",
+            "onboarding_step",
+            "user_timezone",
+            "username",
+            "theme",
+            "last_workspace_id",
+            "use_case",
+            "is_password_autoset",
+            "is_email_verified",
+        ]
+        read_only_fields = fields
+
+
+class UserMeSettingsSerializer(BaseSerializer):
+    workspace = serializers.SerializerMethodField()
+
+    class Meta:
+        model = User
+        fields = [
+            "id",
+            "email",
+            "workspace",
+        ]
+        read_only_fields = fields
+
+    def get_workspace(self, obj):
+        workspace_invites = WorkspaceMemberInvite.objects.filter(
+            email=obj.email
+        ).count()
+        if (
+            obj.last_workspace_id is not None
+            and Workspace.objects.filter(
+                pk=obj.last_workspace_id,
+                workspace_member__member=obj.id,
+                workspace_member__is_active=True,
+            ).exists()
+        ):
+            workspace = Workspace.objects.filter(
+                pk=obj.last_workspace_id,
+                workspace_member__member=obj.id,
+                workspace_member__is_active=True,
+            ).first()
+            return {
+                "last_workspace_id": obj.last_workspace_id,
+                "last_workspace_slug": workspace.slug if workspace is not None else "",
+                "fallback_workspace_id": obj.last_workspace_id,
+                "fallback_workspace_slug": workspace.slug
+                if workspace is not None
+                else "",
+                "invites": workspace_invites,
+            }
+        else:
+            fallback_workspace = (
+                Workspace.objects.filter(
+                    workspace_member__member_id=obj.id, workspace_member__is_active=True
+                )
+                .order_by("created_at")
+                .first()
+            )
+            return {
+                "last_workspace_id": None,
+                "last_workspace_slug": None,
+                "fallback_workspace_id": fallback_workspace.id
+                if fallback_workspace is not None
+                else None,
+                "fallback_workspace_slug": fallback_workspace.slug
+                if fallback_workspace is not None
+                else None,
+                "invites": workspace_invites,
+            }
+
+
+class UserLiteSerializer(BaseSerializer):
+    class Meta:
+        model = User
+        fields = [
+            "id",
+            "first_name",
+            "last_name",
+            "avatar",
+            "is_bot",
+            "display_name",
+        ]
+        read_only_fields = [
+            "id",
+            "is_bot",
+        ]
+
+
+class UserAdminLiteSerializer(BaseSerializer):
+    class Meta:
+        model = User
+        fields = [
+            "id",
+            "first_name",
+            "last_name",
+            "avatar",
+            "is_bot",
+            "display_name",
+            "email",
+        ]
+        read_only_fields = [
+            "id",
+            "is_bot",
+        ]
+
+
+class ChangePasswordSerializer(serializers.Serializer):
+    model = User
+
+    """
+    Serializer for password change endpoint.
+    """
+    old_password = serializers.CharField(required=True)
+    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"):
+            raise serializers.ValidationError(
+                {"error": "New password cannot be same as old password."}
+            )
+
+        if data.get("new_password") != data.get("confirm_password"):
+            raise serializers.ValidationError(
+                {"error": "Confirm password should be same as the new password."}
+            )
+
+        return data
+
+
+class ResetPasswordSerializer(serializers.Serializer):
+    model = User
+
+    """
+    Serializer for password change endpoint.
+    """
+    new_password = serializers.CharField(required=True)

apiserver/plane/app/serializers/view.py

@@ -57,7 +57,7 @@ class IssueViewSerializer(BaseSerializer):
         if bool(query_params):
             validated_data["query"] = issue_filters(query_params, "POST")
         else:
-            validated_data["query"] = dict()
+            validated_data["query"] = {}
         return IssueView.objects.create(**validated_data)
 
     def update(self, instance, validated_data):
@@ -65,7 +65,7 @@ class IssueViewSerializer(BaseSerializer):
         if bool(query_params):
             validated_data["query"] = issue_filters(query_params, "POST")
         else:
-            validated_data["query"] = dict()
+            validated_data["query"] = {}
         validated_data["query"] = issue_filters(query_params, "PATCH")
         return super().update(instance, validated_data)
 

apiserver/plane/app/serializers/webhook.py

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

apiserver/plane/app/serializers/workspace.py

@@ -0,0 +1,153 @@
+# Third party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from .user import UserLiteSerializer, UserAdminLiteSerializer
+
+from plane.db.models import (
+    User,
+    Workspace,
+    WorkspaceMember,
+    Team,
+    TeamMember,
+    WorkspaceMemberInvite,
+    WorkspaceTheme,
+)
+
+
+class WorkSpaceSerializer(BaseSerializer):
+    owner = UserLiteSerializer(read_only=True)
+    total_members = serializers.IntegerField(read_only=True)
+    total_issues = serializers.IntegerField(read_only=True)
+
+    def validated(self, data):
+        if data.get("slug") in [
+            "404",
+            "accounts",
+            "api",
+            "create-workspace",
+            "god-mode",
+            "installations",
+            "invitations",
+            "onboarding",
+            "profile",
+            "spaces",
+            "workspace-invitations",
+            "password",
+        ]:
+            raise serializers.ValidationError({"slug": "Slug is not valid"})
+
+    class Meta:
+        model = Workspace
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "owner",
+        ]
+
+class WorkspaceLiteSerializer(BaseSerializer):
+    class Meta:
+        model = Workspace
+        fields = [
+            "name",
+            "slug",
+            "id",
+        ]
+        read_only_fields = fields
+
+
+
+class WorkSpaceMemberSerializer(BaseSerializer):
+    member = UserLiteSerializer(read_only=True)
+    workspace = WorkspaceLiteSerializer(read_only=True)
+
+    class Meta:
+        model = WorkspaceMember
+        fields = "__all__"
+
+
+class WorkspaceMemberMeSerializer(BaseSerializer):
+
+    class Meta:
+        model = WorkspaceMember
+        fields = "__all__"
+
+
+class WorkspaceMemberAdminSerializer(BaseSerializer):
+    member = UserAdminLiteSerializer(read_only=True)
+    workspace = WorkspaceLiteSerializer(read_only=True)
+
+    class Meta:
+        model = WorkspaceMember
+        fields = "__all__"
+
+
+class WorkSpaceMemberInviteSerializer(BaseSerializer):
+    workspace = WorkSpaceSerializer(read_only=True)
+    total_members = serializers.IntegerField(read_only=True)
+    created_by_detail = UserLiteSerializer(read_only=True, source="created_by")
+
+    class Meta:
+        model = WorkspaceMemberInvite
+        fields = "__all__"
+
+
+class TeamSerializer(BaseSerializer):
+    members_detail = UserLiteSerializer(read_only=True, source="members", many=True)
+    members = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
+        write_only=True,
+        required=False,
+    )
+
+    class Meta:
+        model = Team
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+    def create(self, validated_data, **kwargs):
+        if "members" in validated_data:
+            members = validated_data.pop("members")
+            workspace = self.context["workspace"]
+            team = Team.objects.create(**validated_data, workspace=workspace)
+            team_members = [
+                TeamMember(member=member, team=team, workspace=workspace)
+                for member in members
+            ]
+            TeamMember.objects.bulk_create(team_members, batch_size=10)
+            return team
+        team = Team.objects.create(**validated_data)
+        return team
+
+    def update(self, instance, validated_data):
+        if "members" in validated_data:
+            members = validated_data.pop("members")
+            TeamMember.objects.filter(team=instance).delete()
+            team_members = [
+                TeamMember(member=member, team=instance, workspace=instance.workspace)
+                for member in members
+            ]
+            TeamMember.objects.bulk_create(team_members, batch_size=10)
+            return super().update(instance, validated_data)
+        return super().update(instance, validated_data)
+
+
+class WorkspaceThemeSerializer(BaseSerializer):
+    class Meta:
+        model = WorkspaceTheme
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "actor",
+        ]

apiserver/plane/app/urls/__init__.py

@@ -0,0 +1,48 @@
+from .analytic import urlpatterns as analytic_urls
+from .asset import urlpatterns as asset_urls
+from .authentication import urlpatterns as authentication_urls
+from .config import urlpatterns as configuration_urls
+from .cycle import urlpatterns as cycle_urls
+from .estimate import urlpatterns as estimate_urls
+from .external import urlpatterns as external_urls
+from .importer import urlpatterns as importer_urls
+from .inbox import urlpatterns as inbox_urls
+from .integration import urlpatterns as integration_urls
+from .issue import urlpatterns as issue_urls
+from .module import urlpatterns as module_urls
+from .notification import urlpatterns as notification_urls
+from .page import urlpatterns as page_urls
+from .project import urlpatterns as project_urls
+from .search import urlpatterns as search_urls
+from .state import urlpatterns as state_urls
+from .user import urlpatterns as user_urls
+from .views import urlpatterns as view_urls
+from .workspace import urlpatterns as workspace_urls
+from .api import urlpatterns as api_urls
+from .webhook import urlpatterns as webhook_urls
+
+
+urlpatterns = [
+    *analytic_urls,
+    *asset_urls,
+    *authentication_urls,
+    *configuration_urls,
+    *cycle_urls,
+    *estimate_urls,
+    *external_urls,
+    *importer_urls,
+    *inbox_urls,
+    *integration_urls,
+    *issue_urls,
+    *module_urls,
+    *notification_urls,
+    *page_urls,
+    *project_urls,
+    *search_urls,
+    *state_urls,
+    *user_urls,
+    *view_urls,
+    *workspace_urls,
+    *api_urls,
+    *webhook_urls,
+]