fix: cloud fixes

* chore: module constant and helper function added

* style: module card ui revamp

* chore: custom media query added

* chore: circular progress indicator added

* chore: module card item ui improvement

* chore: module list view added

* chore: module sidebar added in list and card view

* chore: module list and card ui improvement

* chore: module sidebar select, avatar and link list component improvement

* chore: sidebar improvement and refactor

* style: module sidebar revamp

* style: module sidebar ui improvement

* chore: module sidebar lead and member select improvement

* style: module sidebar progress section empty state added

* chore: module card issue count validation added

* style: module card and list item ui improvement

.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
 
 

.gitignore

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

ENV_SETUP.md

@@ -0,0 +1,134 @@
+# 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" # change if using a custom endpoint
+OPENAI_API_KEY="sk-" # add your openai key here
+GPT_ENGINE="gpt-3.5-turbo" # use "gpt-4" if you have access
+​
+# Settings related to Docker
+DOCKERIZED=1
+# 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
+DJANGO_SETTINGS_MODULE="plane.settings.selfhosted"
+​
+# 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" # change if using a custom endpoint
+OPENAI_API_KEY="sk-" # add your openai key here
+GPT_ENGINE="gpt-3.5-turbo" # use "gpt-4" if you have access
+​
+# Github
+GITHUB_CLIENT_SECRET="" # For fetching release notes
+​
+# Settings related to Docker
+DOCKERIZED=1
+# 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"
+​
+# 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

@@ -39,33 +39,35 @@ 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
-git clone https://github.com/makeplane/plane
-cd plane
-chmod +x setup.sh
-```
+### Steps
 
-- Run setup.sh
+Setting up local environment is extremely easy and straight forward. Follow the below step and you will be ready to contribute
+
+1. Clone the code locally using `git clone https://github.com/makeplane/plane.git`
+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`
 
 ```bash
 ./setup.sh
 ```
 
-> 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
-docker compose up -d
-```
+## 🍙 Self Hosting
 
-<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/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/plane/api/serializers/__init__.py

@@ -1,5 +1,13 @@
 from .base import BaseSerializer
-from .user import UserSerializer, UserLiteSerializer, ChangePasswordSerializer, ResetPasswordSerializer, UserAdminLiteSerializer
+from .user import (
+    UserSerializer,
+    UserLiteSerializer,
+    ChangePasswordSerializer,
+    ResetPasswordSerializer,
+    UserAdminLiteSerializer,
+    UserMeSerializer,
+    UserMeSettingsSerializer,
+)
 from .workspace import (
     WorkSpaceSerializer,
     WorkSpaceMemberSerializer,
@@ -8,9 +16,11 @@ from .workspace import (
     WorkspaceLiteSerializer,
     WorkspaceThemeSerializer,
     WorkspaceMemberAdminSerializer,
+    WorkspaceMemberMeSerializer,
 )
 from .project import (
     ProjectSerializer,
+    ProjectListSerializer,
     ProjectDetailSerializer,
     ProjectMemberSerializer,
     ProjectMemberInviteSerializer,
@@ -20,11 +30,16 @@ from .project import (
     ProjectMemberLiteSerializer,
     ProjectDeployBoardSerializer,
     ProjectMemberAdminSerializer,
-    ProjectPublicMemberSerializer
+    ProjectPublicMemberSerializer,
 )
 from .state import StateSerializer, StateLiteSerializer
 from .view import GlobalViewSerializer, IssueViewSerializer, IssueViewFavoriteSerializer
-from .cycle import CycleSerializer, CycleIssueSerializer, CycleFavoriteSerializer, CycleWriteSerializer
+from .cycle import (
+    CycleSerializer,
+    CycleIssueSerializer,
+    CycleFavoriteSerializer,
+    CycleWriteSerializer,
+)
 from .asset import FileAssetSerializer
 from .issue import (
     IssueCreateSerializer,

apiserver/plane/api/serializers/base.py

@@ -3,3 +3,56 @@ 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/api/serializers/cycle.py

@@ -12,10 +12,14 @@ from .workspace import WorkspaceLiteSerializer
 from .project import ProjectLiteSerializer
 from plane.db.models import Cycle, CycleIssue, CycleFavorite
 
-class CycleWriteSerializer(BaseSerializer):
 
+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):
+        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
 
@@ -41,7 +45,11 @@ class CycleSerializer(BaseSerializer):
     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
 
@@ -52,7 +60,9 @@ class CycleSerializer(BaseSerializer):
                 "display_name": assignee.display_name,
                 "id": assignee.id,
             }
-            for issue_cycle in obj.issue_cycle.prefetch_related("issue__assignees").all()
+            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

apiserver/plane/api/serializers/issue.py

@@ -75,13 +75,13 @@ class IssueCreateSerializer(BaseSerializer):
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
     workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
 
-    assignees_list = serializers.ListField(
+    assignees = 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()),
         write_only=True,
         required=False,
@@ -99,6 +99,12 @@ class IssueCreateSerializer(BaseSerializer):
             "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
@@ -109,8 +115,8 @@ class IssueCreateSerializer(BaseSerializer):
         return data
 
     def create(self, validated_data):
-        assignees = validated_data.pop("assignees_list", None)
-        labels = validated_data.pop("labels_list", None)
+        assignees = validated_data.pop("assignees", None)
+        labels = validated_data.pop("labels", None)
 
         project_id = self.context["project_id"]
         workspace_id = self.context["workspace_id"]
@@ -168,8 +174,8 @@ class IssueCreateSerializer(BaseSerializer):
         return issue
 
     def update(self, instance, validated_data):
-        assignees = validated_data.pop("assignees_list", None)
-        labels = validated_data.pop("labels_list", None)
+        assignees = validated_data.pop("assignees", None)
+        labels = validated_data.pop("labels", None)
 
         # Related models
         project_id = instance.project_id

apiserver/plane/api/serializers/project.py

@@ -1,11 +1,8 @@
-# Django imports
-from django.db import IntegrityError
-
 # Third party imports
 from rest_framework import serializers
 
 # Module imports
-from .base import BaseSerializer
+from .base import BaseSerializer, DynamicBaseSerializer
 from plane.api.serializers.workspace import WorkSpaceSerializer, WorkspaceLiteSerializer
 from plane.api.serializers.user import UserLiteSerializer, UserAdminLiteSerializer
 from plane.db.models import (
@@ -94,8 +91,33 @@ class ProjectLiteSerializer(BaseSerializer):
         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).values(
+            "id",
+            "member_id",
+            "member__display_name",
+            "member__avatar",
+        )
+        return project_members
+
+    class Meta:
+        model = Project
+        fields = "__all__"
+
+
 class ProjectDetailSerializer(BaseSerializer):
-    workspace = WorkSpaceSerializer(read_only=True)
+    # workspace = WorkSpaceSerializer(read_only=True)
     default_assignee = UserLiteSerializer(read_only=True)
     project_lead = UserLiteSerializer(read_only=True)
     is_favorite = serializers.BooleanField(read_only=True)
@@ -148,8 +170,6 @@ class ProjectIdentifierSerializer(BaseSerializer):
 
 
 class ProjectFavoriteSerializer(BaseSerializer):
-    project_detail = ProjectLiteSerializer(source="project", read_only=True)
-
     class Meta:
         model = ProjectFavorite
         fields = "__all__"
@@ -178,12 +198,12 @@ class ProjectDeployBoardSerializer(BaseSerializer):
         fields = "__all__"
         read_only_fields = [
             "workspace",
-            "project", "anchor",
+            "project",
+            "anchor",
         ]
 
 
 class ProjectPublicMemberSerializer(BaseSerializer):
-
     class Meta:
         model = ProjectPublicMember
         fields = "__all__"

apiserver/plane/api/serializers/user.py

@@ -3,7 +3,7 @@ from rest_framework import serializers
 
 # Module import
 from .base import BaseSerializer
-from plane.db.models import User
+from plane.db.models import User, Workspace, WorkspaceMemberInvite
 
 
 class UserSerializer(BaseSerializer):
@@ -33,6 +33,81 @@ class UserSerializer(BaseSerializer):
             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",
+        ]
+        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:
+            workspace = Workspace.objects.get(
+                pk=obj.last_workspace_id, workspace_member__member=obj.id
+            )
+            return {
+                "last_workspace_id": obj.last_workspace_id,
+                "last_workspace_slug": workspace.slug,
+                "fallback_workspace_id": obj.last_workspace_id,
+                "fallback_workspace_slug": workspace.slug,
+                "invites": workspace_invites,
+            }
+        else:
+            fallback_workspace = (
+                Workspace.objects.filter(workspace_member__member_id=obj.id)
+                .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
@@ -51,7 +126,6 @@ class UserLiteSerializer(BaseSerializer):
 
 
 class UserAdminLiteSerializer(BaseSerializer):
-
     class Meta:
         model = User
         fields = [

apiserver/plane/api/serializers/workspace.py

@@ -54,6 +54,13 @@ class WorkSpaceMemberSerializer(BaseSerializer):
         fields = "__all__"
 
 
+class WorkspaceMemberMeSerializer(BaseSerializer):
+
+    class Meta:
+        model = WorkspaceMember
+        fields = "__all__"
+
+
 class WorkspaceMemberAdminSerializer(BaseSerializer):
     member = UserAdminLiteSerializer(read_only=True)
     workspace = WorkspaceLiteSerializer(read_only=True)

apiserver/plane/api/urls/__init__.py

@@ -0,0 +1,50 @@
+from .analytic import urlpatterns as analytic_urls
+from .asset import urlpatterns as asset_urls
+from .authentication import urlpatterns as authentication_urls
+from .configuration import urlpatterns as configuration_urls
+from .cycle import urlpatterns as cycle_urls
+from .estimate import urlpatterns as estimate_urls
+from .gpt import urlpatterns as gpt_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 .public_board import urlpatterns as public_board_urls
+from .release_note import urlpatterns as release_note_urls
+from .search import urlpatterns as search_urls
+from .state import urlpatterns as state_urls
+from .unsplash import urlpatterns as unsplash_urls
+from .user import urlpatterns as user_urls
+from .views import urlpatterns as view_urls
+from .workspace import urlpatterns as workspace_urls
+
+
+urlpatterns = [
+    *analytic_urls,
+    *asset_urls,
+    *authentication_urls,
+    *configuration_urls,
+    *cycle_urls,
+    *estimate_urls,
+    *gpt_urls,
+    *importer_urls,
+    *inbox_urls,
+    *integration_urls,
+    *issue_urls,
+    *module_urls,
+    *notification_urls,
+    *page_urls,
+    *project_urls,
+    *public_board_urls,
+    *release_note_urls,
+    *search_urls,
+    *state_urls,
+    *unsplash_urls,
+    *user_urls,
+    *view_urls,
+    *workspace_urls,
+]

apiserver/plane/api/urls/analytic.py

@@ -0,0 +1,46 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    AnalyticsEndpoint,
+    AnalyticViewViewset,
+    SavedAnalyticEndpoint,
+    ExportAnalyticsEndpoint,
+    DefaultAnalyticsEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/analytics/",
+        AnalyticsEndpoint.as_view(),
+        name="plane-analytics",
+    ),
+    path(
+        "workspaces/<str:slug>/analytic-view/",
+        AnalyticViewViewset.as_view({"get": "list", "post": "create"}),
+        name="analytic-view",
+    ),
+    path(
+        "workspaces/<str:slug>/analytic-view/<uuid:pk>/",
+        AnalyticViewViewset.as_view(
+            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
+        ),
+        name="analytic-view",
+    ),
+    path(
+        "workspaces/<str:slug>/saved-analytic-view/<uuid:analytic_id>/",
+        SavedAnalyticEndpoint.as_view(),
+        name="saved-analytic-view",
+    ),
+    path(
+        "workspaces/<str:slug>/export-analytics/",
+        ExportAnalyticsEndpoint.as_view(),
+        name="export-analytics",
+    ),
+    path(
+        "workspaces/<str:slug>/default-analytics/",
+        DefaultAnalyticsEndpoint.as_view(),
+        name="default-analytics",
+    ),
+]

apiserver/plane/api/urls/asset.py

@@ -0,0 +1,31 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    FileAssetEndpoint,
+    UserAssetsEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/file-assets/",
+        FileAssetEndpoint.as_view(),
+        name="file-assets",
+    ),
+    path(
+        "workspaces/file-assets/<uuid:workspace_id>/<str:asset_key>/",
+        FileAssetEndpoint.as_view(),
+        name="file-assets",
+    ),
+    path(
+        "users/file-assets/",
+        UserAssetsEndpoint.as_view(),
+        name="user-file-assets",
+    ),
+    path(
+        "users/file-assets/<str:asset_key>/",
+        UserAssetsEndpoint.as_view(),
+        name="user-file-assets",
+    ),
+]

apiserver/plane/api/urls/authentication.py

@@ -0,0 +1,68 @@
+from django.urls import path
+
+from rest_framework_simplejwt.views import TokenRefreshView
+
+
+from plane.api.views import (
+    # Authentication
+    SignUpEndpoint,
+    SignInEndpoint,
+    SignOutEndpoint,
+    MagicSignInEndpoint,
+    MagicSignInGenerateEndpoint,
+    OauthEndpoint,
+    ## End Authentication
+    # Auth Extended
+    ForgotPasswordEndpoint,
+    VerifyEmailEndpoint,
+    ResetPasswordEndpoint,
+    RequestEmailVerificationEndpoint,
+    ChangePasswordEndpoint,
+    ## End Auth Extender
+    # API Tokens
+    ApiTokenEndpoint,
+    ## End API Tokens
+)
+
+
+urlpatterns = [
+    #  Social Auth
+    path("social-auth/", OauthEndpoint.as_view(), name="oauth"),
+    # Auth
+    path("sign-up/", SignUpEndpoint.as_view(), name="sign-up"),
+    path("sign-in/", SignInEndpoint.as_view(), name="sign-in"),
+    path("sign-out/", SignOutEndpoint.as_view(), name="sign-out"),
+    # Magic Sign In/Up
+    path(
+        "magic-generate/", MagicSignInGenerateEndpoint.as_view(), name="magic-generate"
+    ),
+    path("magic-sign-in/", MagicSignInEndpoint.as_view(), name="magic-sign-in"),
+    path("token/refresh/", TokenRefreshView.as_view(), name="token_refresh"),
+    # Email verification
+    path("email-verify/", VerifyEmailEndpoint.as_view(), name="email-verify"),
+    path(
+        "request-email-verify/",
+        RequestEmailVerificationEndpoint.as_view(),
+        name="request-reset-email",
+    ),
+    # Password Manipulation
+    path(
+        "users/me/change-password/",
+        ChangePasswordEndpoint.as_view(),
+        name="change-password",
+    ),
+    path(
+        "reset-password/<uidb64>/<token>/",
+        ResetPasswordEndpoint.as_view(),
+        name="password-reset",
+    ),
+    path(
+        "forgot-password/",
+        ForgotPasswordEndpoint.as_view(),
+        name="forgot-password",
+    ),
+    # API Tokens
+    path("api-tokens/", ApiTokenEndpoint.as_view(), name="api-tokens"),
+    path("api-tokens/<uuid:pk>/", ApiTokenEndpoint.as_view(), name="api-tokens"),
+    ## End API Tokens
+]

apiserver/plane/api/urls/configuration.py

@@ -0,0 +1,12 @@
+from django.urls import path
+
+
+from plane.api.views import ConfigurationEndpoint
+
+urlpatterns = [
+    path(
+        "configs/",
+        ConfigurationEndpoint.as_view(),
+        name="configuration",
+    ),
+]

apiserver/plane/api/urls/cycle.py

@@ -0,0 +1,87 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    CycleViewSet,
+    CycleIssueViewSet,
+    CycleDateCheckEndpoint,
+    CycleFavoriteViewSet,
+    TransferCycleIssueEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/",
+        CycleViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:pk>/",
+        CycleViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/",
+        CycleIssueViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:pk>/",
+        CycleIssueViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/date-check/",
+        CycleDateCheckEndpoint.as_view(),
+        name="project-cycle-date",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-cycles/",
+        CycleFavoriteViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="user-favorite-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-cycles/<uuid:cycle_id>/",
+        CycleFavoriteViewSet.as_view(
+            {
+                "delete": "destroy",
+            }
+        ),
+        name="user-favorite-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/transfer-issues/",
+        TransferCycleIssueEndpoint.as_view(),
+        name="transfer-issues",
+    ),
+]

apiserver/plane/api/urls/estimate.py

@@ -0,0 +1,37 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    ProjectEstimatePointEndpoint,
+    BulkEstimatePointEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/project-estimates/",
+        ProjectEstimatePointEndpoint.as_view(),
+        name="project-estimate-points",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/estimates/",
+        BulkEstimatePointEndpoint.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="bulk-create-estimate-points",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/estimates/<uuid:estimate_id>/",
+        BulkEstimatePointEndpoint.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="bulk-create-estimate-points",
+    ),
+]

apiserver/plane/api/urls/gpt.py

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

apiserver/plane/api/urls/importer.py

@@ -0,0 +1,37 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    ServiceIssueImportSummaryEndpoint,
+    ImportServiceEndpoint,
+    UpdateServiceImportStatusEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/importers/<str:service>/",
+        ServiceIssueImportSummaryEndpoint.as_view(),
+        name="importer-summary",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/importers/<str:service>/",
+        ImportServiceEndpoint.as_view(),
+        name="importer",
+    ),
+    path(
+        "workspaces/<str:slug>/importers/",
+        ImportServiceEndpoint.as_view(),
+        name="importer",
+    ),
+    path(
+        "workspaces/<str:slug>/importers/<str:service>/<uuid:pk>/",
+        ImportServiceEndpoint.as_view(),
+        name="importer",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/service/<str:service>/importers/<uuid:importer_id>/",
+        UpdateServiceImportStatusEndpoint.as_view(),
+        name="importer-status",
+    ),
+]

apiserver/plane/api/urls/inbox.py

@@ -0,0 +1,53 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    InboxViewSet,
+    InboxIssueViewSet,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/",
+        InboxViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="inbox",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:pk>/",
+        InboxViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="inbox",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/",
+        InboxIssueViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="inbox-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/<uuid:pk>/",
+        InboxIssueViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="inbox-issue",
+    ),
+]

apiserver/plane/api/urls/integration.py

@@ -0,0 +1,150 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    IntegrationViewSet,
+    WorkspaceIntegrationViewSet,
+    GithubRepositoriesEndpoint,
+    GithubRepositorySyncViewSet,
+    GithubIssueSyncViewSet,
+    GithubCommentSyncViewSet,
+    BulkCreateGithubIssueSyncEndpoint,
+    SlackProjectSyncViewSet,
+)
+
+
+urlpatterns = [
+    path(
+        "integrations/",
+        IntegrationViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="integrations",
+    ),
+    path(
+        "integrations/<uuid:pk>/",
+        IntegrationViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="integrations",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-integrations/",
+        WorkspaceIntegrationViewSet.as_view(
+            {
+                "get": "list",
+            }
+        ),
+        name="workspace-integrations",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-integrations/<str:provider>/",
+        WorkspaceIntegrationViewSet.as_view(
+            {
+                "post": "create",
+            }
+        ),
+        name="workspace-integrations",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-integrations/<uuid:pk>/provider/",
+        WorkspaceIntegrationViewSet.as_view(
+            {
+                "get": "retrieve",
+                "delete": "destroy",
+            }
+        ),
+        name="workspace-integrations",
+    ),
+    # Github Integrations
+    path(
+        "workspaces/<str:slug>/workspace-integrations/<uuid:workspace_integration_id>/github-repositories/",
+        GithubRepositoriesEndpoint.as_view(),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/github-repository-sync/",
+        GithubRepositorySyncViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/github-repository-sync/<uuid:pk>/",
+        GithubRepositorySyncViewSet.as_view(
+            {
+                "get": "retrieve",
+                "delete": "destroy",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/",
+        GithubIssueSyncViewSet.as_view(
+            {
+                "post": "create",
+                "get": "list",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/bulk-create-github-issue-sync/",
+        BulkCreateGithubIssueSyncEndpoint.as_view(),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:pk>/",
+        GithubIssueSyncViewSet.as_view(
+            {
+                "get": "retrieve",
+                "delete": "destroy",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:issue_sync_id>/github-comment-sync/",
+        GithubCommentSyncViewSet.as_view(
+            {
+                "post": "create",
+                "get": "list",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:issue_sync_id>/github-comment-sync/<uuid:pk>/",
+        GithubCommentSyncViewSet.as_view(
+            {
+                "get": "retrieve",
+                "delete": "destroy",
+            }
+        ),
+    ),
+    ## End Github Integrations
+    # Slack Integration
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/project-slack-sync/",
+        SlackProjectSyncViewSet.as_view(
+            {
+                "post": "create",
+                "get": "list",
+            }
+        ),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/project-slack-sync/<uuid:pk>/",
+        SlackProjectSyncViewSet.as_view(
+            {
+                "delete": "destroy",
+                "get": "retrieve",
+            }
+        ),
+    ),
+    ## End Slack Integration
+]

apiserver/plane/api/urls/issue.py

@@ -0,0 +1,315 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    IssueViewSet,
+    LabelViewSet,
+    BulkCreateIssueLabelsEndpoint,
+    BulkDeleteIssuesEndpoint,
+    BulkImportIssuesEndpoint,
+    UserWorkSpaceIssues,
+    SubIssuesEndpoint,
+    IssueLinkViewSet,
+    IssueAttachmentEndpoint,
+    ExportIssuesEndpoint,
+    IssueActivityEndpoint,
+    IssueCommentViewSet,
+    IssueSubscriberViewSet,
+    IssueReactionViewSet,
+    CommentReactionViewSet,
+    IssueUserDisplayPropertyEndpoint,
+    IssueArchiveViewSet,
+    IssueRelationViewSet,
+    IssueDraftViewSet,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/",
+        IssueViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/",
+        IssueViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/",
+        LabelViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-labels",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/<uuid:pk>/",
+        LabelViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-labels",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-create-labels/",
+        BulkCreateIssueLabelsEndpoint.as_view(),
+        name="project-bulk-labels",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-delete-issues/",
+        BulkDeleteIssuesEndpoint.as_view(),
+        name="project-issues-bulk",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-import-issues/<str:service>/",
+        BulkImportIssuesEndpoint.as_view(),
+        name="project-issues-bulk",
+    ),
+    path(
+        "workspaces/<str:slug>/my-issues/",
+        UserWorkSpaceIssues.as_view(),
+        name="workspace-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/sub-issues/",
+        SubIssuesEndpoint.as_view(),
+        name="sub-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-links/",
+        IssueLinkViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-links",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-links/<uuid:pk>/",
+        IssueLinkViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-links",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-attachments/",
+        IssueAttachmentEndpoint.as_view(),
+        name="project-issue-attachments",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-attachments/<uuid:pk>/",
+        IssueAttachmentEndpoint.as_view(),
+        name="project-issue-attachments",
+    ),
+    path(
+        "workspaces/<str:slug>/export-issues/",
+        ExportIssuesEndpoint.as_view(),
+        name="export-issues",
+    ),
+    ## End Issues
+    ## Issue Activity
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/history/",
+        IssueActivityEndpoint.as_view(),
+        name="project-issue-history",
+    ),
+    ## Issue Activity
+    ## IssueComments
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/",
+        IssueCommentViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-comment",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/<uuid:pk>/",
+        IssueCommentViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-comment",
+    ),
+    ## End IssueComments
+    # Issue Subscribers
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-subscribers/",
+        IssueSubscriberViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-subscribers",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-subscribers/<uuid:subscriber_id>/",
+        IssueSubscriberViewSet.as_view({"delete": "destroy"}),
+        name="project-issue-subscribers",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/subscribe/",
+        IssueSubscriberViewSet.as_view(
+            {
+                "get": "subscription_status",
+                "post": "subscribe",
+                "delete": "unsubscribe",
+            }
+        ),
+        name="project-issue-subscribers",
+    ),
+    ## End Issue Subscribers
+    # Issue Reactions
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/reactions/",
+        IssueReactionViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-reactions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/reactions/<str:reaction_code>/",
+        IssueReactionViewSet.as_view(
+            {
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-reactions",
+    ),
+    ## End Issue Reactions
+    # Comment Reactions
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/comments/<uuid:comment_id>/reactions/",
+        CommentReactionViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-comment-reactions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/comments/<uuid:comment_id>/reactions/<str:reaction_code>/",
+        CommentReactionViewSet.as_view(
+            {
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-comment-reactions",
+    ),
+    ## End Comment Reactions
+    ## IssueProperty
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-display-properties/",
+        IssueUserDisplayPropertyEndpoint.as_view(),
+        name="project-issue-display-properties",
+    ),
+    ## IssueProperty End
+    ## Issue Archives
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-issues/",
+        IssueArchiveViewSet.as_view(
+            {
+                "get": "list",
+            }
+        ),
+        name="project-issue-archive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-issues/<uuid:pk>/",
+        IssueArchiveViewSet.as_view(
+            {
+                "get": "retrieve",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-archive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/unarchive/<uuid:pk>/",
+        IssueArchiveViewSet.as_view(
+            {
+                "post": "unarchive",
+            }
+        ),
+        name="project-issue-archive",
+    ),
+    ## End Issue Archives
+    ## Issue Relation
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-relation/",
+        IssueRelationViewSet.as_view(
+            {
+                "post": "create",
+            }
+        ),
+        name="issue-relation",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-relation/<uuid:pk>/",
+        IssueRelationViewSet.as_view(
+            {
+                "delete": "destroy",
+            }
+        ),
+        name="issue-relation",
+    ),
+    ## End Issue Relation
+    ## Issue Drafts
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-drafts/",
+        IssueDraftViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-draft",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-drafts/<uuid:pk>/",
+        IssueDraftViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-draft",
+    ),
+]

apiserver/plane/api/urls/module.py

@@ -0,0 +1,104 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    ModuleViewSet,
+    ModuleIssueViewSet,
+    ModuleLinkViewSet,
+    ModuleFavoriteViewSet,
+    BulkImportModulesEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/",
+        ModuleViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-modules",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:pk>/",
+        ModuleViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-modules",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/",
+        ModuleIssueViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-module-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/<uuid:pk>/",
+        ModuleIssueViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-module-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-links/",
+        ModuleLinkViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-module-links",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-links/<uuid:pk>/",
+        ModuleLinkViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-module-links",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-modules/",
+        ModuleFavoriteViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="user-favorite-module",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-modules/<uuid:module_id>/",
+        ModuleFavoriteViewSet.as_view(
+            {
+                "delete": "destroy",
+            }
+        ),
+        name="user-favorite-module",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-import-modules/<str:service>/",
+        BulkImportModulesEndpoint.as_view(),
+        name="bulk-modules-create",
+    ),
+]

apiserver/plane/api/urls/notification.py

@@ -0,0 +1,66 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    NotificationViewSet,
+    UnreadNotificationEndpoint,
+    MarkAllReadNotificationViewSet,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/users/notifications/",
+        NotificationViewSet.as_view(
+            {
+                "get": "list",
+            }
+        ),
+        name="notifications",
+    ),
+    path(
+        "workspaces/<str:slug>/users/notifications/<uuid:pk>/",
+        NotificationViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="notifications",
+    ),
+    path(
+        "workspaces/<str:slug>/users/notifications/<uuid:pk>/read/",
+        NotificationViewSet.as_view(
+            {
+                "post": "mark_read",
+                "delete": "mark_unread",
+            }
+        ),
+        name="notifications",
+    ),
+    path(
+        "workspaces/<str:slug>/users/notifications/<uuid:pk>/archive/",
+        NotificationViewSet.as_view(
+            {
+                "post": "archive",
+                "delete": "unarchive",
+            }
+        ),
+        name="notifications",
+    ),
+    path(
+        "workspaces/<str:slug>/users/notifications/unread/",
+        UnreadNotificationEndpoint.as_view(),
+        name="unread-notifications",
+    ),
+    path(
+        "workspaces/<str:slug>/users/notifications/mark-all-read/",
+        MarkAllReadNotificationViewSet.as_view(
+            {
+                "post": "create",
+            }
+        ),
+        name="mark-all-read-notifications",
+    ),
+]

apiserver/plane/api/urls/page.py

@@ -0,0 +1,79 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    PageViewSet,
+    PageBlockViewSet,
+    PageFavoriteViewSet,
+    CreateIssueFromPageBlockEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/",
+        PageViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-pages",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/",
+        PageViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-pages",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/page-blocks/",
+        PageBlockViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-page-blocks",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/page-blocks/<uuid:pk>/",
+        PageBlockViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-page-blocks",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-pages/",
+        PageFavoriteViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="user-favorite-pages",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-pages/<uuid:page_id>/",
+        PageFavoriteViewSet.as_view(
+            {
+                "delete": "destroy",
+            }
+        ),
+        name="user-favorite-pages",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/page-blocks/<uuid:page_block_id>/issues/",
+        CreateIssueFromPageBlockEndpoint.as_view(),
+        name="page-block-issues",
+    ),
+]

apiserver/plane/api/urls/project.py

@@ -0,0 +1,144 @@
+from django.urls import path
+
+from plane.api.views import (
+    ProjectViewSet,
+    InviteProjectEndpoint,
+    ProjectMemberViewSet,
+    ProjectMemberEndpoint,
+    ProjectMemberInvitationsViewset,
+    ProjectMemberUserEndpoint,
+    AddMemberToProjectEndpoint,
+    ProjectJoinEndpoint,
+    AddTeamToProjectEndpoint,
+    ProjectUserViewsEndpoint,
+    ProjectIdentifierEndpoint,
+    ProjectFavoritesViewSet,
+    LeaveProjectEndpoint,
+    ProjectPublicCoverImagesEndpoint
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/",
+        ProjectViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:pk>/",
+        ProjectViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/project-identifiers/",
+        ProjectIdentifierEndpoint.as_view(),
+        name="project-identifiers",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/invite/",
+        InviteProjectEndpoint.as_view(),
+        name="invite-project",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/members/",
+        ProjectMemberViewSet.as_view({"get": "list"}),
+        name="project-member",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/members/<uuid:pk>/",
+        ProjectMemberViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-member",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/project-members/",
+        ProjectMemberEndpoint.as_view(),
+        name="project-member",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/members/add/",
+        AddMemberToProjectEndpoint.as_view(),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/join/",
+        ProjectJoinEndpoint.as_view(),
+        name="project-join",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/team-invite/",
+        AddTeamToProjectEndpoint.as_view(),
+        name="projects",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/invitations/",
+        ProjectMemberInvitationsViewset.as_view({"get": "list"}),
+        name="project-member-invite",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/invitations/<uuid:pk>/",
+        ProjectMemberInvitationsViewset.as_view(
+            {
+                "get": "retrieve",
+                "delete": "destroy",
+            }
+        ),
+        name="project-member-invite",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/project-views/",
+        ProjectUserViewsEndpoint.as_view(),
+        name="project-view",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/project-members/me/",
+        ProjectMemberUserEndpoint.as_view(),
+        name="project-member-view",
+    ),
+    path(
+        "workspaces/<str:slug>/user-favorite-projects/",
+        ProjectFavoritesViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-favorite",
+    ),
+    path(
+        "workspaces/<str:slug>/user-favorite-projects/<uuid:project_id>/",
+        ProjectFavoritesViewSet.as_view(
+            {
+                "delete": "destroy",
+            }
+        ),
+        name="project-favorite",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/members/leave/",
+        LeaveProjectEndpoint.as_view(),
+        name="leave-project",
+    ),
+    path(
+        "project-covers/",
+        ProjectPublicCoverImagesEndpoint.as_view(),
+        name="project-covers",
+    ),
+]

apiserver/plane/api/urls/public_board.py

@@ -0,0 +1,151 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    ProjectDeployBoardViewSet,
+    ProjectDeployBoardPublicSettingsEndpoint,
+    ProjectIssuesPublicEndpoint,
+    IssueRetrievePublicEndpoint,
+    IssueCommentPublicViewSet,
+    IssueReactionPublicViewSet,
+    CommentReactionPublicViewSet,
+    InboxIssuePublicViewSet,
+    IssueVotePublicViewSet,
+    WorkspaceProjectDeployBoardEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/project-deploy-boards/",
+        ProjectDeployBoardViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-deploy-board",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/project-deploy-boards/<uuid:pk>/",
+        ProjectDeployBoardViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-deploy-board",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/settings/",
+        ProjectDeployBoardPublicSettingsEndpoint.as_view(),
+        name="project-deploy-board-settings",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/issues/",
+        ProjectIssuesPublicEndpoint.as_view(),
+        name="project-deploy-board",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/issues/<uuid:issue_id>/",
+        IssueRetrievePublicEndpoint.as_view(),
+        name="workspace-project-boards",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/issues/<uuid:issue_id>/comments/",
+        IssueCommentPublicViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="issue-comments-project-board",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/issues/<uuid:issue_id>/comments/<uuid:pk>/",
+        IssueCommentPublicViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="issue-comments-project-board",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/issues/<uuid:issue_id>/reactions/",
+        IssueReactionPublicViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="issue-reactions-project-board",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/issues/<uuid:issue_id>/reactions/<str:reaction_code>/",
+        IssueReactionPublicViewSet.as_view(
+            {
+                "delete": "destroy",
+            }
+        ),
+        name="issue-reactions-project-board",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/comments/<uuid:comment_id>/reactions/",
+        CommentReactionPublicViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="comment-reactions-project-board",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/comments/<uuid:comment_id>/reactions/<str:reaction_code>/",
+        CommentReactionPublicViewSet.as_view(
+            {
+                "delete": "destroy",
+            }
+        ),
+        name="comment-reactions-project-board",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/",
+        InboxIssuePublicViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="inbox-issue",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/<uuid:pk>/",
+        InboxIssuePublicViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="inbox-issue",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/<uuid:project_id>/issues/<uuid:issue_id>/votes/",
+        IssueVotePublicViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+                "delete": "destroy",
+            }
+        ),
+        name="issue-vote-project-board",
+    ),
+    path(
+        "public/workspaces/<str:slug>/project-boards/",
+        WorkspaceProjectDeployBoardEndpoint.as_view(),
+        name="workspace-project-boards",
+    ),
+]

apiserver/plane/api/urls/release_note.py

@@ -0,0 +1,13 @@
+from django.urls import path
+
+
+from plane.api.views import ReleaseNotesEndpoint
+
+
+urlpatterns = [
+    path(
+        "release-notes/",
+        ReleaseNotesEndpoint.as_view(),
+        name="release-notes",
+    ),
+]

apiserver/plane/api/urls/search.py

@@ -0,0 +1,21 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    GlobalSearchEndpoint,
+    IssueSearchEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/search/",
+        GlobalSearchEndpoint.as_view(),
+        name="global-search",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/search-issues/",
+        IssueSearchEndpoint.as_view(),
+        name="project-issue-search",
+    ),
+]

apiserver/plane/api/urls/state.py

@@ -0,0 +1,30 @@
+from django.urls import path
+
+
+from plane.api.views import StateViewSet
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/states/",
+        StateViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-states",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/states/<uuid:pk>/",
+        StateViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-state",
+    ),
+]

apiserver/plane/api/urls/unsplash.py

@@ -0,0 +1,13 @@
+from django.urls import path
+
+
+from plane.api.views import UnsplashEndpoint
+
+
+urlpatterns = [
+    path(
+        "unsplash/",
+        UnsplashEndpoint.as_view(),
+        name="unsplash",
+    ),
+]

apiserver/plane/api/urls/user.py

@@ -0,0 +1,113 @@
+from django.urls import path
+
+from plane.api.views import (
+    ## User
+    UserEndpoint,
+    UpdateUserOnBoardedEndpoint,
+    UpdateUserTourCompletedEndpoint,
+    UserActivityEndpoint,
+    ChangePasswordEndpoint,
+    ## End User
+    ## Workspaces
+    UserWorkspaceInvitationsEndpoint,
+    UserWorkSpacesEndpoint,
+    JoinWorkspaceEndpoint,
+    UserWorkspaceInvitationsEndpoint,
+    UserWorkspaceInvitationEndpoint,
+    UserActivityGraphEndpoint,
+    UserIssueCompletedGraphEndpoint,
+    UserWorkspaceDashboardEndpoint,
+    UserProjectInvitationsViewset,
+    ## End Workspaces
+)
+
+urlpatterns = [
+    # User Profile
+    path(
+        "users/me/",
+        UserEndpoint.as_view(
+            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
+        ),
+        name="users",
+    ),
+    path(
+        "users/me/settings/",
+        UserEndpoint.as_view(
+            {
+                "get": "retrieve_user_settings",
+            }
+        ),
+        name="users",
+    ),
+    path(
+        "users/me/change-password/",
+        ChangePasswordEndpoint.as_view(),
+        name="change-password",
+    ),
+    path(
+        "users/me/onboard/",
+        UpdateUserOnBoardedEndpoint.as_view(),
+        name="user-onboard",
+    ),
+    path(
+        "users/me/tour-completed/",
+        UpdateUserTourCompletedEndpoint.as_view(),
+        name="user-tour",
+    ),
+    path(
+        "users/workspaces/<str:slug>/activities/",
+        UserActivityEndpoint.as_view(),
+        name="user-activities",
+    ),
+    # user workspaces
+    path(
+        "users/me/workspaces/",
+        UserWorkSpacesEndpoint.as_view(),
+        name="user-workspace",
+    ),
+    # user workspace invitations
+    path(
+        "users/me/invitations/workspaces/",
+        UserWorkspaceInvitationsEndpoint.as_view({"get": "list", "post": "create"}),
+        name="user-workspace-invitations",
+    ),
+    # user workspace invitation
+    path(
+        "users/me/invitations/<uuid:pk>/",
+        UserWorkspaceInvitationEndpoint.as_view(
+            {
+                "get": "retrieve",
+            }
+        ),
+        name="user-workspace-invitation",
+    ),
+    # user join workspace
+    # User Graphs
+    path(
+        "users/me/workspaces/<str:slug>/activity-graph/",
+        UserActivityGraphEndpoint.as_view(),
+        name="user-activity-graph",
+    ),
+    path(
+        "users/me/workspaces/<str:slug>/issues-completed-graph/",
+        UserIssueCompletedGraphEndpoint.as_view(),
+        name="completed-graph",
+    ),
+    path(
+        "users/me/workspaces/<str:slug>/dashboard/",
+        UserWorkspaceDashboardEndpoint.as_view(),
+        name="user-workspace-dashboard",
+    ),
+    ## End User Graph
+    path(
+        "users/me/invitations/workspaces/<str:slug>/<uuid:pk>/join/",
+        JoinWorkspaceEndpoint.as_view(),
+        name="user-join-workspace",
+    ),
+    # user project invitations
+    path(
+        "users/me/invitations/projects/",
+        UserProjectInvitationsViewset.as_view({"get": "list", "post": "create"}),
+        name="user-project-invitations",
+    ),
+]

apiserver/plane/api/urls/views.py

@@ -0,0 +1,85 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    IssueViewViewSet,
+    GlobalViewViewSet,
+    GlobalViewIssuesViewSet,
+    IssueViewFavoriteViewSet,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/views/",
+        IssueViewViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-view",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/views/<uuid:pk>/",
+        IssueViewViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-view",
+    ),
+    path(
+        "workspaces/<str:slug>/views/",
+        GlobalViewViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="global-view",
+    ),
+    path(
+        "workspaces/<str:slug>/views/<uuid:pk>/",
+        GlobalViewViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="global-view",
+    ),
+    path(
+        "workspaces/<str:slug>/issues/",
+        GlobalViewIssuesViewSet.as_view(
+            {
+                "get": "list",
+            }
+        ),
+        name="global-view-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-views/",
+        IssueViewFavoriteViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="user-favorite-view",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-views/<uuid:view_id>/",
+        IssueViewFavoriteViewSet.as_view(
+            {
+                "delete": "destroy",
+            }
+        ),
+        name="user-favorite-view",
+    ),
+]

apiserver/plane/api/urls/workspace.py

@@ -0,0 +1,182 @@
+from django.urls import path
+
+
+from plane.api.views import (
+    WorkSpaceViewSet,
+    InviteWorkspaceEndpoint,
+    WorkSpaceMemberViewSet,
+    WorkspaceMembersEndpoint,
+    WorkspaceInvitationsViewset,
+    WorkspaceMemberUserEndpoint,
+    WorkspaceMemberUserViewsEndpoint,
+    WorkSpaceAvailabilityCheckEndpoint,
+    TeamMemberViewSet,
+    UserLastProjectWithWorkspaceEndpoint,
+    WorkspaceThemeViewSet,
+    WorkspaceUserProfileStatsEndpoint,
+    WorkspaceUserActivityEndpoint,
+    WorkspaceUserProfileEndpoint,
+    WorkspaceUserProfileIssuesEndpoint,
+    WorkspaceLabelsEndpoint,
+    LeaveWorkspaceEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspace-slug-check/",
+        WorkSpaceAvailabilityCheckEndpoint.as_view(),
+        name="workspace-availability",
+    ),
+    path(
+        "workspaces/",
+        WorkSpaceViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/",
+        WorkSpaceViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/invite/",
+        InviteWorkspaceEndpoint.as_view(),
+        name="invite-workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/invitations/",
+        WorkspaceInvitationsViewset.as_view({"get": "list"}),
+        name="workspace-invitations",
+    ),
+    path(
+        "workspaces/<str:slug>/invitations/<uuid:pk>/",
+        WorkspaceInvitationsViewset.as_view(
+            {
+                "delete": "destroy",
+                "get": "retrieve",
+            }
+        ),
+        name="workspace-invitations",
+    ),
+    path(
+        "workspaces/<str:slug>/members/",
+        WorkSpaceMemberViewSet.as_view({"get": "list"}),
+        name="workspace-member",
+    ),
+    path(
+        "workspaces/<str:slug>/members/<uuid:pk>/",
+        WorkSpaceMemberViewSet.as_view(
+            {
+                "patch": "partial_update",
+                "delete": "destroy",
+                "get": "retrieve",
+            }
+        ),
+        name="workspace-member",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-members/",
+        WorkspaceMembersEndpoint.as_view(),
+        name="workspace-members",
+    ),
+    path(
+        "workspaces/<str:slug>/teams/",
+        TeamMemberViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="workspace-team-members",
+    ),
+    path(
+        "workspaces/<str:slug>/teams/<uuid:pk>/",
+        TeamMemberViewSet.as_view(
+            {
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+                "get": "retrieve",
+            }
+        ),
+        name="workspace-team-members",
+    ),
+    path(
+        "users/last-visited-workspace/",
+        UserLastProjectWithWorkspaceEndpoint.as_view(),
+        name="workspace-project-details",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-members/me/",
+        WorkspaceMemberUserEndpoint.as_view(),
+        name="workspace-member-details",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-views/",
+        WorkspaceMemberUserViewsEndpoint.as_view(),
+        name="workspace-member-views-details",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-themes/",
+        WorkspaceThemeViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="workspace-themes",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-themes/<uuid:pk>/",
+        WorkspaceThemeViewSet.as_view(
+            {
+                "get": "retrieve",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="workspace-themes",
+    ),
+    path(
+        "workspaces/<str:slug>/user-stats/<uuid:user_id>/",
+        WorkspaceUserProfileStatsEndpoint.as_view(),
+        name="workspace-user-stats",
+    ),
+    path(
+        "workspaces/<str:slug>/user-activity/<uuid:user_id>/",
+        WorkspaceUserActivityEndpoint.as_view(),
+        name="workspace-user-activity",
+    ),
+    path(
+        "workspaces/<str:slug>/user-profile/<uuid:user_id>/",
+        WorkspaceUserProfileEndpoint.as_view(),
+        name="workspace-user-profile-page",
+    ),
+    path(
+        "workspaces/<str:slug>/user-issues/<uuid:user_id>/",
+        WorkspaceUserProfileIssuesEndpoint.as_view(),
+        name="workspace-user-profile-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/labels/",
+        WorkspaceLabelsEndpoint.as_view(),
+        name="workspace-labels",
+    ),
+    path(
+        "workspaces/<str:slug>/members/leave/",
+        LeaveWorkspaceEndpoint.as_view(),
+        name="leave-workspace-members",
+    ),
+]

apiserver/plane/api/urls_deprecated.py

@@ -1,5 +1,6 @@
 from django.urls import path
 
+from rest_framework_simplejwt.views import TokenRefreshView
 
 # Create your urls here.
 
@@ -81,7 +82,7 @@ from plane.api.views import (
     BulkDeleteIssuesEndpoint,
     BulkImportIssuesEndpoint,
     ProjectUserViewsEndpoint,
-    IssuePropertyViewSet,
+    IssueUserDisplayPropertyEndpoint,
     LabelViewSet,
     SubIssuesEndpoint,
     IssueLinkViewSet,
@@ -191,6 +192,9 @@ from plane.api.views import (
 )
 
 
+#TODO: Delete this file
+# This url file has been deprecated use apiserver/plane/urls folder to create new urls
+
 urlpatterns = [
     #  Social Auth
     path("social-auth/", OauthEndpoint.as_view(), name="oauth"),
@@ -203,6 +207,7 @@ urlpatterns = [
         "magic-generate/", MagicSignInGenerateEndpoint.as_view(), name="magic-generate"
     ),
     path("magic-sign-in/", MagicSignInEndpoint.as_view(), name="magic-sign-in"),
+    path('token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
     # Email verification
     path("email-verify/", VerifyEmailEndpoint.as_view(), name="email-verify"),
     path(
@@ -229,6 +234,15 @@ urlpatterns = [
         ),
         name="users",
     ),
+    path(
+        "users/me/settings/",
+        UserEndpoint.as_view(
+            {
+                "get": "retrieve_user_settings",
+            }
+        ),
+        name="users",
+    ),
     path(
         "users/me/change-password/",
         ChangePasswordEndpoint.as_view(),
@@ -556,6 +570,7 @@ urlpatterns = [
         "workspaces/<str:slug>/user-favorite-projects/",
         ProjectFavoritesViewSet.as_view(
             {
+                "get": "list",
                 "post": "create",
             }
         ),
@@ -993,26 +1008,9 @@ urlpatterns = [
     ## End Comment Reactions
     ## IssueProperty
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-properties/",
-        IssuePropertyViewSet.as_view(
-            {
-                "get": "list",
-                "post": "create",
-            }
-        ),
-        name="project-issue-roadmap",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-properties/<uuid:pk>/",
-        IssuePropertyViewSet.as_view(
-            {
-                "get": "retrieve",
-                "put": "update",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="project-issue-roadmap",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-display-properties/",
+        IssueUserDisplayPropertyEndpoint.as_view(),
+        name="project-issue-display-properties",
     ),
     ## IssueProperty Ebd
     ## Issue Archives

apiserver/plane/api/views/__init__.py

@@ -71,7 +71,7 @@ from .issue import (
     WorkSpaceIssuesEndpoint,
     IssueActivityEndpoint,
     IssueCommentViewSet,
-    IssuePropertyViewSet,
+    IssueUserDisplayPropertyEndpoint,
     LabelViewSet,
     BulkDeleteIssuesEndpoint,
     UserWorkSpaceIssues,

apiserver/plane/api/views/analytic.py

@@ -1,10 +1,5 @@
 # Django imports
-from django.db.models import (
-    Count,
-    Sum,
-    F,
-    Q
-)
+from django.db.models import Count, Sum, F, Q
 from django.db.models.functions import ExtractMonth
 
 # Third party imports
@@ -28,82 +23,156 @@ class AnalyticsEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug):
-        try:
         x_axis = request.GET.get("x_axis", False)
         y_axis = request.GET.get("y_axis", False)
+        segment = request.GET.get("segment", False)
 
-            if not x_axis or not y_axis:
+        valid_xaxis_segment = [
+            "state_id",
+            "state__group",
+            "labels__id",
+            "assignees__id",
+            "estimate_point",
+            "issue_cycle__cycle_id",
+            "issue_module__module_id",
+            "priority",
+            "start_date",
+            "target_date",
+            "created_at",
+            "completed_at",
+        ]
+
+        valid_yaxis = [
+            "issue_count",
+            "estimate",
+        ]
+
+        # Check for x-axis and y-axis as thery are required parameters
+        if (
+            not x_axis
+            or not y_axis
+            or not x_axis in valid_xaxis_segment
+            or not y_axis in valid_yaxis
+        ):
             return Response(
-                    {"error": "x-axis and y-axis dimensions are required"},
+                {
+                    "error": "x-axis and y-axis dimensions are required and the values should be valid"
+                },
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-            segment = request.GET.get("segment", False)
+        # If segment is present it cannot be same as x-axis
+        if segment and (segment not in valid_xaxis_segment or x_axis == segment):
+            return Response(
+                {
+                    "error": "Both segment and x axis cannot be same and segment should be valid"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Additional filters that need to be applied
         filters = issue_filters(request.GET, "GET")
 
+        # Get the issues for the workspace with the additional filters applied
         queryset = Issue.issue_objects.filter(workspace__slug=slug, **filters)
 
+        # Get the total issue count
         total_issues = queryset.count()
+
+        # Build the graph payload
         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")
+        state_details = {}
+        if x_axis in ["state_id"] or segment in ["state_id"]:
+            state_details = (
+                Issue.issue_objects.filter(
+                    workspace__slug=slug,
+                    **filters,
+                )
+                .distinct("state_id")
+                .order_by("state_id")
+                .values("state_id", "state__name", "state__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"
+        label_details = {}
+        if x_axis in ["labels__id"] or segment in ["labels__id"]:
+            label_details = (
+                Issue.objects.filter(
+                    workspace__slug=slug, **filters, labels__id__isnull=False
                 )
+                .distinct("labels__id")
+                .order_by("labels__id")
+                .values("labels__id", "labels__color", "labels__name")
             )
 
         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)
+                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")
+                .values(
+                    "assignees__avatar",
+                    "assignees__display_name",
+                    "assignees__first_name",
+                    "assignees__last_name",
+                    "assignees__id",
+                )
             )
 
+        cycle_details = {}
+        if x_axis in ["issue_cycle__cycle_id"] or segment in ["issue_cycle__cycle_id"]:
+            cycle_details = (
+                Issue.issue_objects.filter(
+                    workspace__slug=slug,
+                    **filters,
+                    issue_cycle__cycle_id__isnull=False,
+                )
+                .distinct("issue_cycle__cycle_id")
+                .order_by("issue_cycle__cycle_id")
+                .values(
+                    "issue_cycle__cycle_id",
+                    "issue_cycle__cycle__name",
+                )
+            )
+
+        module_details = {}
+        if x_axis in ["issue_module__module_id"] or segment in [
+            "issue_module__module_id"
+        ]:
+            module_details = (
+                Issue.issue_objects.filter(
+                    workspace__slug=slug,
+                    **filters,
+                    issue_module__module_id__isnull=False,
+                )
+                .distinct("issue_module__module_id")
+                .order_by("issue_module__module_id")
+                .values(
+                    "issue_module__module_id",
+                    "issue_module__module__name",
+                )
+            )
 
         return Response(
             {
                 "total": total_issues,
                 "distribution": distribution,
-                    "extras": {"colors": colors, "assignee_details": assignee_details},
+                "extras": {
+                    "state_details": state_details,
+                    "assignee_details": assignee_details,
+                    "label_details": label_details,
+                    "cycle_details": cycle_details,
+                    "module_details": module_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 = [
@@ -128,10 +197,7 @@ class SavedAnalyticEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug, analytic_id):
-        try:
-            analytic_view = AnalyticView.objects.get(
-                pk=analytic_id, workspace__slug=slug
-            )
+        analytic_view = AnalyticView.objects.get(pk=analytic_id, workspace__slug=slug)
 
         filter = analytic_view.query
         queryset = Issue.issue_objects.filter(**filter)
@@ -155,18 +221,6 @@ class SavedAnalyticEndpoint(BaseAPIView):
             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 = [
@@ -174,13 +228,50 @@ class ExportAnalyticsEndpoint(BaseAPIView):
     ]
 
     def post(self, request, slug):
-        try:
         x_axis = request.data.get("x_axis", False)
         y_axis = request.data.get("y_axis", False)
+        segment = request.data.get("segment", False)
 
-            if not x_axis or not y_axis:
+        valid_xaxis_segment = [
+            "state_id",
+            "state__group",
+            "labels__id",
+            "assignees__id",
+            "estimate_point",
+            "issue_cycle__cycle_id",
+            "issue_module__module_id",
+            "priority",
+            "start_date",
+            "target_date",
+            "created_at",
+            "completed_at",
+        ]
+
+        valid_yaxis = [
+            "issue_count",
+            "estimate",
+        ]
+
+        # Check for x-axis and y-axis as thery are required parameters
+        if (
+            not x_axis
+            or not y_axis
+            or not x_axis in valid_xaxis_segment
+            or not y_axis in valid_yaxis
+        ):
             return Response(
-                    {"error": "x-axis and y-axis dimensions are required"},
+                {
+                    "error": "x-axis and y-axis dimensions are required and the values should be valid"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # If segment is present it cannot be same as x-axis
+        if segment and (segment not in valid_xaxis_segment or x_axis == segment):
+            return Response(
+                {
+                    "error": "Both segment and x axis cannot be same and segment should be valid"
+                },
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
@@ -194,12 +285,6 @@ class ExportAnalyticsEndpoint(BaseAPIView):
             },
             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):
@@ -208,70 +293,79 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug):
-        try:
         filters = issue_filters(request.GET, "GET")
+        base_issues = Issue.issue_objects.filter(workspace__slug=slug, **filters)
 
-            queryset = Issue.issue_objects.filter(workspace__slug=slug, **filters)
+        total_issues = base_issues.count()
 
-            total_issues = queryset.count()
+        state_groups = base_issues.annotate(state_group=F("state__group"))
 
         total_issues_classified = (
-                queryset.annotate(state_group=F("state__group"))
-                .values("state_group")
+            state_groups.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_groups = ["backlog", "unstarted", "started"]
+        open_issues_queryset = state_groups.filter(state__group__in=open_issues_groups)
 
+        open_issues = open_issues_queryset.count()
         open_issues_classified = (
-                queryset.filter(state__group__in=["backlog", "unstarted", "started"])
-                .annotate(state_group=F("state__group"))
-                .values("state_group")
+            open_issues_queryset.values("state_group")
             .annotate(state_count=Count("state_group"))
             .order_by("state_group")
         )
 
         issue_completed_month_wise = (
-                queryset.filter(completed_at__isnull=False)
+            base_issues.filter(completed_at__isnull=False)
             .annotate(month=ExtractMonth("completed_at"))
             .values("month")
             .annotate(count=Count("*"))
             .order_by("month")
         )
+
+        user_details = [
+            "created_by__first_name",
+            "created_by__last_name",
+            "created_by__avatar",
+            "created_by__display_name",
+            "created_by__id",
+        ]
+
         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")
+            base_issues.exclude(created_by=None)
+            .values(*user_details)
             .annotate(count=Count("id"))
-                .order_by("-count")
-            )[:5]
+            .order_by("-count")[:5]
+        )
+
+        user_assignee_details = [
+            "assignees__first_name",
+            "assignees__last_name",
+            "assignees__avatar",
+            "assignees__display_name",
+            "assignees__id",
+        ]
 
         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")
+            base_issues.filter(completed_at__isnull=False)
+            .exclude(assignees=None)
+            .values(*user_assignee_details)
             .annotate(count=Count("id"))
-                .order_by("-count")
-            )[:5]
+            .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")
+            base_issues.filter(completed_at__isnull=True)
+            .values(*user_assignee_details)
             .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"]
+        open_estimate_sum = open_issues_queryset.aggregate(sum=Sum("estimate_point"))[
+            "sum"
+        ]
+        total_estimate_sum = base_issues.aggregate(sum=Sum("estimate_point"))["sum"]
 
         return Response(
             {
@@ -288,10 +382,3 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
             },
             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

@@ -14,7 +14,6 @@ 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)
 
@@ -34,37 +33,15 @@ class ApiTokenEndpoint(BaseAPIView):
             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

@@ -18,7 +18,6 @@ class FileAssetEndpoint(BaseAPIView):
     """
 
     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():
@@ -26,16 +25,9 @@ class FileAssetEndpoint(BaseAPIView):
             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
@@ -43,17 +35,9 @@ class FileAssetEndpoint(BaseAPIView):
             serializer.save(workspace_id=workspace.id)
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        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
@@ -61,65 +45,31 @@ class FileAssetEndpoint(BaseAPIView):
         # 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

@@ -9,7 +9,6 @@ from django.utils.encoding import (
     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
@@ -128,7 +127,6 @@ class ResetPasswordEndpoint(BaseAPIView):
 
 class ChangePasswordEndpoint(BaseAPIView):
     def post(self, request):
-        try:
         serializer = ChangePasswordSerializer(data=request.data)
 
         user = User.objects.get(pk=request.user.id)
@@ -151,9 +149,3 @@ class ChangePasswordEndpoint(BaseAPIView):
             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

@@ -40,7 +40,6 @@ class SignUpEndpoint(BaseAPIView):
     permission_classes = (AllowAny,)
 
     def post(self, request):
-        try:
         if not settings.ENABLE_SIGNUP:
             return Response(
                 {
@@ -87,14 +86,11 @@ class SignUpEndpoint(BaseAPIView):
         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
@@ -121,19 +117,11 @@ class SignUpEndpoint(BaseAPIView):
 
         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)
 
@@ -180,8 +168,6 @@ class SignInEndpoint(BaseAPIView):
                 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()
@@ -215,32 +201,19 @@ class SignInEndpoint(BaseAPIView):
         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."
-                    },
+                {"error": "No refresh token provided"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
@@ -254,14 +227,6 @@ class SignOutEndpoint(BaseAPIView):
         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):
@@ -270,7 +235,6 @@ class MagicSignInGenerateEndpoint(BaseAPIView):
     ]
 
     def post(self, request):
-        try:
         email = request.data.get("email", False)
 
         if not email:
@@ -327,17 +291,6 @@ class MagicSignInGenerateEndpoint(BaseAPIView):
         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):
@@ -346,7 +299,6 @@ class MagicSignInEndpoint(BaseAPIView):
     ]
 
     def post(self, request):
-        try:
         user_token = request.data.get("token", "").strip()
         key = request.data.get("key", False).strip().lower()
 
@@ -383,9 +335,7 @@ class MagicSignInEndpoint(BaseAPIView):
                                 "user": {"email": email, "id": str(user.id)},
                                 "device_ctx": {
                                     "ip": request.META.get("REMOTE_ADDR"),
-                                        "user_agent": request.META.get(
-                                            "HTTP_USER_AGENT"
-                                        ),
+                                    "user_agent": request.META.get("HTTP_USER_AGENT"),
                                 },
                                 "event_type": "SIGN_IN",
                             },
@@ -413,9 +363,7 @@ class MagicSignInEndpoint(BaseAPIView):
                                 "user": {"email": email, "id": str(user.id)},
                                 "device_ctx": {
                                     "ip": request.META.get("REMOTE_ADDR"),
-                                        "user_agent": request.META.get(
-                                            "HTTP_USER_AGENT"
-                                        ),
+                                    "user_agent": request.META.get("HTTP_USER_AGENT"),
                                 },
                                 "event_type": "SIGN_UP",
                             },
@@ -427,13 +375,11 @@ class MagicSignInEndpoint(BaseAPIView):
                 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)
@@ -449,10 +395,3 @@ class MagicSignInEndpoint(BaseAPIView):
                 {"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

@@ -5,10 +5,14 @@ import zoneinfo
 from django.urls import resolve
 from django.conf import settings
 from django.utils import timezone
-# Third part imports
+from django.db import IntegrityError
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
 
+# Third part imports
+from rest_framework import status
 from rest_framework import status
 from rest_framework.viewsets import ModelViewSet
+from rest_framework.response import Response
 from rest_framework.exceptions import APIException
 from rest_framework.views import APIView
 from rest_framework.filters import SearchFilter
@@ -33,8 +37,6 @@ class TimezoneMixin:
             timezone.deactivate()
 
 
-
-
 class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
 
     model = None
@@ -59,7 +61,36 @@ class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
             capture_exception(e)
             raise APIException("Please check the view", status.HTTP_400_BAD_REQUEST)
         
+    def handle_exception(self, exc):
+        """
+        Handle any exception that occurs, by returning an appropriate response,
+        or re-raising the error.
+        """
+        try:
+            response = super().handle_exception(exc)
+            return response
+        except Exception as e:
+            if isinstance(e, IntegrityError):
+                return Response({"error": "The payload is not valid"}, status=status.HTTP_400_BAD_REQUEST)
+            
+            if isinstance(e, ValidationError):
+                return Response({"error": "Please provide valid detail"}, status=status.HTTP_400_BAD_REQUEST)
+            
+            if isinstance(e, ObjectDoesNotExist):
+                model_name = str(exc).split(" matching query does not exist.")[0]
+                return Response({"error": f"{model_name} does not exist."}, status=status.HTTP_404_NOT_FOUND)
+            
+            if isinstance(e, KeyError):
+                capture_exception(e)
+                return Response({"error": f"key {e} does not exist"}, status=status.HTTP_400_BAD_REQUEST)
+            
+            print(e) if settings.DEBUG else print("Server Error")
+            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:
@@ -70,6 +101,10 @@ class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
                 )
             return response
 
+        except Exception as exc:
+            response = self.handle_exception(exc)
+            return exc
+
     @property
     def workspace_slug(self):
         return self.kwargs.get("slug", None)
@@ -104,7 +139,36 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
             queryset = backend().filter_queryset(self.request, queryset, self)
         return queryset
 
+
+    def handle_exception(self, exc):
+        """
+        Handle any exception that occurs, by returning an appropriate response,
+        or re-raising the error.
+        """
+        try:
+            response = super().handle_exception(exc)
+            return response
+        except Exception as e:
+            if isinstance(e, IntegrityError):
+                return Response({"error": "The payload is not valid"}, status=status.HTTP_400_BAD_REQUEST)
+            
+            if isinstance(e, ValidationError):
+                return Response({"error": "Please provide valid detail"}, status=status.HTTP_400_BAD_REQUEST)
+            
+            if isinstance(e, ObjectDoesNotExist):
+                model_name = str(exc).split(" matching query does not exist.")[0]
+                return Response({"error": f"{model_name} does not exist."}, status=status.HTTP_404_NOT_FOUND)
+            
+            if isinstance(e, KeyError):
+                return Response({"error": f"key {e} does not exist"}, status=status.HTTP_400_BAD_REQUEST)
+            
+            print(e) if settings.DEBUG else print("Server Error")
+            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:
@@ -115,6 +179,10 @@ class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
                 )
             return response
 
+        except Exception as exc:
+            response = self.handle_exception(exc)
+            return exc
+
     @property
     def workspace_slug(self):
         return self.kwargs.get("slug", None)

apiserver/plane/api/views/config.py

@@ -20,7 +20,6 @@ class ConfigurationEndpoint(BaseAPIView):
     ]
 
     def get(self, request):
-        try:
         data = {}
         data["google"] = os.environ.get("GOOGLE_CLIENT_ID", None)
         data["github"] = os.environ.get("GITHUB_CLIENT_ID", None)
@@ -32,9 +31,3 @@ class ConfigurationEndpoint(BaseAPIView):
             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/cycle.py

@@ -2,7 +2,6 @@
 import json
 
 # Django imports
-from django.db import IntegrityError
 from django.db.models import (
     OuterRef,
     Func,
@@ -62,29 +61,6 @@ class CycleViewSet(BaseViewSet):
             project_id=self.kwargs.get("project_id"), owned_by=self.request.user
         )
 
-    def perform_destroy(self, instance):
-        cycle_issues = list(
-            CycleIssue.objects.filter(cycle_id=self.kwargs.get("pk")).values_list(
-                "issue", flat=True
-            )
-        )
-        issue_activity.delay(
-            type="cycle.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "cycle_id": str(self.kwargs.get("pk")),
-                    "issues": [str(issue_id) for issue_id in cycle_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=None,
-            epoch=int(timezone.now().timestamp())
-        )
-
-        return super().perform_destroy(instance)
-
     def get_queryset(self):
         subquery = CycleFavorite.objects.filter(
             user=self.request.user,
@@ -199,19 +175,12 @@ class CycleViewSet(BaseViewSet):
         )
 
     def list(self, request, slug, project_id):
-        try:
         queryset = self.get_queryset()
         cycle_view = request.GET.get("cycle_view", "all")
         order_by = request.GET.get("order_by", "sort_order")
 
         queryset = queryset.order_by(order_by)
 
-            # All Cycles
-            if cycle_view == "all":
-                return Response(
-                    CycleSerializer(queryset, many=True).data, status=status.HTTP_200_OK
-                )
-
         # Current Cycle
         if cycle_view == "current":
             queryset = queryset.filter(
@@ -348,19 +317,12 @@ class CycleViewSet(BaseViewSet):
                 CycleSerializer(queryset, many=True).data, status=status.HTTP_200_OK
             )
 
+        # If no matching view is found return all cycles
         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,
+            CycleSerializer(queryset, many=True).data, status=status.HTTP_200_OK
         )
 
     def create(self, request, slug, project_id):
-        try:
         if (
             request.data.get("start_date", None) is None
             and request.data.get("end_date", None) is None
@@ -383,18 +345,9 @@ class CycleViewSet(BaseViewSet):
                 },
                 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:
-            cycle = Cycle.objects.get(
-                workspace__slug=slug, project_id=project_id, pk=pk
-            )
+        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
 
         request_data = request.data
 
@@ -417,19 +370,8 @@ class CycleViewSet(BaseViewSet):
             serializer.save()
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Cycle.DoesNotExist:
-            return Response(
-                {"error": "Cycle 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, pk):
-        try:
         queryset = self.get_queryset().get(pk=pk)
 
         # Assignee Distribution
@@ -444,9 +386,7 @@ class CycleViewSet(BaseViewSet):
             .annotate(assignee_id=F("assignees__id"))
             .annotate(avatar=F("assignees__avatar"))
             .annotate(display_name=F("assignees__display_name"))
-                .values(
-                    "first_name", "last_name", "assignee_id", "avatar", "display_name"
-                )
+            .values("first_name", "last_name", "assignee_id", "avatar", "display_name")
             .annotate(
                 total_issues=Count(
                     "assignee_id",
@@ -532,16 +472,31 @@ class CycleViewSet(BaseViewSet):
             data,
             status=status.HTTP_200_OK,
         )
-        except Cycle.DoesNotExist:
-            return Response(
-                {"error": "Cycle Does not exists"}, status=status.HTTP_400_BAD_REQUEST
+
+    def destroy(self, request, slug, project_id, pk):
+        cycle_issues = list(
+            CycleIssue.objects.filter(cycle_id=self.kwargs.get("pk")).values_list(
+                "issue", flat=True
             )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
         )
+        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+        # Delete the cycle
+        cycle.delete()
+        issue_activity.delay(
+            type="cycle.activity.deleted",
+            requested_data=json.dumps(
+                {
+                    "cycle_id": str(pk),
+                    "issues": [str(issue_id) for issue_id in cycle_issues],
+                }
+            ),
+            actor_id=str(request.user.id),
+            issue_id=str(pk),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
 
 
 class CycleIssueViewSet(BaseViewSet):
@@ -563,23 +518,6 @@ class CycleIssueViewSet(BaseViewSet):
             cycle_id=self.kwargs.get("cycle_id"),
         )
 
-    def perform_destroy(self, instance):
-        issue_activity.delay(
-            type="cycle.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "cycle_id": str(self.kwargs.get("cycle_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(
             super()
@@ -604,7 +542,6 @@ class CycleIssueViewSet(BaseViewSet):
 
     @method_decorator(gzip_page)
     def list(self, request, slug, project_id, cycle_id):
-        try:
         order_by = request.GET.get("order_by", "created_at")
         group_by = request.GET.get("group_by", False)
         sub_group_by = request.GET.get("sub_group_by", False)
@@ -635,9 +572,7 @@ class CycleIssueViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                    attachment_count=IssueAttachment.objects.filter(
-                        issue=OuterRef("id")
-                    )
+                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
@@ -653,24 +588,17 @@ class CycleIssueViewSet(BaseViewSet):
             )
 
         if group_by:
+            grouped_results = group_results(issues_data, group_by, sub_group_by)
             return Response(
-                    group_results(issues_data, group_by, sub_group_by),
+                grouped_results,
                 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,
+            issues_data, status=status.HTTP_200_OK
         )
 
     def create(self, request, slug, project_id, cycle_id):
-        try:
         issues = request.data.get("issues", [])
 
         if not len(issues):
@@ -752,7 +680,7 @@ class CycleIssueViewSet(BaseViewSet):
                     ),
                 }
             ),
-                epoch=int(timezone.now().timestamp())
+            epoch=int(timezone.now().timestamp()),
         )
 
         # Return all Cycle Issues
@@ -761,16 +689,27 @@ class CycleIssueViewSet(BaseViewSet):
             status=status.HTTP_200_OK,
         )
 
-        except Cycle.DoesNotExist:
-            return Response(
-                {"error": "Cycle not found"}, status=status.HTTP_404_NOT_FOUND
+    def destroy(self, request, slug, project_id, cycle_id, pk):
+        cycle_issue = CycleIssue.objects.get(
+            pk=pk, workspace__slug=slug, project_id=project_id, cycle_id=cycle_id
         )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
+        issue_id = cycle_issue.issue_id
+        cycle_issue.delete()
+        issue_activity.delay(
+            type="cycle.activity.deleted",
+            requested_data=json.dumps(
+                {
+                    "cycle_id": str(self.kwargs.get("cycle_id")),
+                    "issues": [str(issue_id)],
+                }
+            ),
+            actor_id=str(self.request.user.id),
+            issue_id=str(self.kwargs.get("pk", None)),
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
         )
+        return Response(status=status.HTTP_204_NO_CONTENT)
 
 
 class CycleDateCheckEndpoint(BaseAPIView):
@@ -779,7 +718,6 @@ class CycleDateCheckEndpoint(BaseAPIView):
     ]
 
     def post(self, request, slug, project_id):
-        try:
         start_date = request.data.get("start_date", False)
         end_date = request.data.get("end_date", False)
         cycle_id = request.data.get("cycle_id")
@@ -802,18 +740,12 @@ class CycleDateCheckEndpoint(BaseAPIView):
         if cycles.exists():
             return Response(
                 {
-                        "error": "You have a cycle already on the given dates, if you want to create your draft cycle you can do that by removing dates",
+                    "error": "You have a cycle already on the given dates, if you want to create a draft cycle you can do that by removing dates",
                     "status": False,
                 }
             )
         else:
             return Response({"status": True}, 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 CycleFavoriteViewSet(BaseViewSet):
@@ -830,33 +762,13 @@ class CycleFavoriteViewSet(BaseViewSet):
         )
 
     def create(self, request, slug, project_id):
-        try:
         serializer = CycleFavoriteSerializer(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 cycle 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, cycle_id):
-        try:
         cycle_favorite = CycleFavorite.objects.get(
             project=project_id,
             user=request.user,
@@ -865,17 +777,6 @@ class CycleFavoriteViewSet(BaseViewSet):
         )
         cycle_favorite.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
-        except CycleFavorite.DoesNotExist:
-            return Response(
-                {"error": "Cycle 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 TransferCycleIssueEndpoint(BaseAPIView):
@@ -884,7 +785,6 @@ class TransferCycleIssueEndpoint(BaseAPIView):
     ]
 
     def post(self, request, slug, project_id, cycle_id):
-        try:
         new_cycle_id = request.data.get("new_cycle_id", False)
 
         if not new_cycle_id:
@@ -925,14 +825,3 @@ class TransferCycleIssueEndpoint(BaseAPIView):
         )
 
         return Response({"message": "Success"}, status=status.HTTP_200_OK)
-        except Cycle.DoesNotExist:
-            return Response(
-                {"error": "New Cycle 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,
-            )

apiserver/plane/api/views/estimate.py

@@ -1,6 +1,3 @@
-# Django imports
-from django.db import IntegrityError
-
 # Third party imports
 from rest_framework.response import Response
 from rest_framework import status
@@ -23,7 +20,6 @@ class ProjectEstimatePointEndpoint(BaseAPIView):
     ]
 
     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(
@@ -34,12 +30,6 @@ class ProjectEstimatePointEndpoint(BaseAPIView):
                 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):
@@ -50,21 +40,13 @@ class BulkEstimatePointEndpoint(BaseViewSet):
     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"},
@@ -84,13 +66,7 @@ class BulkEstimatePointEndpoint(BaseViewSet):
             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(
@@ -120,20 +96,8 @@ class BulkEstimatePointEndpoint(BaseViewSet):
             },
             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
         )
@@ -142,19 +106,8 @@ class BulkEstimatePointEndpoint(BaseViewSet):
             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"},
@@ -176,13 +129,8 @@ class BulkEstimatePointEndpoint(BaseViewSet):
             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", [])
 
@@ -209,15 +157,9 @@ class BulkEstimatePointEndpoint(BaseViewSet):
                 )
                 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(
@@ -227,27 +169,10 @@ class BulkEstimatePointEndpoint(BaseViewSet):
             },
             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

@@ -20,7 +20,6 @@ class ExportIssuesEndpoint(BaseAPIView):
     serializer_class = ExporterHistorySerializer
 
     def post(self, request, slug):
-        try:
         # Get the workspace
         workspace = Workspace.objects.get(slug=slug)
         
@@ -61,20 +60,8 @@ class ExportIssuesEndpoint(BaseAPIView):
                 {"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")
@@ -92,9 +79,3 @@ class ExportIssuesEndpoint(BaseAPIView):
                 {"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

@@ -25,7 +25,6 @@ class GPTIntegrationEndpoint(BaseAPIView):
     ]
 
     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"},
@@ -64,36 +63,17 @@ class GPTIntegrationEndpoint(BaseAPIView):
             },
             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)
@@ -110,9 +90,3 @@ class UnsplashEndpoint(BaseAPIView):
 
         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

@@ -44,7 +44,6 @@ 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)
@@ -117,22 +116,10 @@ class ServiceIssueImportSummaryEndpoint(BaseAPIView):
             {"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:
@@ -220,24 +207,8 @@ class ImportServiceEndpoint(BaseAPIView):
             {"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")
@@ -245,15 +216,8 @@ class ImportServiceEndpoint(BaseAPIView):
         )
         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
         )
@@ -272,15 +236,8 @@ class ImportServiceEndpoint(BaseAPIView):
                 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
         )
@@ -289,21 +246,10 @@ class ImportServiceEndpoint(BaseAPIView):
             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,
@@ -313,15 +259,10 @@ class UpdateServiceImportStatusEndpoint(BaseAPIView):
         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)
 
@@ -504,21 +445,10 @@ class BulkImportIssuesEndpoint(BaseAPIView):
             {"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)
 
@@ -590,13 +520,3 @@ class BulkImportModulesEndpoint(BaseAPIView):
                 {"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

@@ -64,7 +64,6 @@ class InboxViewSet(BaseViewSet):
         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
         )
@@ -76,12 +75,6 @@ class InboxViewSet(BaseViewSet):
             )
         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):
@@ -110,7 +103,6 @@ class InboxIssueViewSet(BaseViewSet):
         )
 
     def list(self, request, slug, project_id, inbox_id):
-        try:
         filters = issue_filters(request.query_params, "GET")
         issues = (
             Issue.objects.filter(
@@ -158,15 +150,8 @@ class InboxIssueViewSet(BaseViewSet):
             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, inbox_id):
-        try:
         if not request.data.get("issue", {}).get("name", False):
             return Response(
                 {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
@@ -225,15 +210,8 @@ class InboxIssueViewSet(BaseViewSet):
 
         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:
         inbox_issue = InboxIssue.objects.get(
             pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
         )
@@ -330,20 +308,8 @@ class InboxIssueViewSet(BaseViewSet):
             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"},
-                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):
-        try:
         inbox_issue = InboxIssue.objects.get(
             pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
         )
@@ -352,15 +318,8 @@ class InboxIssueViewSet(BaseViewSet):
         )
         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 destroy(self, request, slug, project_id, inbox_id, pk):
-        try:
         inbox_issue = InboxIssue.objects.get(
             pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
         )
@@ -377,14 +336,6 @@ class InboxIssueViewSet(BaseViewSet):
 
         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):
@@ -413,7 +364,6 @@ class InboxIssuePublicViewSet(BaseViewSet):
             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)
@@ -464,17 +414,8 @@ class InboxIssuePublicViewSet(BaseViewSet):
             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)
@@ -537,15 +478,8 @@ class InboxIssuePublicViewSet(BaseViewSet):
 
         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)
@@ -595,20 +529,8 @@ class InboxIssuePublicViewSet(BaseViewSet):
             issue_serializer.save()
             return Response(issue_serializer.data, status=status.HTTP_200_OK)
         return Response(issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except InboxIssue.DoesNotExist:
-            return Response(
-                {"error": "Inbox Issue 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, 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)
@@ -621,15 +543,8 @@ class InboxIssuePublicViewSet(BaseViewSet):
         )
         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 destroy(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)
@@ -643,12 +558,3 @@ class InboxIssuePublicViewSet(BaseViewSet):
 
         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,
-            )
-

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

@@ -2,7 +2,6 @@
 import uuid
 
 # Django imports
-from django.db import IntegrityError
 from django.contrib.auth.hashers import make_password
 
 # Third party imports
@@ -33,21 +32,13 @@ class IntegrationViewSet(BaseViewSet):
     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(
@@ -64,20 +55,7 @@ class IntegrationViewSet(BaseViewSet):
             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(
@@ -87,11 +65,6 @@ class IntegrationViewSet(BaseViewSet):
 
         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):
@@ -111,7 +84,6 @@ class WorkspaceIntegrationViewSet(BaseViewSet):
         )
 
     def create(self, request, slug, provider):
-        try:
         workspace = Workspace.objects.get(slug=slug)
         integration = Integration.objects.get(provider=provider)
         config = {}
@@ -175,33 +147,8 @@ class WorkspaceIntegrationViewSet(BaseViewSet):
             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
         )
@@ -215,15 +162,3 @@ class WorkspaceIntegrationViewSet(BaseViewSet):
 
         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

@@ -30,7 +30,6 @@ class GithubRepositoriesEndpoint(BaseAPIView):
     ]
 
     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
@@ -49,11 +48,6 @@ class GithubRepositoriesEndpoint(BaseAPIView):
         )
         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):
@@ -76,7 +70,6 @@ class GithubRepositorySyncViewSet(BaseViewSet):
         )
 
     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", {})
@@ -147,18 +140,6 @@ class GithubRepositorySyncViewSet(BaseViewSet):
             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 = [
@@ -177,7 +158,6 @@ class GithubIssueSyncViewSet(BaseViewSet):
 
 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", [])
@@ -202,17 +182,6 @@ class BulkCreateGithubIssueSyncEndpoint(BaseAPIView):
 
         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):

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

@@ -32,7 +32,6 @@ class SlackProjectSyncViewSet(BaseViewSet):
         )
 
     def create(self, request, slug, project_id, workspace_integration_id):
-        try:
         serializer = SlackProjectSyncSerializer(data=request.data)
 
         workspace_integration = WorkspaceIntegration.objects.get(
@@ -55,19 +54,3 @@ class SlackProjectSyncViewSet(BaseViewSet):
 
             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

@@ -141,31 +141,7 @@ class ModuleViewSet(BaseViewSet):
             .order_by(order_by, "name")
         )
 
-    def perform_destroy(self, instance):
-        module_issues = list(
-            ModuleIssue.objects.filter(module_id=self.kwargs.get("pk")).values_list(
-                "issue", flat=True
-            )
-        )
-        issue_activity.delay(
-            type="module.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "module_id": str(self.kwargs.get("pk")),
-                    "issues": [str(issue_id) for issue_id in module_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=None,
-            epoch=int(timezone.now().timestamp())
-        )
-
-        return super().perform_destroy(instance)
-
     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}
@@ -173,28 +149,13 @@ class ModuleViewSet(BaseViewSet):
 
         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)
 
-        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 = (
@@ -208,9 +169,7 @@ class ModuleViewSet(BaseViewSet):
             .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"
-                )
+            .values("first_name", "last_name", "assignee_id", "avatar", "display_name")
             .annotate(
                 total_issues=Count(
                     "assignee_id",
@@ -302,12 +261,27 @@ class ModuleViewSet(BaseViewSet):
             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 destroy(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)
         )
+        module.delete()
+        issue_activity.delay(
+            type="module.activity.deleted",
+            requested_data=json.dumps(
+                {
+                    "module_id": str(pk),
+                    "issues": [str(issue_id) for issue_id in module_issues],
+                }
+            ),
+            actor_id=str(request.user.id),
+            issue_id=str(pk),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
 
 
 class ModuleIssueViewSet(BaseViewSet):
@@ -329,23 +303,6 @@ class ModuleIssueViewSet(BaseViewSet):
             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(
             super()
@@ -371,7 +328,6 @@ class ModuleIssueViewSet(BaseViewSet):
 
     @method_decorator(gzip_page)
     def list(self, request, slug, project_id, module_id):
-        try:
         order_by = request.GET.get("order_by", "created_at")
         group_by = request.GET.get("group_by", False)
         sub_group_by = request.GET.get("sub_group_by", False)
@@ -402,15 +358,12 @@ class ModuleIssueViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                    attachment_count=IssueAttachment.objects.filter(
-                        issue=OuterRef("id")
-                    )
+                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
             )
         )
-
         issues_data = IssueStateSerializer(issues, many=True).data
 
         if sub_group_by and sub_group_by == group_by:
@@ -420,24 +373,17 @@ class ModuleIssueViewSet(BaseViewSet):
             )
 
         if group_by:
+            grouped_results = group_results(issues_data, group_by, sub_group_by)
             return Response(
-                    group_results(issues_data, group_by, sub_group_by),
+                grouped_results,
                 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,
+            issues_data, status=status.HTTP_200_OK
         )
 
     def create(self, request, slug, project_id, module_id):
-        try:
         issues = request.data.get("issues", [])
         if not len(issues):
             return Response(
@@ -510,23 +456,34 @@ class ModuleIssueViewSet(BaseViewSet):
                     ),
                 }
             ),
-                epoch=int(timezone.now().timestamp())
+            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
+
+    def destroy(self, request, slug, project_id, module_id, pk):
+        module_issue = ModuleIssue.objects.get(
+            workspace__slug=slug, project_id=project_id, module_id=module_id, pk=pk
         )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
+        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(pk),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
         )
+        return Response(status=status.HTTP_204_NO_CONTENT)
 
 
 class ModuleLinkViewSet(BaseViewSet):
@@ -570,33 +527,13 @@ class ModuleFavoriteViewSet(BaseViewSet):
         )
 
     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)
-                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, module_id):
-        try:
         module_favorite = ModuleFavorite.objects.get(
             project=project_id,
             user=request.user,
@@ -605,14 +542,3 @@ class ModuleFavoriteViewSet(BaseViewSet):
         )
         module_favorite.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
-        except ModuleFavorite.DoesNotExist:
-            return Response(
-                {"error": "Module 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/api/views/notification.py

@@ -36,12 +36,10 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
         )
 
     def list(self, request, slug):
-        try:
+        # Get query parameters
         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 = (
@@ -52,27 +50,24 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
             .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),
-                )
+        # Filters based on query parameters
+        snoozed_filters = {
+            "true": Q(snoozed_till__lt=timezone.now()) | Q(snoozed_till__isnull=False),
+            "false": 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)
-                )
+        notifications = notifications.filter(snoozed_filters[snoozed])
+
+        archived_filters = {
+            "true": Q(archived_at__isnull=False),
+            "false": Q(archived_at__isnull=True),
+        }
+
+        notifications = notifications.filter(archived_filters[archived])
 
         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(
@@ -97,9 +92,7 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
                 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
-                    )
+                notifications = notifications.filter(entity_identifier__in=issue_ids)
 
         # Pagination
         if request.GET.get("per_page", False) and request.GET.get("cursor", False):
@@ -113,15 +106,8 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
 
         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
         )
@@ -137,20 +123,8 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
             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
         )
@@ -158,20 +132,8 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
         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
         )
@@ -179,20 +141,8 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
         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
         )
@@ -200,20 +150,8 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
         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
         )
@@ -221,22 +159,10 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
         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,
@@ -278,17 +204,10 @@ class UnreadNotificationEndpoint(BaseAPIView):
             },
             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")
@@ -343,9 +262,7 @@ class MarkAllReadNotificationViewSet(BaseViewSet):
                 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
-                    )
+                notifications = notifications.filter(entity_identifier__in=issue_ids)
 
         updated_notifications = []
         for notification in notifications:
@@ -355,9 +272,3 @@ class MarkAllReadNotificationViewSet(BaseViewSet):
             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

@@ -15,6 +15,7 @@ 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
@@ -186,14 +187,11 @@ class OauthEndpoint(BaseAPIView):
             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(
@@ -264,14 +262,11 @@ class OauthEndpoint(BaseAPIView):
             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(
@@ -304,11 +299,3 @@ class OauthEndpoint(BaseAPIView):
                 },
             )
             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

@@ -2,7 +2,6 @@
 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
 
@@ -78,7 +77,6 @@ class PageViewSet(BaseViewSet):
         )
 
     def create(self, request, slug, project_id):
-        try:
         serializer = PageSerializer(
             data=request.data,
             context={"project_id": project_id, "owned_by_id": request.user.id},
@@ -89,15 +87,7 @@ class PageViewSet(BaseViewSet):
             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 (
@@ -115,19 +105,8 @@ class PageViewSet(BaseViewSet):
             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)
 
@@ -173,9 +152,7 @@ class PageViewSet(BaseViewSet):
             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
@@ -225,33 +202,13 @@ class PageFavoriteViewSet(BaseViewSet):
         )
 
     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,
@@ -260,18 +217,6 @@ class PageFavoriteViewSet(BaseViewSet):
         )
         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 = [
@@ -279,7 +224,6 @@ class CreateIssueFromPageBlockEndpoint(BaseAPIView):
     ]
 
     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,
@@ -309,13 +253,3 @@ class CreateIssueFromPageBlockEndpoint(BaseAPIView):
         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/project.py

@@ -7,6 +7,7 @@ from datetime import datetime
 from django.core.exceptions import ValidationError
 from django.db import IntegrityError
 from django.db.models import (
+    Prefetch,
     Q,
     Exists,
     OuterRef,
@@ -29,6 +30,7 @@ from sentry_sdk import capture_exception
 from .base import BaseViewSet, BaseAPIView
 from plane.api.serializers import (
     ProjectSerializer,
+    ProjectListSerializer,
     ProjectMemberSerializer,
     ProjectDetailSerializer,
     ProjectMemberInviteSerializer,
@@ -67,6 +69,7 @@ from plane.db.models import (
     ModuleMember,
     Inbox,
     ProjectDeployBoard,
+    IssueProperty,
 )
 
 from plane.bgtasks.project_invitation_task import project_invitation
@@ -86,12 +89,6 @@ class ProjectViewSet(BaseViewSet):
         return ProjectDetailSerializer
 
     def get_queryset(self):
-        subquery = ProjectFavorite.objects.filter(
-            user=self.request.user,
-            project_id=OuterRef("pk"),
-            workspace__slug=self.kwargs.get("slug"),
-        )
-
         return self.filter_queryset(
             super()
             .get_queryset()
@@ -100,7 +97,15 @@ class ProjectViewSet(BaseViewSet):
             .select_related(
                 "workspace", "workspace__owner", "default_assignee", "project_lead"
             )
-            .annotate(is_favorite=Exists(subquery))
+            .annotate(
+                is_favorite=Exists(
+                    ProjectFavorite.objects.filter(
+                        user=self.request.user,
+                        project_id=OuterRef("pk"),
+                        workspace__slug=self.kwargs.get("slug"),
+                    )
+                )
+            )
             .annotate(
                 is_member=Exists(
                     ProjectMember.objects.filter(
@@ -148,13 +153,8 @@ class ProjectViewSet(BaseViewSet):
         )
 
     def list(self, request, slug):
-        try:
-            is_favorite = request.GET.get("is_favorite", "all")
-            subquery = ProjectFavorite.objects.filter(
-                user=self.request.user,
-                project_id=OuterRef("pk"),
-                workspace__slug=self.kwargs.get("slug"),
-            )
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
+
         sort_order_query = ProjectMember.objects.filter(
             member=request.user,
             project_id=OuterRef("pk"),
@@ -162,42 +162,30 @@ class ProjectViewSet(BaseViewSet):
         ).values("sort_order")
         projects = (
             self.get_queryset()
-                .annotate(is_favorite=Exists(subquery))
             .annotate(sort_order=Subquery(sort_order_query))
+            .prefetch_related(
+                Prefetch(
+                    "project_projectmember",
+                    queryset=ProjectMember.objects.filter(
+                        workspace__slug=slug,
+                    ).select_related("member"),
+                )
+            )
             .order_by("sort_order", "name")
-                .annotate(
-                    total_members=ProjectMember.objects.filter(
-                        project_id=OuterRef("id")
-                    )
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    total_cycles=Cycle.objects.filter(project_id=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    total_modules=Module.objects.filter(project_id=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
         )
+        if request.GET.get("per_page", False) and request.GET.get("cursor", False):
+            return self.paginate(
+                request=request,
+                queryset=(projects),
+                on_results=lambda projects: ProjectListSerializer(
+                    projects, many=True
+                ).data,
             )
 
-            if is_favorite == "true":
-                projects = projects.filter(is_favorite=True)
-            if is_favorite == "false":
-                projects = projects.filter(is_favorite=False)
-
-            return Response(ProjectDetailSerializer(projects, 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,
+            ProjectListSerializer(
+                projects, many=True, fields=fields if fields else None
+            ).data
         )
 
     def create(self, request, slug):
@@ -214,6 +202,11 @@ class ProjectViewSet(BaseViewSet):
                 project_member = ProjectMember.objects.create(
                     project_id=serializer.data["id"], member=request.user, role=20
                 )
+                # Also create the issue property for the user
+                _ = IssueProperty.objects.create(
+                    project_id=serializer.data["id"],
+                    user=request.user,
+                )
 
                 if serializer.data["project_lead"] is not None and str(
                     serializer.data["project_lead"]
@@ -223,6 +216,11 @@ class ProjectViewSet(BaseViewSet):
                         member_id=serializer.data["project_lead"],
                         role=20,
                     )
+                    # Also create the issue property for the user
+                    IssueProperty.objects.create(
+                        project_id=serializer.data["id"],
+                        user_id=serializer.data["project_lead"],
+                    )
 
                 # Default states
                 states = [
@@ -275,12 +273,9 @@ class ProjectViewSet(BaseViewSet):
                     ]
                 )
 
-                data = serializer.data
-                # Additional fields of the member
-                data["sort_order"] = project_member.sort_order
-                data["member_role"] = project_member.role
-                data["is_member"] = True
-                return Response(data, status=status.HTTP_201_CREATED)
+                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
+                serializer = ProjectListSerializer(project)
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
             return Response(
                 serializer.errors,
                 status=status.HTTP_400_BAD_REQUEST,
@@ -291,12 +286,6 @@ class ProjectViewSet(BaseViewSet):
                     {"name": "The project name is already taken"},
                     status=status.HTTP_410_GONE,
                 )
-            else:
-                capture_exception(e)
-                return Response(
-                    {"error": "Something went wrong please try again later"},
-                    status=status.HTTP_410_GONE,
-                )
         except Workspace.DoesNotExist as e:
             return Response(
                 {"error": "Workspace does not exist"}, status=status.HTTP_404_NOT_FOUND
@@ -306,12 +295,6 @@ class ProjectViewSet(BaseViewSet):
                 {"identifier": "The project identifier 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 partial_update(self, request, slug, pk=None):
         try:
@@ -342,6 +325,8 @@ class ProjectViewSet(BaseViewSet):
                         color="#ff7700",
                     )
 
+                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
+                serializer = ProjectListSerializer(project)
                 return Response(serializer.data, status=status.HTTP_200_OK)
             return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
@@ -360,12 +345,6 @@ class ProjectViewSet(BaseViewSet):
                 {"identifier": "The project identifier 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,
-            )
 
 
 class InviteProjectEndpoint(BaseAPIView):
@@ -374,7 +353,6 @@ class InviteProjectEndpoint(BaseAPIView):
     ]
 
     def post(self, request, slug, project_id):
-        try:
         email = request.data.get("email", False)
         role = request.data.get("role", False)
 
@@ -425,29 +403,12 @@ class InviteProjectEndpoint(BaseAPIView):
             member=user, project_id=project_id, role=role
         )
 
+        _ = IssueProperty.objects.create(user=user, project_id=project_id)
+
         return Response(
             ProjectMemberSerializer(project_member).data, status=status.HTTP_200_OK
         )
 
-        except ValidationError:
-            return Response(
-                {
-                    "error": "Invalid email address provided a valid email address is required to send the invite"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except (Workspace.DoesNotExist, Project.DoesNotExist) as e:
-            return Response(
-                {"error": "Workspace or Project 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 UserProjectInvitationsViewset(BaseViewSet):
     serializer_class = ProjectMemberInviteSerializer
@@ -462,7 +423,6 @@ class UserProjectInvitationsViewset(BaseViewSet):
         )
 
     def create(self, request):
-        try:
         invitations = request.data.get("invitations")
         project_invitations = ProjectMemberInvite.objects.filter(
             pk__in=invitations, accepted=True
@@ -480,16 +440,22 @@ class UserProjectInvitationsViewset(BaseViewSet):
             ]
         )
 
+        IssueProperty.objects.bulk_create(
+            [
+                ProjectMember(
+                    project=invitation.project,
+                    workspace=invitation.project.workspace,
+                    user=request.user,
+                    created_by=request.user,
+                )
+                for invitation in project_invitations
+            ]
+        )
+
         # Delete joined project invites
         project_invitations.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,
-            )
 
 
 class ProjectMemberViewSet(BaseViewSet):
@@ -517,7 +483,6 @@ class ProjectMemberViewSet(BaseViewSet):
         )
 
     def partial_update(self, request, slug, project_id, pk):
-        try:
         project_member = ProjectMember.objects.get(
             pk=pk, workspace__slug=slug, project_id=project_id
         )
@@ -536,9 +501,7 @@ class ProjectMemberViewSet(BaseViewSet):
             > requested_project_member.role
         ):
             return Response(
-                    {
-                        "error": "You cannot update a role that is higher than your own role"
-                    },
+                {"error": "You cannot update a role that is higher than your own role"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
@@ -550,20 +513,8 @@ class ProjectMemberViewSet(BaseViewSet):
             serializer.save()
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except ProjectMember.DoesNotExist:
-            return Response(
-                {"error": "Project Member 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, pk):
-        try:
         project_member = ProjectMember.objects.get(
             workspace__slug=slug, project_id=project_id, pk=pk
         )
@@ -573,9 +524,7 @@ class ProjectMemberViewSet(BaseViewSet):
         )
         if requesting_project_member.role < project_member.role:
             return Response(
-                    {
-                        "error": "You cannot remove a user having role higher than yourself"
-                    },
+                {"error": "You cannot remove a user having role higher than yourself"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
@@ -616,14 +565,6 @@ class ProjectMemberViewSet(BaseViewSet):
         ).delete()
         project_member.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
-        except ProjectMember.DoesNotExist:
-            return Response(
-                {"error": "Project Member 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"})
 
 
 class AddMemberToProjectEndpoint(BaseAPIView):
@@ -632,7 +573,6 @@ class AddMemberToProjectEndpoint(BaseAPIView):
     ]
 
     def post(self, request, slug, project_id):
-        try:
         members = request.data.get("members", [])
 
         # get the project
@@ -644,6 +584,7 @@ class AddMemberToProjectEndpoint(BaseAPIView):
                 status=status.HTTP_400_BAD_REQUEST,
             )
         bulk_project_members = []
+        bulk_issue_props = []
 
         project_members = (
             ProjectMember.objects.filter(
@@ -670,6 +611,13 @@ class AddMemberToProjectEndpoint(BaseAPIView):
                     sort_order=sort_order[0] - 10000 if len(sort_order) else 65535,
                 )
             )
+            bulk_issue_props.append(
+                IssueProperty(
+                    user_id=member.get("member_id"),
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                )
+            )
 
         project_members = ProjectMember.objects.bulk_create(
             bulk_project_members,
@@ -677,28 +625,13 @@ class AddMemberToProjectEndpoint(BaseAPIView):
             ignore_conflicts=True,
         )
 
+        _ = IssueProperty.objects.bulk_create(
+            bulk_issue_props, batch_size=10, ignore_conflicts=True
+        )
+
         serializer = ProjectMemberSerializer(project_members, many=True)
 
         return Response(serializer.data, status=status.HTTP_201_CREATED)
-        except KeyError:
-            return Response(
-                {"error": "Incorrect data sent"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except Project.DoesNotExist:
-            return Response(
-                {"error": "Project does not exist"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except IntegrityError:
-            return Response(
-                {"error": "User not member of 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 AddTeamToProjectEndpoint(BaseAPIView):
@@ -707,7 +640,6 @@ class AddTeamToProjectEndpoint(BaseAPIView):
     ]
 
     def post(self, request, slug, project_id):
-        try:
         team_members = TeamMember.objects.filter(
             workspace__slug=slug, team__in=request.data.get("teams", [])
         ).values_list("member", flat=True)
@@ -720,6 +652,7 @@ class AddTeamToProjectEndpoint(BaseAPIView):
         workspace = Workspace.objects.get(slug=slug)
 
         project_members = []
+        issue_props = []
         for member in team_members:
             project_members.append(
                 ProjectMember(
@@ -729,30 +662,25 @@ class AddTeamToProjectEndpoint(BaseAPIView):
                     created_by=request.user,
                 )
             )
+            issue_props.append(
+                IssueProperty(
+                    project_id=project_id,
+                    user_id=member,
+                    workspace=workspace,
+                    created_by=request.user,
+                )
+            )
 
         ProjectMember.objects.bulk_create(
             project_members, batch_size=10, ignore_conflicts=True
         )
 
+        _ = IssueProperty.objects.bulk_create(
+            issue_props, batch_size=10, ignore_conflicts=True
+        )
+
         serializer = ProjectMemberSerializer(project_members, many=True)
         return Response(serializer.data, status=status.HTTP_201_CREATED)
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"error": "The team with the name already exists"},
-                    status=status.HTTP_410_GONE,
-                )
-        except Workspace.DoesNotExist:
-            return Response(
-                {"error": "The requested workspace could not be found"},
-                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 ProjectMemberInvitationsViewset(BaseViewSet):
@@ -801,7 +729,6 @@ class ProjectIdentifierEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug):
-        try:
         name = request.GET.get("name", "").strip().upper()
 
         if name == "":
@@ -817,15 +744,8 @@ class ProjectIdentifierEndpoint(BaseAPIView):
             {"exists": len(exists), "identifiers": exists},
             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, slug):
-        try:
         name = request.data.get("name", "").strip().upper()
 
         if name == "":
@@ -844,17 +764,10 @@ class ProjectIdentifierEndpoint(BaseAPIView):
         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,
-            )
 
 
 class ProjectJoinEndpoint(BaseAPIView):
     def post(self, request, slug):
-        try:
         project_ids = request.data.get("project_ids", [])
 
         # Get the workspace user role
@@ -881,26 +794,27 @@ class ProjectJoinEndpoint(BaseAPIView):
             ignore_conflicts=True,
         )
 
+        IssueProperty.objects.bulk_create(
+            [
+                IssueProperty(
+                    project_id=project_id,
+                    user=request.user,
+                    workspace=workspace,
+                    created_by=request.user,
+                )
+                for project_id in project_ids
+            ],
+            ignore_conflicts=True,
+        )
+
         return Response(
             {"message": "Projects joined successfully"},
             status=status.HTTP_201_CREATED,
         )
-        except WorkspaceMember.DoesNotExist:
-            return Response(
-                {"error": "User is not a member of workspace"},
-                status=status.HTTP_403_FORBIDDEN,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
 
 
 class ProjectUserViewsEndpoint(BaseAPIView):
     def post(self, request, slug, project_id):
-        try:
         project = Project.objects.get(pk=project_id, workspace__slug=slug)
 
         project_member = ProjectMember.objects.filter(
@@ -908,9 +822,7 @@ class ProjectUserViewsEndpoint(BaseAPIView):
         ).first()
 
         if project_member is None:
-                return Response(
-                    {"error": "Forbidden"}, status=status.HTTP_403_FORBIDDEN
-                )
+            return Response({"error": "Forbidden"}, status=status.HTTP_403_FORBIDDEN)
 
         view_props = project_member.view_props
         default_props = project_member.default_props
@@ -918,30 +830,17 @@ class ProjectUserViewsEndpoint(BaseAPIView):
         sort_order = project_member.sort_order
 
         project_member.view_props = request.data.get("view_props", view_props)
-            project_member.default_props = request.data.get(
-                "default_props", default_props
-            )
+        project_member.default_props = request.data.get("default_props", default_props)
         project_member.preferences = request.data.get("preferences", preferences)
         project_member.sort_order = request.data.get("sort_order", sort_order)
 
         project_member.save()
 
         return Response(status=status.HTTP_204_NO_CONTENT)
-        except Project.DoesNotExist:
-            return Response(
-                {"error": "The requested resource does not exists"},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-        except Exception as e:
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
 
 
 class ProjectMemberUserEndpoint(BaseAPIView):
     def get(self, request, slug, project_id):
-        try:
         project_member = ProjectMember.objects.get(
             project_id=project_id, workspace__slug=slug, member=request.user
         )
@@ -949,18 +848,6 @@ class ProjectMemberUserEndpoint(BaseAPIView):
 
         return Response(serializer.data, status=status.HTTP_200_OK)
 
-        except ProjectMember.DoesNotExist:
-            return Response(
-                {"error": "User not a member of the project"},
-                status=status.HTTP_403_FORBIDDEN,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
 
 class ProjectFavoritesViewSet(BaseViewSet):
     serializer_class = ProjectFavoriteSerializer
@@ -982,50 +869,18 @@ class ProjectFavoritesViewSet(BaseViewSet):
         serializer.save(user=self.request.user)
 
     def create(self, request, slug):
-        try:
         serializer = ProjectFavoriteSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save(user=request.user)
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError as e:
-            print(str(e))
-            if "already exists" in str(e):
-                return Response(
-                    {"error": "The project 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_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 destroy(self, request, slug, project_id):
-        try:
         project_favorite = ProjectFavorite.objects.get(
             project=project_id, user=request.user, workspace__slug=slug
         )
         project_favorite.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
-        except ProjectFavorite.DoesNotExist:
-            return Response(
-                {"error": "Project 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 ProjectDeployBoardViewSet(BaseViewSet):
@@ -1047,7 +902,6 @@ class ProjectDeployBoardViewSet(BaseViewSet):
         )
 
     def create(self, request, slug, project_id):
-        try:
         comments = request.data.get("comments", False)
         reactions = request.data.get("reactions", False)
         inbox = request.data.get("inbox", None)
@@ -1077,12 +931,6 @@ class ProjectDeployBoardViewSet(BaseViewSet):
 
         serializer = ProjectDeployBoardSerializer(project_deploy_board)
         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,
-            )
 
 
 class ProjectMemberEndpoint(BaseAPIView):
@@ -1091,7 +939,6 @@ class ProjectMemberEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug, project_id):
-        try:
         project_members = ProjectMember.objects.filter(
             project_id=project_id,
             workspace__slug=slug,
@@ -1099,12 +946,6 @@ class ProjectMemberEndpoint(BaseAPIView):
         ).select_related("project", "member", "workspace")
         serializer = ProjectMemberSerializer(project_members, 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,
-            )
 
 
 class ProjectDeployBoardPublicSettingsEndpoint(BaseAPIView):
@@ -1113,23 +954,11 @@ class ProjectDeployBoardPublicSettingsEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug, project_id):
-        try:
         project_deploy_board = ProjectDeployBoard.objects.get(
             workspace__slug=slug, project_id=project_id
         )
         serializer = ProjectDeployBoardSerializer(project_deploy_board)
         return Response(serializer.data, status=status.HTTP_200_OK)
-        except ProjectDeployBoard.DoesNotExist:
-            return Response(
-                {"error": "Project Deploy Board 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 WorkspaceProjectDeployBoardEndpoint(BaseAPIView):
@@ -1138,7 +967,6 @@ class WorkspaceProjectDeployBoardEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug):
-        try:
         projects = (
             Project.objects.filter(workspace__slug=slug)
             .annotate(
@@ -1160,12 +988,6 @@ class WorkspaceProjectDeployBoardEndpoint(BaseAPIView):
         )
 
         return Response(projects, 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 LeaveProjectEndpoint(BaseAPIView):
@@ -1174,7 +996,6 @@ class LeaveProjectEndpoint(BaseAPIView):
     ]
 
     def delete(self, request, slug, project_id):
-        try:
         project_member = ProjectMember.objects.get(
             workspace__slug=slug,
             member=request.user,
@@ -1200,17 +1021,6 @@ class LeaveProjectEndpoint(BaseAPIView):
         # Delete the member from workspace
         project_member.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
-        except ProjectMember.DoesNotExist:
-            return Response(
-                {"error": "Workspace member 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 ProjectPublicCoverImagesEndpoint(BaseAPIView):
@@ -1219,7 +1029,6 @@ class ProjectPublicCoverImagesEndpoint(BaseAPIView):
     ]
 
     def get(self, request):
-        try:
         files = []
         s3 = boto3.client(
             "s3",
@@ -1243,6 +1052,3 @@ class ProjectPublicCoverImagesEndpoint(BaseAPIView):
                     )
 
         return Response(files, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response([], status=status.HTTP_200_OK)

apiserver/plane/api/views/search.py

@@ -168,7 +168,6 @@ class GlobalSearchEndpoint(BaseAPIView):
         )
 
     def get(self, request, slug):
-        try:
         query = request.query_params.get("search", False)
         workspace_search = request.query_params.get("workspace_search", "false")
         project_id = request.query_params.get("project_id", False)
@@ -206,17 +205,9 @@ class GlobalSearchEndpoint(BaseAPIView):
             results[model] = func(query, slug, project_id, workspace_search)
         return Response({"results": results}, 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 IssueSearchEndpoint(BaseAPIView):
     def get(self, request, slug, project_id):
-        try:
         query = request.query_params.get("search", False)
         workspace_search = request.query_params.get("workspace_search", "false")
         parent = request.query_params.get("parent", "false")
@@ -281,13 +272,3 @@ class IssueSearchEndpoint(BaseAPIView):
             ),
             status=status.HTTP_200_OK,
         )
-        except Issue.DoesNotExist:
-            return Response(
-                {"error": "Issue 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/state.py

@@ -2,7 +2,6 @@
 from itertools import groupby
 
 # Django imports
-from django.db import IntegrityError
 from django.db.models import Q
 
 # Third party imports
@@ -41,26 +40,13 @@ class StateViewSet(BaseViewSet):
         )
 
     def create(self, request, slug, project_id):
-        try:
         serializer = StateSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save(project_id=project_id)
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError:
-            return Response(
-                {"error": "State with the name already 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 list(self, request, slug, project_id):
-        try:
         state_dict = dict()
         states = StateSerializer(self.get_queryset(), many=True).data
 
@@ -71,15 +57,8 @@ class StateViewSet(BaseViewSet):
             state_dict[str(key)] = list(value)
 
         return Response(state_dict, 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 destroy(self, request, slug, project_id, pk):
-        try:
         state = State.objects.get(
             ~Q(name="Triage"),
             pk=pk, project_id=project_id, workspace__slug=slug,
@@ -103,5 +82,3 @@ class StateViewSet(BaseViewSet):
 
         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

@@ -8,6 +8,8 @@ from sentry_sdk import capture_exception
 from plane.api.serializers import (
     UserSerializer,
     IssueActivitySerializer,
+    UserMeSerializer,
+    UserMeSettingsSerializer,
 )
 
 from plane.api.views.base import BaseViewSet, BaseAPIView
@@ -30,115 +32,35 @@ class UserEndpoint(BaseViewSet):
         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
-
+        serialized_data = UserMeSerializer(request.user).data
         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,
-            )
+    def retrieve_user_settings(self, request):
+        serialized_data = UserMeSettingsSerializer(request.user).data
+        return Response(serialized_data, status=status.HTTP_200_OK)
 
 
 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,
-            )
+        return Response({"message": "Updated successfully"}, status=status.HTTP_200_OK)
 
 
 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,
-            )
+        return Response({"message": "Updated successfully"}, status=status.HTTP_200_OK)
 
 
 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")
@@ -150,9 +72,3 @@ class UserActivityEndpoint(BaseAPIView, BasePaginator):
                 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

@@ -13,7 +13,6 @@ from django.db.models import (
 )
 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
@@ -94,10 +93,8 @@ class GlobalViewIssuesViewSet(BaseViewSet):
             )
         )
 
-        
     @method_decorator(gzip_page)
     def list(self, request, slug):
-        try:
         filters = issue_filters(request.query_params, "GET")
 
         # Custom ordering for priority and state
@@ -119,9 +116,7 @@ class GlobalViewIssuesViewSet(BaseViewSet):
                 .values("count")
             )
             .annotate(
-                    attachment_count=IssueAttachment.objects.filter(
-                        issue=OuterRef("id")
-                    )
+                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
@@ -131,9 +126,7 @@ class GlobalViewIssuesViewSet(BaseViewSet):
         # 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]
+                priority_order if order_by_param == "priority" else priority_order[::-1]
             )
             issue_queryset = issue_queryset.annotate(
                 priority_order=Case(
@@ -185,7 +178,6 @@ class GlobalViewIssuesViewSet(BaseViewSet):
             )
         else:
             issue_queryset = issue_queryset.order_by(order_by_param)
-
         issues = IssueLiteSerializer(issue_queryset, many=True).data
 
         ## Grouping the results
@@ -198,19 +190,14 @@ class GlobalViewIssuesViewSet(BaseViewSet):
             )
 
         if group_by:
+            grouped_results = group_results(issues, group_by, sub_group_by)
             return Response(
-                    group_results(issues, group_by, sub_group_by), status=status.HTTP_200_OK
+                grouped_results,
+                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
@@ -257,33 +244,13 @@ class IssueViewFavoriteViewSet(BaseViewSet):
         )
 
     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,
@@ -292,14 +259,3 @@ class IssueViewFavoriteViewSet(BaseViewSet):
         )
         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/api/views/workspace.py

@@ -48,6 +48,7 @@ from plane.api.serializers import (
     IssueActivitySerializer,
     IssueLiteSerializer,
     WorkspaceMemberAdminSerializer,
+    WorkspaceMemberMeSerializer,
 )
 from plane.api.views.base import BaseAPIView
 from . import BaseViewSet
@@ -164,23 +165,12 @@ class WorkSpaceViewSet(BaseViewSet):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        ## Handling unique integrity error for now
-        ## TODO: Extend this to handle other common errors which are not automatically handled by APIException
         except IntegrityError as e:
             if "already exists" in str(e):
                 return Response(
                     {"slug": "The workspace with the slug already exists"},
                     status=status.HTTP_410_GONE,
                 )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {
-                    "error": "Something went wrong please try again later",
-                    "identifier": None,
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
 
 
 class UserWorkSpacesEndpoint(BaseAPIView):
@@ -192,7 +182,6 @@ class UserWorkSpacesEndpoint(BaseAPIView):
     ]
 
     def get(self, request):
-        try:
         member_count = (
             WorkspaceMember.objects.filter(
                 workspace=OuterRef("id"), member__is_bot=False
@@ -212,9 +201,7 @@ class UserWorkSpacesEndpoint(BaseAPIView):
         workspace = (
             (
                 Workspace.objects.prefetch_related(
-                        Prefetch(
-                            "workspace_member", queryset=WorkspaceMember.objects.all()
-                        )
+                    Prefetch("workspace_member", queryset=WorkspaceMember.objects.all())
                 )
                 .filter(
                     workspace_member__member=request.user,
@@ -228,17 +215,9 @@ class UserWorkSpacesEndpoint(BaseAPIView):
         serializer = WorkSpaceSerializer(self.filter_queryset(workspace), 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,
-            )
-
 
 class WorkSpaceAvailabilityCheckEndpoint(BaseAPIView):
     def get(self, request):
-        try:
         slug = request.GET.get("slug", False)
 
         if not slug or slug == "":
@@ -249,12 +228,6 @@ class WorkSpaceAvailabilityCheckEndpoint(BaseAPIView):
 
         workspace = Workspace.objects.filter(slug=slug).exists()
         return Response({"status": not workspace}, 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 InviteWorkspaceEndpoint(BaseAPIView):
@@ -263,7 +236,6 @@ class InviteWorkspaceEndpoint(BaseAPIView):
     ]
 
     def post(self, request, slug):
-        try:
         emails = request.data.get("emails", False)
         # Check if email is provided
         if not emails or not len(emails):
@@ -372,18 +344,6 @@ class InviteWorkspaceEndpoint(BaseAPIView):
             status=status.HTTP_200_OK,
         )
 
-        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,
-            )
-
 
 class JoinWorkspaceEndpoint(BaseAPIView):
     permission_classes = [
@@ -391,7 +351,6 @@ class JoinWorkspaceEndpoint(BaseAPIView):
     ]
 
     def post(self, request, slug, pk):
-        try:
         workspace_invite = WorkspaceMemberInvite.objects.get(
             pk=pk, workspace__slug=slug
         )
@@ -442,18 +401,6 @@ class JoinWorkspaceEndpoint(BaseAPIView):
             status=status.HTTP_400_BAD_REQUEST,
         )
 
-        except WorkspaceMemberInvite.DoesNotExist:
-            return Response(
-                {"error": "The invitation either got expired or could not be found"},
-                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 WorkspaceInvitationsViewset(BaseViewSet):
     serializer_class = WorkSpaceMemberInviteSerializer
@@ -472,7 +419,6 @@ class WorkspaceInvitationsViewset(BaseViewSet):
         )
 
     def destroy(self, request, slug, pk):
-        try:
         workspace_member_invite = WorkspaceMemberInvite.objects.get(
             pk=pk, workspace__slug=slug
         )
@@ -483,17 +429,6 @@ class WorkspaceInvitationsViewset(BaseViewSet):
                 user.delete()
         workspace_member_invite.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
-        except WorkspaceMemberInvite.DoesNotExist:
-            return Response(
-                {"error": "Workspace member invite 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 UserWorkspaceInvitationsEndpoint(BaseViewSet):
@@ -510,11 +445,8 @@ class UserWorkspaceInvitationsEndpoint(BaseViewSet):
         )
 
     def create(self, request):
-        try:
         invitations = request.data.get("invitations")
-            workspace_invitations = WorkspaceMemberInvite.objects.filter(
-                pk__in=invitations
-            )
+        workspace_invitations = WorkspaceMemberInvite.objects.filter(pk__in=invitations)
 
         WorkspaceMember.objects.bulk_create(
             [
@@ -533,12 +465,6 @@ class UserWorkspaceInvitationsEndpoint(BaseViewSet):
         workspace_invitations.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,
-            )
 
 
 class WorkSpaceMemberViewSet(BaseViewSet):
@@ -564,7 +490,6 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         )
 
     def partial_update(self, request, slug, pk):
-        try:
         workspace_member = WorkspaceMember.objects.get(pk=pk, workspace__slug=slug)
         if request.user.id == workspace_member.member_id:
             return Response(
@@ -584,9 +509,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
             > requested_workspace_member.role
         ):
             return Response(
-                    {
-                        "error": "You cannot update a role that is higher than your own role"
-                    },
+                {"error": "You cannot update a role that is higher than your own role"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
@@ -598,20 +521,8 @@ class WorkSpaceMemberViewSet(BaseViewSet):
             serializer.save()
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except WorkspaceMember.DoesNotExist:
-            return Response(
-                {"error": "Workspace Member 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, pk):
-        try:
         # Check the user role who is deleting the user
         workspace_member = WorkspaceMember.objects.get(workspace__slug=slug, pk=pk)
 
@@ -676,17 +587,6 @@ class WorkSpaceMemberViewSet(BaseViewSet):
 
         workspace_member.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
-        except WorkspaceMember.DoesNotExist:
-            return Response(
-                {"error": "Workspace Member 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 TeamMemberViewSet(BaseViewSet):
@@ -711,7 +611,6 @@ class TeamMemberViewSet(BaseViewSet):
         )
 
     def create(self, request, slug):
-        try:
         members = list(
             WorkspaceMember.objects.filter(
                 workspace__slug=slug, member__id__in=request.data.get("members", [])
@@ -736,25 +635,11 @@ class TeamMemberViewSet(BaseViewSet):
 
         workspace = Workspace.objects.get(slug=slug)
 
-            serializer = TeamSerializer(
-                data=request.data, context={"workspace": workspace}
-            )
+        serializer = TeamSerializer(data=request.data, context={"workspace": workspace})
         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 IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"error": "The team with the name already exists"},
-                    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,
-            )
 
 
 class UserWorkspaceInvitationEndpoint(BaseViewSet):
@@ -776,7 +661,6 @@ class UserWorkspaceInvitationEndpoint(BaseViewSet):
 
 class UserLastProjectWithWorkspaceEndpoint(BaseAPIView):
     def get(self, request):
-        try:
         user = User.objects.get(pk=request.user.id)
 
         last_workspace_id = user.last_workspace_id
@@ -797,9 +681,7 @@ class UserLastProjectWithWorkspaceEndpoint(BaseAPIView):
             workspace_id=last_workspace_id, member=request.user
         ).select_related("workspace", "project", "member", "workspace__owner")
 
-            project_member_serializer = ProjectMemberSerializer(
-                project_member, many=True
-            )
+        project_member_serializer = ProjectMemberSerializer(project_member, many=True)
 
         return Response(
             {
@@ -809,37 +691,18 @@ class UserLastProjectWithWorkspaceEndpoint(BaseAPIView):
             status=status.HTTP_200_OK,
         )
 
-        except User.DoesNotExist:
-            return Response({"error": "Forbidden"}, status=status.HTTP_403_FORBIDDEN)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
 
 class WorkspaceMemberUserEndpoint(BaseAPIView):
     def get(self, request, slug):
-        try:
         workspace_member = WorkspaceMember.objects.get(
             member=request.user, workspace__slug=slug
         )
-            serializer = WorkSpaceMemberSerializer(workspace_member)
+        serializer = WorkspaceMemberMeSerializer(workspace_member)
         return Response(serializer.data, status=status.HTTP_200_OK)
-        except (Workspace.DoesNotExist, WorkspaceMember.DoesNotExist):
-            return Response({"error": "Forbidden"}, status=status.HTTP_403_FORBIDDEN)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
 
 
 class WorkspaceMemberUserViewsEndpoint(BaseAPIView):
     def post(self, request, slug):
-        try:
         workspace_member = WorkspaceMember.objects.get(
             workspace__slug=slug, member=request.user
         )
@@ -847,22 +710,10 @@ class WorkspaceMemberUserViewsEndpoint(BaseAPIView):
         workspace_member.save()
 
         return Response(status=status.HTTP_204_NO_CONTENT)
-        except WorkspaceMember.DoesNotExist:
-            return Response(
-                {"error": "User not a member of workspace"},
-                status=status.HTTP_403_FORBIDDEN,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
 
 
 class UserActivityGraphEndpoint(BaseAPIView):
     def get(self, request, slug):
-        try:
         issue_activities = (
             IssueActivity.objects.filter(
                 actor=request.user,
@@ -876,17 +727,10 @@ class UserActivityGraphEndpoint(BaseAPIView):
         )
 
         return Response(issue_activities, 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 UserIssueCompletedGraphEndpoint(BaseAPIView):
     def get(self, request, slug):
-        try:
         month = request.GET.get("month", 1)
 
         issues = (
@@ -904,12 +748,6 @@ class UserIssueCompletedGraphEndpoint(BaseAPIView):
         )
 
         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 WeekInMonth(Func):
@@ -919,7 +757,6 @@ class WeekInMonth(Func):
 
 class UserWorkspaceDashboardEndpoint(BaseAPIView):
     def get(self, request, slug):
-        try:
         issue_activities = (
             IssueActivity.objects.filter(
                 actor=request.user,
@@ -1015,13 +852,6 @@ class UserWorkspaceDashboardEndpoint(BaseAPIView):
             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 WorkspaceThemeViewSet(BaseViewSet):
     permission_classes = [
@@ -1034,29 +864,16 @@ class WorkspaceThemeViewSet(BaseViewSet):
         return super().get_queryset().filter(workspace__slug=self.kwargs.get("slug"))
 
     def create(self, request, slug):
-        try:
         workspace = Workspace.objects.get(slug=slug)
         serializer = WorkspaceThemeSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save(workspace=workspace, actor=request.user)
             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,
-            )
 
 
 class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
     def get(self, request, slug, user_id):
-        try:
         filters = issue_filters(request.query_params, "GET")
 
         state_distribution = (
@@ -1179,12 +996,6 @@ class WorkspaceUserProfileStatsEndpoint(BaseAPIView):
                 "upcoming_cycles": upcoming_cycles,
             }
         )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
 
 
 class WorkspaceUserActivityEndpoint(BaseAPIView):
@@ -1193,7 +1004,6 @@ class WorkspaceUserActivityEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug, user_id):
-        try:
         projects = request.query_params.getlist("project", [])
 
         queryset = IssueActivity.objects.filter(
@@ -1213,17 +1023,10 @@ class WorkspaceUserActivityEndpoint(BaseAPIView):
                 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,
-            )
 
 
 class WorkspaceUserProfileEndpoint(BaseAPIView):
     def get(self, request, slug, user_id):
-        try:
         user_data = User.objects.get(pk=user_id)
 
         requesting_workspace_member = WorkspaceMember.objects.get(
@@ -1311,14 +1114,6 @@ class WorkspaceUserProfileEndpoint(BaseAPIView):
             },
             status=status.HTTP_200_OK,
         )
-        except WorkspaceMember.DoesNotExist:
-            return Response({"error": "Forbidden"}, status=status.HTTP_403_FORBIDDEN)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
 
 
 class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
@@ -1327,7 +1122,6 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug, user_id):
-        try:
         filters = issue_filters(request.query_params, "GET")
 
         # Custom ordering for priority and state
@@ -1366,9 +1160,7 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
                 .values("count")
             )
             .annotate(
-                    attachment_count=IssueAttachment.objects.filter(
-                        issue=OuterRef("id")
-                    )
+                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
                 .order_by()
                 .annotate(count=Func(F("id"), function="Count"))
                 .values("count")
@@ -1378,9 +1170,7 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
         # 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]
+                priority_order if order_by_param == "priority" else priority_order[::-1]
             )
             issue_queryset = issue_queryset.annotate(
                 priority_order=Case(
@@ -1438,16 +1228,14 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
         ## Grouping the results
         group_by = request.GET.get("group_by", False)
         if group_by:
+            grouped_results = group_results(issues, group_by)
             return Response(
-                    group_results(issues, group_by), status=status.HTTP_200_OK
+                grouped_results,
+                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,
+            issues, status=status.HTTP_200_OK
         )
 
 
@@ -1457,18 +1245,11 @@ class WorkspaceLabelsEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug):
-        try:
         labels = Label.objects.filter(
             workspace__slug=slug,
             project__project_projectmember__member=request.user,
         ).values("parent", "name", "color", "id", "project_id", "workspace__slug")
         return Response(labels, 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 WorkspaceMembersEndpoint(BaseAPIView):
@@ -1477,19 +1258,12 @@ class WorkspaceMembersEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug):
-        try:
         workspace_members = WorkspaceMember.objects.filter(
             workspace__slug=slug,
             member__is_bot=False,
         ).select_related("workspace", "member")
         serialzier = WorkSpaceMemberSerializer(workspace_members, many=True)
         return Response(serialzier.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 LeaveWorkspaceEndpoint(BaseAPIView):
@@ -1498,7 +1272,6 @@ class LeaveWorkspaceEndpoint(BaseAPIView):
     ]
 
     def delete(self, request, slug):
-        try:
         workspace_member = WorkspaceMember.objects.get(
             workspace__slug=slug, member=request.user
         )
@@ -1506,9 +1279,7 @@ class LeaveWorkspaceEndpoint(BaseAPIView):
         # Only Admin case
         if (
             workspace_member.role == 20
-                and WorkspaceMember.objects.filter(
-                    workspace__slug=slug, role=20
-                ).count()
+            and WorkspaceMember.objects.filter(workspace__slug=slug, role=20).count()
             == 1
         ):
             return Response(
@@ -1520,14 +1291,3 @@ class LeaveWorkspaceEndpoint(BaseAPIView):
         # Delete the member from workspace
         workspace_member.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
-        except WorkspaceMember.DoesNotExist:
-            return Response(
-                {"error": "Workspace member 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/bgtasks/analytic_plot_export.py

@@ -20,8 +20,8 @@ from plane.utils.issue_filters import issue_filters
 row_mapping = {
     "state__name": "State",
     "state__group": "State Group",
-    "labels__name": "Label",
-    "assignees__display_name": "Assignee Name",
+    "labels__id": "Label",
+    "assignees__id": "Assignee Name",
     "start_date": "Start Date",
     "target_date": "Due Date",
     "completed_at": "Completed At",
@@ -29,8 +29,321 @@ row_mapping = {
     "issue_count": "Issue Count",
     "priority": "Priority",
     "estimate": "Estimate",
+    "issue_cycle__cycle_id": "Cycle",
+    "issue_module__module_id": "Module"
 }
 
+ASSIGNEE_ID = "assignees__id"
+LABEL_ID = "labels__id"
+STATE_ID = "state_id"
+CYCLE_ID = "issue_cycle__cycle_id"
+MODULE_ID = "issue_module__module_id"
+
+
+def send_export_email(email, slug, csv_buffer):
+    """Helper function to send export email."""
+    subject = "Your Export is ready"
+    html_content = render_to_string("emails/exports/analytics.html", {})
+    text_content = strip_tags(html_content)
+
+    csv_buffer.seek(0)
+    msg = EmailMultiAlternatives(subject, text_content, settings.EMAIL_FROM, [email])
+    msg.attach(f"{slug}-analytics.csv", csv_buffer.getvalue())
+    msg.send(fail_silently=False)
+
+
+def get_assignee_details(slug, filters):
+    """Fetch assignee details if required."""
+    return (
+        Issue.issue_objects.filter(
+            workspace__slug=slug, **filters, assignees__avatar__isnull=False
+        )
+        .distinct("assignees__id")
+        .order_by("assignees__id")
+        .values(
+            "assignees__avatar",
+            "assignees__display_name",
+            "assignees__first_name",
+            "assignees__last_name",
+            "assignees__id",
+        )
+    )
+
+
+def get_label_details(slug, filters):
+    """Fetch label details if required"""
+    return (
+        Issue.objects.filter(workspace__slug=slug, **filters, labels__id__isnull=False)
+        .distinct("labels__id")
+        .order_by("labels__id")
+        .values("labels__id", "labels__color", "labels__name")
+    )
+
+
+def get_state_details(slug, filters):
+    return (
+        Issue.issue_objects.filter(
+            workspace__slug=slug,
+            **filters,
+        )
+        .distinct("state_id")
+        .order_by("state_id")
+        .values("state_id", "state__name", "state__color")
+    )
+
+
+def get_module_details(slug, filters):
+    return (
+        Issue.issue_objects.filter(
+            workspace__slug=slug,
+            **filters,
+            issue_module__module_id__isnull=False,
+        )
+        .distinct("issue_module__module_id")
+        .order_by("issue_module__module_id")
+        .values(
+            "issue_module__module_id",
+            "issue_module__module__name",
+        )
+    )
+
+
+def get_cycle_details(slug, filters):
+    return (
+        Issue.issue_objects.filter(
+            workspace__slug=slug,
+            **filters,
+            issue_cycle__cycle_id__isnull=False,
+        )
+        .distinct("issue_cycle__cycle_id")
+        .order_by("issue_cycle__cycle_id")
+        .values(
+            "issue_cycle__cycle_id",
+            "issue_cycle__cycle__name",
+        )
+    )
+
+
+def generate_csv_from_rows(rows):
+    """Generate CSV buffer from rows."""
+    csv_buffer = io.StringIO()
+    writer = csv.writer(csv_buffer, delimiter=",", quoting=csv.QUOTE_ALL)
+    [writer.writerow(row) for row in rows]
+    return csv_buffer
+
+
+def generate_segmented_rows(
+    distribution,
+    x_axis,
+    y_axis,
+    segment,
+    key,
+    assignee_details,
+    label_details,
+    state_details,
+    cycle_details,
+    module_details,
+):
+    segment_zero = list(
+        set(
+            item.get("segment") for sublist in distribution.values() for item in sublist
+        )
+    )
+
+    segmented = segment
+
+    row_zero = [
+        row_mapping.get(x_axis, "X-Axis"),
+        row_mapping.get(y_axis, "Y-Axis"),
+    ] + segment_zero
+
+    rows = []
+    for item, data in distribution.items():
+        generated_row = [
+            item,
+            sum(obj.get(key) for obj in data if obj.get(key) is not None),
+        ]
+
+        for segment in segment_zero:
+            value = next((x.get(key) for x in data if x.get("segment") == segment), "0")
+            generated_row.append(value)
+
+        if x_axis == ASSIGNEE_ID:
+            assignee = next(
+                (
+                    user
+                    for user in assignee_details
+                    if str(user[ASSIGNEE_ID]) == str(item)
+                ),
+                None,
+            )
+            if assignee:
+                generated_row[
+                    0
+                ] = f"{assignee['assignees__first_name']} {assignee['assignees__last_name']}"
+
+        if x_axis == LABEL_ID:
+            label = next(
+                (lab for lab in label_details if str(lab[LABEL_ID]) == str(item)),
+                None,
+            )
+
+            if label:
+                generated_row[0] = f"{label['labels__name']}"
+
+        if x_axis == STATE_ID:
+            state = next(
+                (sta for sta in state_details if str(sta[STATE_ID]) == str(item)),
+                None,
+            )
+
+            if state:
+                generated_row[0] = f"{state['state__name']}"
+
+        if x_axis == CYCLE_ID:
+            cycle = next(
+                (cyc for cyc in cycle_details if str(cyc[CYCLE_ID]) == str(item)),
+                None,
+            )
+
+            if cycle:
+                generated_row[0] = f"{cycle['issue_cycle__cycle__name']}"
+
+        if x_axis == MODULE_ID:
+            module = next(
+                (mod for mod in module_details if str(mod[MODULE_ID]) == str(item)),
+                None,
+            )
+
+            if module:
+                generated_row[0] = f"{module['issue_module__module__name']}"
+
+        rows.append(tuple(generated_row))
+
+    if segmented == ASSIGNEE_ID:
+        for index, segm in enumerate(row_zero[2:]):
+            assignee = next(
+                (
+                    user
+                    for user in assignee_details
+                    if str(user[ASSIGNEE_ID]) == str(segm)
+                ),
+                None,
+            )
+            if assignee:
+                row_zero[
+                    index + 2
+                ] = f"{assignee['assignees__first_name']} {assignee['assignees__last_name']}"
+
+    if segmented == LABEL_ID:
+        for index, segm in enumerate(row_zero[2:]):
+            label = next(
+                (lab for lab in label_details if str(lab[LABEL_ID]) == str(segm)),
+                None,
+            )
+            if label:
+                row_zero[index + 2] = label["labels__name"]
+
+    if segmented == STATE_ID:
+        for index, segm in enumerate(row_zero[2:]):
+            state = next(
+                (sta for sta in state_details if str(sta[STATE_ID]) == str(segm)),
+                None,
+            )
+            if state:
+                row_zero[index + 2] = state["state__name"]
+
+    if segmented == MODULE_ID:
+        for index, segm in enumerate(row_zero[2:]):
+            module = next(
+                (mod for mod in label_details if str(mod[MODULE_ID]) == str(segm)),
+                None,
+            )
+            if module:
+                row_zero[index + 2] = module["issue_module__module__name"]
+
+    if segmented == CYCLE_ID:
+        for index, segm in enumerate(row_zero[2:]):
+            cycle = next(
+                (cyc for cyc in cycle_details if str(cyc[CYCLE_ID]) == str(segm)),
+                None,
+            )
+            if cycle:
+                row_zero[index + 2] = cycle["issue_cycle__cycle__name"]
+
+    return [tuple(row_zero)] + rows
+
+
+def generate_non_segmented_rows(
+    distribution,
+    x_axis,
+    y_axis,
+    key,
+    assignee_details,
+    label_details,
+    state_details,
+    cycle_details,
+    module_details,
+):
+    rows = []
+    for item, data in distribution.items():
+        row = [item, data[0].get("count" if y_axis == "issue_count" else "estimate")]
+
+        if x_axis == ASSIGNEE_ID:
+            assignee = next(
+                (
+                    user
+                    for user in assignee_details
+                    if str(user[ASSIGNEE_ID]) == str(item)
+                ),
+                None,
+            )
+            if assignee:
+                row[
+                    0
+                ] = f"{assignee['assignees__first_name']} {assignee['assignees__last_name']}"
+
+        if x_axis == LABEL_ID:
+            label = next(
+                (lab for lab in label_details if str(lab[LABEL_ID]) == str(item)),
+                None,
+            )
+
+            if label:
+                row[0] = f"{label['labels__name']}"
+
+        if x_axis == STATE_ID:
+            state = next(
+                (sta for sta in state_details if str(sta[STATE_ID]) == str(item)),
+                None,
+            )
+
+            if state:
+                row[0] = f"{state['state__name']}"
+
+        if x_axis == CYCLE_ID:
+            cycle = next(
+                (cyc for cyc in cycle_details if str(cyc[CYCLE_ID]) == str(item)),
+                None,
+            )
+
+            if cycle:
+                row[0] = f"{cycle['issue_cycle__cycle__name']}"
+
+        if x_axis == MODULE_ID:
+            module = next(
+                (mod for mod in module_details if str(mod[MODULE_ID]) == str(item)),
+                None,
+            )
+
+            if module:
+                row[0] = f"{module['issue_module__module__name']}"
+
+        rows.append(tuple(row))
+
+    row_zero = [row_mapping.get(x_axis, "X-Axis"), row_mapping.get(y_axis, "Y-Axis")]
+    return [tuple(row_zero)] + rows
+
 
 @shared_task
 def analytic_export_task(email, data, slug):
@@ -43,134 +356,70 @@ def analytic_export_task(email, data, slug):
         segment = data.get("segment", False)
 
         distribution = build_graph_plot(
-            queryset=queryset, x_axis=x_axis, y_axis=y_axis, segment=segment
+            queryset, x_axis=x_axis, y_axis=y_axis, segment=segment
         )
-
         key = "count" if y_axis == "issue_count" else "estimate"
 
-        segmented = segment
-
-        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")
+            get_assignee_details(slug, filters)
+            if x_axis == ASSIGNEE_ID or segment == ASSIGNEE_ID
+            else {}
+        )
+
+        label_details = (
+            get_label_details(slug, filters)
+            if x_axis == LABEL_ID or segment == LABEL_ID
+            else {}
+        )
+
+        state_details = (
+            get_state_details(slug, filters)
+            if x_axis == STATE_ID or segment == STATE_ID
+            else {}
+        )
+
+        cycle_details = (
+            get_cycle_details(slug, filters)
+            if x_axis == CYCLE_ID or segment == CYCLE_ID
+            else {}
+        )
+
+        module_details = (
+            get_module_details(slug, filters)
+            if x_axis == MODULE_ID or segment == MODULE_ID
+            else {}
         )
 
         if segment:
-            segment_zero = []
-            for item in distribution:
-                current_dict = distribution.get(item)
-                for current in current_dict:
-                    segment_zero.append(current.get("segment"))
-
-            segment_zero = list(set(segment_zero))
-            row_zero = (
-                [
-                    row_mapping.get(x_axis, "X-Axis"),
-                ]
-                + [
-                    row_mapping.get(y_axis, "Y-Axis"),
-                ]
-                + segment_zero
+            rows = generate_segmented_rows(
+                distribution,
+                x_axis,
+                y_axis,
+                segment,
+                key,
+                assignee_details,
+                label_details,
+                state_details,
+                cycle_details,
+                module_details,
             )
-            rows = []
-            for item in distribution:
-                generated_row = [
-                    item,
-                ]
-
-                data = distribution.get(item)
-                # Add y axis values
-                generated_row.append(sum(obj.get(key) for obj in data if obj.get(key, None) is not None))
-
-                for segment in segment_zero:
-                    value = [x for x in data if x.get("segment") == segment]
-                    if len(value):
-                        generated_row.append(value[0].get(key))
         else:
-                        generated_row.append("0")
-                # x-axis replacement for names
-                if x_axis in ["assignees__id"]:
-                    assignee = [user for user in assignee_details if str(user.get("assignees__id")) == str(item)]
-                    if len(assignee):
-                        generated_row[0] = str(assignee[0].get("assignees__first_name")) + " " + str(assignee[0].get("assignees__last_name"))
-                rows.append(tuple(generated_row))
-
-            # If segment is ["assignees__display_name"] then replace segment_zero rows with first and last names
-            if segmented in ["assignees__id"]:
-                for index, segm in enumerate(row_zero[2:]):
-                    # find the name of the user
-                    assignee = [user for user in assignee_details if str(user.get("assignees__id")) == str(segm)]
-                    if len(assignee):
-                        row_zero[index + 2] = str(assignee[0].get("assignees__first_name")) + " " + str(assignee[0].get("assignees__last_name"))
-
-            rows = [tuple(row_zero)] + rows
-            csv_buffer = io.StringIO()
-            writer = csv.writer(csv_buffer, delimiter=",", quoting=csv.QUOTE_ALL)
-
-            # Write CSV data to the buffer
-            for row in rows:
-                writer.writerow(row)
-
-            subject = "Your Export is ready"
-
-            html_content = render_to_string("emails/exports/analytics.html", {})
-
-            text_content = strip_tags(html_content)
-            csv_buffer.seek(0)
-            msg = EmailMultiAlternatives(
-                subject, text_content, settings.EMAIL_FROM, [email]
+            rows = generate_non_segmented_rows(
+                distribution,
+                x_axis,
+                y_axis,
+                segment,
+                key,
+                assignee_details,
+                label_details,
+                state_details,
+                cycle_details,
+                module_details,
             )
-            msg.attach(f"{slug}-analytics.csv", csv_buffer.read())
-            msg.send(fail_silently=False)
-
-        else:
-            row_zero = [
-                row_mapping.get(x_axis, "X-Axis"),
-                row_mapping.get(y_axis, "Y-Axis"),
-            ]
-            rows = []
-            for item in distribution:
-                row =  [
-                            item,
-                            distribution.get(item)[0].get("count")
-                            if y_axis == "issue_count"
-                            else distribution.get(item)[0].get("estimate  "),
-                        ]
-                # x-axis replacement to names
-                if x_axis in ["assignees__id"]:
-                    assignee = [user for user in assignee_details if str(user.get("assignees__id")) == str(item)]
-                    if len(assignee):
-                        row[0] = str(assignee[0].get("assignees__first_name")) + " " + str(assignee[0].get("assignees__last_name"))
-
-                rows.append(tuple(row))
-            rows = [tuple(row_zero)] + rows
-            csv_buffer = io.StringIO()
-            writer = csv.writer(csv_buffer, delimiter=",", quoting=csv.QUOTE_ALL)
-
-            # Write CSV data to the buffer
-            for row in rows:
-                writer.writerow(row)
-
-            subject = "Your Export is ready"
-
-            html_content = render_to_string("emails/exports/analytics.html", {})
-
-            text_content = strip_tags(html_content)
-
-            csv_buffer.seek(0)
-            msg = EmailMultiAlternatives(
-                subject, text_content, settings.EMAIL_FROM, [email]
-            )
-            msg.attach(f"{slug}-analytics.csv", csv_buffer.read())
-            msg.send(fail_silently=False)
 
+        csv_buffer = generate_csv_from_rows(rows)
+        send_export_email(email, slug, csv_buffer)
     except Exception as e:
-        # Print logs if in DEBUG mode
         if settings.DEBUG:
             print(e)
         capture_exception(e)
-        return

apiserver/plane/bgtasks/forgot_password_task.py

@@ -16,7 +16,7 @@ from plane.db.models import User
 def forgot_password(first_name, email, uidb64, token, current_site):
 
     try:
-        realtivelink = f"/reset-password/?uidb64={uidb64}&token={token}"
+        realtivelink = f"/accounts/reset-password/?uidb64={uidb64}&token={token}"
         abs_url = current_site + realtivelink
 
         from_email_string = settings.EMAIL_FROM

apiserver/plane/bgtasks/importer_task.py

@@ -25,6 +25,7 @@ from plane.db.models import (
     WorkspaceIntegration,
     Label,
     User,
+    IssueProperty,
 )
 from .workspace_invitation_task import workspace_invitation
 from plane.bgtasks.user_welcome_task import send_welcome_slack
@@ -103,6 +104,20 @@ def service_importer(service, importer_id):
                 ignore_conflicts=True,
             )
 
+            IssueProperty.objects.bulk_create(
+                [
+                    IssueProperty(
+                        project_id=importer.project_id,
+                        workspace_id=importer.workspace_id,
+                        user=user,
+                        created_by=importer.created_by,
+                    )
+                    for user in workspace_users
+                ],
+                batch_size=100,
+                ignore_conflicts=True,
+            )
+
         # Check if sync config is on for github importers
         if service == "github" and importer.config.get("sync", False):
             name = importer.metadata.get("name", False)

apiserver/plane/bgtasks/notification_task.py

@@ -0,0 +1,102 @@
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+
+# Module imports
+from plane.db.models import IssueSubscriber, Project, IssueAssignee, Issue, Notification
+
+# Third Party imports
+from celery import shared_task
+
+
+@shared_task
+def notifications(type, issue_id, project_id, actor_id, subscriber, issue_activities_created):
+    issue_activities_created = (
+        json.loads(issue_activities_created) if issue_activities_created is not None else None
+    )
+    if type not in [
+        "cycle.activity.created",
+        "cycle.activity.deleted",
+        "module.activity.created",
+        "module.activity.deleted",
+        "issue_reaction.activity.created",
+        "issue_reaction.activity.deleted",
+        "comment_reaction.activity.created",
+        "comment_reaction.activity.deleted",
+        "issue_vote.activity.created",
+        "issue_vote.activity.deleted",
+        "issue_draft.activity.created",
+        "issue_draft.activity.updated",
+        "issue_draft.activity.deleted",
+    ]:
+        # Create Notifications
+        bulk_notifications = []
+        issue_subscribers = list(
+            IssueSubscriber.objects.filter(project_id=project_id, issue_id=issue_id)
+            .exclude(subscriber_id=actor_id)
+            .values_list("subscriber", flat=True)
+        )
+
+        issue_assignees = list(
+            IssueAssignee.objects.filter(project_id=project_id, issue_id=issue_id)
+            .exclude(assignee_id=actor_id)
+            .values_list("assignee", flat=True)
+        )
+
+        issue_subscribers = issue_subscribers + issue_assignees
+
+        issue = Issue.objects.filter(pk=issue_id).first()
+
+        if subscriber:
+            # add the user to issue subscriber
+            try:
+                _ = IssueSubscriber.objects.get_or_create(
+                    issue_id=issue_id, subscriber_id=actor_id
+                )
+            except Exception as e:
+                pass
+
+        project = Project.objects.get(pk=project_id)
+
+        for subscriber in list(set(issue_subscribers)):
+            for issue_activity in issue_activities_created:
+                bulk_notifications.append(
+                    Notification(
+                        workspace=project.workspace,
+                        sender="in_app:issue_activities",
+                        triggered_by_id=actor_id,
+                        receiver_id=subscriber,
+                        entity_identifier=issue_id,
+                        entity_name="issue",
+                        project=project,
+                        title=issue_activity.get("comment"),
+                        data={
+                            "issue": {
+                                "id": str(issue_id),
+                                "name": str(issue.name),
+                                "identifier": str(issue.project.identifier),
+                                "sequence_id": issue.sequence_id,
+                                "state_name": issue.state.name,
+                                "state_group": issue.state.group,
+                            },
+                            "issue_activity": {
+                                "id": str(issue_activity.get("id")),
+                                "verb": str(issue_activity.get("verb")),
+                                "field": str(issue_activity.get("field")),
+                                "actor": str(issue_activity.get("actor_id")),
+                                "new_value": str(issue_activity.get("new_value")),
+                                "old_value": str(issue_activity.get("old_value")),
+                                "issue_comment": str(
+                                    issue_activity.get("issue_comment").comment_stripped
+                                    if issue_activity.get("issue_comment") is not None
+                                    else ""
+                                ),
+                            },
+                        },
+                    )
+                )
+
+        # Bulk create notifications
+        Notification.objects.bulk_create(bulk_notifications, batch_size=100)

apiserver/plane/db/migrations/0046_alter_analyticview_created_by_and_more.py

@@ -0,0 +1,21 @@
+# Generated by Django 4.2.5 on 2023-10-18 12:04
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import plane.db.models.issue
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('db', '0045_issueactivity_epoch_workspacemember_issue_props_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='issueproperty',
+            name='properties',
+            field=models.JSONField(default=plane.db.models.issue.get_default_properties),
+        ),
+    ]

apiserver/plane/db/models/issue.py

@@ -16,6 +16,24 @@ from . import ProjectBaseModel
 from plane.utils.html_processor import strip_tags
 
 
+def get_default_properties():
+    return {
+        "assignee": True,
+        "start_date": True,
+        "due_date": True,
+        "labels": True,
+        "key": True,
+        "priority": True,
+        "state": True,
+        "sub_issue_count": True,
+        "link": True,
+        "attachment_count": True,
+        "estimate": True,
+        "created_on": True,
+        "updated_on": True,
+    }
+
+
 # TODO: Handle identifiers for Bulk Inserts - nk
 class IssueManager(models.Manager):
     def get_queryset(self):
@@ -39,7 +57,7 @@ class Issue(ProjectBaseModel):
         ("high", "High"),
         ("medium", "Medium"),
         ("low", "Low"),
-        ("none", "None")
+        ("none", "None"),
     )
     parent = models.ForeignKey(
         "self",
@@ -327,7 +345,9 @@ class IssueComment(ProjectBaseModel):
     comment_json = models.JSONField(blank=True, default=dict)
     comment_html = models.TextField(blank=True, default="<p></p>")
     attachments = ArrayField(models.URLField(), size=10, blank=True, default=list)
-    issue = models.ForeignKey(Issue, on_delete=models.CASCADE, related_name="issue_comments")
+    issue = models.ForeignKey(
+        Issue, on_delete=models.CASCADE, related_name="issue_comments"
+    )
     # System can also create comment
     actor = models.ForeignKey(
         settings.AUTH_USER_MODEL,
@@ -367,7 +387,7 @@ class IssueProperty(ProjectBaseModel):
         on_delete=models.CASCADE,
         related_name="issue_property_user",
     )
-    properties = models.JSONField(default=dict)
+    properties = models.JSONField(default=get_default_properties)
 
     class Meta:
         verbose_name = "Issue Property"
@@ -515,7 +535,10 @@ class IssueVote(ProjectBaseModel):
     )
 
     class Meta:
-        unique_together = ["issue", "actor",]
+        unique_together = [
+            "issue",
+            "actor",
+        ]
         verbose_name = "Issue Vote"
         verbose_name_plural = "Issue Votes"
         db_table = "issue_votes"

apiserver/plane/settings/local.py

@@ -12,6 +12,10 @@ from .common import *  # noqa
 
 DEBUG = int(os.environ.get("DEBUG", 1)) == 1
 
+ALLOWED_HOSTS = [
+    "*",
+]
+
 EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"
 
 

apiserver/plane/settings/production.py

@@ -14,19 +14,21 @@ from .common import *  # noqa
 # Database
 DEBUG = int(os.environ.get("DEBUG", 0)) == 1
 
-DATABASES = {
+if bool(os.environ.get("DATABASE_URL")):
+    # Parse database configuration from $DATABASE_URL
+    DATABASES["default"] = dj_database_url.config()
+else:
+    DATABASES = {
         "default": {
             "ENGINE": "django.db.backends.postgresql",
-        "NAME": "plane",
-        "USER": os.environ.get("PGUSER", ""),
-        "PASSWORD": os.environ.get("PGPASSWORD", ""),
-        "HOST": os.environ.get("PGHOST", ""),
+            "NAME": os.environ.get("POSTGRES_DB"),
+            "USER": os.environ.get("POSTGRES_USER"),
+            "PASSWORD": os.environ.get("POSTGRES_PASSWORD"),
+            "HOST": os.environ.get("POSTGRES_HOST"),
+        }
     }
-}
 
 
-# Parse database configuration from $DATABASE_URL
-DATABASES["default"] = dj_database_url.config()
 SITE_ID = 1
 
 # Set the variable true if running in docker environment
@@ -278,4 +280,3 @@ SCOUT_NAME = "Plane"
 
 # Unsplash Access key
 UNSPLASH_ACCESS_KEY = os.environ.get("UNSPLASH_ACCESS_KEY")
-

apiserver/plane/utils/analytics_plot.py

@@ -12,34 +12,47 @@ from django.db.models.functions import Coalesce, ExtractMonth, ExtractYear, Conc
 from plane.db.models import Issue
 
 
-def build_graph_plot(queryset, x_axis, y_axis, segment=None):
-
-    temp_axis = x_axis
-
-    if x_axis in ["created_at", "start_date", "target_date", "completed_at"]:
-        year = ExtractYear(x_axis)
-        month = ExtractMonth(x_axis)
+def annotate_with_monthly_dimension(queryset, field_name):
+    # Get the year and the months
+    year = ExtractYear(field_name)
+    month = ExtractMonth(field_name)
+    # Concat the year and month
     dimension = Concat(year, Value("-"), month, output_field=CharField())
-        queryset = queryset.annotate(dimension=dimension)
-        x_axis = "dimension"
+    # Annotate the dimension
+    return queryset.annotate(dimension=dimension)
+
+def extract_axis(queryset, x_axis):
+    # Format the dimension when the axis is in date
+    if x_axis in ["created_at", "start_date", "target_date", "completed_at"]:
+        queryset = annotate_with_monthly_dimension(queryset, x_axis)
+        return queryset, "dimension"
     else:
-        queryset = queryset.annotate(dimension=F(x_axis))
-        x_axis = "dimension"
+        return queryset.annotate(dimension=F(x_axis)), "dimension"
 
-    if x_axis in ["created_at", "start_date", "target_date", "completed_at"]:
-        queryset = queryset.exclude(x_axis__is_null=True)
+def sort_data(data, temp_axis):
+    # When the axis is in priority order by
+    if temp_axis == "priority":
+        order = ["low", "medium", "high", "urgent", "none"]
+        return {key: data[key] for key in order if key in data}
+    else:
+        return dict(sorted(data.items(), key=lambda x: (x[0] == "none", x[0])))
 
+def build_graph_plot(queryset, x_axis, y_axis, segment=None):
+    # temp x_axis
+    temp_axis = x_axis
+    # Extract the x_axis and queryset
+    queryset, x_axis = extract_axis(queryset, x_axis)
+    if x_axis == "dimension":
+        queryset = queryset.exclude(dimension__isnull=True)
+
+    # 
     if segment in ["created_at", "start_date", "target_date", "completed_at"]:
-        year = ExtractYear(segment)
-        month = ExtractMonth(segment)
-        dimension = Concat(year, Value("-"), month, output_field=CharField())
-        queryset = queryset.annotate(segmented=dimension)
+        queryset = annotate_with_monthly_dimension(queryset, segment)
         segment = "segmented"
 
     queryset = queryset.values(x_axis)
 
-    # Group queryset by x_axis field
-
+    # Issue count
     if y_axis == "issue_count":
         queryset = queryset.annotate(
             is_null=Case(
@@ -49,37 +62,20 @@ def build_graph_plot(queryset, x_axis, y_axis, segment=None):
             ),
             dimension_ex=Coalesce("dimension", Value("null")),
         ).values("dimension")
-        if segment:
-            queryset = queryset.annotate(segment=F(segment)).values(
-                "dimension", "segment"
-            )
-        else:
-            queryset = queryset.values("dimension")
-
+        queryset = queryset.annotate(segment=F(segment)) if segment else queryset
+        queryset = queryset.values("dimension", "segment") if segment else queryset.values("dimension")
         queryset = queryset.annotate(count=Count("*")).order_by("dimension")
 
-    if y_axis == "estimate":
-        queryset = queryset.annotate(estimate=Sum("estimate_point")).order_by(x_axis)
-        if segment:
-            queryset = queryset.annotate(segment=F(segment)).values(
-                "dimension", "segment", "estimate"
-            )
+    # Estimate
     else:
-            queryset = queryset.values("dimension", "estimate")
+        queryset = queryset.annotate(estimate=Sum("estimate_point")).order_by(x_axis)
+        queryset = queryset.annotate(segment=F(segment)) if segment else queryset
+        queryset = queryset.values("dimension", "segment", "estimate") if segment else queryset.values("dimension", "estimate")
 
     result_values = list(queryset)
-    grouped_data = {}
-    for key, items in groupby(result_values, key=lambda x: x[str("dimension")]):
-        grouped_data[str(key)] = list(items)
-
-    sorted_data = grouped_data
-    if temp_axis == "priority":
-        order = ["low", "medium", "high", "urgent", "none"]
-        sorted_data = {key: grouped_data[key] for key in order if key in grouped_data}
-    else:
-        sorted_data = dict(sorted(grouped_data.items(), key=lambda x: (x[0] == "none", x[0])))
-    return sorted_data
+    grouped_data = {str(key): list(items) for key, items in groupby(result_values, key=lambda x: x[str("dimension")])}
 
+    return sort_data(grouped_data, temp_axis)
 
 def burndown_plot(queryset, slug, project_id, cycle_id=None, module_id=None):
     # Total Issues in Cycle or Module

apiserver/plane/utils/issue_filters.py

@@ -1,10 +1,24 @@
 import re
+import uuid
 from datetime import timedelta
 from django.utils import timezone
 
+
 # The date from pattern
 pattern = re.compile(r"\d+_(weeks|months)$")
 
+# check the valid uuids
+def filter_valid_uuids(uuid_list):
+    valid_uuids = []
+    for uuid_str in uuid_list:
+        try:
+            uuid_obj = uuid.UUID(uuid_str)
+            valid_uuids.append(uuid_obj)
+        except ValueError:
+            # ignore the invalid uuids
+            pass
+    return valid_uuids
+
 
 # Get the 2_weeks, 3_months
 def string_date_filter(filter, duration, subsequent, term, date_filter, offset):
@@ -61,40 +75,41 @@ def date_filter(filter, date_term, queries):
 
 def filter_state(params, filter, method):
     if method == "GET":
-        states = params.get("state").split(",")
+        states = [item for item in params.get("state").split(",") if item != 'null']
+        states = filter_valid_uuids(states)
         if len(states) and "" not in states:
             filter["state__in"] = states
     else:
-        if params.get("state", None) and len(params.get("state")):
+        if params.get("state", None) and len(params.get("state")) and params.get("state") != 'null':
             filter["state__in"] = params.get("state")
     return filter
 
 
 def filter_state_group(params, filter, method):
     if method == "GET":
-        state_group = params.get("state_group").split(",")
+        state_group = [item for item in params.get("state_group").split(",") if item != 'null']
         if len(state_group) and "" not in state_group:
             filter["state__group__in"] = state_group
     else:
-        if params.get("state_group", None) and len(params.get("state_group")):
+        if params.get("state_group", None) and len(params.get("state_group")) and params.get("state_group") != 'null':
             filter["state__group__in"] = params.get("state_group")
     return filter
 
 
 def filter_estimate_point(params, filter, method):
     if method == "GET":
-        estimate_points = params.get("estimate_point").split(",")
+        estimate_points = [item for item in params.get("estimate_point").split(",") if item != 'null']
         if len(estimate_points) and "" not in estimate_points:
             filter["estimate_point__in"] = estimate_points
     else:
-        if params.get("estimate_point", None) and len(params.get("estimate_point")):
+        if params.get("estimate_point", None) and len(params.get("estimate_point")) and params.get("estimate_point") != 'null':
             filter["estimate_point__in"] = params.get("estimate_point")
     return filter
 
 
 def filter_priority(params, filter, method):
     if method == "GET":
-        priorities = params.get("priority").split(",")
+        priorities = [item for item in params.get("priority").split(",") if item != 'null']
         if len(priorities) and "" not in priorities:
             filter["priority__in"] = priorities
     return filter
@@ -102,44 +117,48 @@ def filter_priority(params, filter, method):
 
 def filter_parent(params, filter, method):
     if method == "GET":
-        parents = params.get("parent").split(",")
+        parents = [item for item in params.get("parent").split(",") if item != 'null']
+        parents = filter_valid_uuids(parents)
         if len(parents) and "" not in parents:
             filter["parent__in"] = parents
     else:
-        if params.get("parent", None) and len(params.get("parent")):
+        if params.get("parent", None) and len(params.get("parent")) and params.get("parent") != 'null':
             filter["parent__in"] = params.get("parent")
     return filter
 
 
 def filter_labels(params, filter, method):
     if method == "GET":
-        labels = params.get("labels").split(",")
+        labels = [item for item in params.get("labels").split(",") if item != 'null']
+        labels = filter_valid_uuids(labels)
         if len(labels) and "" not in labels:
             filter["labels__in"] = labels
     else:
-        if params.get("labels", None) and len(params.get("labels")):
+        if params.get("labels", None) and len(params.get("labels")) and params.get("labels") != 'null':
             filter["labels__in"] = params.get("labels")
     return filter
 
 
 def filter_assignees(params, filter, method):
     if method == "GET":
-        assignees = params.get("assignees").split(",")
+        assignees = [item for item in params.get("assignees").split(",") if item != 'null']
+        assignees = filter_valid_uuids(assignees)
         if len(assignees) and "" not in assignees:
             filter["assignees__in"] = assignees
     else:
-        if params.get("assignees", None) and len(params.get("assignees")):
+        if params.get("assignees", None) and len(params.get("assignees")) and params.get("assignees") != 'null':
             filter["assignees__in"] = params.get("assignees")
     return filter
 
 
 def filter_created_by(params, filter, method):
     if method == "GET":
-        created_bys = params.get("created_by").split(",")
+        created_bys = [item for item in params.get("created_by").split(",") if item != 'null']
+        created_bys = filter_valid_uuids(created_bys)
         if len(created_bys) and "" not in created_bys:
             filter["created_by__in"] = created_bys
     else:
-        if params.get("created_by", None) and len(params.get("created_by")):
+        if params.get("created_by", None) and len(params.get("created_by")) and params.get("created_by") != 'null':
             filter["created_by__in"] = params.get("created_by")
     return filter
 
@@ -187,7 +206,6 @@ def filter_target_date(params, filter, method):
     if method == "GET":
         target_dates = params.get("target_date").split(",")
         if len(target_dates) and "" not in target_dates:
-
             date_filter(filter=filter, date_term="target_date", queries=target_dates)
     else:
         if params.get("target_date", None) and len(params.get("target_date")):
@@ -220,44 +238,47 @@ def filter_issue_state_type(params, filter, method):
 
 def filter_project(params, filter, method):
     if method == "GET":
-        projects = params.get("project").split(",")
+        projects = [item for item in params.get("project").split(",") if item != 'null']
+        projects = filter_valid_uuids(projects)
         if len(projects) and "" not in projects:
             filter["project__in"] = projects
     else:
-        if params.get("project", None) and len(params.get("project")):
+        if params.get("project", None) and len(params.get("project")) and params.get("project") != 'null':
             filter["project__in"] = params.get("project")
     return filter
 
 
 def filter_cycle(params, filter, method):
     if method == "GET":
-        cycles = params.get("cycle").split(",")
+        cycles = [item for item in params.get("cycle").split(",") if item != 'null']
+        cycles = filter_valid_uuids(cycles)
         if len(cycles) and "" not in cycles:
             filter["issue_cycle__cycle_id__in"] = cycles
     else:
-        if params.get("cycle", None) and len(params.get("cycle")):
+        if params.get("cycle", None) and len(params.get("cycle")) and params.get("cycle") != 'null':
             filter["issue_cycle__cycle_id__in"] = params.get("cycle")
     return filter
 
 
 def filter_module(params, filter, method):
     if method == "GET":
-        modules = params.get("module").split(",")
+        modules = [item for item in params.get("module").split(",") if item != 'null']
+        modules = filter_valid_uuids(modules)
         if len(modules) and "" not in modules:
             filter["issue_module__module_id__in"] = modules
     else:
-        if params.get("module", None) and len(params.get("module")):
+        if params.get("module", None) and len(params.get("module")) and params.get("module") != 'null':
             filter["issue_module__module_id__in"] = params.get("module")
     return filter
 
 
 def filter_inbox_status(params, filter, method):
     if method == "GET":
-        status = params.get("inbox_status").split(",")
+        status = [item for item in params.get("inbox_status").split(",") if item != 'null']
         if len(status) and "" not in status:
             filter["issue_inbox__status__in"] = status
     else:
-        if params.get("inbox_status", None) and len(params.get("inbox_status")):
+        if params.get("inbox_status", None) and len(params.get("inbox_status")) and params.get("inbox_status") != 'null':
             filter["issue_inbox__status__in"] = params.get("inbox_status")
     return filter
 
@@ -276,11 +297,12 @@ def filter_sub_issue_toggle(params, filter, method):
 
 def filter_subscribed_issues(params, filter, method):
     if method == "GET":
-        subscribers = params.get("subscriber").split(",")
+        subscribers = [item for item in params.get("subscriber").split(",") if item != 'null']
+        subscribers = filter_valid_uuids(subscribers)
         if len(subscribers) and "" not in subscribers:
             filter["issue_subscribers__subscriber_id__in"] = subscribers
     else:
-        if params.get("subscriber", None) and len(params.get("subscriber")):
+        if params.get("subscriber", None) and len(params.get("subscriber")) and params.get("subscriber") != 'null':
             filter["issue_subscribers__subscriber_id__in"] = params.get("subscriber")
     return filter
 

apiserver/runtime.txt

@@ -1 +1 @@
-python-3.11.5
+python-3.11.6

deploy/heroku/Dockerfile

@@ -1,4 +0,0 @@
-# Deploy the Plane image
-FROM makeplane/plane
-
-LABEL maintainer="engineering@plane.so"

deploy/selfhost/docker-compose.yml

@@ -0,0 +1,168 @@
+version: "3.8"
+
+x-app-env : &app-env
+  environment:
+    - NGINX_PORT=${NGINX_PORT:-84}
+    - DEBUG=${DEBUG:-0}
+    - DJANGO_SETTINGS_MODULE=${DJANGO_SETTINGS_MODULE:-plane.settings.selfhosted}
+    - NEXT_PUBLIC_ENABLE_OAUTH=${NEXT_PUBLIC_ENABLE_OAUTH:-0}
+    - NEXT_PUBLIC_DEPLOY_URL=${NEXT_PUBLIC_DEPLOY_URL:-http://localhost/spaces}
+    - SENTRY_DSN=${SENTRY_DSN:-""}
+    - GITHUB_CLIENT_SECRET=${GITHUB_CLIENT_SECRET:-""}
+    - DOCKERIZED=${DOCKERIZED:-1}
+    #DB SETTINGS
+    - PGHOST=${PGHOST:-plane-db}
+    - PGDATABASE=${PGDATABASE:-plane}
+    - POSTGRES_USER=${POSTGRES_USER:-plane}
+    - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-plane}
+    - POSTGRES_DB=${POSTGRES_DB:-plane}
+    - PGDATA=${PGDATA:-/var/lib/postgresql/data}
+    - DATABASE_URL=${DATABASE_URL:-postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${PGHOST}/${PGDATABASE}}
+    # REDIS SETTINGS
+    - REDIS_HOST=${REDIS_HOST:-plane-redis}
+    - REDIS_PORT=${REDIS_PORT:-6379}
+    - REDIS_URL=${REDIS_URL:-redis://${REDIS_HOST}:6379/}
+    # EMAIL SETTINGS
+    - EMAIL_HOST=${EMAIL_HOST:-""}
+    - EMAIL_HOST_USER=${EMAIL_HOST_USER:-""}
+    - EMAIL_HOST_PASSWORD=${EMAIL_HOST_PASSWORD:-""}
+    - EMAIL_PORT=${EMAIL_PORT:-587}
+    - EMAIL_FROM=${EMAIL_FROM:-"Team Plane <team@mailer.plane.so>"}
+    - EMAIL_USE_TLS=${EMAIL_USE_TLS:-1}
+    - EMAIL_USE_SSL=${EMAIL_USE_SSL:-0}
+    - DEFAULT_EMAIL=${DEFAULT_EMAIL:-captain@plane.so}
+    - DEFAULT_PASSWORD=${DEFAULT_PASSWORD:-password123}
+    # OPENAI SETTINGS
+    - OPENAI_API_BASE=${OPENAI_API_BASE:-https://api.openai.com/v1}
+    - OPENAI_API_KEY=${OPENAI_API_KEY:-"sk-"}
+    - GPT_ENGINE=${GPT_ENGINE:-"gpt-3.5-turbo"}
+    # LOGIN/SIGNUP SETTINGS
+    - ENABLE_SIGNUP=${ENABLE_SIGNUP:-1}
+    - ENABLE_EMAIL_PASSWORD=${ENABLE_EMAIL_PASSWORD:-1}
+    - ENABLE_MAGIC_LINK_LOGIN=${ENABLE_MAGIC_LINK_LOGIN:-0}
+    - SECRET_KEY=${SECRET_KEY:-60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5}
+    # DATA STORE SETTINGS
+    - USE_MINIO=${USE_MINIO:-1}
+    - AWS_REGION=${AWS_REGION:-""}
+    - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-"access-key"}
+    - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-"secret-key"}
+    - AWS_S3_ENDPOINT_URL=${AWS_S3_ENDPOINT_URL:-http://plane-minio:9000}
+    - AWS_S3_BUCKET_NAME=${AWS_S3_BUCKET_NAME:-uploads}
+    - MINIO_ROOT_USER=${MINIO_ROOT_USER:-"access-key"}
+    - MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD:-"secret-key"}
+    - BUCKET_NAME=${BUCKET_NAME:-uploads}
+    - FILE_SIZE_LIMIT=${FILE_SIZE_LIMIT:-5242880}
+
+services:
+  web:
+    <<: *app-env
+    platform: linux/amd64
+    image: makeplane/plane-frontend:${APP_RELEASE:-latest}
+    restart: unless-stopped
+    command: /usr/local/bin/start.sh web/server.js web
+    deploy:
+      replicas: ${WEB_REPLICAS:-1}
+    depends_on:
+      - api
+      - worker
+
+  space:
+    <<: *app-env
+    platform: linux/amd64
+    image: makeplane/plane-space:${APP_RELEASE:-latest}
+    restart: unless-stopped
+    command: /usr/local/bin/start.sh space/server.js space
+    deploy:
+      replicas: ${SPACE_REPLICAS:-1}
+    depends_on:
+      - api
+      - worker
+      - web
+
+  api:
+    <<: *app-env
+    platform: linux/amd64
+    image: makeplane/plane-backend:${APP_RELEASE:-latest}
+    restart: unless-stopped
+    command: ./bin/takeoff
+    deploy:
+      replicas: ${API_REPLICAS:-1}
+    depends_on:
+      - plane-db
+      - plane-redis
+
+  worker:
+    <<: *app-env
+    container_name: bgworker
+    platform: linux/amd64
+    image: makeplane/plane-backend:${APP_RELEASE:-latest}
+    restart: unless-stopped
+    command: ./bin/worker
+    depends_on:
+      - api
+      - plane-db
+      - plane-redis
+
+  beat-worker:
+    <<: *app-env
+    container_name: beatworker
+    platform: linux/amd64
+    image: makeplane/plane-backend:${APP_RELEASE:-latest}
+    restart: unless-stopped
+    command: ./bin/beat
+    depends_on:
+      - api
+      - plane-db
+      - plane-redis
+
+  plane-db:
+    <<: *app-env
+    container_name: plane-db
+    image: postgres:15.2-alpine
+    restart: unless-stopped
+    command: postgres -c 'max_connections=1000'
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    
+  plane-redis:
+    <<: *app-env
+    container_name: plane-redis
+    image: redis:6.2.7-alpine
+    restart: unless-stopped
+    volumes:
+      - redisdata:/data
+
+  plane-minio:
+    <<: *app-env
+    container_name: plane-minio
+    image: minio/minio
+    restart: unless-stopped
+    command: server /export --console-address ":9090"
+    volumes:
+      - uploads:/export
+
+  createbuckets:
+    <<: *app-env
+    image: minio/mc
+    entrypoint: >
+      /bin/sh -c " /usr/bin/mc config host add plane-minio http://plane-minio:9000 \$AWS_ACCESS_KEY_ID \$AWS_SECRET_ACCESS_KEY; /usr/bin/mc mb plane-minio/\$AWS_S3_BUCKET_NAME; /usr/bin/mc anonymous set download plane-minio/\$AWS_S3_BUCKET_NAME; exit 0; "
+    depends_on:
+      - plane-minio
+
+  # Comment this if you already have a reverse proxy running
+  proxy:
+    <<: *app-env
+    container_name: proxy
+    platform: linux/amd64
+    image: makeplane/plane-proxy:${APP_RELEASE:-latest}
+    ports:
+        - ${NGINX_PORT}:80
+    depends_on:
+      - web
+      - api
+      - space
+
+volumes:
+  pgdata:
+  redisdata:
+  uploads:

deploy/selfhost/install.sh

@@ -0,0 +1,111 @@
+#!/bin/bash
+
+BRANCH=${BRANCH:-master}
+SCRIPT_DIR=$PWD
+PLANE_INSTALL_DIR=$PWD/plane-app
+mkdir -p $PLANE_INSTALL_DIR/archive
+
+function install(){
+    echo 
+    echo "Installing on $PLANE_INSTALL_DIR"
+    download
+}
+function download(){
+    cd $SCRIPT_DIR
+    TS=$(date +%s)
+    if [ -f "$PLANE_INSTALL_DIR/docker-compose.yaml" ]
+    then
+        mv $PLANE_INSTALL_DIR/docker-compose.yaml $PLANE_INSTALL_DIR/archive/$TS.docker-compose.yaml
+    fi
+
+    curl -H 'Cache-Control: no-cache, no-store' -s -o $PLANE_INSTALL_DIR/docker-compose.yaml  https://raw.githubusercontent.com/makeplane/plane/$BRANCH/deploy/selfhost/docker-compose.yml?$(date +%s)
+    curl -H 'Cache-Control: no-cache, no-store' -s -o $PLANE_INSTALL_DIR/variables-upgrade.env https://raw.githubusercontent.com/makeplane/plane/$BRANCH/deploy/selfhost/variables.env?$(date +%s)
+
+    if [ -f "$PLANE_INSTALL_DIR/.env" ];
+    then
+        cp $PLANE_INSTALL_DIR/.env $PLANE_INSTALL_DIR/archive/$TS.env
+    else
+        mv $PLANE_INSTALL_DIR/variables-upgrade.env $PLANE_INSTALL_DIR/.env
+    fi
+
+
+    echo ""
+    echo "Latest version is now available for you to use"
+    echo ""
+    echo "In case of Upgrade, your new setting file is availabe as 'variables-upgrade.env'. Please compare and set the required values in '.env 'file."
+    echo ""
+
+}
+function startServices(){
+    cd $PLANE_INSTALL_DIR
+    docker compose up -d
+    cd $SCRIPT_DIR
+}
+function stopServices(){
+    cd $PLANE_INSTALL_DIR
+    docker compose down
+    cd $SCRIPT_DIR
+}
+function restartServices(){
+    cd $PLANE_INSTALL_DIR
+    docker compose restart
+    cd $SCRIPT_DIR
+}
+function upgrade(){
+    echo "***** STOPPING SERVICES ****"
+    stopServices
+
+    echo
+    echo "***** DOWNLOADING LATEST VERSION ****"
+    download
+
+    echo "***** PLEASE VALIDATE AND START SERVICES ****"
+
+}
+function askForAction(){
+    echo
+    echo "Select a Action you want to perform:"
+    echo "   1) Install"
+    echo "   2) Start"
+    echo "   3) Stop"
+    echo "   4) Restart"
+    echo "   5) Upgrade"
+    echo "   6) Exit"
+    echo 
+    read -p "Action [2]: " ACTION
+    until [[ -z "$ACTION" || "$ACTION" =~ ^[1-6]$ ]]; do
+        echo "$ACTION: invalid selection."
+        read -p "Action [2]: " ACTION
+    done
+    echo
+
+
+    if [ "$ACTION" == "1" ]
+    then
+        install
+        askForAction
+    elif [ "$ACTION" == "2" ] || [ "$ACTION" == "" ]
+    then
+        startServices
+        askForAction
+    elif [ "$ACTION" == "3" ] 
+    then
+        stopServices
+        askForAction
+    elif [ "$ACTION" == "4" ] 
+    then
+        restartServices
+        askForAction
+    elif [ "$ACTION" == "5" ] 
+    then
+        upgrade
+        askForAction
+    elif [ "$ACTION" == "6" ] 
+    then
+        exit 0
+    else
+        echo "INVALID ACTION SUPPLIED"
+    fi
+}
+
+askForAction

deploy/selfhost/variables.env

@@ -0,0 +1,63 @@
+APP_RELEASE=latest
+
+WEB_REPLICAS=1
+SPACE_REPLICAS=1
+API_REPLICAS=1
+
+NGINX_PORT=80
+DEBUG=0
+DJANGO_SETTINGS_MODULE=plane.settings.selfhosted
+NEXT_PUBLIC_ENABLE_OAUTH=0
+NEXT_PUBLIC_DEPLOY_URL=http://localhost/spaces
+SENTRY_DSN=""
+GITHUB_CLIENT_SECRET=""
+DOCKERIZED=1
+
+#DB SETTINGS
+PGHOST=plane-db
+PGDATABASE=plane
+POSTGRES_USER=plane
+POSTGRES_PASSWORD=plane
+POSTGRES_DB=plane
+PGDATA=/var/lib/postgresql/data
+DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${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
+DEFAULT_EMAIL=captain@plane.so
+DEFAULT_PASSWORD=password123
+
+# OPENAI SETTINGS
+OPENAI_API_BASE=https://api.openai.com/v1
+OPENAI_API_KEY="sk-"
+GPT_ENGINE="gpt-3.5-turbo"
+
+# LOGIN/SIGNUP SETTINGS
+ENABLE_SIGNUP=1
+ENABLE_EMAIL_PASSWORD=1
+ENABLE_MAGIC_LINK_LOGIN=0
+SECRET_KEY=60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5
+
+# DATA STORE SETTINGS
+USE_MINIO=1
+AWS_REGION=""
+AWS_ACCESS_KEY_ID="access-key"
+AWS_SECRET_ACCESS_KEY="secret-key"
+AWS_S3_ENDPOINT_URL=http://plane-minio:9000
+AWS_S3_BUCKET_NAME=uploads
+MINIO_ROOT_USER="access-key"
+MINIO_ROOT_PASSWORD="secret-key"
+BUCKET_NAME=uploads
+FILE_SIZE_LIMIT=5242880
+

docker-compose-hub.yml

@@ -1,126 +0,0 @@
-version: "3.8"
-
-services:
-        web:
-                container_name: web
-                image: makeplane/plane-frontend:latest
-                restart: always
-                command: /usr/local/bin/start.sh web/server.js web
-                env_file:
-                        - ./web/.env
-                depends_on:
-                        - api
-                        - worker
-
-        space:
-                container_name: space
-                image: makeplane/plane-space:latest
-                restart: always
-                command: /usr/local/bin/start.sh space/server.js space
-                env_file:
-                        - ./space/.env
-                depends_on:
-                        - api
-                        - worker
-                        - web
-
-        api:
-                container_name: api
-                image: makeplane/plane-backend:latest
-                restart: always
-                command: ./bin/takeoff
-                env_file:
-                        - ./apiserver/.env
-                depends_on:
-                        - plane-db
-                        - plane-redis
-
-        worker:
-                container_name: bgworker
-                image: makeplane/plane-backend:latest
-                restart: always
-                command: ./bin/worker
-                env_file:
-                        - ./apiserver/.env
-                depends_on:
-                        - api
-                        - plane-db
-                        - plane-redis
-
-        beat-worker:
-                container_name: beatworker
-                image: makeplane/plane-backend:latest
-                restart: always
-                command: ./bin/beat
-                env_file:
-                        - ./apiserver/.env
-                depends_on:
-                        - api
-                        - plane-db
-                        - plane-redis
-
-
-        plane-db:
-                container_name: plane-db
-                image: postgres:15.2-alpine
-                restart: always
-                command: postgres -c 'max_connections=1000'
-                volumes:
-                        - pgdata:/var/lib/postgresql/data
-                env_file:
-                        - .env
-                environment:
-                        POSTGRES_USER: ${PGUSER}
-                        POSTGRES_DB: ${PGDATABASE}
-                        POSTGRES_PASSWORD: ${PGPASSWORD}
-                        PGDATA: /var/lib/postgresql/data
-
-        plane-redis:
-                container_name: plane-redis
-                image: redis:6.2.7-alpine
-                restart: always
-                volumes:
-                        - redisdata:/data
-
-        plane-minio:
-                container_name: plane-minio
-                image: minio/minio
-                restart: always
-                command: server /export --console-address ":9090"
-                volumes:
-                        - uploads:/export
-                env_file:
-                        - .env
-                environment:
-                        MINIO_ROOT_USER: ${AWS_ACCESS_KEY_ID}
-                        MINIO_ROOT_PASSWORD: ${AWS_SECRET_ACCESS_KEY}
-
-        createbuckets:
-                image: minio/mc
-                entrypoint: >
-                        /bin/sh -c " /usr/bin/mc config host add plane-minio http://plane-minio:9000 \$AWS_ACCESS_KEY_ID \$AWS_SECRET_ACCESS_KEY; /usr/bin/mc mb plane-minio/\$AWS_S3_BUCKET_NAME; /usr/bin/mc anonymous set download plane-minio/\$AWS_S3_BUCKET_NAME; exit 0; "
-                env_file:
-                        - .env
-                depends_on:
-                        - plane-minio
-
-        # Comment this if you already have a reverse proxy running
-        proxy:
-                container_name: proxy
-                image: makeplane/plane-proxy:latest
-                ports:
-                        - ${NGINX_PORT}:80
-                env_file:
-                        - .env
-                environment:
-                        FILE_SIZE_LIMIT: ${FILE_SIZE_LIMIT:-5242880}
-                        BUCKET_NAME: ${AWS_S3_BUCKET_NAME:-uploads}
-                depends_on:
-                        - web
-                        - api
-                        - space
-
-volumes:
-        pgdata:
-        redisdata:
-        uploads:

docker-compose-local.yml

@@ -0,0 +1,178 @@
+version: "3.8"
+
+networks:
+  dev_env:
+    driver: bridge
+
+volumes:
+  redisdata:
+  uploads:
+  pgdata:
+  
+
+services:
+  plane-redis:
+    container_name: plane-redis
+    image: redis:6.2.7-alpine
+    restart: unless-stopped
+    networks:
+      - dev_env
+    volumes:
+      - redisdata:/data
+ 
+  plane-minio:
+    container_name: plane-minio
+    image: minio/minio
+    restart: unless-stopped
+    networks:
+      - dev_env
+    command: server /export --console-address ":9090"
+    volumes:
+      - uploads:/export
+    env_file:
+      - .env
+    environment:
+      MINIO_ROOT_USER: ${AWS_ACCESS_KEY_ID}
+      MINIO_ROOT_PASSWORD: ${AWS_SECRET_ACCESS_KEY}
+ 
+  createbuckets:
+    image: minio/mc
+    networks:
+      - dev_env
+    entrypoint: >
+      /bin/sh -c " /usr/bin/mc config host add plane-minio http://plane-minio:9000 \$AWS_ACCESS_KEY_ID \$AWS_SECRET_ACCESS_KEY; /usr/bin/mc mb plane-minio/\$AWS_S3_BUCKET_NAME; /usr/bin/mc anonymous set download plane-minio/\$AWS_S3_BUCKET_NAME; exit 0; "
+    env_file:
+      - .env
+    depends_on:
+      - plane-minio
+ 
+  plane-db:
+    container_name: plane-db
+    image: postgres:15.2-alpine
+    restart: unless-stopped
+    networks:
+      - dev_env
+    command: postgres -c 'max_connections=1000'
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    env_file:
+      - .env
+    environment:
+      POSTGRES_USER: ${PGUSER}
+      POSTGRES_DB: ${PGDATABASE}
+      POSTGRES_PASSWORD: ${PGPASSWORD}
+      PGDATA: /var/lib/postgresql/data
+
+  web:
+    container_name: web
+    build:
+      context: .
+      dockerfile: ./web/Dockerfile.dev
+    restart: unless-stopped
+    networks:
+      - dev_env
+    volumes:
+      - .:/app
+    command: yarn dev --filter=web
+    env_file:
+      - ./web/.env
+    depends_on:
+      - api
+      - worker
+
+  space:
+    build:
+      context: .
+      dockerfile: ./space/Dockerfile.dev
+    container_name: space
+    restart: unless-stopped
+    networks:
+      - dev_env
+    volumes:
+      - .:/app
+    command: yarn dev --filter=space
+    env_file:
+      - ./space/.env
+    depends_on:
+      - api
+      - worker
+      - web
+
+  api:
+    container_name: api
+    build:
+      context: ./apiserver
+      dockerfile: Dockerfile.dev
+      args:
+        DOCKER_BUILDKIT: 1
+    restart: unless-stopped
+    networks:
+      - dev_env
+    volumes:
+      - ./apiserver:/code
+    command: /bin/sh -c "python manage.py migrate && python manage.py runserver 0.0.0.0:8000 --settings=plane.settings.local"
+    env_file:
+      - ./apiserver/.env
+    depends_on:
+      - plane-db
+      - plane-redis
+  
+  worker:
+    container_name: bgworker
+    build:
+      context: ./apiserver
+      dockerfile: Dockerfile.dev
+      args:
+        DOCKER_BUILDKIT: 1
+    restart: unless-stopped
+    networks:
+      - dev_env
+    volumes:
+      - ./apiserver:/code
+    command: /bin/sh -c "celery -A plane worker -l info"
+    env_file:
+      - ./apiserver/.env
+    depends_on:
+      - api
+      - plane-db
+      - plane-redis
+
+  beat-worker:
+    container_name: beatworker
+    build:
+      context: ./apiserver
+      dockerfile: Dockerfile.dev
+      args:
+        DOCKER_BUILDKIT: 1
+    restart: unless-stopped
+    networks:
+      - dev_env
+    volumes:
+      - ./apiserver:/code
+    command: /bin/sh -c "celery -A plane beat -l info"
+    env_file:
+      - ./apiserver/.env
+    depends_on:
+      - api
+      - plane-db
+      - plane-redis
+
+  proxy:
+    container_name: proxy
+    build:
+      context: ./nginx
+      dockerfile: Dockerfile
+    restart: unless-stopped
+    networks:
+      - dev_env
+    ports:
+      - ${NGINX_PORT}:80
+    env_file:
+      - .env
+    environment:
+      FILE_SIZE_LIMIT: ${FILE_SIZE_LIMIT:-5242880}
+      BUCKET_NAME: ${AWS_S3_BUCKET_NAME:-uploads}
+    depends_on:
+      - web
+      - api
+      - space

package.json

@@ -6,7 +6,11 @@
   "workspaces": [
     "web",
     "space",
-    "packages/*"
+    "packages/editor/*",
+    "packages/eslint-config-custom",
+    "packages/tailwind-config-custom",
+    "packages/tsconfig",
+    "packages/ui"
   ],
   "scripts": {
     "build": "turbo run build",
@@ -23,7 +27,10 @@
     "prettier": "latest",
     "prettier-plugin-tailwindcss": "^0.5.4",
     "tailwindcss": "^3.3.3",
-    "turbo": "latest"
+    "turbo": "^1.10.14"
+  },
+  "resolutions": {
+    "@types/react": "18.2.0"
   },
   "packageManager": "yarn@1.22.19"
 }

packages/editor/core/Readme.md

@@ -0,0 +1,112 @@
+# @plane/editor-core
+
+## Description
+
+The `@plane/editor-core` package serves as the foundation for our editor system. It provides the base functionality for our other editor packages, but it will not be used directly in any of the projects but only for extending other editors.
+
+## Utilities
+
+We provide a wide range of utilities for extending the core itself.
+
+1. Merging classes and custom styling
+2. Adding new extensions
+3. Adding custom props
+4. Base menu items, and their commands
+
+This allows for extensive customization and flexibility in the Editors created using our `editor-core` package.
+
+### Here's a detailed overview of what's exported
+
+1. useEditor - A hook that you can use to extend the Plane editor.
+
+    | Prop | Type | Description |
+    | --- | --- | --- |
+    | `extensions` | `Extension[]` | An array of custom extensions you want to add into the editor to extend it's core features |
+    | `editorProps` | `EditorProps` | Extend the editor props by passing in a custom props object |
+    | `uploadFile` | `(file: File) => Promise<string>` | A function that handles file upload. It takes a file as input and handles the process of uploading that file. |
+    | `deleteFile` | `(assetUrlWithWorkspaceId: string) => Promise<any>` | A function that handles deleting an image. It takes the asset url from your bucket and handles the process of deleting that image. |
+    | `value` | `html string` | The initial content of the editor. |
+    | `debouncedUpdatesEnabled` | `boolean` | If set to true, the `onChange` event handler is debounced, meaning it will only be invoked after the specified delay (default 1500ms) once the user has stopped typing. |
+    | `onChange` | `(json: any, html: string) => void` | This function is invoked whenever the content of the editor changes. It is passed the new content in both JSON and HTML formats. |
+    | `setIsSubmitting` | `(isSubmitting: "submitting" \| "submitted" \| "saved") => void` | This function is called to update the submission status. |
+    | `setShouldShowAlert` | `(showAlert: boolean) => void` | This function is used to show or hide an alert in case of content not being "saved". |
+    | `forwardedRef` | `any` | Pass this in whenever you want to control the editor's state from an external component |
+
+2. useReadOnlyEditor - A hook that can be used to extend a Read Only instance of the core editor.
+
+    | Prop | Type | Description |
+    | --- | --- | --- |
+    | `value` | `string` | The initial content of the editor. |
+    | `forwardedRef` | `any` | Pass this in whenever you want to control the editor's state from an external component |
+    | `extensions` | `Extension[]` | An array of custom extensions you want to add into the editor to extend it's core features |
+    | `editorProps` | `EditorProps` | Extend the editor props by passing in a custom props object |
+
+3. Items and Commands - H1, H2, H3, task list, quote, code block, etc's methods.
+
+4. UI Wrappers
+
+- `EditorContainer` - Wrap your Editor Container with this to apply base classes and styles.
+- `EditorContentWrapper` - Use this to get Editor's Content and base menus.
+
+5. Extending with Custom Styles
+
+```ts
+const customEditorClassNames = getEditorClassNames({ noBorder, borderOnFocus, customClassName });
+```
+
+## Core features
+
+- **Content Trimming**: The Editor’s content is now automatically trimmed of empty line breaks from the start and end before submitting it to the backend. This ensures cleaner, more consistent data.
+- **Value Cleaning**: The Editor’s value is cleaned at the editor core level, eliminating the need for additional validation before sending from our app. This results in cleaner code and less potential for errors.
+- **Turbo Pipeline**: Added a turbo pipeline for both dev and build tasks for projects depending on the editor package.
+
+```json
+    "web#develop": {
+      "cache": false,
+      "persistent": true,
+      "dependsOn": [
+        "@plane/lite-text-editor#build",
+        "@plane/rich-text-editor#build"
+      ]
+    },
+    "space#develop": {
+      "cache": false,
+      "persistent": true,
+      "dependsOn": [
+        "@plane/lite-text-editor#build",
+        "@plane/rich-text-editor#build"
+      ]
+    },
+    "web#build": {
+      "cache": true,
+      "dependsOn": [
+        "@plane/lite-text-editor#build",
+        "@plane/rich-text-editor#build"
+      ]
+    },
+    "space#build": {
+      "cache": true,
+      "dependsOn": [
+        "@plane/lite-text-editor#build",
+        "@plane/rich-text-editor#build"
+      ]
+    },
+
+```
+
+## Base extensions included
+
+- BulletList
+- OrderedList
+- Blockquote
+- Code
+- Gapcursor
+- Link
+- Image
+- Basic Marks
+  - Underline
+  - TextStyle
+  - Color
+- TaskList
+- Markdown
+- Table

packages/editor/core/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@plane/editor-core",
+  "version": "0.0.1",
+  "description": "Core Editor that powers Plane",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist/**/*"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "module": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "check-types": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "react": "^18.2.0",
+    "react-dom": "18.2.0",
+    "next": "12.3.2",
+    "next-themes": "^0.2.1"
+  },
+  "dependencies": {
+    "react-moveable" : "^0.54.2",
+    "@blueprintjs/popover2": "^2.0.10",
+    "@tiptap/core": "^2.1.7",
+    "@tiptap/extension-color": "^2.1.11",
+    "@tiptap/extension-image": "^2.1.7",
+    "@tiptap/extension-link": "^2.1.7",
+    "@tiptap/extension-table": "^2.1.6",
+    "@tiptap/extension-table-cell": "^2.1.6",
+    "@tiptap/extension-table-header": "^2.1.6",
+    "@tiptap/extension-table-row": "^2.1.6",
+    "@tiptap/extension-task-item": "^2.1.7",
+    "@tiptap/extension-task-list": "^2.1.7",
+    "@tiptap/extension-text-style": "^2.1.11",
+    "@tiptap/extension-underline": "^2.1.7",
+    "@tiptap/pm": "^2.1.7",
+    "@tiptap/react": "^2.1.7",
+    "@tiptap/starter-kit": "^2.1.10",
+    "@types/react": "^18.2.5",
+    "@types/react-dom": "18.0.11",
+    "@types/node": "18.15.3",
+    "class-variance-authority": "^0.7.0",
+    "clsx": "^1.2.1",
+    "eslint": "8.36.0",
+    "eslint-config-next": "13.2.4",
+    "eventsource-parser": "^0.1.0",
+    "lucide-react": "^0.244.0",
+    "react-markdown": "^8.0.7",
+    "tailwind-merge": "^1.14.0",
+    "tippy.js": "^6.3.7",
+    "tiptap-markdown": "^0.8.2",
+    "use-debounce": "^9.0.4"
+  },
+  "devDependencies": {
+    "eslint": "^7.32.0",
+    "postcss": "^8.4.29",
+    "tailwind-config-custom": "*",
+    "tsconfig": "*",
+    "tsup": "^7.2.0",
+    "typescript": "4.9.5"
+  },
+  "keywords": [
+    "editor",
+    "rich-text",
+    "markdown",
+    "nextjs",
+    "react"
+  ]
+}

packages/editor/core/postcss.config.js

@@ -0,0 +1,9 @@
+// If you want to use other PostCSS plugins, see the following:
+// https://tailwindcss.com/docs/using-with-preprocessors
+
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};

packages/editor/core/src/index.ts

@@ -0,0 +1,19 @@
+// styles
+// import "./styles/tailwind.css";
+// import "./styles/editor.css";
+
+// utils
+export * from "./lib/utils";
+export { startImageUpload } from "./ui/plugins/upload-image";
+
+// components
+export { EditorContainer } from "./ui/components/editor-container";
+export { EditorContentWrapper } from "./ui/components/editor-content";
+
+// hooks
+export { useEditor } from "./ui/hooks/useEditor";
+export { useReadOnlyEditor } from "./ui/hooks/useReadOnlyEditor";
+
+// helper items
+export * from "./ui/menus/menu-items";
+export * from "./lib/editor-commands";

packages/editor/core/src/lib/editor-commands.ts

@@ -0,0 +1,91 @@
+import { Editor, Range } from "@tiptap/core";
+import { UploadImage } from "../types/upload-image";
+import { startImageUpload } from "../ui/plugins/upload-image";
+
+export const toggleHeadingOne = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).setNode("heading", { level: 1 }).run();
+  else editor.chain().focus().toggleHeading({ level: 1 }).run()
+};
+
+export const toggleHeadingTwo = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).setNode("heading", { level: 2 }).run();
+  else editor.chain().focus().toggleHeading({ level: 2 }).run()
+};
+
+export const toggleHeadingThree = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).setNode("heading", { level: 3 }).run();
+  else editor.chain().focus().toggleHeading({ level: 3 }).run()
+};
+
+export const toggleBold = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).toggleBold().run();
+  else editor.chain().focus().toggleBold().run();
+};
+
+export const toggleItalic = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).toggleItalic().run();
+  else editor.chain().focus().toggleItalic().run();
+};
+
+export const toggleUnderline = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).toggleUnderline().run();
+  else editor.chain().focus().toggleUnderline().run();
+};
+
+export const toggleCode = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).toggleCode().run();
+  else editor.chain().focus().toggleCode().run();
+};
+export const toggleOrderedList = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).toggleOrderedList().run();
+  else editor.chain().focus().toggleOrderedList().run();
+};
+
+export const toggleBulletList = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).toggleBulletList().run();
+  else editor.chain().focus().toggleBulletList().run();
+};
+
+export const toggleTaskList = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).toggleTaskList().run();
+  else editor.chain().focus().toggleTaskList().run()
+};
+
+export const toggleStrike = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).toggleStrike().run();
+  else editor.chain().focus().toggleStrike().run();
+};
+
+export const toggleBlockquote = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).toggleNode("paragraph", "paragraph").toggleBlockquote().run();
+  else editor.chain().focus().toggleNode("paragraph", "paragraph").toggleBlockquote().run();
+};
+
+export const insertTableCommand = (editor: Editor, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run();
+  else editor.chain().focus().insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run();
+};
+
+export const unsetLinkEditor = (editor: Editor) => {
+  editor.chain().focus().unsetLink().run();
+};
+
+export const setLinkEditor = (editor: Editor, url: string) => {
+  editor.chain().focus().setLink({ href: url }).run();
+};
+
+export const insertImageCommand = (editor: Editor, uploadFile: UploadImage, setIsSubmitting?: (isSubmitting: "submitting" | "submitted" | "saved") => void, range?: Range) => {
+  if (range) editor.chain().focus().deleteRange(range).run();
+  const input = document.createElement("input");
+  input.type = "file";
+  input.accept = "image/*";
+  input.onchange = async () => {
+    if (input.files?.length) {
+      const file = input.files[0];
+      const pos = editor.view.state.selection.from;
+      startImageUpload(file, editor.view, pos, uploadFile, setIsSubmitting);
+    }
+  };
+  input.click();
+};
+

packages/editor/core/src/lib/utils.ts

@@ -0,0 +1,45 @@
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+interface EditorClassNames {
+  noBorder?: boolean;
+  borderOnFocus?: boolean;
+  customClassName?: string;
+}
+
+export const getEditorClassNames = ({ noBorder, borderOnFocus, customClassName }: EditorClassNames) => cn(
+  'relative w-full max-w-full sm:rounded-lg mt-2 p-3 relative focus:outline-none rounded-md',
+  noBorder ? '' : 'border border-custom-border-200',
+  borderOnFocus ? 'focus:border border-custom-border-300' : 'focus:border-0',
+  customClassName
+);
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+export const findTableAncestor = (
+  node: Node | null
+): HTMLTableElement | null => {
+  while (node !== null && node.nodeName !== "TABLE") {
+    node = node.parentNode;
+  }
+  return node as HTMLTableElement;
+};
+
+export const getTrimmedHTML = (html: string) => {
+  html = html.replace(/^(<p><\/p>)+/, '');
+  html = html.replace(/(<p><\/p>)+$/, '');
+  return html;
+}
+
+export const isValidHttpUrl = (string: string): boolean => {
+  let url: URL;
+
+  try {
+    url = new URL(string);
+  } catch (_) {
+    return false;
+  }
+
+  return url.protocol === "http:" || url.protocol === "https:";
+}

packages/editor/core/src/styles/editor.css

@@ -0,0 +1,231 @@
+.ProseMirror p.is-editor-empty:first-child::before {
+  content: attr(data-placeholder);
+  float: left;
+  color: rgb(var(--color-text-400));
+  pointer-events: none;
+  height: 0;
+}
+
+.ProseMirror .is-empty::before {
+  content: attr(data-placeholder);
+  float: left;
+  color: rgb(var(--color-text-400));
+  pointer-events: none;
+  height: 0;
+}
+
+/* Custom image styles */
+
+.ProseMirror img {
+  transition: filter 0.1s ease-in-out;
+
+  &:hover {
+    cursor: pointer;
+    filter: brightness(90%);
+  }
+
+  &.ProseMirror-selectednode {
+    outline: 3px solid #5abbf7;
+    filter: brightness(90%);
+  }
+}
+
+.ProseMirror-gapcursor:after {
+  border-top: 1px solid rgb(var(--color-text-100)) !important;
+}
+
+/* Custom TODO list checkboxes – shoutout to this awesome tutorial: https://moderncss.dev/pure-css-custom-checkbox-style/ */
+
+ul[data-type="taskList"] li > label {
+  margin-right: 0.2rem;
+  user-select: none;
+}
+
+@media screen and (max-width: 768px) {
+  ul[data-type="taskList"] li > label {
+    margin-right: 0.5rem;
+  }
+}
+
+ul[data-type="taskList"] li > label input[type="checkbox"] {
+  -webkit-appearance: none;
+  appearance: none;
+  background-color: rgb(var(--color-background-100));
+  margin: 0;
+  cursor: pointer;
+  width: 1.2rem;
+  height: 1.2rem;
+  position: relative;
+  border: 2px solid rgb(var(--color-text-100));
+  margin-right: 0.3rem;
+  display: grid;
+  place-content: center;
+
+  &:hover {
+    background-color: rgb(var(--color-background-80));
+  }
+
+  &:active {
+    background-color: rgb(var(--color-background-90));
+  }
+
+  &::before {
+    content: "";
+    width: 0.65em;
+    height: 0.65em;
+    transform: scale(0);
+    transition: 120ms transform ease-in-out;
+    box-shadow: inset 1em 1em;
+    transform-origin: center;
+    clip-path: polygon(14% 44%, 0 65%, 50% 100%, 100% 16%, 80% 0%, 43% 62%);
+  }
+
+  &:checked::before {
+    transform: scale(1);
+  }
+}
+
+ul[data-type="taskList"] li[data-checked="true"] > div > p {
+  color: rgb(var(--color-text-200));
+  text-decoration: line-through;
+  text-decoration-thickness: 2px;
+}
+
+/* Overwrite tippy-box original max-width */
+
+.tippy-box {
+  max-width: 400px !important;
+}
+
+.ProseMirror {
+  position: relative;
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  -moz-tab-size: 4;
+  tab-size: 4;
+  -webkit-user-select: text;
+  -moz-user-select: text;
+  -ms-user-select: text;
+  user-select: text;
+  outline: none;
+  cursor: text;
+  line-height: 1.2;
+  font-family: inherit;
+  font-size: 14px;
+  color: inherit;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  appearance: textfield;
+  -webkit-appearance: textfield;
+  -moz-appearance: textfield;
+}
+
+.fadeIn {
+  opacity: 1;
+  transition: opacity 0.3s ease-in;
+}
+
+.fadeOut {
+  opacity: 0;
+  transition: opacity 0.2s ease-out;
+}
+
+.img-placeholder {
+  position: relative;
+  width: 35%;
+
+  &:before {
+    content: "";
+    box-sizing: border-box;
+    position: absolute;
+    top: 50%;
+    left: 45%;
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    border: 3px solid rgba(var(--color-text-200));
+    border-top-color: rgba(var(--color-text-800));
+    animation: spinning 0.6s linear infinite;
+  }
+}
+
+@keyframes spinning {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+#editor-container {
+  table {
+    border-collapse: collapse;
+    table-layout: fixed;
+    margin: 0;
+    border: 1px solid rgb(var(--color-border-200));
+    width: 100%;
+
+    td,
+    th {
+      min-width: 1em;
+      border: 1px solid rgb(var(--color-border-200));
+      padding: 10px 15px;
+      vertical-align: top;
+      box-sizing: border-box;
+      position: relative;
+      transition: background-color 0.3s ease;
+
+      > * {
+        margin-bottom: 0;
+      }
+    }
+
+    th {
+      font-weight: bold;
+      text-align: left;
+      background-color: rgb(var(--color-primary-100));
+    }
+
+    td:hover {
+      background-color: rgba(var(--color-primary-300), 0.1);
+    }
+
+    .selectedCell:after {
+      z-index: 2;
+      position: absolute;
+      content: "";
+      left: 0;
+      right: 0;
+      top: 0;
+      bottom: 0;
+      background-color: rgba(var(--color-primary-300), 0.1);
+      pointer-events: none;
+    }
+
+    .column-resize-handle {
+      position: absolute;
+      right: -2px;
+      top: 0;
+      bottom: -2px;
+      width: 2px;
+      background-color: rgb(var(--color-primary-400));
+      pointer-events: none;
+    }
+  }
+}
+
+.tableWrapper {
+  overflow-x: auto;
+}
+
+.resize-cursor {
+  cursor: ew-resize;
+  cursor: col-resize;
+}
+
+.ProseMirror table * p {
+  padding: 0px 1px;
+  margin: 6px 2px;
+}
+
+.ProseMirror table * .is-empty::before {
+  opacity: 0;
+}

packages/editor/core/src/styles/tailwind.css

@@ -0,0 +1,3 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;

packages/editor/core/src/types/delete-image.ts

@@ -0,0 +1 @@
+export type DeleteImage = (assetUrlWithWorkspaceId: string) => Promise<any>;

packages/editor/core/src/types/upload-image.ts

@@ -0,0 +1 @@
+export type UploadImage = (file: File) => Promise<string>;

packages/editor/core/src/ui/components/editor-container.tsx

@@ -0,0 +1,20 @@
+import { Editor } from "@tiptap/react";
+import { ReactNode } from "react";
+
+interface EditorContainerProps {
+  editor: Editor | null;
+  editorClassNames: string;
+  children: ReactNode;
+}
+
+export const EditorContainer = ({ editor, editorClassNames, children }: EditorContainerProps) => (
+  <div
+    id="editor-container"
+    onClick={() => {
+      editor?.chain().focus().run();
+    }}
+    className={`cursor-text ${editorClassNames}`}
+  >
+    {children}
+  </div>
+);

packages/editor/core/src/ui/components/editor-content.tsx

@@ -0,0 +1,20 @@
+import { Editor, EditorContent } from "@tiptap/react";
+import { ReactNode } from "react";
+import { ImageResizer } from "../extensions/image/image-resize";
+import { TableMenu } from "../menus/table-menu";
+
+interface EditorContentProps {
+  editor: Editor | null;
+  editorContentCustomClassNames: string | undefined;
+  children?: ReactNode;
+}
+
+export const EditorContentWrapper = ({ editor, editorContentCustomClassNames = '', children }: EditorContentProps) => (
+  <div className={`${editorContentCustomClassNames}`}>
+    {/* @ts-ignore */}
+    <EditorContent editor={editor} />
+    {editor?.isEditable && <TableMenu editor={editor} />}
+    {(editor?.isActive("image") && editor?.isEditable) && <ImageResizer editor={editor} />}
+    {children}
+  </div>
+);

packages/editor/core/src/ui/extensions/image/index.tsx

@@ -0,0 +1,23 @@
+import Image from "@tiptap/extension-image";
+import TrackImageDeletionPlugin from "../../plugins/delete-image";
+import UploadImagesPlugin from "../../plugins/upload-image";
+import { DeleteImage } from "../../../types/delete-image";
+
+const ImageExtension = (deleteImage: DeleteImage) => Image.extend({
+  addProseMirrorPlugins() {
+    return [UploadImagesPlugin(), TrackImageDeletionPlugin(deleteImage)];
+  },
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      width: {
+        default: "35%",
+      },
+      height: {
+        default: null,
+      },
+    };
+  },
+});
+
+export default ImageExtension;

packages/editor/core/src/ui/extensions/image/read-only-image.tsx

@@ -0,0 +1,17 @@
+import Image from "@tiptap/extension-image";
+
+const ReadOnlyImageExtension = Image.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      width: {
+        default: "35%",
+      },
+      height: {
+        default: null,
+      },
+    };
+  },
+});
+
+export default ReadOnlyImageExtension;

packages/editor/core/src/ui/extensions/index.tsx

@@ -1,35 +1,26 @@
 import StarterKit from "@tiptap/starter-kit";
-import HorizontalRule from "@tiptap/extension-horizontal-rule";
 import TiptapLink from "@tiptap/extension-link";
-import Placeholder from "@tiptap/extension-placeholder";
 import TiptapUnderline from "@tiptap/extension-underline";
 import TextStyle from "@tiptap/extension-text-style";
 import { Color } from "@tiptap/extension-color";
 import TaskItem from "@tiptap/extension-task-item";
 import TaskList from "@tiptap/extension-task-list";
 import { Markdown } from "tiptap-markdown";
-import Highlight from "@tiptap/extension-highlight";
-import CodeBlockLowlight from "@tiptap/extension-code-block-lowlight";
-import { lowlight } from "lowlight/lib/core";
-import SlashCommand from "../slash-command";
-import { InputRule } from "@tiptap/core";
 import Gapcursor from "@tiptap/extension-gapcursor";
 
-import ts from "highlight.js/lib/languages/typescript";
-
-import "highlight.js/styles/github-dark.css";
-import UpdatedImage from "./updated-image";
-import isValidHttpUrl from "../bubble-menu/utils/link-validator";
 import { CustomTableCell } from "./table/table-cell";
-import { Table } from "./table/table";
+import { Table } from "./table";
 import { TableHeader } from "./table/table-header";
 import { TableRow } from "@tiptap/extension-table-row";
 
-lowlight.registerLanguage("ts", ts);
+import ImageExtension from "./image";
 
-export const TiptapExtensions = (
-  workspaceSlug: string,
-  setIsSubmitting?: (isSubmitting: "submitting" | "submitted" | "saved") => void
+import { DeleteImage } from "../../types/delete-image";
+import { isValidHttpUrl } from "../../lib/utils";
+
+
+export const CoreEditorExtensions = (
+  deleteFile: DeleteImage,
 ) => [
     StarterKit.configure({
       bulletList: {
@@ -67,32 +58,6 @@ export const TiptapExtensions = (
       },
       gapcursor: false,
     }),
-    CodeBlockLowlight.configure({
-      lowlight,
-    }),
-    HorizontalRule.extend({
-      addInputRules() {
-        return [
-          new InputRule({
-            find: /^(?:---|—-|___\s|\*\*\*\s)$/,
-            handler: ({ state, range, commands }) => {
-              commands.splitBlock();
-
-              const attributes = {};
-              const { tr } = state;
-              const start = range.from;
-              const end = range.to;
-              // @ts-ignore
-              tr.replaceWith(start - 1, end, this.type.create(attributes));
-            },
-          }),
-        ];
-      },
-    }).configure({
-      HTMLAttributes: {
-        class: "mb-6 border-t border-custom-border-300",
-      },
-    }),
     Gapcursor,
     TiptapLink.configure({
       protocols: ["http", "https"],
@@ -102,31 +67,14 @@ export const TiptapExtensions = (
           "text-custom-primary-300 underline underline-offset-[3px] hover:text-custom-primary-500 transition-colors cursor-pointer",
       },
     }),
-    UpdatedImage.configure({
+    ImageExtension(deleteFile).configure({
       HTMLAttributes: {
         class: "rounded-lg border border-custom-border-300",
       },
     }),
-    Placeholder.configure({
-      placeholder: ({ node }) => {
-        if (node.type.name === "heading") {
-          return `Heading ${node.attrs.level}`;
-        }
-        if (node.type.name === "image" || node.type.name === "table") {
-          return "";
-        }
-
-        return "Press '/' for commands...";
-      },
-      includeChildren: true,
-    }),
-    SlashCommand(workspaceSlug, setIsSubmitting),
     TiptapUnderline,
     TextStyle,
     Color,
-    Highlight.configure({
-      multicolor: true,
-    }),
     TaskList.configure({
       HTMLAttributes: {
         class: "not-prose pl-2",