chore: minor optimizations

When using a boolean attribute in JSX, you can set the attribute value to true or omit the value. This helps to keep consistency in code.

Co-authored-by: deepsource-autofix[bot] <62050782+deepsource-autofix[bot]@users.noreply.github.com>

.deepsource.toml

@@ -0,0 +1,17 @@
+version = 1
+
+[[analyzers]]
+name = "shell"
+
+[[analyzers]]
+name = "javascript"
+
+  [analyzers.meta]
+  plugins = ["react"]
+  environment = ["nodejs"]
+
+[[analyzers]]
+name = "python"
+
+  [analyzers.meta]
+  runtime_version = "3.x.x"

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

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

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

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

.gitignore

@@ -16,6 +16,8 @@ node_modules
 
 # Production
 /build
+dist/
+out/
 
 # Misc
 .DS_Store
@@ -73,3 +75,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,10 +45,14 @@ 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
-    
+
     def get_assignees(self, obj):
         members = [
             {
@@ -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/module.py

@@ -19,7 +19,7 @@ from plane.db.models import (
 
 
 class ModuleWriteSerializer(BaseSerializer):
-    members_list = serializers.ListField(
+    members = serializers.ListField(
         child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
         write_only=True,
         required=False,
@@ -39,6 +39,11 @@ class ModuleWriteSerializer(BaseSerializer):
             "created_at",
             "updated_at",
         ]
+    
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        data['members'] = [str(member.id) for member in instance.members.all()]
+        return data
 
     def validate(self, data):
         if data.get("start_date", None) is not None and data.get("target_date", None) is not None and data.get("start_date", None) > data.get("target_date", None):
@@ -46,7 +51,7 @@ class ModuleWriteSerializer(BaseSerializer):
         return data    
 
     def create(self, validated_data):
-        members = validated_data.pop("members_list", None)
+        members = validated_data.pop("members", None)
 
         project = self.context["project"]
 
@@ -72,7 +77,7 @@ class ModuleWriteSerializer(BaseSerializer):
         return module
 
     def update(self, instance, validated_data):
-        members = validated_data.pop("members_list", None)
+        members = validated_data.pop("members", None)
 
         if members is not None:
             ModuleMember.objects.filter(module=instance).delete()

apiserver/plane/api/serializers/page.py

@@ -33,7 +33,7 @@ class PageBlockLiteSerializer(BaseSerializer):
 class PageSerializer(BaseSerializer):
     is_favorite = serializers.BooleanField(read_only=True)
     label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
-    labels_list = serializers.ListField(
+    labels = serializers.ListField(
         child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
         write_only=True,
         required=False,
@@ -50,9 +50,13 @@ class PageSerializer(BaseSerializer):
             "project",
             "owned_by",
         ]
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        data['labels'] = [str(label.id) for label in instance.labels.all()]
+        return data
 
     def create(self, validated_data):
-        labels = validated_data.pop("labels_list", None)
+        labels = validated_data.pop("labels", None)
         project_id = self.context["project_id"]
         owned_by_id = self.context["owned_by_id"]
         page = Page.objects.create(
@@ -77,7 +81,7 @@ class PageSerializer(BaseSerializer):
         return page
 
     def update(self, instance, validated_data):
-        labels = validated_data.pop("labels_list", None)
+        labels = validated_data.pop("labels", None)
         if labels is not None:
             PageLabel.objects.filter(page=instance).delete()
             PageLabel.objects.bulk_create(

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.filter(
+                pk=obj.last_workspace_id, workspace_member__member=obj.id
+            ).first()
+            return {
+                "last_workspace_id": obj.last_workspace_id,
+                "last_workspace_slug": workspace.slug if workspace is not None else "",
+                "fallback_workspace_id": obj.last_workspace_id,
+                "fallback_workspace_slug": workspace.slug if workspace is not None else "",
+                "invites": workspace_invites,
+            }
+        else:
+            fallback_workspace = (
+                Workspace.objects.filter(workspace_member__member_id=obj.id)
+                .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,
@@ -106,7 +107,6 @@ from plane.api.views import (
     GlobalViewViewSet,
     GlobalViewIssuesViewSet,
     IssueViewViewSet,
-    ViewIssuesEndpoint,
     IssueViewFavoriteViewSet,
     ## End Views
     # Cycles
@@ -192,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"),
@@ -204,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(
@@ -230,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(),
@@ -557,6 +570,7 @@ urlpatterns = [
         "workspaces/<str:slug>/user-favorite-projects/",
         ProjectFavoritesViewSet.as_view(
             {
+                "get": "list",
                 "post": "create",
             }
         ),
@@ -657,11 +671,6 @@ urlpatterns = [
         ),
         name="project-view",
     ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/views/<uuid:view_id>/issues/",
-        ViewIssuesEndpoint.as_view(),
-        name="project-view-issues",
-    ),
     path(
         "workspaces/<str:slug>/views/",
         GlobalViewViewSet.as_view(
@@ -999,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

@@ -57,7 +57,7 @@ from .workspace import (
     LeaveWorkspaceEndpoint,
 )
 from .state import StateViewSet
-from .view import GlobalViewViewSet, GlobalViewIssuesViewSet, IssueViewViewSet, ViewIssuesEndpoint, IssueViewFavoriteViewSet
+from .view import GlobalViewViewSet, GlobalViewIssuesViewSet, IssueViewViewSet, IssueViewFavoriteViewSet
 from .cycle import (
     CycleViewSet,
     CycleIssueViewSet,
@@ -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)
+        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:
-                return Response(
-                    {"error": "x-axis and y-axis dimensions are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            segment = request.GET.get("segment", False)
-            filters = issue_filters(request.GET, "GET")
-
-            queryset = Issue.issue_objects.filter(workspace__slug=slug, **filters)
-
-            total_issues = queryset.count()
-            distribution = build_graph_plot(
-                queryset=queryset, x_axis=x_axis, y_axis=y_axis, segment=segment
-            )
-
-            colors = dict()
-            if x_axis in ["state__name", "state__group"] or segment in [
-                "state__name",
-                "state__group",
-            ]:
-                if x_axis in ["state__name", "state__group"]:
-                    key = "name" if x_axis == "state__name" else "group"
-                else:
-                    key = "name" if segment == "state__name" else "group"
-
-                colors = (
-                    State.objects.filter(
-                        ~Q(name="Triage"),
-                        workspace__slug=slug, project_id__in=filters.get("project__in")
-                    ).values(key, "color")
-                    if filters.get("project__in", False)
-                    else State.objects.filter(~Q(name="Triage"), workspace__slug=slug).values(key, "color")
-                )
-
-            if x_axis in ["labels__name"] or segment in ["labels__name"]:
-                colors = (
-                    Label.objects.filter(
-                        workspace__slug=slug, project_id__in=filters.get("project__in")
-                    ).values("name", "color")
-                    if filters.get("project__in", False)
-                    else Label.objects.filter(workspace__slug=slug).values(
-                        "name", "color"
-                    )
-                )
-
-            assignee_details = {}
-            if x_axis in ["assignees__id"] or segment in ["assignees__id"]:
-                assignee_details = (
-                    Issue.issue_objects.filter(workspace__slug=slug, **filters, assignees__avatar__isnull=False)
-                    .order_by("assignees__id")
-                    .distinct("assignees__id")
-                    .values("assignees__avatar", "assignees__display_name", "assignees__first_name", "assignees__last_name", "assignees__id")
-                )
+        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(
                 {
-                    "total": total_issues,
-                    "distribution": distribution,
-                    "extras": {"colors": colors, "assignee_details": assignee_details},
+                    "error": "x-axis and y-axis dimensions are required and the values should be valid"
                 },
-                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,
             )
 
+        # 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
+        )
+
+        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")
+            )
+
+        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
+                )
+                .order_by("assignees__id")
+                .distinct("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": {
+                    "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,
+        )
+
 
 class AnalyticViewViewset(BaseViewSet):
     permission_classes = [
@@ -128,45 +197,30 @@ 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)
+        filter = analytic_view.query
+        queryset = Issue.issue_objects.filter(**filter)
 
-            x_axis = analytic_view.query_dict.get("x_axis", False)
-            y_axis = analytic_view.query_dict.get("y_axis", False)
+        x_axis = analytic_view.query_dict.get("x_axis", False)
+        y_axis = analytic_view.query_dict.get("y_axis", False)
 
-            if not x_axis or not y_axis:
-                return Response(
-                    {"error": "x-axis and y-axis dimensions are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            segment = request.GET.get("segment", False)
-            distribution = build_graph_plot(
-                queryset=queryset, x_axis=x_axis, y_axis=y_axis, segment=segment
-            )
-            total_issues = queryset.count()
+        if not x_axis or not y_axis:
             return Response(
-                {"total": total_issues, "distribution": distribution},
-                status=status.HTTP_200_OK,
-            )
-
-        except AnalyticView.DoesNotExist:
-            return Response(
-                {"error": "Analytic View Does not exist"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
+                {"error": "x-axis and y-axis dimensions are required"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        segment = request.GET.get("segment", False)
+        distribution = build_graph_plot(
+            queryset=queryset, x_axis=x_axis, y_axis=y_axis, segment=segment
+        )
+        total_issues = queryset.count()
+        return Response(
+            {"total": total_issues, "distribution": distribution},
+            status=status.HTTP_200_OK,
+        )
+
 
 class ExportAnalyticsEndpoint(BaseAPIView):
     permission_classes = [
@@ -174,33 +228,64 @@ 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)
+        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:
-                return Response(
-                    {"error": "x-axis and y-axis dimensions are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
+        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",
+        ]
 
-            analytic_export_task.delay(
-                email=request.user.email, data=request.data, slug=slug
-            )
+        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(
                 {
-                    "message": f"Once the export is ready it will be emailed to you at {str(request.user.email)}"
+                    "error": "x-axis and y-axis dimensions are required and the values should be valid"
                 },
-                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,
             )
 
+        # 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,
+            )
+
+        analytic_export_task.delay(
+            email=request.user.email, data=request.data, slug=slug
+        )
+
+        return Response(
+            {
+                "message": f"Once the export is ready it will be emailed to you at {str(request.user.email)}"
+            },
+            status=status.HTTP_200_OK,
+        )
+
 
 class DefaultAnalyticsEndpoint(BaseAPIView):
     permission_classes = [
@@ -208,90 +293,92 @@ class DefaultAnalyticsEndpoint(BaseAPIView):
     ]
 
     def get(self, request, slug):
-        try:
-            filters = issue_filters(request.GET, "GET")
+        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")
-                .annotate(state_count=Count("state_group"))
-                .order_by("state_group")
-            )
+        total_issues_classified = (
+            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_classified = (
-                queryset.filter(state__group__in=["backlog", "unstarted", "started"])
-                .annotate(state_group=F("state__group"))
-                .values("state_group")
-                .annotate(state_count=Count("state_group"))
-                .order_by("state_group")
-            )
+        open_issues = open_issues_queryset.count()
+        open_issues_classified = (
+            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)
-                .annotate(month=ExtractMonth("completed_at"))
-                .values("month")
-                .annotate(count=Count("*"))
-                .order_by("month")
-            )
-            most_issue_created_user = (
-                queryset.exclude(created_by=None)
-                .values("created_by__first_name", "created_by__last_name", "created_by__avatar", "created_by__display_name", "created_by__id")
-                .annotate(count=Count("id"))
-                .order_by("-count")
-            )[:5]
+        issue_completed_month_wise = (
+            base_issues.filter(completed_at__isnull=False)
+            .annotate(month=ExtractMonth("completed_at"))
+            .values("month")
+            .annotate(count=Count("*"))
+            .order_by("month")
+        )
 
-            most_issue_closed_user = (
-                queryset.filter(completed_at__isnull=False, assignees__isnull=False)
-                .values("assignees__first_name", "assignees__last_name", "assignees__avatar", "assignees__display_name", "assignees__id")
-                .annotate(count=Count("id"))
-                .order_by("-count")
-            )[:5]
+        user_details = [
+            "created_by__first_name",
+            "created_by__last_name",
+            "created_by__avatar",
+            "created_by__display_name",
+            "created_by__id",
+        ]
 
-            pending_issue_user = (
-                queryset.filter(completed_at__isnull=True)
-                .values("assignees__first_name", "assignees__last_name", "assignees__avatar", "assignees__display_name", "assignees__id")
-                .annotate(count=Count("id"))
-                .order_by("-count")
-            )
+        most_issue_created_user = (
+            base_issues.exclude(created_by=None)
+            .values(*user_details)
+            .annotate(count=Count("id"))
+            .order_by("-count")[:5]
+        )
 
-            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"]
+        user_assignee_details = [
+            "assignees__first_name",
+            "assignees__last_name",
+            "assignees__avatar",
+            "assignees__display_name",
+            "assignees__id",
+        ]
 
-            return Response(
-                {
-                    "total_issues": total_issues,
-                    "total_issues_classified": total_issues_classified,
-                    "open_issues": open_issues,
-                    "open_issues_classified": open_issues_classified,
-                    "issue_completed_month_wise": issue_completed_month_wise,
-                    "most_issue_created_user": most_issue_created_user,
-                    "most_issue_closed_user": most_issue_closed_user,
-                    "pending_issue_user": pending_issue_user,
-                    "open_estimate_sum": open_estimate_sum,
-                    "total_estimate_sum": total_estimate_sum,
-                },
-                status=status.HTTP_200_OK,
-            )
+        most_issue_closed_user = (
+            base_issues.filter(completed_at__isnull=False)
+            .exclude(assignees=None)
+            .values(*user_assignee_details)
+            .annotate(count=Count("id"))
+            .order_by("-count")[:5]
+        )
 
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        pending_issue_user = (
+            base_issues.filter(completed_at__isnull=True)
+            .values(*user_assignee_details)
+            .annotate(count=Count("id"))
+            .order_by("-count")
+        )
+
+        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(
+            {
+                "total_issues": total_issues,
+                "total_issues_classified": total_issues_classified,
+                "open_issues": open_issues,
+                "open_issues_classified": open_issues_classified,
+                "issue_completed_month_wise": issue_completed_month_wise,
+                "most_issue_created_user": most_issue_created_user,
+                "most_issue_closed_user": most_issue_closed_user,
+                "pending_issue_user": pending_issue_user,
+                "open_estimate_sum": open_estimate_sum,
+                "total_estimate_sum": total_estimate_sum,
+            },
+            status=status.HTTP_200_OK,
+        )

apiserver/plane/api/views/api_token.py

@@ -14,57 +14,34 @@ 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)
+        label = request.data.get("label", str(uuid4().hex))
+        workspace = request.data.get("workspace", False)
 
-            if not workspace:
-                return Response(
-                    {"error": "Workspace is required"}, status=status.HTTP_200_OK
-                )
-
-            api_token = APIToken.objects.create(
-                label=label, user=request.user, workspace_id=workspace
-            )
-
-            serializer = APITokenSerializer(api_token)
-            # Token will be only vissible while creating
+        if not workspace:
             return Response(
-                {"api_token": serializer.data, "token": api_token.token},
-                status=status.HTTP_201_CREATED,
+                {"error": "Workspace is required"}, 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,
-            )
+        api_token = APIToken.objects.create(
+            label=label, user=request.user, workspace_id=workspace
+        )
+
+        serializer = APITokenSerializer(api_token)
+        # Token will be only vissible while creating
+        return Response(
+            {"api_token": serializer.data, "token": api_token.token},
+            status=status.HTTP_201_CREATED,
+        )
+
 
     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,
-            )
+        api_tokens = APIToken.objects.filter(user=request.user)
+        serializer = APITokenSerializer(api_tokens, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
 
     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,
-            )
+        api_token = APIToken.objects.get(pk=pk)
+        api_token.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+

apiserver/plane/api/views/asset.py

@@ -18,108 +18,58 @@ 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():
-                serializer = FileAssetSerializer(files, context={"request": request}, many=True)
-                return Response({"data": serializer.data, "status": True}, status=status.HTTP_200_OK)
-            else:
-                return Response({"error": "Asset key does not exist", "status": False}, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        asset_key = str(workspace_id) + "/" + asset_key
+        files = FileAsset.objects.filter(asset=asset_key)
+        if files.exists():
+            serializer = FileAssetSerializer(files, context={"request": request}, many=True)
+            return Response({"data": serializer.data, "status": True}, status=status.HTTP_200_OK)
+        else:
+            return Response({"error": "Asset key does not exist", "status": False}, status=status.HTTP_200_OK)
 
 
     def post(self, request, slug):
-        try:
-            serializer = FileAssetSerializer(data=request.data)
-            if serializer.is_valid():
-                # Get the workspace
-                workspace = Workspace.objects.get(slug=slug)
-                serializer.save(workspace_id=workspace.id)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Workspace.DoesNotExist:
-            return Response({"error": "Workspace does not exist"}, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        serializer = FileAssetSerializer(data=request.data)
+        if serializer.is_valid():
+            # Get the workspace
+            workspace = Workspace.objects.get(slug=slug)
+            serializer.save(workspace_id=workspace.id)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
 
     def delete(self, request, workspace_id, asset_key):
-        try:
-            asset_key = str(workspace_id) + "/" + asset_key
-            file_asset = FileAsset.objects.get(asset=asset_key)
-            # Delete the file from storage
-            file_asset.asset.delete(save=False)
-            # Delete the file object
-            file_asset.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except FileAsset.DoesNotExist:
-            return Response(
-                {"error": "File Asset doesn't exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        asset_key = str(workspace_id) + "/" + asset_key
+        file_asset = FileAsset.objects.get(asset=asset_key)
+        # Delete the file from storage
+        file_asset.asset.delete(save=False)
+        # Delete the file object
+        file_asset.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
 
 
 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,32 +127,25 @@ class ResetPasswordEndpoint(BaseAPIView):
 
 class ChangePasswordEndpoint(BaseAPIView):
     def post(self, request):
-        try:
-            serializer = ChangePasswordSerializer(data=request.data)
+        serializer = ChangePasswordSerializer(data=request.data)
 
-            user = User.objects.get(pk=request.user.id)
-            if serializer.is_valid():
-                # Check old password
-                if not user.object.check_password(serializer.data.get("old_password")):
-                    return Response(
-                        {"old_password": ["Wrong password."]},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                # set_password also hashes the password that the user will get
-                self.object.set_password(serializer.data.get("new_password"))
-                self.object.save()
-                response = {
-                    "status": "success",
-                    "code": status.HTTP_200_OK,
-                    "message": "Password updated successfully",
-                }
+        user = User.objects.get(pk=request.user.id)
+        if serializer.is_valid():
+            # Check old password
+            if not user.object.check_password(serializer.data.get("old_password")):
+                return Response(
+                    {"old_password": ["Wrong password."]},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+            # set_password also hashes the password that the user will get
+            self.object.set_password(serializer.data.get("new_password"))
+            self.object.save()
+            response = {
+                "status": "success",
+                "code": status.HTTP_200_OK,
+                "message": "Password updated successfully",
+            }
 
-                return Response(response)
+            return Response(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,
-            )
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/api/views/authentication.py

@@ -40,229 +40,194 @@ class SignUpEndpoint(BaseAPIView):
     permission_classes = (AllowAny,)
 
     def post(self, request):
-        try:
-            if not settings.ENABLE_SIGNUP:
-                return Response(
-                    {
-                        "error": "New account creation is disabled. Please contact your site administrator"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            email = request.data.get("email", False)
-            password = request.data.get("password", False)
-
-            ## Raise exception if any of the above are missing
-            if not email or not password:
-                return Response(
-                    {"error": "Both email and password are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            email = email.strip().lower()
-
-            try:
-                validate_email(email)
-            except ValidationError as e:
-                return Response(
-                    {"error": "Please provide a valid email address."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            # Check if the user already exists
-            if User.objects.filter(email=email).exists():
-                return Response(
-                    {"error": "User with this email already exists"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            user = User.objects.create(email=email, username=uuid.uuid4().hex)
-            user.set_password(password)
-
-            # settings last actives for the user
-            user.last_active = timezone.now()
-            user.last_login_time = timezone.now()
-            user.last_login_ip = request.META.get("REMOTE_ADDR")
-            user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
-            user.token_updated_at = timezone.now()
-            user.save()
-
-            serialized_user = UserSerializer(user).data
-
-            access_token, refresh_token = get_tokens_for_user(user)
-
-            data = {
-                "access_token": access_token,
-                "refresh_token": refresh_token,
-                "user": serialized_user,
-            }
-
-            # Send Analytics
-            if settings.ANALYTICS_BASE_API:
-                _ = requests.post(
-                    settings.ANALYTICS_BASE_API,
-                    headers={
-                        "Content-Type": "application/json",
-                        "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
-                    },
-                    json={
-                        "event_id": uuid.uuid4().hex,
-                        "event_data": {
-                            "medium": "email",
-                        },
-                        "user": {"email": email, "id": str(user.id)},
-                        "device_ctx": {
-                            "ip": request.META.get("REMOTE_ADDR"),
-                            "user_agent": request.META.get("HTTP_USER_AGENT"),
-                        },
-                        "event_type": "SIGN_UP",
-                    },
-                )
-
-            return Response(data, status=status.HTTP_200_OK)
-
-        except Exception as e:
-            capture_exception(e)
+        if not settings.ENABLE_SIGNUP:
             return Response(
-                {"error": "Something went wrong please try again later"},
+                {
+                    "error": "New account creation is disabled. Please contact your site administrator"
+                },
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        email = request.data.get("email", False)
+        password = request.data.get("password", False)
+
+        ## Raise exception if any of the above are missing
+        if not email or not password:
+            return Response(
+                {"error": "Both email and password are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        email = email.strip().lower()
+
+        try:
+            validate_email(email)
+        except ValidationError as e:
+            return Response(
+                {"error": "Please provide a valid email address."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if the user already exists
+        if User.objects.filter(email=email).exists():
+            return Response(
+                {"error": "User with this email already exists"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        user = User.objects.create(email=email, username=uuid.uuid4().hex)
+        user.set_password(password)
+
+        # settings last actives for the user
+        user.last_active = timezone.now()
+        user.last_login_time = timezone.now()
+        user.last_login_ip = request.META.get("REMOTE_ADDR")
+        user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
+        user.token_updated_at = timezone.now()
+        user.save()
+
+        access_token, refresh_token = get_tokens_for_user(user)
+
+        data = {
+            "access_token": access_token,
+            "refresh_token": refresh_token,
+        }
+
+        # Send Analytics
+        if settings.ANALYTICS_BASE_API:
+            _ = requests.post(
+                settings.ANALYTICS_BASE_API,
+                headers={
+                    "Content-Type": "application/json",
+                    "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
+                },
+                json={
+                    "event_id": uuid.uuid4().hex,
+                    "event_data": {
+                        "medium": "email",
+                    },
+                    "user": {"email": email, "id": str(user.id)},
+                    "device_ctx": {
+                        "ip": request.META.get("REMOTE_ADDR"),
+                        "user_agent": request.META.get("HTTP_USER_AGENT"),
+                    },
+                    "event_type": "SIGN_UP",
+                },
+            )
+
+        return Response(data, status=status.HTTP_200_OK)
+
 
 class SignInEndpoint(BaseAPIView):
     permission_classes = (AllowAny,)
 
     def post(self, request):
-        try:
-            email = request.data.get("email", False)
-            password = request.data.get("password", False)
+        email = request.data.get("email", False)
+        password = request.data.get("password", False)
 
-            ## Raise exception if any of the above are missing
-            if not email or not password:
-                return Response(
-                    {"error": "Both email and password are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            email = email.strip().lower()
-
-            try:
-                validate_email(email)
-            except ValidationError as e:
-                return Response(
-                    {"error": "Please provide a valid email address."},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            user = User.objects.filter(email=email).first()
-
-            if user is None:
-                return Response(
-                    {
-                        "error": "Sorry, we could not find a user with the provided credentials. Please try again."
-                    },
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-
-            # Sign up Process
-            if not user.check_password(password):
-                return Response(
-                    {
-                        "error": "Sorry, we could not find a user with the provided credentials. Please try again."
-                    },
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-            if not user.is_active:
-                return Response(
-                    {
-                        "error": "Your account has been deactivated. Please contact your site administrator."
-                    },
-                    status=status.HTTP_403_FORBIDDEN,
-                )
-
-            serialized_user = UserSerializer(user).data
-
-            # settings last active for the user
-            user.last_active = timezone.now()
-            user.last_login_time = timezone.now()
-            user.last_login_ip = request.META.get("REMOTE_ADDR")
-            user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
-            user.token_updated_at = timezone.now()
-            user.save()
-
-            access_token, refresh_token = get_tokens_for_user(user)
-            # Send Analytics
-            if settings.ANALYTICS_BASE_API:
-                _ = requests.post(
-                    settings.ANALYTICS_BASE_API,
-                    headers={
-                        "Content-Type": "application/json",
-                        "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
-                    },
-                    json={
-                        "event_id": uuid.uuid4().hex,
-                        "event_data": {
-                            "medium": "email",
-                        },
-                        "user": {"email": email, "id": str(user.id)},
-                        "device_ctx": {
-                            "ip": request.META.get("REMOTE_ADDR"),
-                            "user_agent": request.META.get("HTTP_USER_AGENT"),
-                        },
-                        "event_type": "SIGN_IN",
-                    },
-                )
-            data = {
-                "access_token": access_token,
-                "refresh_token": refresh_token,
-                "user": serialized_user,
-            }
-
-            return Response(data, status=status.HTTP_200_OK)
-
-        except Exception as e:
-            capture_exception(e)
+        ## Raise exception if any of the above are missing
+        if not email or not password:
             return Response(
-                {
-                    "error": "Something went wrong. Please try again later or contact the support team."
-                },
+                {"error": "Both email and password are required"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        email = email.strip().lower()
+
+        try:
+            validate_email(email)
+        except ValidationError as e:
+            return Response(
+                {"error": "Please provide a valid email address."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        user = User.objects.filter(email=email).first()
+
+        if user is None:
+            return Response(
+                {
+                    "error": "Sorry, we could not find a user with the provided credentials. Please try again."
+                },
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        # Sign up Process
+        if not user.check_password(password):
+            return Response(
+                {
+                    "error": "Sorry, we could not find a user with the provided credentials. Please try again."
+                },
+                status=status.HTTP_403_FORBIDDEN,
+            )
+        if not user.is_active:
+            return Response(
+                {
+                    "error": "Your account has been deactivated. Please contact your site administrator."
+                },
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        # settings last active for the user
+        user.last_active = timezone.now()
+        user.last_login_time = timezone.now()
+        user.last_login_ip = request.META.get("REMOTE_ADDR")
+        user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
+        user.token_updated_at = timezone.now()
+        user.save()
+
+        access_token, refresh_token = get_tokens_for_user(user)
+        # Send Analytics
+        if settings.ANALYTICS_BASE_API:
+            _ = requests.post(
+                settings.ANALYTICS_BASE_API,
+                headers={
+                    "Content-Type": "application/json",
+                    "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
+                },
+                json={
+                    "event_id": uuid.uuid4().hex,
+                    "event_data": {
+                        "medium": "email",
+                    },
+                    "user": {"email": email, "id": str(user.id)},
+                    "device_ctx": {
+                        "ip": request.META.get("REMOTE_ADDR"),
+                        "user_agent": request.META.get("HTTP_USER_AGENT"),
+                    },
+                    "event_type": "SIGN_IN",
+                },
+            )
+        data = {
+            "access_token": access_token,
+            "refresh_token": refresh_token,
+        }
+
+        return Response(data, status=status.HTTP_200_OK)
+
 
 class SignOutEndpoint(BaseAPIView):
     def post(self, request):
-        try:
-            refresh_token = request.data.get("refresh_token", False)
+        refresh_token = request.data.get("refresh_token", False)
 
-            if not refresh_token:
-                capture_message("No refresh token provided")
-                return Response(
-                    {
-                        "error": "Something went wrong. Please try again later or contact the support team."
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            user = User.objects.get(pk=request.user.id)
-
-            user.last_logout_time = timezone.now()
-            user.last_logout_ip = request.META.get("REMOTE_ADDR")
-
-            user.save()
-
-            token = RefreshToken(refresh_token)
-            token.blacklist()
-            return Response({"message": "success"}, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
+        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,
             )
 
+        user = User.objects.get(pk=request.user.id)
+
+        user.last_logout_time = timezone.now()
+        user.last_logout_ip = request.META.get("REMOTE_ADDR")
+
+        user.save()
+
+        token = RefreshToken(refresh_token)
+        token.blacklist()
+        return Response({"message": "success"}, status=status.HTTP_200_OK)
+
 
 class MagicSignInGenerateEndpoint(BaseAPIView):
     permission_classes = [
@@ -270,74 +235,62 @@ class MagicSignInGenerateEndpoint(BaseAPIView):
     ]
 
     def post(self, request):
-        try:
-            email = request.data.get("email", False)
+        email = request.data.get("email", False)
 
-            if not email:
+        if not email:
+            return Response(
+                {"error": "Please provide a valid email address"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Clean up
+        email = email.strip().lower()
+        validate_email(email)
+
+        ## Generate a random token
+        token = (
+            "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
+            + "-"
+            + "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
+            + "-"
+            + "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
+        )
+
+        ri = redis_instance()
+
+        key = "magic_" + str(email)
+
+        # Check if the key already exists in python
+        if ri.exists(key):
+            data = json.loads(ri.get(key))
+
+            current_attempt = data["current_attempt"] + 1
+
+            if data["current_attempt"] > 2:
                 return Response(
-                    {"error": "Please provide a valid email address"},
+                    {"error": "Max attempts exhausted. Please try again later."},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            # Clean up
-            email = email.strip().lower()
-            validate_email(email)
+            value = {
+                "current_attempt": current_attempt,
+                "email": email,
+                "token": token,
+            }
+            expiry = 600
 
-            ## Generate a random token
-            token = (
-                "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
-                + "-"
-                + "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
-                + "-"
-                + "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
-            )
+            ri.set(key, json.dumps(value), ex=expiry)
 
-            ri = redis_instance()
+        else:
+            value = {"current_attempt": 0, "email": email, "token": token}
+            expiry = 600
 
-            key = "magic_" + str(email)
+            ri.set(key, json.dumps(value), ex=expiry)
 
-            # Check if the key already exists in python
-            if ri.exists(key):
-                data = json.loads(ri.get(key))
+        current_site = settings.WEB_URL
+        magic_link.delay(email, key, token, current_site)
 
-                current_attempt = data["current_attempt"] + 1
-
-                if data["current_attempt"] > 2:
-                    return Response(
-                        {"error": "Max attempts exhausted. Please try again later."},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-
-                value = {
-                    "current_attempt": current_attempt,
-                    "email": email,
-                    "token": token,
-                }
-                expiry = 600
-
-                ri.set(key, json.dumps(value), ex=expiry)
-
-            else:
-                value = {"current_attempt": 0, "email": email, "token": token}
-                expiry = 600
-
-                ri.set(key, json.dumps(value), ex=expiry)
-
-            current_site = settings.WEB_URL
-            magic_link.delay(email, key, token, current_site)
-
-            return Response({"key": key}, status=status.HTTP_200_OK)
-        except ValidationError:
-            return Response(
-                {"error": "Please provide a valid email address."},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        return Response({"key": key}, status=status.HTTP_200_OK)
 
 
 class MagicSignInEndpoint(BaseAPIView):
@@ -346,113 +299,99 @@ class MagicSignInEndpoint(BaseAPIView):
     ]
 
     def post(self, request):
-        try:
-            user_token = request.data.get("token", "").strip()
-            key = request.data.get("key", False).strip().lower()
+        user_token = request.data.get("token", "").strip()
+        key = request.data.get("key", False).strip().lower()
 
-            if not key or user_token == "":
-                return Response(
-                    {"error": "User token and key are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
+        if not key or user_token == "":
+            return Response(
+                {"error": "User token and key are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
 
-            ri = redis_instance()
+        ri = redis_instance()
 
-            if ri.exists(key):
-                data = json.loads(ri.get(key))
+        if ri.exists(key):
+            data = json.loads(ri.get(key))
 
-                token = data["token"]
-                email = data["email"]
+            token = data["token"]
+            email = data["email"]
 
-                if str(token) == str(user_token):
-                    if User.objects.filter(email=email).exists():
-                        user = User.objects.get(email=email)
-                        # Send event to Jitsu for tracking
-                        if settings.ANALYTICS_BASE_API:
-                            _ = requests.post(
-                                settings.ANALYTICS_BASE_API,
-                                headers={
-                                    "Content-Type": "application/json",
-                                    "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
+            if str(token) == str(user_token):
+                if User.objects.filter(email=email).exists():
+                    user = User.objects.get(email=email)
+                    # Send event to Jitsu for tracking
+                    if settings.ANALYTICS_BASE_API:
+                        _ = requests.post(
+                            settings.ANALYTICS_BASE_API,
+                            headers={
+                                "Content-Type": "application/json",
+                                "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
+                            },
+                            json={
+                                "event_id": uuid.uuid4().hex,
+                                "event_data": {
+                                    "medium": "code",
                                 },
-                                json={
-                                    "event_id": uuid.uuid4().hex,
-                                    "event_data": {
-                                        "medium": "code",
-                                    },
-                                    "user": {"email": email, "id": str(user.id)},
-                                    "device_ctx": {
-                                        "ip": request.META.get("REMOTE_ADDR"),
-                                        "user_agent": request.META.get(
-                                            "HTTP_USER_AGENT"
-                                        ),
-                                    },
-                                    "event_type": "SIGN_IN",
+                                "user": {"email": email, "id": str(user.id)},
+                                "device_ctx": {
+                                    "ip": request.META.get("REMOTE_ADDR"),
+                                    "user_agent": request.META.get("HTTP_USER_AGENT"),
                                 },
-                            )
-                    else:
-                        user = User.objects.create(
-                            email=email,
-                            username=uuid.uuid4().hex,
-                            password=make_password(uuid.uuid4().hex),
-                            is_password_autoset=True,
+                                "event_type": "SIGN_IN",
+                            },
                         )
-                        # Send event to Jitsu for tracking
-                        if settings.ANALYTICS_BASE_API:
-                            _ = requests.post(
-                                settings.ANALYTICS_BASE_API,
-                                headers={
-                                    "Content-Type": "application/json",
-                                    "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
-                                },
-                                json={
-                                    "event_id": uuid.uuid4().hex,
-                                    "event_data": {
-                                        "medium": "code",
-                                    },
-                                    "user": {"email": email, "id": str(user.id)},
-                                    "device_ctx": {
-                                        "ip": request.META.get("REMOTE_ADDR"),
-                                        "user_agent": request.META.get(
-                                            "HTTP_USER_AGENT"
-                                        ),
-                                    },
-                                    "event_type": "SIGN_UP",
-                                },
-                            )
-
-                    user.last_active = timezone.now()
-                    user.last_login_time = timezone.now()
-                    user.last_login_ip = request.META.get("REMOTE_ADDR")
-                    user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
-                    user.token_updated_at = timezone.now()
-                    user.save()
-                    serialized_user = UserSerializer(user).data
-
-                    access_token, refresh_token = get_tokens_for_user(user)
-                    data = {
-                        "access_token": access_token,
-                        "refresh_token": refresh_token,
-                        "user": serialized_user,
-                    }
-
-                    return Response(data, status=status.HTTP_200_OK)
-
                 else:
-                    return Response(
-                        {"error": "Your login code was incorrect. Please try again."},
-                        status=status.HTTP_400_BAD_REQUEST,
+                    user = User.objects.create(
+                        email=email,
+                        username=uuid.uuid4().hex,
+                        password=make_password(uuid.uuid4().hex),
+                        is_password_autoset=True,
                     )
+                    # Send event to Jitsu for tracking
+                    if settings.ANALYTICS_BASE_API:
+                        _ = requests.post(
+                            settings.ANALYTICS_BASE_API,
+                            headers={
+                                "Content-Type": "application/json",
+                                "X-Auth-Token": settings.ANALYTICS_SECRET_KEY,
+                            },
+                            json={
+                                "event_id": uuid.uuid4().hex,
+                                "event_data": {
+                                    "medium": "code",
+                                },
+                                "user": {"email": email, "id": str(user.id)},
+                                "device_ctx": {
+                                    "ip": request.META.get("REMOTE_ADDR"),
+                                    "user_agent": request.META.get("HTTP_USER_AGENT"),
+                                },
+                                "event_type": "SIGN_UP",
+                            },
+                        )
+
+                user.last_active = timezone.now()
+                user.last_login_time = timezone.now()
+                user.last_login_ip = request.META.get("REMOTE_ADDR")
+                user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
+                user.token_updated_at = timezone.now()
+                user.save()
+
+                access_token, refresh_token = get_tokens_for_user(user)
+                data = {
+                    "access_token": access_token,
+                    "refresh_token": refresh_token,
+                }
+
+                return Response(data, status=status.HTTP_200_OK)
 
             else:
                 return Response(
-                    {"error": "The magic code/link has expired please try again"},
+                    {"error": "Your login code was incorrect. Please try again."},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-        except Exception as e:
-            capture_exception(e)
+        else:
             return Response(
-                {"error": "Something went wrong please try again later"},
+                {"error": "The magic code/link has expired please try again"},
                 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
@@ -58,17 +60,50 @@ class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
         except Exception as e:
             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):
-        response = super().dispatch(request, *args, **kwargs)
+        try:
+            response = super().dispatch(request, *args, **kwargs)
 
-        if settings.DEBUG:
-            from django.db import connection
+            if settings.DEBUG:
+                from django.db import connection
 
-            print(
-                f"{request.method} - {request.get_full_path()} of Queries: {len(connection.queries)}"
-            )
-        return response
+                print(
+                    f"{request.method} - {request.get_full_path()} of Queries: {len(connection.queries)}"
+                )
+            return response
+
+        except Exception as exc:
+            response = self.handle_exception(exc)
+            return exc
 
     @property
     def workspace_slug(self):
@@ -104,16 +139,49 @@ 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):
-        response = super().dispatch(request, *args, **kwargs)
+        try:
+            response = super().dispatch(request, *args, **kwargs)
 
-        if settings.DEBUG:
-            from django.db import connection
+            if settings.DEBUG:
+                from django.db import connection
 
-            print(
-                f"{request.method} - {request.get_full_path()} of Queries: {len(connection.queries)}"
-            )
-        return response
+                print(
+                    f"{request.method} - {request.get_full_path()} of Queries: {len(connection.queries)}"
+                )
+            return response
+
+        except Exception as exc:
+            response = self.handle_exception(exc)
+            return exc
 
     @property
     def workspace_slug(self):

apiserver/plane/api/views/config.py

@@ -20,21 +20,14 @@ 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)
-            data["github_app_name"] = os.environ.get("GITHUB_APP_NAME", None)
-            data["magic_login"] = (
-                bool(settings.EMAIL_HOST_USER) and bool(settings.EMAIL_HOST_PASSWORD)
-            ) and os.environ.get("ENABLE_MAGIC_LINK_LOGIN", "0") == "1"
-            data["email_password_login"] = (
-                os.environ.get("ENABLE_EMAIL_PASSWORD", "0") == "1"
-            )
-            return Response(data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        data = {}
+        data["google"] = os.environ.get("GOOGLE_CLIENT_ID", None)
+        data["github"] = os.environ.get("GITHUB_CLIENT_ID", None)
+        data["github_app_name"] = os.environ.get("GITHUB_APP_NAME", None)
+        data["magic_login"] = (
+            bool(settings.EMAIL_HOST_USER) and bool(settings.EMAIL_HOST_PASSWORD)
+        ) and os.environ.get("ENABLE_MAGIC_LINK_LOGIN", "0") == "1"
+        data["email_password_login"] = (
+            os.environ.get("ENABLE_EMAIL_PASSWORD", "0") == "1"
+        )
+        return Response(data, status=status.HTTP_200_OK)

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,204 +40,139 @@ 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,
-            )
+        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)
 
     def create(self, request, slug, project_id):
-        try:
-            if not request.data.get("estimate", False):
-                return Response(
-                    {"error": "Estimate is required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            estimate_points = request.data.get("estimate_points", [])
-
-            if not len(estimate_points) or len(estimate_points) > 8:
-                return Response(
-                    {"error": "Estimate points are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            estimate_serializer = EstimateSerializer(data=request.data.get("estimate"))
-            if not estimate_serializer.is_valid():
-                return Response(
-                    estimate_serializer.errors, status=status.HTTP_400_BAD_REQUEST
-                )
-            try:
-                estimate = estimate_serializer.save(project_id=project_id)
-            except IntegrityError:
-                return Response(
-                    {"errror": "Estimate with the name already exists"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            estimate_points = EstimatePoint.objects.bulk_create(
-                [
-                    EstimatePoint(
-                        estimate=estimate,
-                        key=estimate_point.get("key", 0),
-                        value=estimate_point.get("value", ""),
-                        description=estimate_point.get("description", ""),
-                        project_id=project_id,
-                        workspace_id=estimate.workspace_id,
-                        created_by=request.user,
-                        updated_by=request.user,
-                    )
-                    for estimate_point in estimate_points
-                ],
-                batch_size=10,
-                ignore_conflicts=True,
-            )
-
-            estimate_point_serializer = EstimatePointSerializer(
-                estimate_points, many=True
-            )
-
+        if not request.data.get("estimate", False):
             return Response(
-                {
-                    "estimate": estimate_serializer.data,
-                    "estimate_points": estimate_point_serializer.data,
-                },
-                status=status.HTTP_200_OK,
-            )
-        except Estimate.DoesNotExist:
-            return Response(
-                {"error": "Estimate does not exist"},
+                {"error": "Estimate is required"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-        except Exception as e:
-            capture_exception(e)
+
+        estimate_points = request.data.get("estimate_points", [])
+
+        if not len(estimate_points) or len(estimate_points) > 8:
             return Response(
-                {"error": "Something went wrong please try again later"},
+                {"error": "Estimate points are required"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        estimate_serializer = EstimateSerializer(data=request.data.get("estimate"))
+        if not estimate_serializer.is_valid():
+            return Response(
+                estimate_serializer.errors, status=status.HTTP_400_BAD_REQUEST
+            )
+        estimate = estimate_serializer.save(project_id=project_id)
+        estimate_points = EstimatePoint.objects.bulk_create(
+            [
+                EstimatePoint(
+                    estimate=estimate,
+                    key=estimate_point.get("key", 0),
+                    value=estimate_point.get("value", ""),
+                    description=estimate_point.get("description", ""),
+                    project_id=project_id,
+                    workspace_id=estimate.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for estimate_point in estimate_points
+            ],
+            batch_size=10,
+            ignore_conflicts=True,
+        )
+
+        estimate_point_serializer = EstimatePointSerializer(
+            estimate_points, many=True
+        )
+
+        return Response(
+            {
+                "estimate": estimate_serializer.data,
+                "estimate_points": estimate_point_serializer.data,
+            },
+            status=status.HTTP_200_OK,
+        )
+
     def retrieve(self, request, slug, project_id, estimate_id):
-        try:
-            estimate = Estimate.objects.get(
-                pk=estimate_id, workspace__slug=slug, project_id=project_id
-            )
-            serializer = EstimateReadSerializer(estimate)
-            return Response(
-                serializer.data,
-                status=status.HTTP_200_OK,
-            )
-        except Estimate.DoesNotExist:
-            return Response(
-                {"error": "Estimate does not exist"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        estimate = Estimate.objects.get(
+            pk=estimate_id, workspace__slug=slug, project_id=project_id
+        )
+        serializer = EstimateReadSerializer(estimate)
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK,
+        )
 
     def partial_update(self, request, slug, project_id, estimate_id):
-        try:
-            if not request.data.get("estimate", False):
-                return Response(
-                    {"error": "Estimate is required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if not len(request.data.get("estimate_points", [])):
-                return Response(
-                    {"error": "Estimate points are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            estimate = Estimate.objects.get(pk=estimate_id)
-
-            estimate_serializer = EstimateSerializer(
-                estimate, data=request.data.get("estimate"), partial=True
-            )
-            if not estimate_serializer.is_valid():
-                return Response(
-                    estimate_serializer.errors, status=status.HTTP_400_BAD_REQUEST
-                )
-            try:
-                estimate = estimate_serializer.save()
-            except IntegrityError:
-                return Response(
-                    {"errror": "Estimate with the name already exists"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            estimate_points_data = request.data.get("estimate_points", [])
-
-            estimate_points = EstimatePoint.objects.filter(
-                pk__in=[
-                    estimate_point.get("id") for estimate_point in estimate_points_data
-                ],
-                workspace__slug=slug,
-                project_id=project_id,
-                estimate_id=estimate_id,
-            )
-
-            updated_estimate_points = []
-            for estimate_point in estimate_points:
-                # Find the data for that estimate point
-                estimate_point_data = [
-                    point
-                    for point in estimate_points_data
-                    if point.get("id") == str(estimate_point.id)
-                ]
-                if len(estimate_point_data):
-                    estimate_point.value = estimate_point_data[0].get(
-                        "value", estimate_point.value
-                    )
-                    updated_estimate_points.append(estimate_point)
-
-            try:
-                EstimatePoint.objects.bulk_update(
-                    updated_estimate_points, ["value"], batch_size=10,
-                )
-            except IntegrityError as e:
-                return Response(
-                    {"error": "Values need to be unique for each key"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            estimate_point_serializer = EstimatePointSerializer(estimate_points, many=True)
+        if not request.data.get("estimate", False):
             return Response(
-                {
-                    "estimate": estimate_serializer.data,
-                    "estimate_points": estimate_point_serializer.data,
-                },
-                status=status.HTTP_200_OK,
-            )
-        except Estimate.DoesNotExist:
-            return Response(
-                {"error": "Estimate does not exist"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
+                {"error": "Estimate is required"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        if not len(request.data.get("estimate_points", [])):
+            return Response(
+                {"error": "Estimate points are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        estimate = Estimate.objects.get(pk=estimate_id)
+
+        estimate_serializer = EstimateSerializer(
+            estimate, data=request.data.get("estimate"), partial=True
+        )
+        if not estimate_serializer.is_valid():
+            return Response(
+                estimate_serializer.errors, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        estimate = estimate_serializer.save()
+
+        estimate_points_data = request.data.get("estimate_points", [])
+
+        estimate_points = EstimatePoint.objects.filter(
+            pk__in=[
+                estimate_point.get("id") for estimate_point in estimate_points_data
+            ],
+            workspace__slug=slug,
+            project_id=project_id,
+            estimate_id=estimate_id,
+        )
+
+        updated_estimate_points = []
+        for estimate_point in estimate_points:
+            # Find the data for that estimate point
+            estimate_point_data = [
+                point
+                for point in estimate_points_data
+                if point.get("id") == str(estimate_point.id)
+            ]
+            if len(estimate_point_data):
+                estimate_point.value = estimate_point_data[0].get(
+                    "value", estimate_point.value
+                )
+                updated_estimate_points.append(estimate_point)
+
+        EstimatePoint.objects.bulk_update(
+            updated_estimate_points, ["value"], batch_size=10,
+        )
+
+        estimate_point_serializer = EstimatePointSerializer(estimate_points, many=True)
+        return Response(
+            {
+                "estimate": estimate_serializer.data,
+                "estimate_points": estimate_point_serializer.data,
+            },
+            status=status.HTTP_200_OK,
+        )
+
     def destroy(self, request, slug, 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,
-            )
+        estimate = Estimate.objects.get(
+            pk=estimate_id, workspace__slug=slug, project_id=project_id
+        )
+        estimate.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/exporter.py

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

apiserver/plane/api/views/external.py

@@ -25,94 +25,68 @@ 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"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            prompt = request.data.get("prompt", False)
-            task = request.data.get("task", False)
-
-            if not task:
-                return Response(
-                    {"error": "Task is required"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            final_text = task + "\n" + prompt
-
-            openai.api_key = settings.OPENAI_API_KEY
-            response = openai.ChatCompletion.create(
-                model=settings.GPT_ENGINE,
-                messages=[{"role": "user", "content": final_text}],
-                temperature=0.7,
-                max_tokens=1024,
-            )
-
-            workspace = Workspace.objects.get(slug=slug)
-            project = Project.objects.get(pk=project_id)
-
-            text = response.choices[0].message.content.strip()
-            text_html = text.replace("\n", "<br/>")
+        if not settings.OPENAI_API_KEY or not settings.GPT_ENGINE:
             return Response(
-                {
-                    "response": text,
-                    "response_html": text_html,
-                    "project_detail": ProjectLiteSerializer(project).data,
-                    "workspace_detail": WorkspaceLiteSerializer(workspace).data,
-                },
-                status=status.HTTP_200_OK,
-            )
-        except (Workspace.DoesNotExist, Project.DoesNotExist) as e:
-            return Response(
-                {"error": "Workspace or Project Does not exist"},
+                {"error": "OpenAI API key and engine is required"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-        except Exception as e:
-            capture_exception(e)
+
+        prompt = request.data.get("prompt", False)
+        task = request.data.get("task", False)
+
+        if not task:
             return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
+                {"error": "Task is required"}, status=status.HTTP_400_BAD_REQUEST
             )
 
+        final_text = task + "\n" + prompt
+
+        openai.api_key = settings.OPENAI_API_KEY
+        response = openai.ChatCompletion.create(
+            model=settings.GPT_ENGINE,
+            messages=[{"role": "user", "content": final_text}],
+            temperature=0.7,
+            max_tokens=1024,
+        )
+
+        workspace = Workspace.objects.get(slug=slug)
+        project = Project.objects.get(pk=project_id)
+
+        text = response.choices[0].message.content.strip()
+        text_html = text.replace("\n", "<br/>")
+        return Response(
+            {
+                "response": text,
+                "response_html": text_html,
+                "project_detail": ProjectLiteSerializer(project).data,
+                "workspace_detail": WorkspaceLiteSerializer(workspace).data,
+            },
+            status=status.HTTP_200_OK,
+        )
+
 
 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,
-            )
+        release_notes = get_release_notes()
+        return Response(release_notes, status=status.HTTP_200_OK)
 
 
 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)
+        query = request.GET.get("query", False)
+        page = request.GET.get("page", 1)
+        per_page = request.GET.get("per_page", 20)
 
-            url = (
-                f"https://api.unsplash.com/search/photos/?client_id={settings.UNSPLASH_ACCESS_KEY}&query={query}&page=${page}&per_page={per_page}"
-                if query
-                else f"https://api.unsplash.com/photos/?client_id={settings.UNSPLASH_ACCESS_KEY}&page={page}&per_page={per_page}"
-            )
+        url = (
+            f"https://api.unsplash.com/search/photos/?client_id={settings.UNSPLASH_ACCESS_KEY}&query={query}&page=${page}&per_page={per_page}"
+            if query
+            else f"https://api.unsplash.com/photos/?client_id={settings.UNSPLASH_ACCESS_KEY}&page={page}&per_page={per_page}"
+        )
 
-            headers = {
-                "Content-Type": "application/json",
-            }
+        headers = {
+            "Content-Type": "application/json",
+        }
 
-            resp = requests.get(url=url, headers=headers)
-            return Response(resp.json(), status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        resp = requests.get(url=url, headers=headers)
+        return Response(resp.json(), status=status.HTTP_200_OK)

apiserver/plane/api/views/importer.py

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

apiserver/plane/api/views/inbox.py

@@ -64,24 +64,17 @@ 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
-            )
-            # Handle default inbox delete
-            if inbox.is_default:
-                return Response(
-                    {"error": "You cannot delete the default inbox"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            inbox.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except Exception as e:
-            capture_exception(e)
+        inbox = Inbox.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=pk
+        )
+        # Handle default inbox delete
+        if inbox.is_default:
             return Response(
-                {"error": "Something went wronf please try again later"},
+                {"error": "You cannot delete the default inbox"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
+        inbox.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
 
 
 class InboxIssueViewSet(BaseViewSet):
@@ -110,281 +103,239 @@ class InboxIssueViewSet(BaseViewSet):
         )
 
     def list(self, request, slug, project_id, inbox_id):
-        try:
-            filters = issue_filters(request.query_params, "GET")
-            issues = (
-                Issue.objects.filter(
-                    issue_inbox__inbox_id=inbox_id,
-                    workspace__slug=slug,
-                    project_id=project_id,
+        filters = issue_filters(request.query_params, "GET")
+        issues = (
+            Issue.objects.filter(
+                issue_inbox__inbox_id=inbox_id,
+                workspace__slug=slug,
+                project_id=project_id,
+            )
+            .filter(**filters)
+            .annotate(bridge_id=F("issue_inbox__id"))
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels")
+            .order_by("issue_inbox__snoozed_till", "issue_inbox__status")
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
-                .filter(**filters)
-                .annotate(bridge_id=F("issue_inbox__id"))
-                .select_related("workspace", "project", "state", "parent")
-                .prefetch_related("assignees", "labels")
-                .order_by("issue_inbox__snoozed_till", "issue_inbox__status")
-                .annotate(
-                    sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    attachment_count=IssueAttachment.objects.filter(
-                        issue=OuterRef("id")
-                    )
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .prefetch_related(
-                    Prefetch(
-                        "issue_inbox",
-                        queryset=InboxIssue.objects.only(
-                            "status", "duplicate_to", "snoozed_till", "source"
-                        ),
-                    )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_inbox",
+                    queryset=InboxIssue.objects.only(
+                        "status", "duplicate_to", "snoozed_till", "source"
+                    ),
                 )
             )
-            issues_data = IssueStateInboxSerializer(issues, many=True).data
-            return Response(
-                issues_data,
-                status=status.HTTP_200_OK,
-            )
+        )
+        issues_data = IssueStateInboxSerializer(issues, many=True).data
+        return Response(
+            issues_data,
+            status=status.HTTP_200_OK,
+        )
 
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
 
     def create(self, request, slug, project_id, inbox_id):
-        try:
-            if not request.data.get("issue", {}).get("name", False):
-                return Response(
-                    {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            # Check for valid priority
-            if not request.data.get("issue", {}).get("priority", "none") in [
-                "low",
-                "medium",
-                "high",
-                "urgent",
-                "none",
-            ]:
-                return Response(
-                    {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            # Create or get state
-            state, _ = State.objects.get_or_create(
-                name="Triage",
-                group="backlog",
-                description="Default state for managing all Inbox Issues",
-                project_id=project_id,
-                color="#ff7700",
-            )
-
-            # create an issue
-            issue = Issue.objects.create(
-                name=request.data.get("issue", {}).get("name"),
-                description=request.data.get("issue", {}).get("description", {}),
-                description_html=request.data.get("issue", {}).get(
-                    "description_html", "<p></p>"
-                ),
-                priority=request.data.get("issue", {}).get("priority", "low"),
-                project_id=project_id,
-                state=state,
-            )
-
-            # Create an Issue Activity
-            issue_activity.delay(
-                type="issue.activity.created",
-                requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
-                actor_id=str(request.user.id),
-                issue_id=str(issue.id),
-                project_id=str(project_id),
-                current_instance=None,
-                epoch=int(timezone.now().timestamp())
-            )
-            # create an inbox issue
-            InboxIssue.objects.create(
-                inbox_id=inbox_id,
-                project_id=project_id,
-                issue=issue,
-                source=request.data.get("source", "in-app"),
-            )
-
-            serializer = IssueStateInboxSerializer(issue)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
+        if not request.data.get("issue", {}).get("name", False):
             return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
+                {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
             )
 
+        # Check for valid priority
+        if not request.data.get("issue", {}).get("priority", "none") in [
+            "low",
+            "medium",
+            "high",
+            "urgent",
+            "none",
+        ]:
+            return Response(
+                {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # Create or get state
+        state, _ = State.objects.get_or_create(
+            name="Triage",
+            group="backlog",
+            description="Default state for managing all Inbox Issues",
+            project_id=project_id,
+            color="#ff7700",
+        )
+
+        # create an issue
+        issue = Issue.objects.create(
+            name=request.data.get("issue", {}).get("name"),
+            description=request.data.get("issue", {}).get("description", {}),
+            description_html=request.data.get("issue", {}).get(
+                "description_html", "<p></p>"
+            ),
+            priority=request.data.get("issue", {}).get("priority", "low"),
+            project_id=project_id,
+            state=state,
+        )
+
+        # Create an Issue Activity
+        issue_activity.delay(
+            type="issue.activity.created",
+            requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+            actor_id=str(request.user.id),
+            issue_id=str(issue.id),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp())
+        )
+        # create an inbox issue
+        InboxIssue.objects.create(
+            inbox_id=inbox_id,
+            project_id=project_id,
+            issue=issue,
+            source=request.data.get("source", "in-app"),
+        )
+
+        serializer = IssueStateInboxSerializer(issue)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
     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
+        inbox_issue = InboxIssue.objects.get(
+            pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+        )
+        # Get the project member
+        project_member = ProjectMember.objects.get(workspace__slug=slug, project_id=project_id, member=request.user)
+        # Only project members admins and created_by users can access this endpoint
+        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(request.user.id):
+            return Response({"error": "You cannot edit inbox issues"}, status=status.HTTP_400_BAD_REQUEST)
+
+        # Get issue data
+        issue_data = request.data.pop("issue", False)
+
+        if bool(issue_data):
+            issue = Issue.objects.get(
+                pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
             )
-            # Get the project member
-            project_member = ProjectMember.objects.get(workspace__slug=slug, project_id=project_id, member=request.user)
-            # Only project members admins and created_by users can access this endpoint
-            if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(request.user.id):
-                return Response({"error": "You cannot edit inbox issues"}, status=status.HTTP_400_BAD_REQUEST)
+            # Only allow guests and viewers to edit name and description
+            if project_member.role <= 10:
+                # viewers and guests since only viewers and guests 
+                issue_data = {
+                    "name": issue_data.get("name", issue.name),
+                    "description_html": issue_data.get("description_html", issue.description_html),
+                    "description": issue_data.get("description", issue.description)
+                }
 
-            # Get issue data
-            issue_data = request.data.pop("issue", False)
+            issue_serializer = IssueCreateSerializer(
+                issue, data=issue_data, partial=True
+            )
 
-            if bool(issue_data):
-                issue = Issue.objects.get(
-                    pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
-                )
-                # Only allow guests and viewers to edit name and description
-                if project_member.role <= 10:
-                    # viewers and guests since only viewers and guests 
-                    issue_data = {
-                        "name": issue_data.get("name", issue.name),
-                        "description_html": issue_data.get("description_html", issue.description_html),
-                        "description": issue_data.get("description", issue.description)
-                    }
-
-                issue_serializer = IssueCreateSerializer(
-                    issue, data=issue_data, partial=True
+            if issue_serializer.is_valid():
+                current_instance = issue
+                # Log all the updates
+                requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
+                if issue is not None:
+                    issue_activity.delay(
+                        type="issue.activity.updated",
+                        requested_data=requested_data,
+                        actor_id=str(request.user.id),
+                        issue_id=str(issue.id),
+                        project_id=str(project_id),
+                        current_instance=json.dumps(
+                            IssueSerializer(current_instance).data,
+                            cls=DjangoJSONEncoder,
+                        ),
+                        epoch=int(timezone.now().timestamp())
+                    )
+                issue_serializer.save()
+            else:
+                return Response(
+                    issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
                 )
 
-                if issue_serializer.is_valid():
-                    current_instance = issue
-                    # Log all the updates
-                    requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
-                    if issue is not None:
-                        issue_activity.delay(
-                            type="issue.activity.updated",
-                            requested_data=requested_data,
-                            actor_id=str(request.user.id),
-                            issue_id=str(issue.id),
-                            project_id=str(project_id),
-                            current_instance=json.dumps(
-                                IssueSerializer(current_instance).data,
-                                cls=DjangoJSONEncoder,
-                            ),
-                            epoch=int(timezone.now().timestamp())
-                        )
-                    issue_serializer.save()
-                else:
-                    return Response(
-                        issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
+        # Only project admins and members can edit inbox issue attributes
+        if project_member.role > 10:
+            serializer = InboxIssueSerializer(
+                inbox_issue, data=request.data, partial=True
+            )
+
+            if serializer.is_valid():
+                serializer.save()
+                # Update the issue state if the issue is rejected or marked as duplicate
+                if serializer.data["status"] in [-1, 2]:
+                    issue = Issue.objects.get(
+                        pk=inbox_issue.issue_id,
+                        workspace__slug=slug,
+                        project_id=project_id,
+                    )
+                    state = State.objects.filter(
+                        group="cancelled", workspace__slug=slug, project_id=project_id
+                    ).first()
+                    if state is not None:
+                        issue.state = state
+                        issue.save()
+
+                # Update the issue state if it is accepted
+                if serializer.data["status"] in [1]:
+                    issue = Issue.objects.get(
+                        pk=inbox_issue.issue_id,
+                        workspace__slug=slug,
+                        project_id=project_id,
                     )
 
-            # Only project admins and members can edit inbox issue attributes
-            if project_member.role > 10:
-                serializer = InboxIssueSerializer(
-                    inbox_issue, data=request.data, partial=True
-                )
-
-                if serializer.is_valid():
-                    serializer.save()
-                    # Update the issue state if the issue is rejected or marked as duplicate
-                    if serializer.data["status"] in [-1, 2]:
-                        issue = Issue.objects.get(
-                            pk=inbox_issue.issue_id,
-                            workspace__slug=slug,
-                            project_id=project_id,
-                        )
+                    # Update the issue state only if it is in triage state
+                    if issue.state.name == "Triage":
+                        # Move to default state
                         state = State.objects.filter(
-                            group="cancelled", workspace__slug=slug, project_id=project_id
+                            workspace__slug=slug, project_id=project_id, default=True
                         ).first()
                         if state is not None:
                             issue.state = state
                             issue.save()
 
-                    # Update the issue state if it is accepted
-                    if serializer.data["status"] in [1]:
-                        issue = Issue.objects.get(
-                            pk=inbox_issue.issue_id,
-                            workspace__slug=slug,
-                            project_id=project_id,
-                        )
-
-                        # Update the issue state only if it is in triage state
-                        if issue.state.name == "Triage":
-                            # Move to default state
-                            state = State.objects.filter(
-                                workspace__slug=slug, project_id=project_id, default=True
-                            ).first()
-                            if state is not None:
-                                issue.state = state
-                                issue.save()
-
-                    return Response(serializer.data, status=status.HTTP_200_OK)
-                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-            else:
-                return Response(InboxIssueSerializer(inbox_issue).data, status=status.HTTP_200_OK)
-        except InboxIssue.DoesNotExist:
-            return Response(
-                {"error": "Inbox Issue does not exist"},
-                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,
-            )
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        else:
+            return Response(InboxIssueSerializer(inbox_issue).data, status=status.HTTP_200_OK)
 
     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
-            )
-            issue = Issue.objects.get(
-                pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
-            )
-            serializer = IssueStateInboxSerializer(issue)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        inbox_issue = InboxIssue.objects.get(
+            pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+        )
+        issue = Issue.objects.get(
+            pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
+        )
+        serializer = IssueStateInboxSerializer(issue)
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
     def destroy(self, request, slug, project_id, inbox_id, pk):
-        try:
-            inbox_issue = InboxIssue.objects.get(
-                pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
-            )
-            # Get the project member
-            project_member = ProjectMember.objects.get(workspace__slug=slug, project_id=project_id, member=request.user)
+        inbox_issue = InboxIssue.objects.get(
+            pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+        )
+        # Get the project member
+        project_member = ProjectMember.objects.get(workspace__slug=slug, project_id=project_id, member=request.user)
 
-            if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(request.user.id):
-                return Response({"error": "You cannot delete inbox issue"}, status=status.HTTP_400_BAD_REQUEST)
+        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(request.user.id):
+            return Response({"error": "You cannot delete inbox issue"}, status=status.HTTP_400_BAD_REQUEST)
 
-            # Check the issue status
-            if inbox_issue.status in [-2, -1, 0, 2]:
-                # Delete the issue also
-                Issue.objects.filter(workspace__slug=slug, project_id=project_id, pk=inbox_issue.issue_id).delete() 
+        # Check the issue status
+        if inbox_issue.status in [-2, -1, 0, 2]:
+            # Delete the issue also
+            Issue.objects.filter(workspace__slug=slug, project_id=project_id, pk=inbox_issue.issue_id).delete() 
 
-            inbox_issue.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except InboxIssue.DoesNotExist:
-            return Response({"error": "Inbox Issue does not exists"}, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        inbox_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
 
 
 class InboxIssuePublicViewSet(BaseViewSet):
@@ -413,242 +364,197 @@ 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)
+        project_deploy_board = ProjectDeployBoard.objects.get(workspace__slug=slug, project_id=project_id)
+        if project_deploy_board.inbox is None:
+            return Response({"error": "Inbox is not enabled for this Project Board"}, status=status.HTTP_400_BAD_REQUEST)
 
-            filters = issue_filters(request.query_params, "GET")
-            issues = (
-                Issue.objects.filter(
-                    issue_inbox__inbox_id=inbox_id,
-                    workspace__slug=slug,
-                    project_id=project_id,
+        filters = issue_filters(request.query_params, "GET")
+        issues = (
+            Issue.objects.filter(
+                issue_inbox__inbox_id=inbox_id,
+                workspace__slug=slug,
+                project_id=project_id,
+            )
+            .filter(**filters)
+            .annotate(bridge_id=F("issue_inbox__id"))
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels")
+            .order_by("issue_inbox__snoozed_till", "issue_inbox__status")
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(
+                    issue=OuterRef("id")
                 )
-                .filter(**filters)
-                .annotate(bridge_id=F("issue_inbox__id"))
-                .select_related("workspace", "project", "state", "parent")
-                .prefetch_related("assignees", "labels")
-                .order_by("issue_inbox__snoozed_till", "issue_inbox__status")
-                .annotate(
-                    sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    attachment_count=IssueAttachment.objects.filter(
-                        issue=OuterRef("id")
-                    )
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .prefetch_related(
-                    Prefetch(
-                        "issue_inbox",
-                        queryset=InboxIssue.objects.only(
-                            "status", "duplicate_to", "snoozed_till", "source"
-                        ),
-                    )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_inbox",
+                    queryset=InboxIssue.objects.only(
+                        "status", "duplicate_to", "snoozed_till", "source"
+                    ),
                 )
             )
-            issues_data = IssueStateInboxSerializer(issues, many=True).data
-            return Response(
-                issues_data,
-                status=status.HTTP_200_OK,
-            )
-        except ProjectDeployBoard.DoesNotExist:
-            return Response({"error": "Project Deploy Board does not exist"}, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        )
+        issues_data = IssueStateInboxSerializer(issues, many=True).data
+        return Response(
+            issues_data,
+            status=status.HTTP_200_OK,
+        )
 
     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)
+        project_deploy_board = ProjectDeployBoard.objects.get(workspace__slug=slug, project_id=project_id)
+        if project_deploy_board.inbox is None:
+            return Response({"error": "Inbox is not enabled for this Project Board"}, status=status.HTTP_400_BAD_REQUEST)
 
-            if not request.data.get("issue", {}).get("name", False):
-                return Response(
-                    {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            # Check for valid priority
-            if not request.data.get("issue", {}).get("priority", "none") in [
-                "low",
-                "medium",
-                "high",
-                "urgent",
-                "none",
-            ]:
-                return Response(
-                    {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
-                )
-
-            # Create or get state
-            state, _ = State.objects.get_or_create(
-                name="Triage",
-                group="backlog",
-                description="Default state for managing all Inbox Issues",
-                project_id=project_id,
-                color="#ff7700",
-            )
-
-            # create an issue
-            issue = Issue.objects.create(
-                name=request.data.get("issue", {}).get("name"),
-                description=request.data.get("issue", {}).get("description", {}),
-                description_html=request.data.get("issue", {}).get(
-                    "description_html", "<p></p>"
-                ),
-                priority=request.data.get("issue", {}).get("priority", "low"),
-                project_id=project_id,
-                state=state,
-            )
-
-            # Create an Issue Activity
-            issue_activity.delay(
-                type="issue.activity.created",
-                requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
-                actor_id=str(request.user.id),
-                issue_id=str(issue.id),
-                project_id=str(project_id),
-                current_instance=None,
-                epoch=int(timezone.now().timestamp())
-            )
-            # create an inbox issue
-            InboxIssue.objects.create(
-                inbox_id=inbox_id,
-                project_id=project_id,
-                issue=issue,
-                source=request.data.get("source", "in-app"),
-            )
-
-            serializer = IssueStateInboxSerializer(issue)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
+        if not request.data.get("issue", {}).get("name", False):
             return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
+                {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
             )
 
+        # Check for valid priority
+        if not request.data.get("issue", {}).get("priority", "none") in [
+            "low",
+            "medium",
+            "high",
+            "urgent",
+            "none",
+        ]:
+            return Response(
+                {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # Create or get state
+        state, _ = State.objects.get_or_create(
+            name="Triage",
+            group="backlog",
+            description="Default state for managing all Inbox Issues",
+            project_id=project_id,
+            color="#ff7700",
+        )
+
+        # create an issue
+        issue = Issue.objects.create(
+            name=request.data.get("issue", {}).get("name"),
+            description=request.data.get("issue", {}).get("description", {}),
+            description_html=request.data.get("issue", {}).get(
+                "description_html", "<p></p>"
+            ),
+            priority=request.data.get("issue", {}).get("priority", "low"),
+            project_id=project_id,
+            state=state,
+        )
+
+        # Create an Issue Activity
+        issue_activity.delay(
+            type="issue.activity.created",
+            requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+            actor_id=str(request.user.id),
+            issue_id=str(issue.id),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp())
+        )
+        # create an inbox issue
+        InboxIssue.objects.create(
+            inbox_id=inbox_id,
+            project_id=project_id,
+            issue=issue,
+            source=request.data.get("source", "in-app"),
+        )
+
+        serializer = IssueStateInboxSerializer(issue)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
     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)
+        project_deploy_board = ProjectDeployBoard.objects.get(workspace__slug=slug, project_id=project_id)
+        if project_deploy_board.inbox is None:
+            return Response({"error": "Inbox is not enabled for this Project Board"}, status=status.HTTP_400_BAD_REQUEST)
 
-            inbox_issue = InboxIssue.objects.get(
-                pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
-            )
-            # Get the project member
-            if str(inbox_issue.created_by_id) != str(request.user.id):
-                return Response({"error": "You cannot edit inbox issues"}, status=status.HTTP_400_BAD_REQUEST)
+        inbox_issue = InboxIssue.objects.get(
+            pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+        )
+        # Get the project member
+        if str(inbox_issue.created_by_id) != str(request.user.id):
+            return Response({"error": "You cannot edit inbox issues"}, status=status.HTTP_400_BAD_REQUEST)
 
-            # Get issue data
-            issue_data = request.data.pop("issue", False)
+        # Get issue data
+        issue_data = request.data.pop("issue", False)
 
 
-            issue = Issue.objects.get(
-                pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
-            )
-            # viewers and guests since only viewers and guests 
-            issue_data = {
-                "name": issue_data.get("name", issue.name),
-                "description_html": issue_data.get("description_html", issue.description_html),
-                "description": issue_data.get("description", issue.description)
-            }
+        issue = Issue.objects.get(
+            pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
+        )
+        # viewers and guests since only viewers and guests 
+        issue_data = {
+            "name": issue_data.get("name", issue.name),
+            "description_html": issue_data.get("description_html", issue.description_html),
+            "description": issue_data.get("description", issue.description)
+        }
 
-            issue_serializer = IssueCreateSerializer(
-                issue, data=issue_data, partial=True
-            )
+        issue_serializer = IssueCreateSerializer(
+            issue, data=issue_data, partial=True
+        )
 
-            if issue_serializer.is_valid():
-                current_instance = issue
-                # Log all the updates
-                requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
-                if issue is not None:
-                    issue_activity.delay(
-                        type="issue.activity.updated",
-                        requested_data=requested_data,
-                        actor_id=str(request.user.id),
-                        issue_id=str(issue.id),
-                        project_id=str(project_id),
-                        current_instance=json.dumps(
-                            IssueSerializer(current_instance).data,
-                            cls=DjangoJSONEncoder,
-                        ),
-                        epoch=int(timezone.now().timestamp())
-                    )
-                issue_serializer.save()
-                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,
-            )
+        if issue_serializer.is_valid():
+            current_instance = issue
+            # Log all the updates
+            requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
+            if issue is not None:
+                issue_activity.delay(
+                    type="issue.activity.updated",
+                    requested_data=requested_data,
+                    actor_id=str(request.user.id),
+                    issue_id=str(issue.id),
+                    project_id=str(project_id),
+                    current_instance=json.dumps(
+                        IssueSerializer(current_instance).data,
+                        cls=DjangoJSONEncoder,
+                    ),
+                    epoch=int(timezone.now().timestamp())
+                )
+            issue_serializer.save()
+            return Response(issue_serializer.data, status=status.HTTP_200_OK)
+        return Response(issue_serializer.errors, 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)
-        
-            inbox_issue = InboxIssue.objects.get(
-                pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
-            )
-            issue = Issue.objects.get(
-                pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
-            )
-            serializer = IssueStateInboxSerializer(issue)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        project_deploy_board = ProjectDeployBoard.objects.get(workspace__slug=slug, project_id=project_id)
+        if project_deploy_board.inbox is None:
+            return Response({"error": "Inbox is not enabled for this Project Board"}, status=status.HTTP_400_BAD_REQUEST)
+    
+        inbox_issue = InboxIssue.objects.get(
+            pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+        )
+        issue = Issue.objects.get(
+            pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
+        )
+        serializer = IssueStateInboxSerializer(issue)
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
     def destroy(self, request, slug, project_id, inbox_id, pk):
-        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)
+        project_deploy_board = ProjectDeployBoard.objects.get(workspace__slug=slug, project_id=project_id)
+        if project_deploy_board.inbox is None:
+            return Response({"error": "Inbox is not enabled for this Project Board"}, status=status.HTTP_400_BAD_REQUEST)
 
-            inbox_issue = InboxIssue.objects.get(
-                pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
-            )
+        inbox_issue = InboxIssue.objects.get(
+            pk=pk, workspace__slug=slug, project_id=project_id, inbox_id=inbox_id
+        )
 
-            if str(inbox_issue.created_by_id) != str(request.user.id):
-                return Response({"error": "You cannot delete inbox issue"}, status=status.HTTP_400_BAD_REQUEST)
-
-            inbox_issue.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except InboxIssue.DoesNotExist:
-            return Response({"error": "Inbox Issue does not exists"}, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        if str(inbox_issue.created_by_id) != str(request.user.id):
+            return Response({"error": "You cannot delete inbox issue"}, status=status.HTTP_400_BAD_REQUEST)
 
+        inbox_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

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,66 +32,40 @@ 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,
-            )
+        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)
 
     def partial_update(self, request, pk):
-        try:
-            integration = Integration.objects.get(pk=pk)
-            if integration.verified:
-                return Response(
-                    {"error": "Verified integrations cannot be updated"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            serializer = IntegrationSerializer(
-                integration, data=request.data, partial=True
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-        except Integration.DoesNotExist:
+        integration = Integration.objects.get(pk=pk)
+        if integration.verified:
             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"},
+                {"error": "Verified integrations cannot be updated"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-    def destroy(self, request, pk):
-        try:
-            integration = Integration.objects.get(pk=pk)
-            if integration.verified:
-                return Response(
-                    {"error": "Verified integrations cannot be updated"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
+        serializer = IntegrationSerializer(
+            integration, data=request.data, partial=True
+        )
 
-            integration.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except Integration.DoesNotExist:
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def destroy(self, request, pk):
+        integration = Integration.objects.get(pk=pk)
+        if integration.verified:
             return Response(
-                {"error": "Integration Does not exist"},
-                status=status.HTTP_404_NOT_FOUND,
+                {"error": "Verified integrations cannot be updated"},
+                status=status.HTTP_400_BAD_REQUEST,
             )
 
+        integration.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
 
 class WorkspaceIntegrationViewSet(BaseViewSet):
     serializer_class = WorkspaceIntegrationSerializer
@@ -111,119 +84,81 @@ class WorkspaceIntegrationViewSet(BaseViewSet):
         )
 
     def create(self, request, slug, provider):
-        try:
-            workspace = Workspace.objects.get(slug=slug)
-            integration = Integration.objects.get(provider=provider)
-            config = {}
-            if provider == "github":
-                installation_id = request.data.get("installation_id", None)
-                if not installation_id:
-                    return Response(
-                        {"error": "Installation ID is required"},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                metadata = get_github_metadata(installation_id)
-                config = {"installation_id": installation_id}
-
-            if provider == "slack":
-                metadata = request.data.get("metadata", {})
-                access_token = metadata.get("access_token", False)
-                team_id = metadata.get("team", {}).get("id", False)
-                if not metadata or not access_token or not team_id:
-                    return Response(
-                        {"error": "Access token and team id is required"},
-                        status=status.HTTP_400_BAD_REQUEST,
-                    )
-                config = {"team_id": team_id, "access_token": access_token}
-
-            # Create a bot user
-            bot_user = User.objects.create(
-                email=f"{uuid.uuid4().hex}@plane.so",
-                username=uuid.uuid4().hex,
-                password=make_password(uuid.uuid4().hex),
-                is_password_autoset=True,
-                is_bot=True,
-                first_name=integration.title,
-                avatar=integration.avatar_url
-                if integration.avatar_url is not None
-                else "",
-            )
-
-            # Create an API Token for the bot user
-            api_token = APIToken.objects.create(
-                user=bot_user,
-                user_type=1,  # bot user
-                workspace=workspace,
-            )
-
-            workspace_integration = WorkspaceIntegration.objects.create(
-                workspace=workspace,
-                integration=integration,
-                actor=bot_user,
-                api_token=api_token,
-                metadata=metadata,
-                config=config,
-            )
-
-            # Add bot user as a member of workspace
-            _ = WorkspaceMember.objects.create(
-                workspace=workspace_integration.workspace,
-                member=bot_user,
-                role=20,
-            )
-            return Response(
-                WorkspaceIntegrationSerializer(workspace_integration).data,
-                status=status.HTTP_201_CREATED,
-            )
-        except IntegrityError as e:
-            if "already exists" in str(e):
+        workspace = Workspace.objects.get(slug=slug)
+        integration = Integration.objects.get(provider=provider)
+        config = {}
+        if provider == "github":
+            installation_id = request.data.get("installation_id", None)
+            if not installation_id:
                 return Response(
-                    {"error": "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"},
+                    {"error": "Installation ID is required"},
                     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,
-            )
+            metadata = get_github_metadata(installation_id)
+            config = {"installation_id": installation_id}
+
+        if provider == "slack":
+            metadata = request.data.get("metadata", {})
+            access_token = metadata.get("access_token", False)
+            team_id = metadata.get("team", {}).get("id", False)
+            if not metadata or not access_token or not team_id:
+                return Response(
+                    {"error": "Access token and team id is required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+            config = {"team_id": team_id, "access_token": access_token}
+
+        # Create a bot user
+        bot_user = User.objects.create(
+            email=f"{uuid.uuid4().hex}@plane.so",
+            username=uuid.uuid4().hex,
+            password=make_password(uuid.uuid4().hex),
+            is_password_autoset=True,
+            is_bot=True,
+            first_name=integration.title,
+            avatar=integration.avatar_url
+            if integration.avatar_url is not None
+            else "",
+        )
+
+        # Create an API Token for the bot user
+        api_token = APIToken.objects.create(
+            user=bot_user,
+            user_type=1,  # bot user
+            workspace=workspace,
+        )
+
+        workspace_integration = WorkspaceIntegration.objects.create(
+            workspace=workspace,
+            integration=integration,
+            actor=bot_user,
+            api_token=api_token,
+            metadata=metadata,
+            config=config,
+        )
+
+        # Add bot user as a member of workspace
+        _ = WorkspaceMember.objects.create(
+            workspace=workspace_integration.workspace,
+            member=bot_user,
+            role=20,
+        )
+        return Response(
+            WorkspaceIntegrationSerializer(workspace_integration).data,
+            status=status.HTTP_201_CREATED,
+        )
 
     def destroy(self, request, slug, pk):
-        try:
-            workspace_integration = WorkspaceIntegration.objects.get(
-                pk=pk, workspace__slug=slug
-            )
+        workspace_integration = WorkspaceIntegration.objects.get(
+            pk=pk, workspace__slug=slug
+        )
 
-            if workspace_integration.integration.provider == "github":
-                installation_id = workspace_integration.config.get(
-                    "installation_id", False
-                )
-                if installation_id:
-                    delete_github_installation(installation_id=installation_id)
-
-            workspace_integration.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-
-        except WorkspaceIntegration.DoesNotExist:
-            return Response(
-                {"error": "Workspace Integration Does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
+        if workspace_integration.integration.provider == "github":
+            installation_id = workspace_integration.config.get(
+                "installation_id", False
             )
+            if installation_id:
+                delete_github_installation(installation_id=installation_id)
+
+        workspace_integration.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

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

@@ -30,31 +30,25 @@ 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
-            )
+        page = request.GET.get("page", 1)
+        workspace_integration = WorkspaceIntegration.objects.get(
+            workspace__slug=slug, pk=workspace_integration_id
+        )
 
-            if workspace_integration.integration.provider != "github":
-                return Response(
-                    {"error": "Not a github integration"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            access_tokens_url = workspace_integration.metadata["access_tokens_url"]
-            repositories_url = (
-                workspace_integration.metadata["repositories_url"]
-                + f"?per_page=100&page={page}"
-            )
-            repositories = get_github_repos(access_tokens_url, repositories_url)
-            return Response(repositories, status=status.HTTP_200_OK)
-        except WorkspaceIntegration.DoesNotExist:
+        if workspace_integration.integration.provider != "github":
             return Response(
-                {"error": "Workspace Integration Does not exists"},
+                {"error": "Not a github integration"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        access_tokens_url = workspace_integration.metadata["access_tokens_url"]
+        repositories_url = (
+            workspace_integration.metadata["repositories_url"]
+            + f"?per_page=100&page={page}"
+        )
+        repositories = get_github_repos(access_tokens_url, repositories_url)
+        return Response(repositories, status=status.HTTP_200_OK)
+
 
 class GithubRepositorySyncViewSet(BaseViewSet):
     permission_classes = [
@@ -76,89 +70,76 @@ 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", {})
-            repository_id = request.data.get("repository_id", False)
-            owner = request.data.get("owner", False)
+        name = request.data.get("name", False)
+        url = request.data.get("url", False)
+        config = request.data.get("config", {})
+        repository_id = request.data.get("repository_id", False)
+        owner = request.data.get("owner", False)
 
-            if not name or not url or not repository_id or not owner:
-                return Response(
-                    {"error": "Name, url, repository_id and owner are required"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            # Get the workspace integration
-            workspace_integration = WorkspaceIntegration.objects.get(
-                pk=workspace_integration_id
-            )
-
-            # Delete the old repository object
-            GithubRepositorySync.objects.filter(
-                project_id=project_id, workspace__slug=slug
-            ).delete()
-            GithubRepository.objects.filter(
-                project_id=project_id, workspace__slug=slug
-            ).delete()
-
-            # Create repository
-            repo = GithubRepository.objects.create(
-                name=name,
-                url=url,
-                config=config,
-                repository_id=repository_id,
-                owner=owner,
-                project_id=project_id,
-            )
-
-            # Create a Label for github
-            label = Label.objects.filter(
-                name="GitHub",
-                project_id=project_id,
-            ).first()
-
-            if label is None:
-                label = Label.objects.create(
-                    name="GitHub",
-                    project_id=project_id,
-                    description="Label to sync Plane issues with GitHub issues",
-                    color="#003773",
-                )
-
-            # Create repo sync
-            repo_sync = GithubRepositorySync.objects.create(
-                repository=repo,
-                workspace_integration=workspace_integration,
-                actor=workspace_integration.actor,
-                credentials=request.data.get("credentials", {}),
-                project_id=project_id,
-                label=label,
-            )
-
-            # Add bot as a member in the project
-            _ = ProjectMember.objects.get_or_create(
-                member=workspace_integration.actor, role=20, project_id=project_id
-            )
-
-            # Return Response
+        if not name or not url or not repository_id or not owner:
             return Response(
-                GithubRepositorySyncSerializer(repo_sync).data,
-                status=status.HTTP_201_CREATED,
-            )
-
-        except WorkspaceIntegration.DoesNotExist:
-            return Response(
-                {"error": "Workspace Integration does not exist"},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
+                {"error": "Name, url, repository_id and owner are required"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        # Get the workspace integration
+        workspace_integration = WorkspaceIntegration.objects.get(
+            pk=workspace_integration_id
+        )
+
+        # Delete the old repository object
+        GithubRepositorySync.objects.filter(
+            project_id=project_id, workspace__slug=slug
+        ).delete()
+        GithubRepository.objects.filter(
+            project_id=project_id, workspace__slug=slug
+        ).delete()
+
+        # Create repository
+        repo = GithubRepository.objects.create(
+            name=name,
+            url=url,
+            config=config,
+            repository_id=repository_id,
+            owner=owner,
+            project_id=project_id,
+        )
+
+        # Create a Label for github
+        label = Label.objects.filter(
+            name="GitHub",
+            project_id=project_id,
+        ).first()
+
+        if label is None:
+            label = Label.objects.create(
+                name="GitHub",
+                project_id=project_id,
+                description="Label to sync Plane issues with GitHub issues",
+                color="#003773",
+            )
+
+        # Create repo sync
+        repo_sync = GithubRepositorySync.objects.create(
+            repository=repo,
+            workspace_integration=workspace_integration,
+            actor=workspace_integration.actor,
+            credentials=request.data.get("credentials", {}),
+            project_id=project_id,
+            label=label,
+        )
+
+        # Add bot as a member in the project
+        _ = ProjectMember.objects.get_or_create(
+            member=workspace_integration.actor, role=20, project_id=project_id
+        )
+
+        # Return Response
+        return Response(
+            GithubRepositorySyncSerializer(repo_sync).data,
+            status=status.HTTP_201_CREATED,
+        )
+
 
 class GithubIssueSyncViewSet(BaseViewSet):
     permission_classes = [
@@ -177,42 +158,30 @@ 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)
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
 
-            github_issue_syncs = request.data.get("github_issue_syncs", [])
-            github_issue_syncs = GithubIssueSync.objects.bulk_create(
-                [
-                    GithubIssueSync(
-                        issue_id=github_issue_sync.get("issue"),
-                        repo_issue_id=github_issue_sync.get("repo_issue_id"),
-                        issue_url=github_issue_sync.get("issue_url"),
-                        github_issue_id=github_issue_sync.get("github_issue_id"),
-                        repository_sync_id=repo_sync_id,
-                        project_id=project_id,
-                        workspace_id=project.workspace_id,
-                        created_by=request.user,
-                        updated_by=request.user,
-                    )
-                    for github_issue_sync in github_issue_syncs
-                ],
-                batch_size=100,
-                ignore_conflicts=True,
-            )
+        github_issue_syncs = request.data.get("github_issue_syncs", [])
+        github_issue_syncs = GithubIssueSync.objects.bulk_create(
+            [
+                GithubIssueSync(
+                    issue_id=github_issue_sync.get("issue"),
+                    repo_issue_id=github_issue_sync.get("repo_issue_id"),
+                    issue_url=github_issue_sync.get("issue_url"),
+                    github_issue_id=github_issue_sync.get("github_issue_id"),
+                    repository_sync_id=repo_sync_id,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for github_issue_sync in github_issue_syncs
+            ],
+            batch_size=100,
+            ignore_conflicts=True,
+        )
 
-            serializer = GithubIssueSyncSerializer(github_issue_syncs, many=True)
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        except Project.DoesNotExist:
-            return Response(
-                {"error": "Project does not exist"},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        serializer = GithubIssueSyncSerializer(github_issue_syncs, many=True)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
 
 
 class GithubCommentSyncViewSet(BaseViewSet):

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

@@ -32,42 +32,25 @@ class SlackProjectSyncViewSet(BaseViewSet):
         )
 
     def create(self, request, slug, project_id, workspace_integration_id):
-        try:
-            serializer = SlackProjectSyncSerializer(data=request.data)
+        serializer = SlackProjectSyncSerializer(data=request.data)
+
+        workspace_integration = WorkspaceIntegration.objects.get(
+            workspace__slug=slug, pk=workspace_integration_id
+        )
+
+        if serializer.is_valid():
+            serializer.save(
+                project_id=project_id,
+                workspace_integration_id=workspace_integration_id,
+            )
 
             workspace_integration = WorkspaceIntegration.objects.get(
-                workspace__slug=slug, pk=workspace_integration_id
+                pk=workspace_integration_id, workspace__slug=slug
             )
 
-            if serializer.is_valid():
-                serializer.save(
-                    project_id=project_id,
-                    workspace_integration_id=workspace_integration_id,
-                )
-
-                workspace_integration = WorkspaceIntegration.objects.get(
-                    pk=workspace_integration_id, workspace__slug=slug
-                )
-
-                _ = ProjectMember.objects.get_or_create(
-                    member=workspace_integration.actor, role=20, project_id=project_id
-                )
-
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError:
-            return Response(
-                {"error": "Slack is already enabled for the project"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except WorkspaceIntegration.DoesNotExist:
-            return Response(
-                {"error": "Workspace Integration does not exist"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            print(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
+            _ = ProjectMember.objects.get_or_create(
+                member=workspace_integration.actor, role=20, project_id=project_id
             )
+
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/api/views/module.py

@@ -141,173 +141,147 @@ 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
-            )
+    def create(self, request, slug, project_id):
+        project = Project.objects.get(workspace__slug=slug, pk=project_id)
+        serializer = ModuleWriteSerializer(
+            data=request.data, context={"project": project}
         )
+
+        if serializer.is_valid():
+            serializer.save()
+
+            module = Module.objects.get(pk=serializer.data["id"])
+            serializer = ModuleSerializer(module)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def retrieve(self, request, slug, project_id, pk):
+        queryset = self.get_queryset().get(pk=pk)
+
+        assignee_distribution = (
+            Issue.objects.filter(
+                issue_module__module_id=pk,
+                workspace__slug=slug,
+                project_id=project_id,
+            )
+            .annotate(first_name=F("assignees__first_name"))
+            .annotate(last_name=F("assignees__last_name"))
+            .annotate(assignee_id=F("assignees__id"))
+            .annotate(display_name=F("assignees__display_name"))
+            .annotate(avatar=F("assignees__avatar"))
+            .values("first_name", "last_name", "assignee_id", "avatar", "display_name")
+            .annotate(
+                total_issues=Count(
+                    "assignee_id",
+                    filter=Q(
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                completed_issues=Count(
+                    "assignee_id",
+                    filter=Q(
+                        completed_at__isnull=False,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                pending_issues=Count(
+                    "assignee_id",
+                    filter=Q(
+                        completed_at__isnull=True,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .order_by("first_name", "last_name")
+        )
+
+        label_distribution = (
+            Issue.objects.filter(
+                issue_module__module_id=pk,
+                workspace__slug=slug,
+                project_id=project_id,
+            )
+            .annotate(label_name=F("labels__name"))
+            .annotate(color=F("labels__color"))
+            .annotate(label_id=F("labels__id"))
+            .values("label_name", "color", "label_id")
+            .annotate(
+                total_issues=Count(
+                    "label_id",
+                    filter=Q(
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                ),
+            )
+            .annotate(
+                completed_issues=Count(
+                    "label_id",
+                    filter=Q(
+                        completed_at__isnull=False,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                pending_issues=Count(
+                    "label_id",
+                    filter=Q(
+                        completed_at__isnull=True,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .order_by("label_name")
+        )
+
+        data = ModuleSerializer(queryset).data
+        data["distribution"] = {
+            "assignees": assignee_distribution,
+            "labels": label_distribution,
+            "completion_chart": {},
+        }
+
+        if queryset.start_date and queryset.target_date:
+            data["distribution"]["completion_chart"] = burndown_plot(
+                queryset=queryset, slug=slug, project_id=project_id, module_id=pk
+            )
+
+        return Response(
+            data,
+            status=status.HTTP_200_OK,
+        )
+
+    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(self.kwargs.get("pk")),
+                    "module_id": str(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)),
+            actor_id=str(request.user.id),
+            issue_id=str(pk),
+            project_id=str(project_id),
             current_instance=None,
-            epoch=int(timezone.now().timestamp())
+            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}
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-        except Project.DoesNotExist:
-            return Response(
-                {"error": "Project was not found"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"name": "The module name is already taken"},
-                    status=status.HTTP_410_GONE,
-                )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def retrieve(self, request, slug, project_id, pk):
-        try:
-            queryset = self.get_queryset().get(pk=pk)
-
-            assignee_distribution = (
-                Issue.objects.filter(
-                    issue_module__module_id=pk,
-                    workspace__slug=slug,
-                    project_id=project_id,
-                )
-                .annotate(first_name=F("assignees__first_name"))
-                .annotate(last_name=F("assignees__last_name"))
-                .annotate(assignee_id=F("assignees__id"))
-                .annotate(display_name=F("assignees__display_name"))
-                .annotate(avatar=F("assignees__avatar"))
-                .values(
-                    "first_name", "last_name", "assignee_id", "avatar", "display_name"
-                )
-                .annotate(
-                    total_issues=Count(
-                        "assignee_id",
-                        filter=Q(
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    completed_issues=Count(
-                        "assignee_id",
-                        filter=Q(
-                            completed_at__isnull=False,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    pending_issues=Count(
-                        "assignee_id",
-                        filter=Q(
-                            completed_at__isnull=True,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .order_by("first_name", "last_name")
-            )
-
-            label_distribution = (
-                Issue.objects.filter(
-                    issue_module__module_id=pk,
-                    workspace__slug=slug,
-                    project_id=project_id,
-                )
-                .annotate(label_name=F("labels__name"))
-                .annotate(color=F("labels__color"))
-                .annotate(label_id=F("labels__id"))
-                .values("label_name", "color", "label_id")
-                .annotate(
-                    total_issues=Count(
-                        "label_id",
-                        filter=Q(
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    ),
-                )
-                .annotate(
-                    completed_issues=Count(
-                        "label_id",
-                        filter=Q(
-                            completed_at__isnull=False,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .annotate(
-                    pending_issues=Count(
-                        "label_id",
-                        filter=Q(
-                            completed_at__isnull=True,
-                            archived_at__isnull=True,
-                            is_draft=False,
-                        ),
-                    )
-                )
-                .order_by("label_name")
-            )
-
-            data = ModuleSerializer(queryset).data
-            data["distribution"] = {
-                "assignees": assignee_distribution,
-                "labels": label_distribution,
-                "completion_chart": {},
-            }
-
-            if queryset.start_date and queryset.target_date:
-                data["distribution"]["completion_chart"] = burndown_plot(
-                    queryset=queryset, slug=slug, project_id=project_id, module_id=pk
-                )
-
-            return Response(
-                data,
-                status=status.HTTP_200_OK,
-            )
-
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        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,162 +328,162 @@ 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)
-            filters = issue_filters(request.query_params, "GET")
-            issues = (
-                Issue.issue_objects.filter(issue_module__module_id=module_id)
-                .annotate(
-                    sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(bridge_id=F("issue_module__id"))
-                .filter(project_id=project_id)
-                .filter(workspace__slug=slug)
-                .select_related("project")
-                .select_related("workspace")
-                .select_related("state")
-                .select_related("parent")
-                .prefetch_related("assignees")
-                .prefetch_related("labels")
-                .order_by(order_by)
-                .filter(**filters)
-                .annotate(
-                    link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    attachment_count=IssueAttachment.objects.filter(
-                        issue=OuterRef("id")
-                    )
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
+        order_by = request.GET.get("order_by", "created_at")
+        group_by = request.GET.get("group_by", False)
+        sub_group_by = request.GET.get("sub_group_by", False)
+        filters = issue_filters(request.query_params, "GET")
+        issues = (
+            Issue.issue_objects.filter(issue_module__module_id=module_id)
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=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:
-                return Response(
-                    {"error": "Group by and sub group by cannot be same"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if group_by:
-                return Response(
-                    group_results(issues_data, group_by, sub_group_by),
-                    status=status.HTTP_200_OK,
-                )
-
-            return Response(
-                issues_data,
-                status=status.HTTP_200_OK,
+            .annotate(bridge_id=F("issue_module__id"))
+            .filter(project_id=project_id)
+            .filter(workspace__slug=slug)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("state")
+            .select_related("parent")
+            .prefetch_related("assignees")
+            .prefetch_related("labels")
+            .order_by(order_by)
+            .filter(**filters)
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
             )
-        except Exception as e:
-            capture_exception(e)
+            .annotate(
+                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:
             return Response(
-                {"error": "Something went wrong please try again later"},
+                {"error": "Group by and sub group by cannot be same"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        if group_by:
+            grouped_results = group_results(issues_data, group_by, sub_group_by)
+            return Response(
+                grouped_results,
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(
+            issues_data, status=status.HTTP_200_OK
+        )
+
     def create(self, request, slug, project_id, module_id):
-        try:
-            issues = request.data.get("issues", [])
-            if not len(issues):
-                return Response(
-                    {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
-                )
-            module = Module.objects.get(
-                workspace__slug=slug, project_id=project_id, pk=module_id
+        issues = request.data.get("issues", [])
+        if not len(issues):
+            return Response(
+                {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
             )
+        module = Module.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=module_id
+        )
 
-            module_issues = list(ModuleIssue.objects.filter(issue_id__in=issues))
+        module_issues = list(ModuleIssue.objects.filter(issue_id__in=issues))
 
-            update_module_issue_activity = []
-            records_to_update = []
-            record_to_create = []
+        update_module_issue_activity = []
+        records_to_update = []
+        record_to_create = []
 
-            for issue in issues:
-                module_issue = [
-                    module_issue
-                    for module_issue in module_issues
-                    if str(module_issue.issue_id) in issues
-                ]
+        for issue in issues:
+            module_issue = [
+                module_issue
+                for module_issue in module_issues
+                if str(module_issue.issue_id) in issues
+            ]
 
-                if len(module_issue):
-                    if module_issue[0].module_id != module_id:
-                        update_module_issue_activity.append(
-                            {
-                                "old_module_id": str(module_issue[0].module_id),
-                                "new_module_id": str(module_id),
-                                "issue_id": str(module_issue[0].issue_id),
-                            }
-                        )
-                        module_issue[0].module_id = module_id
-                        records_to_update.append(module_issue[0])
-                else:
-                    record_to_create.append(
-                        ModuleIssue(
-                            module=module,
-                            issue_id=issue,
-                            project_id=project_id,
-                            workspace=module.workspace,
-                            created_by=request.user,
-                            updated_by=request.user,
-                        )
+            if len(module_issue):
+                if module_issue[0].module_id != module_id:
+                    update_module_issue_activity.append(
+                        {
+                            "old_module_id": str(module_issue[0].module_id),
+                            "new_module_id": str(module_id),
+                            "issue_id": str(module_issue[0].issue_id),
+                        }
                     )
+                    module_issue[0].module_id = module_id
+                    records_to_update.append(module_issue[0])
+            else:
+                record_to_create.append(
+                    ModuleIssue(
+                        module=module,
+                        issue_id=issue,
+                        project_id=project_id,
+                        workspace=module.workspace,
+                        created_by=request.user,
+                        updated_by=request.user,
+                    )
+                )
 
-            ModuleIssue.objects.bulk_create(
-                record_to_create,
-                batch_size=10,
-                ignore_conflicts=True,
-            )
+        ModuleIssue.objects.bulk_create(
+            record_to_create,
+            batch_size=10,
+            ignore_conflicts=True,
+        )
 
-            ModuleIssue.objects.bulk_update(
-                records_to_update,
-                ["module"],
-                batch_size=10,
-            )
+        ModuleIssue.objects.bulk_update(
+            records_to_update,
+            ["module"],
+            batch_size=10,
+        )
 
-            # Capture Issue Activity
-            issue_activity.delay(
-                type="module.activity.created",
-                requested_data=json.dumps({"modules_list": issues}),
-                actor_id=str(self.request.user.id),
-                issue_id=str(self.kwargs.get("pk", None)),
-                project_id=str(self.kwargs.get("project_id", None)),
-                current_instance=json.dumps(
-                    {
-                        "updated_module_issues": update_module_issue_activity,
-                        "created_module_issues": serializers.serialize(
-                            "json", record_to_create
-                        ),
-                    }
-                ),
-                epoch=int(timezone.now().timestamp())
-            )
+        # Capture Issue Activity
+        issue_activity.delay(
+            type="module.activity.created",
+            requested_data=json.dumps({"modules_list": issues}),
+            actor_id=str(self.request.user.id),
+            issue_id=str(self.kwargs.get("pk", None)),
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps(
+                {
+                    "updated_module_issues": update_module_issue_activity,
+                    "created_module_issues": serializers.serialize(
+                        "json", record_to_create
+                    ),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
+        )
 
-            return Response(
-                ModuleIssueSerializer(self.get_queryset(), many=True).data,
-                status=status.HTTP_200_OK,
-            )
-        except Module.DoesNotExist:
-            return Response(
-                {"error": "Module Does not exists"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        return Response(
+            ModuleIssueSerializer(self.get_queryset(), many=True).data,
+            status=status.HTTP_200_OK,
+        )
+
+    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
+        )
+        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,49 +527,18 @@ 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,
-            )
+        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)
 
     def destroy(self, request, slug, project_id, module_id):
-        try:
-            module_favorite = ModuleFavorite.objects.get(
-                project=project_id,
-                user=request.user,
-                workspace__slug=slug,
-                module_id=module_id,
-            )
-            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,
-            )
+        module_favorite = ModuleFavorite.objects.get(
+            project=project_id,
+            user=request.user,
+            workspace__slug=slug,
+            module_id=module_id,
+        )
+        module_favorite.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/notification.py

@@ -36,328 +36,239 @@ class NotificationViewSet(BaseViewSet, BasePaginator):
         )
 
     def list(self, request, slug):
-        try:
-            snoozed = request.GET.get("snoozed", "false")
-            archived = request.GET.get("archived", "false")
-            read = request.GET.get("read", "true")
+        # Get query parameters
+        snoozed = request.GET.get("snoozed", "false")
+        archived = request.GET.get("archived", "false")
+        read = request.GET.get("read", "true")
+        type = request.GET.get("type", "all")
 
-            # Filter type
-            type = request.GET.get("type", "all")
-
-            notifications = (
-                Notification.objects.filter(
-                    workspace__slug=slug, receiver_id=request.user.id
-                )
-                .select_related("workspace", "project", "triggered_by", "receiver")
-                .order_by("snoozed_till", "-created_at")
+        notifications = (
+            Notification.objects.filter(
+                workspace__slug=slug, receiver_id=request.user.id
             )
+            .select_related("workspace", "project", "triggered_by", "receiver")
+            .order_by("snoozed_till", "-created_at")
+        )
 
-            # Filter for snoozed notifications
-            if snoozed == "false":
-                notifications = notifications.filter(
-                    Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
-                )
+        # 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])
 
-            if read == "false":
-                notifications = notifications.filter(read_at__isnull=True)
+        archived_filters = {
+            "true": Q(archived_at__isnull=False),
+            "false": Q(archived_at__isnull=True),
+        }
 
-            # Filter for archived or unarchive
-            if archived == "false":
-                notifications = notifications.filter(archived_at__isnull=True)
+        notifications = notifications.filter(archived_filters[archived])
 
-            if archived == "true":
-                notifications = notifications.filter(archived_at__isnull=False)
+        if read == "false":
+            notifications = notifications.filter(read_at__isnull=True)
 
-            # Subscribed issues
-            if type == "watching":
-                issue_ids = IssueSubscriber.objects.filter(
-                    workspace__slug=slug, subscriber_id=request.user.id
-                ).values_list("issue_id", flat=True)
+        # Subscribed issues
+        if type == "watching":
+            issue_ids = IssueSubscriber.objects.filter(
+                workspace__slug=slug, subscriber_id=request.user.id
+            ).values_list("issue_id", flat=True)
+            notifications = notifications.filter(entity_identifier__in=issue_ids)
+
+        # Assigned Issues
+        if type == "assigned":
+            issue_ids = IssueAssignee.objects.filter(
+                workspace__slug=slug, assignee_id=request.user.id
+            ).values_list("issue_id", flat=True)
+            notifications = notifications.filter(entity_identifier__in=issue_ids)
+
+        # Created issues
+        if type == "created":
+            if WorkspaceMember.objects.filter(
+                workspace__slug=slug, member=request.user, role__lt=15
+            ).exists():
+                notifications = Notification.objects.none()
+            else:
+                issue_ids = Issue.objects.filter(
+                    workspace__slug=slug, created_by=request.user
+                ).values_list("pk", flat=True)
                 notifications = notifications.filter(entity_identifier__in=issue_ids)
 
-            # Assigned Issues
-            if type == "assigned":
-                issue_ids = IssueAssignee.objects.filter(
-                    workspace__slug=slug, assignee_id=request.user.id
-                ).values_list("issue_id", flat=True)
-                notifications = notifications.filter(entity_identifier__in=issue_ids)
-
-            # Created issues
-            if type == "created":
-                if WorkspaceMember.objects.filter(
-                    workspace__slug=slug, member=request.user, role__lt=15
-                ).exists():
-                    notifications = Notification.objects.none()
-                else:
-                    issue_ids = Issue.objects.filter(
-                        workspace__slug=slug, created_by=request.user
-                    ).values_list("pk", flat=True)
-                    notifications = notifications.filter(
-                        entity_identifier__in=issue_ids
-                    )
-
-            # Pagination
-            if request.GET.get("per_page", False) and request.GET.get("cursor", False):
-                return self.paginate(
-                    request=request,
-                    queryset=(notifications),
-                    on_results=lambda notifications: NotificationSerializer(
-                        notifications, many=True
-                    ).data,
-                )
-
-            serializer = NotificationSerializer(notifications, many=True)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
+        # Pagination
+        if request.GET.get("per_page", False) and request.GET.get("cursor", False):
+            return self.paginate(
+                request=request,
+                queryset=(notifications),
+                on_results=lambda notifications: NotificationSerializer(
+                    notifications, many=True
+                ).data,
             )
 
+        serializer = NotificationSerializer(notifications, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
     def partial_update(self, request, slug, pk):
-        try:
-            notification = Notification.objects.get(
-                workspace__slug=slug, pk=pk, receiver=request.user
-            )
-            # Only read_at and snoozed_till can be updated
-            notification_data = {
-                "snoozed_till": request.data.get("snoozed_till", None),
-            }
-            serializer = NotificationSerializer(
-                notification, data=notification_data, partial=True
-            )
+        notification = Notification.objects.get(
+            workspace__slug=slug, pk=pk, receiver=request.user
+        )
+        # Only read_at and snoozed_till can be updated
+        notification_data = {
+            "snoozed_till": request.data.get("snoozed_till", None),
+        }
+        serializer = NotificationSerializer(
+            notification, data=notification_data, partial=True
+        )
 
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Notification.DoesNotExist:
-            return Response(
-                {"error": "Notification does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def mark_read(self, request, slug, pk):
-        try:
-            notification = Notification.objects.get(
-                receiver=request.user, workspace__slug=slug, pk=pk
-            )
-            notification.read_at = timezone.now()
-            notification.save()
-            serializer = NotificationSerializer(notification)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Notification.DoesNotExist:
-            return Response(
-                {"error": "Notification does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        notification = Notification.objects.get(
+            receiver=request.user, workspace__slug=slug, pk=pk
+        )
+        notification.read_at = timezone.now()
+        notification.save()
+        serializer = NotificationSerializer(notification)
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
     def mark_unread(self, request, slug, pk):
-        try:
-            notification = Notification.objects.get(
-                receiver=request.user, workspace__slug=slug, pk=pk
-            )
-            notification.read_at = None
-            notification.save()
-            serializer = NotificationSerializer(notification)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Notification.DoesNotExist:
-            return Response(
-                {"error": "Notification does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        notification = Notification.objects.get(
+            receiver=request.user, workspace__slug=slug, pk=pk
+        )
+        notification.read_at = None
+        notification.save()
+        serializer = NotificationSerializer(notification)
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
     def archive(self, request, slug, pk):
-        try:
-            notification = Notification.objects.get(
-                receiver=request.user, workspace__slug=slug, pk=pk
-            )
-            notification.archived_at = timezone.now()
-            notification.save()
-            serializer = NotificationSerializer(notification)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Notification.DoesNotExist:
-            return Response(
-                {"error": "Notification does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        notification = Notification.objects.get(
+            receiver=request.user, workspace__slug=slug, pk=pk
+        )
+        notification.archived_at = timezone.now()
+        notification.save()
+        serializer = NotificationSerializer(notification)
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
     def unarchive(self, request, slug, pk):
-        try:
-            notification = Notification.objects.get(
-                receiver=request.user, workspace__slug=slug, pk=pk
-            )
-            notification.archived_at = None
-            notification.save()
-            serializer = NotificationSerializer(notification)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except Notification.DoesNotExist:
-            return Response(
-                {"error": "Notification does not exists"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        notification = Notification.objects.get(
+            receiver=request.user, workspace__slug=slug, pk=pk
+        )
+        notification.archived_at = None
+        notification.save()
+        serializer = NotificationSerializer(notification)
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
 
 class UnreadNotificationEndpoint(BaseAPIView):
     def get(self, request, slug):
-        try:
-            # Watching Issues Count
-            watching_issues_count = Notification.objects.filter(
-                workspace__slug=slug,
-                receiver_id=request.user.id,
-                read_at__isnull=True,
-                archived_at__isnull=True,
-                entity_identifier__in=IssueSubscriber.objects.filter(
-                    workspace__slug=slug, subscriber_id=request.user.id
-                ).values_list("issue_id", flat=True),
-            ).count()
+        # Watching Issues Count
+        watching_issues_count = Notification.objects.filter(
+            workspace__slug=slug,
+            receiver_id=request.user.id,
+            read_at__isnull=True,
+            archived_at__isnull=True,
+            entity_identifier__in=IssueSubscriber.objects.filter(
+                workspace__slug=slug, subscriber_id=request.user.id
+            ).values_list("issue_id", flat=True),
+        ).count()
 
-            # My Issues Count
-            my_issues_count = Notification.objects.filter(
-                workspace__slug=slug,
-                receiver_id=request.user.id,
-                read_at__isnull=True,
-                archived_at__isnull=True,
-                entity_identifier__in=IssueAssignee.objects.filter(
-                    workspace__slug=slug, assignee_id=request.user.id
-                ).values_list("issue_id", flat=True),
-            ).count()
+        # My Issues Count
+        my_issues_count = Notification.objects.filter(
+            workspace__slug=slug,
+            receiver_id=request.user.id,
+            read_at__isnull=True,
+            archived_at__isnull=True,
+            entity_identifier__in=IssueAssignee.objects.filter(
+                workspace__slug=slug, assignee_id=request.user.id
+            ).values_list("issue_id", flat=True),
+        ).count()
 
-            # Created Issues Count
-            created_issues_count = Notification.objects.filter(
-                workspace__slug=slug,
-                receiver_id=request.user.id,
-                read_at__isnull=True,
-                archived_at__isnull=True,
-                entity_identifier__in=Issue.objects.filter(
-                    workspace__slug=slug, created_by=request.user
-                ).values_list("pk", flat=True),
-            ).count()
+        # Created Issues Count
+        created_issues_count = Notification.objects.filter(
+            workspace__slug=slug,
+            receiver_id=request.user.id,
+            read_at__isnull=True,
+            archived_at__isnull=True,
+            entity_identifier__in=Issue.objects.filter(
+                workspace__slug=slug, created_by=request.user
+            ).values_list("pk", flat=True),
+        ).count()
 
-            return Response(
-                {
-                    "watching_issues": watching_issues_count,
-                    "my_issues": my_issues_count,
-                    "created_issues": created_issues_count,
-                },
-                status=status.HTTP_200_OK,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        return Response(
+            {
+                "watching_issues": watching_issues_count,
+                "my_issues": my_issues_count,
+                "created_issues": created_issues_count,
+            },
+            status=status.HTTP_200_OK,
+        )
 
 
 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")
+        snoozed = request.data.get("snoozed", False)
+        archived = request.data.get("archived", False)
+        type = request.data.get("type", "all")
 
-            notifications = (
-                Notification.objects.filter(
-                    workspace__slug=slug,
-                    receiver_id=request.user.id,
-                    read_at__isnull=True,
-                )
-                .select_related("workspace", "project", "triggered_by", "receiver")
-                .order_by("snoozed_till", "-created_at")
+        notifications = (
+            Notification.objects.filter(
+                workspace__slug=slug,
+                receiver_id=request.user.id,
+                read_at__isnull=True,
+            )
+            .select_related("workspace", "project", "triggered_by", "receiver")
+            .order_by("snoozed_till", "-created_at")
+        )
+
+        # Filter for snoozed notifications
+        if snoozed:
+            notifications = notifications.filter(
+                Q(snoozed_till__lt=timezone.now()) | Q(snoozed_till__isnull=False)
+            )
+        else:
+            notifications = notifications.filter(
+                Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
             )
 
-            # Filter for snoozed notifications
-            if snoozed:
-                notifications = notifications.filter(
-                    Q(snoozed_till__lt=timezone.now()) | Q(snoozed_till__isnull=False)
-                )
-            else:
-                notifications = notifications.filter(
-                    Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
-                )
+        # Filter for archived or unarchive
+        if archived:
+            notifications = notifications.filter(archived_at__isnull=False)
+        else:
+            notifications = notifications.filter(archived_at__isnull=True)
 
-            # Filter for archived or unarchive
-            if archived:
-                notifications = notifications.filter(archived_at__isnull=False)
-            else:
-                notifications = notifications.filter(archived_at__isnull=True)
+        # Subscribed issues
+        if type == "watching":
+            issue_ids = IssueSubscriber.objects.filter(
+                workspace__slug=slug, subscriber_id=request.user.id
+            ).values_list("issue_id", flat=True)
+            notifications = notifications.filter(entity_identifier__in=issue_ids)
 
-            # Subscribed issues
-            if type == "watching":
-                issue_ids = IssueSubscriber.objects.filter(
-                    workspace__slug=slug, subscriber_id=request.user.id
-                ).values_list("issue_id", flat=True)
+        # Assigned Issues
+        if type == "assigned":
+            issue_ids = IssueAssignee.objects.filter(
+                workspace__slug=slug, assignee_id=request.user.id
+            ).values_list("issue_id", flat=True)
+            notifications = notifications.filter(entity_identifier__in=issue_ids)
+
+        # Created issues
+        if type == "created":
+            if WorkspaceMember.objects.filter(
+                workspace__slug=slug, member=request.user, role__lt=15
+            ).exists():
+                notifications = Notification.objects.none()
+            else:
+                issue_ids = Issue.objects.filter(
+                    workspace__slug=slug, created_by=request.user
+                ).values_list("pk", flat=True)
                 notifications = notifications.filter(entity_identifier__in=issue_ids)
 
-            # Assigned Issues
-            if type == "assigned":
-                issue_ids = IssueAssignee.objects.filter(
-                    workspace__slug=slug, assignee_id=request.user.id
-                ).values_list("issue_id", flat=True)
-                notifications = notifications.filter(entity_identifier__in=issue_ids)
-
-            # Created issues
-            if type == "created":
-                if WorkspaceMember.objects.filter(
-                    workspace__slug=slug, member=request.user, role__lt=15
-                ).exists():
-                    notifications = Notification.objects.none()
-                else:
-                    issue_ids = Issue.objects.filter(
-                        workspace__slug=slug, created_by=request.user
-                    ).values_list("pk", flat=True)
-                    notifications = notifications.filter(
-                        entity_identifier__in=issue_ids
-                    )
-
-            updated_notifications = []
-            for notification in notifications:
-                notification.read_at = timezone.now()
-                updated_notifications.append(notification)
-            Notification.objects.bulk_update(
-                updated_notifications, ["read_at"], batch_size=100
-            )
-            return Response({"message": "Successful"}, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        updated_notifications = []
+        for notification in notifications:
+            notification.read_at = timezone.now()
+            updated_notifications.append(notification)
+        Notification.objects.bulk_update(
+            updated_notifications, ["read_at"], batch_size=100
+        )
+        return Response({"message": "Successful"}, status=status.HTTP_200_OK)

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,104 +77,82 @@ 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},
-            )
+        serializer = PageSerializer(
+            data=request.data,
+            context={"project_id": project_id, "owned_by_id": request.user.id},
+        )
 
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     def partial_update(self, request, slug, project_id, pk):
-        try:
-            page = Page.objects.get(pk=pk, workspace__slug=slug, project_id=project_id)
-            # Only update access if the page owner is the requesting  user
-            if (
-                page.access != request.data.get("access", page.access)
-                and page.owned_by_id != request.user.id
-            ):
-                return Response(
-                    {
-                        "error": "Access cannot be updated since this page is owned by someone else"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            serializer = PageSerializer(page, data=request.data, partial=True)
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Page.DoesNotExist:
+        page = Page.objects.get(pk=pk, workspace__slug=slug, project_id=project_id)
+        # Only update access if the page owner is the requesting  user
+        if (
+            page.access != request.data.get("access", page.access)
+            and page.owned_by_id != request.user.id
+        ):
             return Response(
-                {"error": "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"},
+                {
+                    "error": "Access cannot be updated since this page is owned by someone else"
+                },
                 status=status.HTTP_400_BAD_REQUEST,
             )
+        serializer = PageSerializer(page, data=request.data, partial=True)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
         
     def list(self, request, slug, project_id):
-        try:
-            queryset = self.get_queryset()
-            page_view = request.GET.get("page_view", False)
+        queryset = self.get_queryset()
+        page_view = request.GET.get("page_view", False)
 
-            if not page_view:
-                return Response({"error": "Page View parameter is required"}, status=status.HTTP_400_BAD_REQUEST)
+        if not page_view:
+            return Response({"error": "Page View parameter is required"}, status=status.HTTP_400_BAD_REQUEST)
 
-            # All Pages
-            if page_view == "all":
-                return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
+        # All Pages
+        if page_view == "all":
+            return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
 
-            # Recent pages
-            if page_view == "recent":
-                current_time = date.today()
-                day_before = current_time - timedelta(days=1)
-                todays_pages = queryset.filter(updated_at__date=date.today())
-                yesterdays_pages = queryset.filter(updated_at__date=day_before)
-                earlier_this_week = queryset.filter(                    updated_at__date__range=(
-                        (timezone.now() - timedelta(days=7)),
-                        (timezone.now() - timedelta(days=2)),
-                    ))
-                return Response(
-                {
-                    "today": PageSerializer(todays_pages, many=True).data,
-                    "yesterday": PageSerializer(yesterdays_pages, many=True).data,
-                    "earlier_this_week": PageSerializer(earlier_this_week, many=True).data,
-                },
-                status=status.HTTP_200_OK,
-            )
+        # Recent pages
+        if page_view == "recent":
+            current_time = date.today()
+            day_before = current_time - timedelta(days=1)
+            todays_pages = queryset.filter(updated_at__date=date.today())
+            yesterdays_pages = queryset.filter(updated_at__date=day_before)
+            earlier_this_week = queryset.filter(                    updated_at__date__range=(
+                    (timezone.now() - timedelta(days=7)),
+                    (timezone.now() - timedelta(days=2)),
+                ))
+            return Response(
+            {
+                "today": PageSerializer(todays_pages, many=True).data,
+                "yesterday": PageSerializer(yesterdays_pages, many=True).data,
+                "earlier_this_week": PageSerializer(earlier_this_week, many=True).data,
+            },
+            status=status.HTTP_200_OK,
+        )
 
-            # Favorite Pages
-            if page_view == "favorite":
-                queryset = queryset.filter(is_favorite=True)
-                return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
-            
-            # My pages
-            if page_view == "created_by_me":
-                queryset = queryset.filter(owned_by=request.user)
-                return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
+        # Favorite Pages
+        if page_view == "favorite":
+            queryset = queryset.filter(is_favorite=True)
+            return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
+        
+        # My pages
+        if page_view == "created_by_me":
+            queryset = queryset.filter(owned_by=request.user)
+            return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
 
-            # Created by other Pages
-            if page_view == "created_by_other":
-                queryset = queryset.filter(~Q(owned_by=request.user),  access=0)
-                return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
+        # Created by other Pages
+        if page_view == "created_by_other":
+            queryset = queryset.filter(~Q(owned_by=request.user),  access=0)
+            return Response(PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK)
+
+        return Response({"error": "No matching view found"}, status=status.HTTP_400_BAD_REQUEST)
 
-            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,53 +202,21 @@ 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,
-            )
+        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)
 
     def destroy(self, request, slug, project_id, page_id):
-        try:
-            page_favorite = PageFavorite.objects.get(
-                project=project_id,
-                user=request.user,
-                workspace__slug=slug,
-                page_id=page_id,
-            )
-            page_favorite.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except PageFavorite.DoesNotExist:
-            return Response(
-                {"error": "Page is not in favorites"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
+        page_favorite = PageFavorite.objects.get(
+            project=project_id,
+            user=request.user,
+            workspace__slug=slug,
+            page_id=page_id,
+        )
+        page_favorite.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
 
 class CreateIssueFromPageBlockEndpoint(BaseAPIView):
     permission_classes = [
@@ -279,43 +224,32 @@ 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,
-                project_id=project_id,
-                page_id=page_id,
-            )
-            issue = Issue.objects.create(
-                name=page_block.name,
-                project_id=project_id,
-                description=page_block.description,
-                description_html=page_block.description_html,
-                description_stripped=page_block.description_stripped,
-            )
-            _ = IssueAssignee.objects.create(
-                issue=issue, assignee=request.user, project_id=project_id
-            )
+        page_block = PageBlock.objects.get(
+            pk=page_block_id,
+            workspace__slug=slug,
+            project_id=project_id,
+            page_id=page_id,
+        )
+        issue = Issue.objects.create(
+            name=page_block.name,
+            project_id=project_id,
+            description=page_block.description,
+            description_html=page_block.description_html,
+            description_stripped=page_block.description_stripped,
+        )
+        _ = IssueAssignee.objects.create(
+            issue=issue, assignee=request.user, project_id=project_id
+        )
 
-            _ = IssueActivity.objects.create(
-                issue=issue,
-                actor=request.user,
-                project_id=project_id,
-                comment=f"created the issue from {page_block.name} block",
-                verb="created",
-            )
+        _ = IssueActivity.objects.create(
+            issue=issue,
+            actor=request.user,
+            project_id=project_id,
+            comment=f"created the issue from {page_block.name} block",
+            verb="created",
+        )
 
-            page_block.issue = issue
-            page_block.save()
+        page_block.issue = issue
+        page_block.save()
 
-            return Response(IssueLiteSerializer(issue).data, status=status.HTTP_200_OK)
-        except PageBlock.DoesNotExist:
-            return Response(
-                {"error": "Page Block does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        return Response(IssueLiteSerializer(issue).data, status=status.HTTP_200_OK)

apiserver/plane/api/views/search.py

@@ -168,126 +168,107 @@ 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)
+        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)
 
-            if not query:
-                return Response(
-                    {
-                        "results": {
-                            "workspace": [],
-                            "project": [],
-                            "issue": [],
-                            "cycle": [],
-                            "module": [],
-                            "issue_view": [],
-                            "page": [],
-                        }
-                    },
-                    status=status.HTTP_200_OK,
-                )
-
-            MODELS_MAPPER = {
-                "workspace": self.filter_workspaces,
-                "project": self.filter_projects,
-                "issue": self.filter_issues,
-                "cycle": self.filter_cycles,
-                "module": self.filter_modules,
-                "issue_view": self.filter_views,
-                "page": self.filter_pages,
-            }
-
-            results = {}
-
-            for model in MODELS_MAPPER.keys():
-                func = MODELS_MAPPER.get(model, None)
-                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)
+        if not query:
             return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
+                {
+                    "results": {
+                        "workspace": [],
+                        "project": [],
+                        "issue": [],
+                        "cycle": [],
+                        "module": [],
+                        "issue_view": [],
+                        "page": [],
+                    }
+                },
+                status=status.HTTP_200_OK,
             )
 
+        MODELS_MAPPER = {
+            "workspace": self.filter_workspaces,
+            "project": self.filter_projects,
+            "issue": self.filter_issues,
+            "cycle": self.filter_cycles,
+            "module": self.filter_modules,
+            "issue_view": self.filter_views,
+            "page": self.filter_pages,
+        }
+
+        results = {}
+
+        for model in MODELS_MAPPER.keys():
+            func = MODELS_MAPPER.get(model, None)
+            results[model] = func(query, slug, project_id, workspace_search)
+        return Response({"results": results}, status=status.HTTP_200_OK)
+
 
 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")
-            issue_relation = request.query_params.get("issue_relation", "false")
-            cycle = request.query_params.get("cycle", "false")
-            module = request.query_params.get("module", "false")
-            sub_issue = request.query_params.get("sub_issue", "false")
+        query = request.query_params.get("search", False)
+        workspace_search = request.query_params.get("workspace_search", "false")
+        parent = request.query_params.get("parent", "false")
+        issue_relation = request.query_params.get("issue_relation", "false")
+        cycle = request.query_params.get("cycle", "false")
+        module = request.query_params.get("module", "false")
+        sub_issue = request.query_params.get("sub_issue", "false")
 
-            issue_id = request.query_params.get("issue_id", False)
+        issue_id = request.query_params.get("issue_id", False)
 
-            issues = Issue.issue_objects.filter(
-                workspace__slug=slug,
-                project__project_projectmember__member=self.request.user,
-            )
+        issues = Issue.issue_objects.filter(
+            workspace__slug=slug,
+            project__project_projectmember__member=self.request.user,
+        )
 
-            if workspace_search == "false":
-                issues = issues.filter(project_id=project_id)
+        if workspace_search == "false":
+            issues = issues.filter(project_id=project_id)
 
-            if query:
-                issues = search_issues(query, issues)
+        if query:
+            issues = search_issues(query, issues)
 
-            if parent == "true" and issue_id:
-                issue = Issue.issue_objects.get(pk=issue_id)
-                issues = issues.filter(
-                    ~Q(pk=issue_id), ~Q(pk=issue.parent_id), parent__isnull=True
-                ).exclude(
-                    pk__in=Issue.issue_objects.filter(parent__isnull=False).values_list(
-                        "parent_id", flat=True
-                    )
+        if parent == "true" and issue_id:
+            issue = Issue.issue_objects.get(pk=issue_id)
+            issues = issues.filter(
+                ~Q(pk=issue_id), ~Q(pk=issue.parent_id), parent__isnull=True
+            ).exclude(
+                pk__in=Issue.issue_objects.filter(parent__isnull=False).values_list(
+                    "parent_id", flat=True
                 )
-            if issue_relation == "true" and issue_id:
-                issue = Issue.issue_objects.get(pk=issue_id)
-                issues = issues.filter(
-                    ~Q(pk=issue_id),
-                    ~Q(issue_related__issue=issue),
-                    ~Q(issue_relation__related_issue=issue),
-                )
-            if sub_issue == "true" and issue_id:
-                issue = Issue.issue_objects.get(pk=issue_id)
-                issues = issues.filter(~Q(pk=issue_id), parent__isnull=True)
-                if issue.parent:
-                    issues = issues.filter(~Q(pk=issue.parent_id))
-
-            if cycle == "true":
-                issues = issues.exclude(issue_cycle__isnull=False)
-
-            if module == "true":
-                issues = issues.exclude(issue_module__isnull=False)
-
-            return Response(
-                issues.values(
-                    "name",
-                    "id",
-                    "sequence_id",
-                    "project__name",
-                    "project__identifier",
-                    "project_id",
-                    "workspace__slug",
-                    "state__name",
-                    "state__group",
-                    "state__color",
-                ),
-                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,
+        if issue_relation == "true" and issue_id:
+            issue = Issue.issue_objects.get(pk=issue_id)
+            issues = issues.filter(
+                ~Q(pk=issue_id),
+                ~Q(issue_related__issue=issue),
+                ~Q(issue_relation__related_issue=issue),
             )
+        if sub_issue == "true" and issue_id:
+            issue = Issue.issue_objects.get(pk=issue_id)
+            issues = issues.filter(~Q(pk=issue_id), parent__isnull=True)
+            if issue.parent:
+                issues = issues.filter(~Q(pk=issue.parent_id))
+
+        if cycle == "true":
+            issues = issues.exclude(issue_cycle__isnull=False)
+
+        if module == "true":
+            issues = issues.exclude(issue_module__isnull=False)
+
+        return Response(
+            issues.values(
+                "name",
+                "id",
+                "sequence_id",
+                "project__name",
+                "project__identifier",
+                "project_id",
+                "workspace__slug",
+                "state__name",
+                "state__group",
+                "state__color",
+            ),
+            status=status.HTTP_200_OK,
+        )

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,67 +40,45 @@ 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,
-            )
+        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)
 
     def list(self, request, slug, project_id):
-        try:
-            state_dict = dict()
-            states = StateSerializer(self.get_queryset(), many=True).data
+        state_dict = dict()
+        states = StateSerializer(self.get_queryset(), many=True).data
 
-            for key, value in groupby(
-                sorted(states, key=lambda state: state["group"]),
-                lambda state: state.get("group"),
-            ):
-                state_dict[str(key)] = list(value)
+        for key, value in groupby(
+            sorted(states, key=lambda state: state["group"]),
+            lambda state: state.get("group"),
+        ):
+            state_dict[str(key)] = list(value)
 
-            return Response(state_dict, status=status.HTTP_200_OK)
-        except Exception as e:
-            capture_exception(e)
+        return Response(state_dict, status=status.HTTP_200_OK)
+
+    def destroy(self, request, slug, project_id, pk):
+        state = State.objects.get(
+            ~Q(name="Triage"),
+            pk=pk, project_id=project_id, workspace__slug=slug,
+        )
+
+        if state.default:
             return Response(
-                {"error": "Something went wrong please try again later"},
+                {"error": "Default state cannot be deleted"}, status=False
+            )
+
+        # Check for any issues in the state
+        issue_exist = Issue.issue_objects.filter(state=pk).exists()
+
+        if issue_exist:
+            return Response(
+                {
+                    "error": "The state is not empty, only empty states can be deleted"
+                },
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-    def destroy(self, request, slug, project_id, pk):
-        try:
-            state = State.objects.get(
-                ~Q(name="Triage"),
-                pk=pk, project_id=project_id, workspace__slug=slug,
-            )
-
-            if state.default:
-                return Response(
-                    {"error": "Default state cannot be deleted"}, status=False
-                )
-
-            # Check for any issues in the state
-            issue_exist = Issue.issue_objects.filter(state=pk).exists()
-
-            if issue_exist:
-                return Response(
-                    {
-                        "error": "The state is not empty, only empty states can be deleted"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            state.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except State.DoesNotExist:
-            return Response({"error": "State does not exists"}, status=status.HTTP_404)
+        state.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

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,129 +32,43 @@ 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 = UserMeSerializer(request.user).data
+        return Response(
+            serialized_data,
+            status=status.HTTP_200_OK,
+        )
 
-            serialized_data = UserSerializer(request.user).data
-            serialized_data["workspace"] = {
-                "last_workspace_id": request.user.last_workspace_id,
-                "last_workspace_slug": workspace.slug,
-                "fallback_workspace_id": request.user.last_workspace_id,
-                "fallback_workspace_slug": workspace.slug,
-                "invites": workspace_invites,
-            }
-            serialized_data.setdefault("issues", {})[
-                "assigned_issues"
-            ] = assigned_issues
-
-            return Response(
-                serialized_data,
-                status=status.HTTP_200_OK,
-            )
-        except Workspace.DoesNotExist:
-            # This exception will be hit even when the `last_workspace_id` is None
-
-            workspace_invites = WorkspaceMemberInvite.objects.filter(
-                email=request.user.email
-            ).count()
-            assigned_issues = Issue.issue_objects.filter(
-                assignees__in=[request.user]
-            ).count()
-
-            fallback_workspace = (
-                Workspace.objects.filter(workspace_member__member=request.user)
-                .order_by("created_at")
-                .first()
-            )
-
-            serialized_data = UserSerializer(request.user).data
-
-            serialized_data["workspace"] = {
-                "last_workspace_id": None,
-                "last_workspace_slug": None,
-                "fallback_workspace_id": fallback_workspace.id
-                if fallback_workspace is not None
-                else None,
-                "fallback_workspace_slug": fallback_workspace.slug
-                if fallback_workspace is not None
-                else None,
-                "invites": workspace_invites,
-            }
-            serialized_data.setdefault("issues", {})[
-                "assigned_issues"
-            ] = assigned_issues
-
-            return Response(
-                serialized_data,
-                status=status.HTTP_200_OK,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+    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,
-            )
+        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)
 
 
 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,
-            )
+        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)
 
 
 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")
+        queryset = IssueActivity.objects.filter(
+            actor=request.user, workspace__slug=slug
+        ).select_related("actor", "workspace", "issue", "project")
 
-            return self.paginate(
-                request=request,
-                queryset=queryset,
-                on_results=lambda issue_activities: IssueActivitySerializer(
-                    issue_activities, many=True
-                ).data,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        return self.paginate(
+            request=request,
+            queryset=queryset,
+            on_results=lambda issue_activities: IssueActivitySerializer(
+                issue_activities, many=True
+            ).data,
+        )

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,123 +93,111 @@ class GlobalViewIssuesViewSet(BaseViewSet):
             )
         )
 
-        
     @method_decorator(gzip_page)
     def list(self, request, slug):
-        try:
-            filters = issue_filters(request.query_params, "GET")
+        filters = issue_filters(request.query_params, "GET")
 
-            # Custom ordering for priority and state
-            priority_order = ["urgent", "high", "medium", "low", "none"]
-            state_order = ["backlog", "unstarted", "started", "completed", "cancelled"]
+        # Custom ordering for priority and state
+        priority_order = ["urgent", "high", "medium", "low", "none"]
+        state_order = ["backlog", "unstarted", "started", "completed", "cancelled"]
 
-            order_by_param = request.GET.get("order_by", "-created_at")
+        order_by_param = request.GET.get("order_by", "-created_at")
 
-            issue_queryset = (
-                self.get_queryset()
-                .filter(**filters)
-                .filter(project__project_projectmember__member=self.request.user)
-                .annotate(cycle_id=F("issue_cycle__cycle_id"))
-                .annotate(module_id=F("issue_module__module_id"))
-                .annotate(
-                    link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
-                .annotate(
-                    attachment_count=IssueAttachment.objects.filter(
-                        issue=OuterRef("id")
-                    )
-                    .order_by()
-                    .annotate(count=Func(F("id"), function="Count"))
-                    .values("count")
-                )
+        issue_queryset = (
+            self.get_queryset()
+            .filter(**filters)
+            .filter(project__project_projectmember__member=self.request.user)
+            .annotate(cycle_id=F("issue_cycle__cycle_id"))
+            .annotate(module_id=F("issue_module__module_id"))
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
             )
+            .annotate(
+                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+        )
 
-            # Priority Ordering
-            if order_by_param == "priority" or order_by_param == "-priority":
-                priority_order = (
-                    priority_order
-                    if order_by_param == "priority"
-                    else priority_order[::-1]
+        # Priority Ordering
+        if order_by_param == "priority" or order_by_param == "-priority":
+            priority_order = (
+                priority_order if order_by_param == "priority" else priority_order[::-1]
+            )
+            issue_queryset = issue_queryset.annotate(
+                priority_order=Case(
+                    *[
+                        When(priority=p, then=Value(i))
+                        for i, p in enumerate(priority_order)
+                    ],
+                    output_field=CharField(),
                 )
-                issue_queryset = issue_queryset.annotate(
-                    priority_order=Case(
-                        *[
-                            When(priority=p, then=Value(i))
-                            for i, p in enumerate(priority_order)
-                        ],
-                        output_field=CharField(),
-                    )
-                ).order_by("priority_order")
+            ).order_by("priority_order")
 
-            # State Ordering
-            elif order_by_param in [
-                "state__name",
-                "state__group",
-                "-state__name",
-                "-state__group",
-            ]:
-                state_order = (
-                    state_order
-                    if order_by_param in ["state__name", "state__group"]
-                    else state_order[::-1]
+        # State Ordering
+        elif order_by_param in [
+            "state__name",
+            "state__group",
+            "-state__name",
+            "-state__group",
+        ]:
+            state_order = (
+                state_order
+                if order_by_param in ["state__name", "state__group"]
+                else state_order[::-1]
+            )
+            issue_queryset = issue_queryset.annotate(
+                state_order=Case(
+                    *[
+                        When(state__group=state_group, then=Value(i))
+                        for i, state_group in enumerate(state_order)
+                    ],
+                    default=Value(len(state_order)),
+                    output_field=CharField(),
                 )
-                issue_queryset = issue_queryset.annotate(
-                    state_order=Case(
-                        *[
-                            When(state__group=state_group, then=Value(i))
-                            for i, state_group in enumerate(state_order)
-                        ],
-                        default=Value(len(state_order)),
-                        output_field=CharField(),
-                    )
-                ).order_by("state_order")
-            # assignee and label ordering
-            elif order_by_param in [
-                "labels__name",
-                "-labels__name",
-                "assignees__first_name",
-                "-assignees__first_name",
-            ]:
-                issue_queryset = issue_queryset.annotate(
-                    max_values=Max(
-                        order_by_param[1::]
-                        if order_by_param.startswith("-")
-                        else order_by_param
-                    )
-                ).order_by(
-                    "-max_values" if order_by_param.startswith("-") else "max_values"
+            ).order_by("state_order")
+        # assignee and label ordering
+        elif order_by_param in [
+            "labels__name",
+            "-labels__name",
+            "assignees__first_name",
+            "-assignees__first_name",
+        ]:
+            issue_queryset = issue_queryset.annotate(
+                max_values=Max(
+                    order_by_param[1::]
+                    if order_by_param.startswith("-")
+                    else order_by_param
                 )
-            else:
-                issue_queryset = issue_queryset.order_by(order_by_param)
+            ).order_by(
+                "-max_values" if order_by_param.startswith("-") else "max_values"
+            )
+        else:
+            issue_queryset = issue_queryset.order_by(order_by_param)
+        issues = IssueLiteSerializer(issue_queryset, many=True).data
 
-            issues = IssueLiteSerializer(issue_queryset, many=True).data
-
-            ## Grouping the results
-            group_by = request.GET.get("group_by", False)
-            sub_group_by = request.GET.get("sub_group_by", False)
-            if sub_group_by and sub_group_by == group_by:
-                return Response(
-                    {"error": "Group by and sub group by cannot be same"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-            
-            if group_by:
-                return Response(
-                    group_results(issues, group_by, sub_group_by), status=status.HTTP_200_OK
-                )
-
-            return Response(issues, status=status.HTTP_200_OK)
-
-        except Exception as e:
-            capture_exception(e)
+        ## Grouping the results
+        group_by = request.GET.get("group_by", False)
+        sub_group_by = request.GET.get("sub_group_by", False)
+        if sub_group_by and sub_group_by == group_by:
             return Response(
-                {"error": "Something went wrong please try again later"},
+                {"error": "Group by and sub group by cannot be same"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        if group_by:
+            grouped_results = group_results(issues, group_by, sub_group_by)
+            return Response(
+                grouped_results,
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(issues, status=status.HTTP_200_OK)
+
 
 class IssueViewViewSet(BaseViewSet):
     serializer_class = IssueViewSerializer
@@ -243,51 +230,6 @@ class IssueViewViewSet(BaseViewSet):
         )
 
 
-class ViewIssuesEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get(self, request, slug, project_id, view_id):
-        try:
-            view = IssueView.objects.get(pk=view_id)
-            queries = view.query
-
-            filters = issue_filters(request.query_params, "GET")
-
-            issues = (
-                Issue.issue_objects.filter(
-                    **queries, project_id=project_id, workspace__slug=slug
-                )
-                .filter(**filters)
-                .select_related("project")
-                .select_related("workspace")
-                .select_related("state")
-                .select_related("parent")
-                .prefetch_related("assignees")
-                .prefetch_related("labels")
-                .prefetch_related(
-                    Prefetch(
-                        "issue_reactions",
-                        queryset=IssueReaction.objects.select_related("actor"),
-                    )
-                )
-            )
-
-            serializer = IssueLiteSerializer(issues, many=True)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except IssueView.DoesNotExist:
-            return Response(
-                {"error": "Issue View does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-
 class IssueViewFavoriteViewSet(BaseViewSet):
     serializer_class = IssueViewFavoriteSerializer
     model = IssueViewFavorite
@@ -302,49 +244,18 @@ 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,
-            )
+        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)
 
     def destroy(self, request, slug, project_id, view_id):
-        try:
-            view_favourite = IssueViewFavorite.objects.get(
-                project=project_id,
-                user=request.user,
-                workspace__slug=slug,
-                view_id=view_id,
-            )
-            view_favourite.delete()
-            return Response(status=status.HTTP_204_NO_CONTENT)
-        except IssueViewFavorite.DoesNotExist:
-            return Response(
-                {"error": "View is not in favorites"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except Exception as e:
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
+        view_favourite = IssueViewFavorite.objects.get(
+            project=project_id,
+            user=request.user,
+            workspace__slug=slug,
+            view_id=view_id,
+        )
+        view_favourite.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

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 = (
+            get_assignee_details(slug, filters)
+            if x_axis == ASSIGNEE_ID or segment == ASSIGNEE_ID
+            else {}
+        )
 
-        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")
-            )
+        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]
-            )
-            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]
+            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)
 
+        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",
@@ -186,7 +204,7 @@ class IssueRelation(ProjectBaseModel):
         ("relates_to", "Relates To"),
         ("blocked_by", "Blocked By"),
     )
-        
+
     issue = models.ForeignKey(
         Issue, related_name="issue_relation", on_delete=models.CASCADE
     )
@@ -208,7 +226,7 @@ class IssueRelation(ProjectBaseModel):
         ordering = ("-created_at",)
 
     def __str__(self):
-        return f"{self.issue.name} {self.related_issue.name}"    
+        return f"{self.issue.name} {self.related_issue.name}"
 
 
 class IssueAssignee(ProjectBaseModel):
@@ -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 = {
-    "default": {
-        "ENGINE": "django.db.backends.postgresql",
-        "NAME": "plane",
-        "USER": os.environ.get("PGUSER", ""),
-        "PASSWORD": os.environ.get("PGPASSWORD", ""),
-        "HOST": os.environ.get("PGHOST", ""),
+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": 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
+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())
+    # 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"]:
-        year = ExtractYear(x_axis)
-        month = ExtractMonth(x_axis)
-        dimension = Concat(year, Value("-"), month, output_field=CharField())
-        queryset = queryset.annotate(dimension=dimension)
-        x_axis = "dimension"
+        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":
+    # Estimate
+    else:
         queryset = queryset.annotate(estimate=Sum("estimate_point")).order_by(x_axis)
-        if segment:
-            queryset = queryset.annotate(segment=F(segment)).values(
-                "dimension", "segment", "estimate"
-            )
-        else:
-            queryset = queryset.values("dimension", "estimate")
+        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,43 +1,115 @@
-from django.utils.timezone import make_aware
-from django.utils.dateparse import parse_datetime
+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):
+    now = timezone.now().date()
+    if term == "months":
+        if subsequent == "after":
+            if offset == "fromnow":
+                filter[f"{date_filter}__gte"] = now + timedelta(days=duration * 30)
+            else:
+                filter[f"{date_filter}__gte"] = now - timedelta(days=duration * 30)
+        else:
+            if offset == "fromnow":
+                filter[f"{date_filter}__lte"] = now + timedelta(days=duration * 30)
+            else:
+                filter[f"{date_filter}__lte"] = now - timedelta(days=duration * 30)
+    if term == "weeks":
+        if subsequent == "after":
+            if offset == "fromnow":
+                filter[f"{date_filter}__gte"] = now + timedelta(weeks=duration)
+            else:
+                filter[f"{date_filter}__gte"] = now - timedelta(weeks=duration)
+        else:
+            if offset == "fromnow":
+                filter[f"{date_filter}__lte"] = now + timedelta(days=duration)
+            else:
+                filter[f"{date_filter}__lte"] = now - timedelta(days=duration)
+
+
+def date_filter(filter, date_term, queries):
+    """
+        Handle all date filters
+    """
+    for query in queries:
+        date_query = query.split(";")
+        if len(date_query) >= 2:
+            match = pattern.match(date_query[0])
+            if match:
+                if len(date_query) == 3:
+                    digit, term = date_query[0].split("_")
+                    string_date_filter(
+                        filter=filter,
+                        duration=int(digit),
+                        subsequent=date_query[1],
+                        term=term,
+                        date_filter="created_at__date",
+                        offset=date_query[2],
+                    )
+            else:
+                if "after" in date_query:
+                    filter[f"{date_term}__gte"] = date_query[0]
+                else:
+                    filter[f"{date_term}__lte"] = date_query[0]
 
 
 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
@@ -45,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
 
@@ -97,20 +173,10 @@ def filter_created_at(params, filter, method):
     if method == "GET":
         created_ats = params.get("created_at").split(",")
         if len(created_ats) and "" not in created_ats:
-            for query in created_ats:
-                created_at_query = query.split(";")
-                if len(created_at_query) == 2 and "after" in created_at_query:
-                    filter["created_at__date__gte"] = created_at_query[0]
-                else:
-                    filter["created_at__date__lte"] = created_at_query[0]
+            date_filter(filter=filter, date_term="created_at__date", queries=created_ats)
     else:
         if params.get("created_at", None) and len(params.get("created_at")):
-            for query in params.get("created_at"):
-                created_at_query = query.split(";")
-                if len(created_at_query) == 2 and "after" in created_at_query:
-                    filter["created_at__date__gte"] = created_at_query[0]
-                else:
-                    filter["created_at__date__lte"] = created_at_query[0]
+            date_filter(filter=filter, date_term="created_at__date", queries=params.get("created_at", []))
     return filter
 
 
@@ -118,20 +184,10 @@ def filter_updated_at(params, filter, method):
     if method == "GET":
         updated_ats = params.get("updated_at").split(",")
         if len(updated_ats) and "" not in updated_ats:
-            for query in updated_ats:
-                updated_at_query = query.split(";")
-                if len(updated_at_query) == 2 and "after" in updated_at_query:
-                    filter["updated_at__date__gte"] = updated_at_query[0]
-                else:
-                    filter["updated_at__date__lte"] = updated_at_query[0]
+            date_filter(filter=filter, date_term="created_at__date", queries=updated_ats)
     else:
         if params.get("updated_at", None) and len(params.get("updated_at")):
-            for query in params.get("updated_at"):
-                updated_at_query = query.split(";")
-                if len(updated_at_query) == 2 and "after" in updated_at_query:
-                    filter["updated_at__date__gte"] = updated_at_query[0]
-                else:
-                    filter["updated_at__date__lte"] = updated_at_query[0]
+            date_filter(filter=filter, date_term="created_at__date", queries=params.get("updated_at", []))
     return filter
 
 
@@ -139,20 +195,10 @@ def filter_start_date(params, filter, method):
     if method == "GET":
         start_dates = params.get("start_date").split(",")
         if len(start_dates) and "" not in start_dates:
-            for query in start_dates:
-                start_date_query = query.split(";")
-                if len(start_date_query) == 2 and "after" in start_date_query:
-                    filter["start_date__gte"] = start_date_query[0]
-                else:
-                    filter["start_date__lte"] = start_date_query[0]
+            date_filter(filter=filter, date_term="start_date", queries=start_dates)
     else:
         if params.get("start_date", None) and len(params.get("start_date")):
-            for query in params.get("start_date"):
-                start_date_query = query.split(";")
-                if len(start_date_query) == 2 and "after" in start_date_query:
-                    filter["start_date__gte"] = start_date_query[0]
-                else:
-                    filter["start_date__lte"] = start_date_query[0]
+            date_filter(filter=filter, date_term="start_date", queries=params.get("start_date", []))
     return filter
 
 
@@ -160,21 +206,10 @@ 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:
-            for query in target_dates:
-                target_date_query = query.split(";")
-                if len(target_date_query) == 2 and "after" in target_date_query:
-                    filter["target_date__gte"] = target_date_query[0]
-                else:
-                    filter["target_date__lte"] = target_date_query[0]
+            date_filter(filter=filter, date_term="target_date", queries=target_dates)
     else:
         if params.get("target_date", None) and len(params.get("target_date")):
-            for query in params.get("target_date"):
-                target_date_query = query.split(";")
-                if len(target_date_query) == 2 and "after" in target_date_query:
-                    filter["target_date__gte"] = target_date_query[0]
-                else:
-                    filter["target_date__lte"] = target_date_query[0]
-
+            date_filter(filter=filter, date_term="target_date", queries=params.get("target_date", []))
     return filter
 
 
@@ -182,20 +217,10 @@ def filter_completed_at(params, filter, method):
     if method == "GET":
         completed_ats = params.get("completed_at").split(",")
         if len(completed_ats) and "" not in completed_ats:
-            for query in completed_ats:
-                completed_at_query = query.split(";")
-                if len(completed_at_query) == 2 and "after" in completed_at_query:
-                    filter["completed_at__date__gte"] = completed_at_query[0]
-                else:
-                    filter["completed_at__lte"] = completed_at_query[0]
+            date_filter(filter=filter, date_term="completed_at__date", queries=completed_ats)
     else:
         if params.get("completed_at", None) and len(params.get("completed_at")):
-            for query in params.get("completed_at"):
-                completed_at_query = query.split(";")
-                if len(completed_at_query) == 2 and "after" in completed_at_query:
-                    filter["completed_at__date__gte"] = completed_at_query[0]
-                else:
-                    filter["completed_at__lte"] = completed_at_query[0]
+            date_filter(filter=filter, date_term="completed_at__date", queries=params.get("completed_at", []))
     return filter
 
 
@@ -213,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
 
@@ -269,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.16"
+  },
+  "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>
+);